From e287f491d278fc16862aa7c0d252226407a63193 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 17:02:52 -0800
Subject: [PATCH 01/80] fix(code-index): fence stale progress boundaries

Refs #4508

Reapply PR #4795 without changing its existing branch or commits.
The previous immutable history failed the 72-character commit header gate.
---
 .../src/code_index_scheduler/serving.rs       |  80 +++++-
 .../tests/code_index_scheduler/serving.rs     | 242 ++++++++++++++++++
 2 files changed, 314 insertions(+), 8 deletions(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
index 3a5e4f37ec4..d1b0c8bb2d6 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
@@ -189,6 +189,7 @@ pub struct CodeIndexBuildProgressSlotStateV1 {
     generation_id: Option<CodeGenerationId>,
     pub(super) owner_epoch: u64,
     progress_epoch: u64,
+    last_progress_micros: Option<i64>,
     snapshot: Option<Arc<CodeIndexBuildProgressV1>>,
 }
 
@@ -198,27 +199,61 @@ impl CodeIndexBuildProgressSlotStateV1 {
         self.progress_epoch = self.progress_epoch.saturating_add(1).max(1);
         self.generation_id = Some(generation_id);
         self.snapshot = None;
+        self.last_progress_micros = None;
         self.owner_epoch
     }
 
+    /// A discarded or replaced staging file starts a different committed
+    /// sequence, even if the sealed generation and scheduler owner survive.
+    /// Only the head-opening singleflight may reset it, after it has verified
+    /// that a new staging builder was actually created. The next boundary
+    /// keeps the monotonic publication epoch and reports its real counters.
+    pub(super) fn begin_staging_attempt(
+        &mut self,
+        generation_id: &CodeGenerationId,
+        owner_epoch: u64,
+    ) -> bool {
+        if self.generation_id.as_ref() != Some(generation_id) || self.owner_epoch != owner_epoch {
+            return false;
+        }
+        self.snapshot = None;
+        true
+    }
+
     pub(super) fn publish(
         &mut self,
         generation_id: &CodeGenerationId,
         owner_epoch: u64,
         mut snapshot: CodeIndexBuildProgressV1,
     ) -> bool {
-        if self.generation_id.as_ref() != Some(generation_id) || self.owner_epoch != owner_epoch {
+        if self.generation_id.as_ref() != Some(generation_id)
+            || self.owner_epoch != owner_epoch
+            || snapshot.generation_id != generation_id.as_str()
+        {
             return false;
         }
-        // A progress producer can timestamp its snapshot before another
-        // producer publishes. Preserve the most recent observed timestamp
-        // even when the later lock acquisition delivers an older sample.
-        // Replacing the generation clears the snapshot and starts a new owner.
         if let Some(current) = self.snapshot.as_ref() {
-            snapshot.last_progress_micros = snapshot
-                .last_progress_micros
-                .max(current.last_progress_micros);
+            // Concurrent phase/report producers may complete out of order.
+            // A delayed report must not undo already committed boundaries or
+            // withdraw a ready text owner from the same generation.
+            if snapshot.committed_pages < current.committed_pages
+                || snapshot.committed_chunks < current.committed_chunks
+                || snapshot.committed_imports < current.committed_imports
+                || snapshot.committed_payload_bytes < current.committed_payload_bytes
+                || (current.phase == CodeIndexBuildPhaseV1::Ready
+                    && snapshot.phase != CodeIndexBuildPhaseV1::Ready)
+            {
+                return false;
+            }
         }
+        // The next producer may have assembled its report before an earlier
+        // producer acquired the lock. Keep the owner's latest observed time
+        // even across a verified staging restart (which clears the snapshot).
+        // Replacing the owner clears this timestamp authority.
+        if let Some(latest) = self.last_progress_micros {
+            snapshot.last_progress_micros = snapshot.last_progress_micros.max(latest);
+        }
+        self.last_progress_micros = Some(snapshot.last_progress_micros);
         self.progress_epoch = self.progress_epoch.saturating_add(1).max(1);
         snapshot.progress_epoch = self.progress_epoch;
 
@@ -233,6 +268,9 @@ impl CodeIndexBuildProgressSlotStateV1 {
         else {
             return;
         };
+        if snapshot.blocked_reason == Some(reason) {
+            return;
+        }
         let mut snapshot = snapshot.as_ref().clone();
         snapshot.blocked_reason = Some(reason);
         let _ = self.publish(&generation_id, self.owner_epoch, snapshot);
@@ -252,6 +290,7 @@ impl CodeIndexBuildProgressSlotStateV1 {
             return false;
         };
         if current.phase == CodeIndexBuildPhaseV1::Ready
+            || current.blocked_reason == Some(reason)
             || expected_progress_epoch.is_some_and(|epoch| current.progress_epoch != epoch)
         {
             return false;
@@ -2693,6 +2732,17 @@ impl LatestCodeTextGenerationV1 {
                 let Some(current) = slot.snapshot() else {
                     return;
                 };
+                // A retry that re-enters an unchanged phase has not made
+                // progress. Keep the last committed observation epoch and
+                // elapsed sample until a new phase or batch boundary arrives.
+                if current.phase == phase
+                    && current.current_batch_pages == current_batch_pages
+                    && current.current_batch_payload_bytes == current_batch_payload_bytes
+                    && !(phase == CodeIndexBuildPhaseV1::Ready
+                        && current.blocked_reason.is_some())
+                {
+                    return;
+                }
                 let mut snapshot = current.as_ref().clone();
                 snapshot.phase = phase;
                 if !phase_has_file_rate_estimate(phase) {
@@ -3220,6 +3270,10 @@ impl LatestCodeTextGenerationV1 {
         } else {
             None
         };
+        // A missing/incompatible staging file is a new durable attempt for
+        // this sealed generation. Its committed counters legitimately start
+        // at zero; the old attempt must not fence that fresh boundary.
+        let mut fresh_staging_attempt = resumed.is_none();
         let mut builder = match resumed {
             Some(builder) => builder,
             None => match self.carry_parent_text_artifact(
@@ -3262,6 +3316,7 @@ impl LatestCodeTextGenerationV1 {
                 Err(VerifiedSealedLexicalCursorRestoreErrorV1::IncompatiblePosition) => {
                     drop(builder);
                     store.discard_incompatible_staging(&staging_path, control)?;
+                    fresh_staging_attempt = true;
                     builder = CodeLexicalArtifactBuilderV1::create_with_memory_budget(
                         &staging_path,
                         metadata,
@@ -3288,6 +3343,15 @@ impl LatestCodeTextGenerationV1 {
             staging_path,
             _build_reservation: build_reservation,
         };
+        if fresh_staging_attempt
+            && !self
+                .text_progress_slot
+                .write()
+                .unwrap_or_else(std::sync::PoisonError::into_inner)
+                .begin_staging_attempt(&generation_id, self.text_progress_owner_epoch)
+        {
+            return Err(RetrievalPortError::GenerationMismatch);
+        }
         self.publish_text_progress_boundary(
             &initialized,
             &progress,
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
index 6a48bb325e3..b33a45fe79e 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
@@ -3041,6 +3041,248 @@ fn progress_timestamp_never_regresses_within_one_owner() {
     assert_eq!(slot.snapshot().unwrap().last_progress_micros, 42);
 }
 
+#[test]
+fn delayed_progress_cannot_undo_committed_boundaries_or_ready() {
+    let generation = CodeGenerationId::new("generation.stale-progress").expect("generation");
+    let mut slot = super::super::CodeIndexBuildProgressSlotStateV1::default();
+    let owner = slot.replace_generation(generation.clone());
+
+    let mut committed = progress_snapshot_for_generation(&generation, 6);
+    committed.committed_imports = 3;
+    committed.last_progress_micros = 600;
+    assert!(slot.publish(&generation, owner, committed));
+    let accepted = slot.snapshot().expect("accepted committed progress");
+
+    for counter in ["pages", "chunks", "imports", "payload"] {
+        let mut delayed = accepted.as_ref().clone();
+        delayed.last_progress_micros = 700;
+        match counter {
+            "pages" => delayed.committed_pages -= 1,
+            "chunks" => delayed.committed_chunks -= 1,
+            "imports" => delayed.committed_imports -= 1,
+            "payload" => delayed.committed_payload_bytes -= 1,
+            _ => unreachable!(),
+        }
+        assert!(
+            !slot.publish(&generation, owner, delayed),
+            "delayed {counter} cannot overwrite committed progress"
+        );
+        assert_eq!(
+            slot.snapshot().expect("progress after stale report").as_ref(),
+            accepted.as_ref(),
+            "refusing stale {counter} must preserve the epoch and last progress time"
+        );
+    }
+
+    let mut wrong_generation = accepted.as_ref().clone();
+    wrong_generation.generation_id = "generation.foreign".to_owned();
+    assert!(!slot.publish(&generation, owner, wrong_generation));
+    assert_eq!(
+        slot.snapshot().expect("correct generation still owns progress").as_ref(),
+        accepted.as_ref()
+    );
+
+    let mut ready = progress_snapshot_for_generation(&generation, 7);
+    ready.committed_imports = 3;
+    ready.phase = CodeIndexBuildPhaseV1::Ready;
+    ready.last_progress_micros = 650;
+    assert!(slot.publish(&generation, owner, ready));
+    let settled = slot.snapshot().expect("ready progress");
+
+    let mut late_build = settled.as_ref().clone();
+    late_build.phase = CodeIndexBuildPhaseV1::BulkCommit;
+    late_build.last_progress_micros = 700;
+    assert!(!slot.publish(&generation, owner, late_build));
+    assert_eq!(
+        slot.snapshot().expect("ready progress remains").as_ref(),
+        settled.as_ref(),
+        "a delayed build phase must not withdraw ready"
+    );
+
+    // A remounted owner starts a new committed sequence even when its
+    // generation identity is the same. The old owner must stay fenced off.
+    let replacement_owner = slot.replace_generation(generation.clone());
+    let fresh = progress_snapshot_for_generation(&generation, 1);
+    assert!(slot.publish(&generation, replacement_owner, fresh));
+    assert_eq!(slot.snapshot().expect("new owner").committed_pages, 1);
+    assert!(!slot.publish(
+        &generation,
+        owner,
+        progress_snapshot_for_generation(&generation, 99)
+    ));
+}
+
+#[test]
+fn a_new_staging_attempt_can_truthfully_restart_committed_progress() {
+    let generation = CodeGenerationId::new("generation.staging-retry").expect("generation");
+    let mut slot = super::super::CodeIndexBuildProgressSlotStateV1::default();
+    let owner = slot.replace_generation(generation.clone());
+
+    let mut old = progress_snapshot_for_generation(&generation, 12);
+    old.last_progress_micros = 500;
+    assert!(slot.publish(&generation, owner, old));
+    let old_epoch = slot.snapshot().expect("first staging attempt").progress_epoch;
+
+    // Missing/incompatible SQLite staging is a verified new build attempt,
+    // not a delayed report from an older commit boundary. Without resetting
+    // the slot, rejecting counter regressions would leave status frozen.
+    assert!(slot.begin_staging_attempt(&generation, owner));
+    let mut restarted = progress_snapshot_for_generation(&generation, 0);
+    // A wall-clock adjustment or delayed sample must not rewind the
+    // timestamp even though a verified new staging attempt reset its counts.
+    restarted.last_progress_micros = 400;
+    restarted.phase = CodeIndexBuildPhaseV1::SourceScan;
+    assert!(slot.publish(&generation, owner, restarted));
+    let restarted = slot.snapshot().expect("new staging attempt");
+    assert_eq!(restarted.committed_pages, 0);
+    assert_eq!(restarted.phase, CodeIndexBuildPhaseV1::SourceScan);
+    assert_eq!(
+        restarted.last_progress_micros, 500,
+        "staging restart must not rewind the same owner's last progress timestamp"
+    );
+    assert!(
+        restarted.progress_epoch > old_epoch,
+        "a new verified staging attempt must produce a newer report epoch"
+    );
+
+    let mut resumed = progress_snapshot_for_generation(&generation, 2);
+    resumed.last_progress_micros = 700;
+    assert!(slot.publish(&generation, owner, resumed));
+    assert_eq!(slot.snapshot().expect("resumed commits").committed_pages, 2);
+
+    let foreign = CodeGenerationId::new("generation.foreign-stage").expect("foreign");
+    assert!(!slot.begin_staging_attempt(&foreign, owner));
+    assert!(!slot.begin_staging_attempt(&generation, owner + 1));
+    assert_eq!(slot.snapshot().expect("unchanged latest").committed_pages, 2);
+}
+
+#[test]
+fn retrying_an_unchanged_phase_does_not_fabricate_status_progress() {
+    let fixture = GitFixture::new(&[(
+        "src/lib.rs",
+        "pub fn caller() { callee(); }\npub fn callee() {}\n",
+    )]);
+    let store = TempDir::new().expect("store root");
+    let mut scheduler = scheduler(
+        &fixture,
+        store.path().to_path_buf(),
+        Arc::new(SharedCodeIndexBytePoolV1::default()),
+    );
+    published(scheduler.reconcile_now().expect("publish"));
+    let latest = scheduler.latest_complete().expect("latest generation");
+    assert!(
+        !latest.advance_text_serving(0).expect("open text projection"),
+        "a zero-work admission must leave the projection pending"
+    );
+    let before = build_progress_snapshot(&scheduler);
+    assert_ne!(before.phase, CodeIndexBuildPhaseV1::Ready);
+
+    latest.text.publish_text_progress_phase(
+        before.phase,
+        before.current_batch_pages,
+        before.current_batch_payload_bytes,
+    );
+    let repeated = build_progress_snapshot(&scheduler);
+    assert_eq!(
+        repeated.progress_epoch, before.progress_epoch,
+        "a retry reporting no new phase or batch boundary must not feign progress"
+    );
+    assert_eq!(repeated.last_progress_micros, before.last_progress_micros);
+    assert_eq!(repeated.committed_pages, before.committed_pages);
+
+    let next_phase = if before.phase == CodeIndexBuildPhaseV1::Verification {
+        CodeIndexBuildPhaseV1::GraphPublication
+    } else {
+        CodeIndexBuildPhaseV1::Verification
+    };
+    latest.text.publish_text_progress_phase(
+        next_phase,
+        before.current_batch_pages,
+        before.current_batch_payload_bytes,
+    );
+    let transitioned = build_progress_snapshot(&scheduler);
+    assert_eq!(transitioned.phase, next_phase);
+    assert!(transitioned.progress_epoch > before.progress_epoch);
+    latest.text.publish_text_progress_phase(
+        next_phase,
+        before.current_batch_pages,
+        before.current_batch_payload_bytes,
+    );
+    let unchanged = build_progress_snapshot(&scheduler);
+    assert_eq!(unchanged.progress_epoch, transitioned.progress_epoch);
+    assert_eq!(unchanged.last_progress_micros, transitioned.last_progress_micros);
+
+    let mut advances = 0;
+    while !latest.advance_text_serving(8).expect("resume durable text build") {
+        advances += 1;
+        assert!(advances < 1_000, "text build failed to finish");
+    }
+    let ready = build_progress_snapshot(&scheduler);
+    assert_eq!(ready.phase, CodeIndexBuildPhaseV1::Ready);
+    assert!(ready.progress_epoch > transitioned.progress_epoch);
+
+    // Ready is the one idempotent-looking phase that may still be a real
+    // state change: success must clear a previously published refusal.
+    scheduler
+        .build_progress_slot()
+        .write()
+        .expect("progress slot")
+        .block_current(CodeIndexBuildBlockedReasonV1::ResidentMemory);
+    let blocked = build_progress_snapshot(&scheduler);
+    assert_eq!(
+        blocked.blocked_reason,
+        Some(CodeIndexBuildBlockedReasonV1::ResidentMemory)
+    );
+    latest.text.publish_text_progress_phase(
+        CodeIndexBuildPhaseV1::Ready,
+        blocked.current_batch_pages,
+        blocked.current_batch_payload_bytes,
+    );
+    let cleared = build_progress_snapshot(&scheduler);
+    assert_eq!(cleared.blocked_reason, None);
+    assert!(cleared.progress_epoch > blocked.progress_epoch);
+}
+
+#[test]
+fn repeated_blocked_reason_is_not_reported_as_new_progress() {
+    let generation = CodeGenerationId::new("generation.blocked-report").expect("generation");
+    let mut slot = super::super::CodeIndexBuildProgressSlotStateV1::default();
+    let owner = slot.replace_generation(generation.clone());
+    assert!(slot.publish(
+        &generation,
+        owner,
+        progress_snapshot_for_generation(&generation, 2)
+    ));
+    slot.block_current(CodeIndexBuildBlockedReasonV1::ResidentMemory);
+    let first = slot.snapshot().expect("first refusal");
+    assert_eq!(
+        first.blocked_reason,
+        Some(CodeIndexBuildBlockedReasonV1::ResidentMemory)
+    );
+
+    slot.block_current(CodeIndexBuildBlockedReasonV1::ResidentMemory);
+    assert!(!slot.block_owned_text(
+        &generation,
+        owner,
+        CodeIndexBuildBlockedReasonV1::ResidentMemory,
+        Some(first.progress_epoch)
+    ));
+    assert_eq!(
+        slot.snapshot().expect("repeated refusal").progress_epoch,
+        first.progress_epoch,
+        "retries without a new refusal or committed work must not inflate the observation epoch"
+    );
+
+    let mut committed = progress_snapshot_for_generation(&generation, 3);
+    committed.last_progress_micros = first.last_progress_micros + 1;
+    assert!(slot.publish(&generation, owner, committed));
+    assert_eq!(
+        slot.snapshot().expect("committed progress").blocked_reason,
+        None,
+        "durable progress clears the previous blocked verdict"
+    );
+}
+
 #[test]
 fn progress_owner_epoch_rejects_original_a_after_a_b_a_replacement() {
     let generation_a = CodeGenerationId::new("generation.progress-a").expect("generation A");

From 8270bfcd81e1c9eab4fc770cd61801bbb24d46de Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 17:10:37 -0800
Subject: [PATCH 02/80] fix(code-index): fence progress identity across staging
 retries

Refs #4508

Reject foreign daemon, producer and sealed-source identity reports,
even after a verified SQLite staging restart clears committed counters.
Add a nonzero regression for the production progress authority.
---
 .../src/code_index_scheduler/serving.rs       | 22 ++++++
 .../tests/code_index_scheduler/serving.rs     | 72 +++++++++++++++++++
 2 files changed, 94 insertions(+)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
index d1b0c8bb2d6..b91cd06c542 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
@@ -190,6 +190,9 @@ pub struct CodeIndexBuildProgressSlotStateV1 {
     pub(super) owner_epoch: u64,
     progress_epoch: u64,
     last_progress_micros: Option<i64>,
+    /// The sealed source and reporting incarnation survive a verified
+    /// SQLite staging restart even though its committed counters reset.
+    progress_identity: Option<(u64, u64, String)>,
     snapshot: Option<Arc<CodeIndexBuildProgressV1>>,
 }
 
@@ -200,6 +203,7 @@ impl CodeIndexBuildProgressSlotStateV1 {
         self.generation_id = Some(generation_id);
         self.snapshot = None;
         self.last_progress_micros = None;
+        self.progress_identity = None;
         self.owner_epoch
     }
 
@@ -232,6 +236,17 @@ impl CodeIndexBuildProgressSlotStateV1 {
         {
             return false;
         }
+        // The same scheduler owner may rebuild its SQLite staging file, but
+        // it must not change the sealed source or the report incarnation.
+        // Keep this binding even when begin_staging_attempt clears counters.
+        if let Some((daemon, producer, digest)) = self.progress_identity.as_ref() {
+            if *daemon != snapshot.daemon_incarnation
+                || *producer != snapshot.producer_incarnation
+                || digest != &snapshot.sealed_source_digest
+            {
+                return false;
+            }
+        }
         if let Some(current) = self.snapshot.as_ref() {
             // Concurrent phase/report producers may complete out of order.
             // A delayed report must not undo already committed boundaries or
@@ -254,6 +269,13 @@ impl CodeIndexBuildProgressSlotStateV1 {
             snapshot.last_progress_micros = snapshot.last_progress_micros.max(latest);
         }
         self.last_progress_micros = Some(snapshot.last_progress_micros);
+        if self.progress_identity.is_none() {
+            self.progress_identity = Some((
+                snapshot.daemon_incarnation,
+                snapshot.producer_incarnation,
+                snapshot.sealed_source_digest.clone(),
+            ));
+        }
         self.progress_epoch = self.progress_epoch.saturating_add(1).max(1);
         snapshot.progress_epoch = self.progress_epoch;
 
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
index b33a45fe79e..c148c5152a0 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
@@ -3156,6 +3156,78 @@ fn a_new_staging_attempt_can_truthfully_restart_committed_progress() {
     assert_eq!(slot.snapshot().expect("unchanged latest").committed_pages, 2);
 }
 
+#[test]
+fn staging_restart_cannot_rebind_the_progress_source_or_incarnation() {
+    let generation = CodeGenerationId::new("generation.report-identity").expect("generation");
+    let mut slot = super::super::CodeIndexBuildProgressSlotStateV1::default();
+    let owner = slot.replace_generation(generation.clone());
+    assert!(slot.publish(
+        &generation,
+        owner,
+        progress_snapshot_for_generation(&generation, 4),
+    ));
+    let accepted = slot.snapshot().expect("first committed report");
+
+    // All three publication identities must be checked independently, not
+    // merely against the generation name in the supplied owner token.
+    for field in ["daemon", "producer", "digest"] {
+        let mut foreign = progress_snapshot_for_generation(&generation, 5);
+        match field {
+            "daemon" => foreign.daemon_incarnation += 1,
+            "producer" => foreign.producer_incarnation += 1,
+            "digest" => foreign.sealed_source_digest =
+                format!("sha256:{}", "b".repeat(64)),
+            _ => unreachable!(),
+        }
+        assert!(
+            !slot.publish(&generation, owner, foreign),
+            "foreign {field} must not replace a committed report"
+        );
+        assert_eq!(
+            slot.snapshot().expect("unchanged committed report").as_ref(),
+            accepted.as_ref()
+        );
+    }
+
+    assert!(slot.begin_staging_attempt(&generation, owner));
+    assert!(slot.snapshot().is_none(), "verified restart clears old counters");
+    for field in ["daemon", "producer", "digest"] {
+        let mut foreign = progress_snapshot_for_generation(&generation, 0);
+        match field {
+            "daemon" => foreign.daemon_incarnation += 1,
+            "producer" => foreign.producer_incarnation += 1,
+            "digest" => foreign.sealed_source_digest =
+                format!("sha256:{}", "b".repeat(64)),
+            _ => unreachable!(),
+        }
+        assert!(
+            !slot.publish(&generation, owner, foreign),
+            "staging reset must retain the {field} identity fence"
+        );
+        assert!(slot.snapshot().is_none(), "foreign report must not seize restart");
+    }
+
+    // A real retry may still reset counters while preserving the identity.
+    assert!(slot.publish(
+        &generation,
+        owner,
+        progress_snapshot_for_generation(&generation, 0),
+    ));
+    let resumed = slot.snapshot().expect("verified restart");
+    assert_eq!(resumed.committed_pages, 0);
+    assert!(resumed.progress_epoch > accepted.progress_epoch);
+
+    // Replacing the scheduler owner permits a genuinely new incarnation.
+    let next_owner = slot.replace_generation(generation.clone());
+    let mut replaced = progress_snapshot_for_generation(&generation, 1);
+    replaced.producer_incarnation += 1;
+    assert!(slot.publish(&generation, next_owner, replaced));
+    assert_eq!(
+        slot.snapshot().expect("replacement owner").producer_incarnation,
+        2
+    );
+}
+
 #[test]
 fn retrying_an_unchanged_phase_does_not_fabricate_status_progress() {
     let fixture = GitFixture::new(&[(

From 6dc0f5804450f9b1fe4a510e5b2958771949c5c5 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 17:17:51 -0800
Subject: [PATCH 03/80] fix(code-index): ignore progress reports without new
 work

---
 .../src/code_index_scheduler/serving.rs       | 21 +++++
 .../tests/code_index_scheduler/serving.rs     | 80 +++++++++++++++++++
 2 files changed, 101 insertions(+)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
index b91cd06c542..f8f5f2189bb 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
@@ -261,6 +261,27 @@ impl CodeIndexBuildProgressSlotStateV1 {
                 return false;
             }
         }
+        // A new observation must be backed by a changed pipeline boundary,
+        // accepted source work, or a changed refusal. Elapsed time, a rate
+        // resample, or another reading of the same committed cursor is not
+        // progress; renewing its timestamp defeats stall detection.
+        if let Some(current) = self.snapshot.as_ref() {
+            if snapshot.phase == current.phase
+                && snapshot.committed_pages == current.committed_pages
+                && snapshot.committed_chunks == current.committed_chunks
+                && snapshot.committed_imports == current.committed_imports
+                && snapshot.committed_payload_bytes == current.committed_payload_bytes
+                && snapshot.completed_files == current.completed_files
+                && snapshot.total_files == current.total_files
+                && snapshot.completed_lexical_units == current.completed_lexical_units
+                && snapshot.total_lexical_units == current.total_lexical_units
+                && snapshot.current_batch_pages == current.current_batch_pages
+                && snapshot.current_batch_payload_bytes == current.current_batch_payload_bytes
+                && snapshot.blocked_reason == current.blocked_reason
+            {
+                return false;
+            }
+        }
         // The next producer may have assembled its report before an earlier
         // producer acquired the lock. Keep the owner's latest observed time
         // even across a verified staging restart (which clears the snapshot).
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
index c148c5152a0..de2074aa2a0 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
@@ -3041,6 +3041,86 @@ fn progress_timestamp_never_regresses_within_one_owner() {
     assert_eq!(slot.snapshot().unwrap().last_progress_micros, 42);
 }
 
+#[test]
+fn unchanged_progress_resampling_cannot_renew_the_work_clock() {
+    let generation = CodeGenerationId::new("generation.idle-report").expect("generation");
+    let mut slot = super::super::CodeIndexBuildProgressSlotStateV1::default();
+    let owner = slot.replace_generation(generation.clone());
+
+    let mut first = progress_snapshot_for_generation(&generation, 3);
+    first.last_progress_micros = 100;
+    assert!(slot.publish(&generation, owner, first));
+    let accepted = slot.snapshot().expect("initial committed progress");
+
+    // Retrying an already committed cursor may resample duration, throughput,
+    // and latency. None proves new work or should revive a stalled generation.
+    let mut idle = accepted.as_ref().clone();
+    idle.elapsed_micros += 1_000;
+    idle.last_progress_micros = 10_000;
+    idle.last_commit_latency_micros = Some(99);
+    idle.files_per_second = Some(12.0);
+    idle.lexical_units_per_second = Some(21.0);
+    idle.estimated_remaining_seconds = Some(5);
+    assert!(!slot.publish(&generation, owner, idle));
+    assert_eq!(
+        slot.snapshot().expect("idle must not publish").as_ref(),
+        accepted.as_ref(),
+        "elapsed time or a new estimate must not refresh a frozen progress epoch"
+    );
+
+    // Authenticated scan work, a phase transition, a durable commit, and a
+    // new refusal are each independently observable progress/state boundaries.
+    let mut scanned = accepted.as_ref().clone();
+    scanned.completed_lexical_units += 1;
+    scanned.last_progress_micros = 200;
+    assert!(slot.publish(&generation, owner, scanned));
+    let scan = slot.snapshot().expect("source scan");
+    assert!(scan.progress_epoch > accepted.progress_epoch);
+    assert_eq!(scan.last_progress_micros, 200);
+
+    let mut phase = scan.as_ref().clone();
+    phase.phase = CodeIndexBuildPhaseV1::IndexBuild;
+    phase.last_progress_micros = 300;
+    assert!(slot.publish(&generation, owner, phase));
+    let phase = slot.snapshot().expect("new phase");
+    assert!(phase.progress_epoch > scan.progress_epoch);
+
+    let mut committed = phase.as_ref().clone();
+    committed.committed_pages += 1;
+    committed.committed_chunks += 1;
+    committed.committed_payload_bytes += 1;
+    committed.completed_files += 1;
+    committed.completed_lexical_units += 1;
+    committed.last_progress_micros = 400;
+    assert!(slot.publish(&generation, owner, committed));
+    let committed = slot.snapshot().expect("new committed page");
+    assert!(committed.progress_epoch > phase.progress_epoch);
+
+    let mut refused = committed.as_ref().clone();
+    refused.blocked_reason = Some(CodeIndexBuildBlockedReasonV1::ResidentMemory);
+    refused.last_progress_micros = 500;
+    assert!(slot.publish(&generation, owner, refused));
+    let blocked = slot.snapshot().expect("new refusal");
+    assert!(blocked.progress_epoch > committed.progress_epoch);
+
+    let mut repeated = blocked.as_ref().clone();
+    repeated.last_progress_micros = 600;
+    assert!(!slot.publish(&generation, owner, repeated));
+    assert_eq!(
+        slot.snapshot().expect("same refusal").as_ref(),
+        blocked.as_ref()
+    );
+
+    let mut recovered = blocked.as_ref().clone();
+    recovered.phase = CodeIndexBuildPhaseV1::Ready;
+    recovered.blocked_reason = None;
+    recovered.last_progress_micros = 700;
+    assert!(slot.publish(&generation, owner, recovered));
+    let ready = slot.snapshot().expect("recovered ready");
+    assert!(ready.progress_epoch > blocked.progress_epoch);
+    assert_eq!(ready.blocked_reason, None);
+}
+
 #[test]
 fn delayed_progress_cannot_undo_committed_boundaries_or_ready() {
     let generation = CodeGenerationId::new("generation.stale-progress").expect("generation");

From 28c1d73786000a9b5361d5e0f49c9fb96f094289 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 17:29:41 -0800
Subject: [PATCH 04/80] style(code-index): format progress boundary regressions

---
 .../src/code_index_scheduler/serving.rs       |  3 +-
 .../tests/code_index_scheduler/serving.rs     | 56 ++++++++++++++-----
 2 files changed, 42 insertions(+), 17 deletions(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
index f8f5f2189bb..9076cfa6b15 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
@@ -2781,8 +2781,7 @@ impl LatestCodeTextGenerationV1 {
                 if current.phase == phase
                     && current.current_batch_pages == current_batch_pages
                     && current.current_batch_payload_bytes == current_batch_payload_bytes
-                    && !(phase == CodeIndexBuildPhaseV1::Ready
-                        && current.blocked_reason.is_some())
+                    && !(phase == CodeIndexBuildPhaseV1::Ready && current.blocked_reason.is_some())
                 {
                     return;
                 }
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
index de2074aa2a0..afa6f88e05a 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/serving.rs
@@ -3148,7 +3148,9 @@ fn delayed_progress_cannot_undo_committed_boundaries_or_ready() {
             "delayed {counter} cannot overwrite committed progress"
         );
         assert_eq!(
-            slot.snapshot().expect("progress after stale report").as_ref(),
+            slot.snapshot()
+                .expect("progress after stale report")
+                .as_ref(),
             accepted.as_ref(),
             "refusing stale {counter} must preserve the epoch and last progress time"
         );
@@ -3158,7 +3160,9 @@ fn delayed_progress_cannot_undo_committed_boundaries_or_ready() {
     wrong_generation.generation_id = "generation.foreign".to_owned();
     assert!(!slot.publish(&generation, owner, wrong_generation));
     assert_eq!(
-        slot.snapshot().expect("correct generation still owns progress").as_ref(),
+        slot.snapshot()
+            .expect("correct generation still owns progress")
+            .as_ref(),
         accepted.as_ref()
     );
 
@@ -3201,7 +3205,10 @@ fn a_new_staging_attempt_can_truthfully_restart_committed_progress() {
     let mut old = progress_snapshot_for_generation(&generation, 12);
     old.last_progress_micros = 500;
     assert!(slot.publish(&generation, owner, old));
-    let old_epoch = slot.snapshot().expect("first staging attempt").progress_epoch;
+    let old_epoch = slot
+        .snapshot()
+        .expect("first staging attempt")
+        .progress_epoch;
 
     // Missing/incompatible SQLite staging is a verified new build attempt,
     // not a delayed report from an older commit boundary. Without resetting
@@ -3233,7 +3240,10 @@ fn a_new_staging_attempt_can_truthfully_restart_committed_progress() {
     let foreign = CodeGenerationId::new("generation.foreign-stage").expect("foreign");
     assert!(!slot.begin_staging_attempt(&foreign, owner));
     assert!(!slot.begin_staging_attempt(&generation, owner + 1));
-    assert_eq!(slot.snapshot().expect("unchanged latest").committed_pages, 2);
+    assert_eq!(
+        slot.snapshot().expect("unchanged latest").committed_pages,
+        2
+    );
 }
 
 #[test]
@@ -3255,8 +3265,7 @@ fn staging_restart_cannot_rebind_the_progress_source_or_incarnation() {
         match field {
             "daemon" => foreign.daemon_incarnation += 1,
             "producer" => foreign.producer_incarnation += 1,
-            "digest" => foreign.sealed_source_digest =
-                format!("sha256:{}", "b".repeat(64)),
+            "digest" => foreign.sealed_source_digest = format!("sha256:{}", "b".repeat(64)),
             _ => unreachable!(),
         }
         assert!(
@@ -3264,27 +3273,34 @@ fn staging_restart_cannot_rebind_the_progress_source_or_incarnation() {
             "foreign {field} must not replace a committed report"
         );
         assert_eq!(
-            slot.snapshot().expect("unchanged committed report").as_ref(),
+            slot.snapshot()
+                .expect("unchanged committed report")
+                .as_ref(),
             accepted.as_ref()
         );
     }
 
     assert!(slot.begin_staging_attempt(&generation, owner));
-    assert!(slot.snapshot().is_none(), "verified restart clears old counters");
+    assert!(
+        slot.snapshot().is_none(),
+        "verified restart clears old counters"
+    );
     for field in ["daemon", "producer", "digest"] {
         let mut foreign = progress_snapshot_for_generation(&generation, 0);
         match field {
             "daemon" => foreign.daemon_incarnation += 1,
             "producer" => foreign.producer_incarnation += 1,
-            "digest" => foreign.sealed_source_digest =
-                format!("sha256:{}", "b".repeat(64)),
+            "digest" => foreign.sealed_source_digest = format!("sha256:{}", "b".repeat(64)),
             _ => unreachable!(),
         }
         assert!(
             !slot.publish(&generation, owner, foreign),
             "staging reset must retain the {field} identity fence"
         );
-        assert!(slot.snapshot().is_none(), "foreign report must not seize restart");
+        assert!(
+            slot.snapshot().is_none(),
+            "foreign report must not seize restart"
+        );
     }
 
     // A real retry may still reset counters while preserving the identity.
@@ -3303,7 +3319,9 @@ fn staging_restart_cannot_rebind_the_progress_source_or_incarnation() {
     replaced.producer_incarnation += 1;
     assert!(slot.publish(&generation, next_owner, replaced));
     assert_eq!(
-        slot.snapshot().expect("replacement owner").producer_incarnation,
+        slot.snapshot()
+            .expect("replacement owner")
+            .producer_incarnation,
         2
     );
 }
@@ -3323,7 +3341,9 @@ fn retrying_an_unchanged_phase_does_not_fabricate_status_progress() {
     published(scheduler.reconcile_now().expect("publish"));
     let latest = scheduler.latest_complete().expect("latest generation");
     assert!(
-        !latest.advance_text_serving(0).expect("open text projection"),
+        !latest
+            .advance_text_serving(0)
+            .expect("open text projection"),
         "a zero-work admission must leave the projection pending"
     );
     let before = build_progress_snapshot(&scheduler);
@@ -3362,10 +3382,16 @@ fn retrying_an_unchanged_phase_does_not_fabricate_status_progress() {
     );
     let unchanged = build_progress_snapshot(&scheduler);
     assert_eq!(unchanged.progress_epoch, transitioned.progress_epoch);
-    assert_eq!(unchanged.last_progress_micros, transitioned.last_progress_micros);
+    assert_eq!(
+        unchanged.last_progress_micros,
+        transitioned.last_progress_micros
+    );
 
     let mut advances = 0;
-    while !latest.advance_text_serving(8).expect("resume durable text build") {
+    while !latest
+        .advance_text_serving(8)
+        .expect("resume durable text build")
+    {
         advances += 1;
         assert!(advances < 1_000, "text build failed to finish");
     }

From 29c1258b8f491def3cf34c5cd6e4b4a6b5e194f6 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 18:23:51 -0800
Subject: [PATCH 05/80] fix(code-index): satisfy Clippy for progress guards

---
 .../src/code_index_scheduler/serving.rs       | 42 +++++++++----------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
index 9076cfa6b15..5b7773f1209 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/serving.rs
@@ -239,13 +239,12 @@ impl CodeIndexBuildProgressSlotStateV1 {
         // The same scheduler owner may rebuild its SQLite staging file, but
         // it must not change the sealed source or the report incarnation.
         // Keep this binding even when begin_staging_attempt clears counters.
-        if let Some((daemon, producer, digest)) = self.progress_identity.as_ref() {
-            if *daemon != snapshot.daemon_incarnation
+        if let Some((daemon, producer, digest)) = self.progress_identity.as_ref()
+            && (*daemon != snapshot.daemon_incarnation
                 || *producer != snapshot.producer_incarnation
-                || digest != &snapshot.sealed_source_digest
-            {
-                return false;
-            }
+                || digest != &snapshot.sealed_source_digest)
+        {
+            return false;
         }
         if let Some(current) = self.snapshot.as_ref() {
             // Concurrent phase/report producers may complete out of order.
@@ -265,22 +264,21 @@ impl CodeIndexBuildProgressSlotStateV1 {
         // accepted source work, or a changed refusal. Elapsed time, a rate
         // resample, or another reading of the same committed cursor is not
         // progress; renewing its timestamp defeats stall detection.
-        if let Some(current) = self.snapshot.as_ref() {
-            if snapshot.phase == current.phase
-                && snapshot.committed_pages == current.committed_pages
-                && snapshot.committed_chunks == current.committed_chunks
-                && snapshot.committed_imports == current.committed_imports
-                && snapshot.committed_payload_bytes == current.committed_payload_bytes
-                && snapshot.completed_files == current.completed_files
-                && snapshot.total_files == current.total_files
-                && snapshot.completed_lexical_units == current.completed_lexical_units
-                && snapshot.total_lexical_units == current.total_lexical_units
-                && snapshot.current_batch_pages == current.current_batch_pages
-                && snapshot.current_batch_payload_bytes == current.current_batch_payload_bytes
-                && snapshot.blocked_reason == current.blocked_reason
-            {
-                return false;
-            }
+        if let Some(current) = self.snapshot.as_ref()
+            && snapshot.phase == current.phase
+            && snapshot.committed_pages == current.committed_pages
+            && snapshot.committed_chunks == current.committed_chunks
+            && snapshot.committed_imports == current.committed_imports
+            && snapshot.committed_payload_bytes == current.committed_payload_bytes
+            && snapshot.completed_files == current.completed_files
+            && snapshot.total_files == current.total_files
+            && snapshot.completed_lexical_units == current.completed_lexical_units
+            && snapshot.total_lexical_units == current.total_lexical_units
+            && snapshot.current_batch_pages == current.current_batch_pages
+            && snapshot.current_batch_payload_bytes == current.current_batch_payload_bytes
+            && snapshot.blocked_reason == current.blocked_reason
+        {
+            return false;
         }
         // The next producer may have assembled its report before an earlier
         // producer acquired the lock. Keep the owner's latest observed time

From 9f3bfe04cbac4dee01979cd44791d57c5a68b99c Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 19:26:29 -0800
Subject: [PATCH 06/80] fix(dashboard): keep unreported code-index builds
 observable

Keep active polling for in-flight rebuilds and lexical artifact restores,
even when the serving envelope or previous generation is already ready.
Do not render an in-flight build without a report as an idle pipeline.

Add polling regressions and DOM transition coverage for unreported work,
committed progress, completion, and bounded artifact restoration.

Refs #4508
---
 .../CodeIndexPipeline.dom.test.tsx            | 238 ++++++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         |  14 +-
 2 files changed, 250 insertions(+), 2 deletions(-)
 create mode 100644 dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx

diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
new file mode 100644
index 00000000000..bc61e12ca98
--- /dev/null
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -0,0 +1,238 @@
+import { cleanup, render, screen } from '@testing-library/react';
+import { afterEach, describe, expect, it } from 'vitest';
+import type {
+  CodeIndexBuildProgressV1,
+  CodeIndexFreshnessPayloadV1,
+  CodeIndexWorktreeFreshnessV1,
+} from '../../contracts/generated.ts';
+import type { EnvelopeResult } from '../../data/query/envelope.ts';
+import { CodeIndexPipeline, hasActiveCodeIndexBuild } from './CodeIndexPipeline.tsx';
+
+type FreshnessResult = Extract<
+  EnvelopeResult<CodeIndexFreshnessPayloadV1>,
+  { outcome: 'envelope' }
+>;
+
+const GENERATION = 'generation.progress';
+const OBSERVED_AT = 1_753_003_600_000_000;
+
+function progress(overrides: Partial<CodeIndexBuildProgressV1> = {}): CodeIndexBuildProgressV1 {
+  return {
+    generation_id: GENERATION,
+    daemon_incarnation: 1,
+    producer_incarnation: 1,
+    progress_epoch: 1,
+    sealed_source_digest: 'sha256:sealed-source',
+    phase: 'bulk_commit',
+    committed_pages: 2,
+    committed_chunks: 2,
+    committed_imports: 0,
+    committed_payload_bytes: 128,
+    completed_files: 2,
+    total_files: 10,
+    completed_lexical_units: 2,
+    total_lexical_units: 10,
+    current_batch_pages: 0,
+    current_batch_payload_bytes: 0,
+    elapsed_micros: 1_000_000,
+    last_commit_latency_micros: 100,
+    files_per_second: null,
+    lexical_units_per_second: null,
+    estimated_remaining_seconds: null,
+    last_progress_micros: OBSERVED_AT,
+    blocked_reason: null,
+    ...overrides,
+  };
+}
+
+function worktree(
+  overrides: Partial<CodeIndexWorktreeFreshnessV1> = {},
+): CodeIndexWorktreeFreshnessV1 {
+  return {
+    worktree_root: '/project',
+    repository_id: 'repository.project',
+    worktree_id: 'worktree.primary',
+    source_reference: 'refs/heads/master',
+    source_revision: null,
+    latest_generation_id: GENERATION,
+    code_graph_serving: { state: 'ready' },
+    clone_index: null,
+    snapshot_content_identity: 'sha256:source',
+    sealed_at_micros: OBSERVED_AT,
+    last_reconcile_micros: OBSERVED_AT,
+    staleness_state: 'fresh',
+    rebuild_in_flight: false,
+    hook_hint_count: 0,
+    coverage: 'complete',
+    progress: null,
+    restore_progress: null,
+    parked: null,
+    ...overrides,
+  };
+}
+
+function freshness(
+  overrides: Partial<CodeIndexWorktreeFreshnessV1> = {},
+  domainState: 'ready' | 'loading' = 'ready',
+): FreshnessResult {
+  return {
+    outcome: 'envelope',
+    envelope: {
+      schema_revision: 1,
+      scope: { project_id: 'project', storage_mode: 'project', store_root: '/store' },
+      version: { entity_version: null, graph_version: null },
+      time: { valid_time_micros: null, observation_time_micros: OBSERVED_AT },
+      source_watermark: null,
+      authorization: { outcome: 'authorized' },
+      coverage: {
+        completeness: 'complete',
+        eligible: 1,
+        examined: 1,
+        matched: 1,
+        excluded: 0,
+        omitted: 0,
+        unknown: 0,
+        denominator: 1,
+        unit: 'mounted_worktree',
+        omission_reasons: [],
+      },
+      freshness: { state: 'fresh', observed_at_micros: OBSERVED_AT, watermark: null },
+      domain_state: domainState,
+      legal_actions: [],
+      payload: {
+        worktrees: [worktree(overrides)],
+        note: 'daemon scheduler state',
+      },
+    },
+  };
+}
+
+const restoreProgress = {
+  generation_id: GENERATION,
+  artifact_digest: 'sha256:artifact',
+  authenticated_completed: 2,
+  authenticated_total: 5,
+  authenticated_remaining: 3,
+};
+
+afterEach(cleanup);
+
+describe('code-index activity polling', () => {
+  it('keeps polling an in-flight rebuild before its first committed report', () => {
+    expect(hasActiveCodeIndexBuild(freshness({ rebuild_in_flight: true }))).toBe(true);
+  });
+
+  it('does not let the previous ready report hide an in-flight successor', () => {
+    expect(hasActiveCodeIndexBuild(freshness({
+      rebuild_in_flight: true,
+      progress: progress({ phase: 'ready' }),
+    }))).toBe(true);
+  });
+
+  it('keeps polling a restore even when serving readiness is ready', () => {
+    expect(hasActiveCodeIndexBuild(freshness({ restore_progress: restoreProgress }))).toBe(true);
+  });
+
+  it('observes active work after an idle worktree in an aggregate read', () => {
+    const result = freshness();
+    result.envelope.payload.worktrees.push(worktree({
+      worktree_root: '/project/linked',
+      rebuild_in_flight: true,
+    }));
+    expect(hasActiveCodeIndexBuild(result)).toBe(true);
+  });
+
+  it('keeps polling measured graph publication', () => {
+    expect(hasActiveCodeIndexBuild(freshness({
+      progress: progress({ phase: 'graph_publication' }),
+    }))).toBe(true);
+  });
+
+  it('keeps polling a loading envelope before a worktree mounts', () => {
+    const result = freshness({}, 'loading');
+    result.envelope.payload.worktrees = [];
+    expect(hasActiveCodeIndexBuild(result)).toBe(true);
+  });
+
+  it('stops active polling after the generation settles', () => {
+    expect(hasActiveCodeIndexBuild(freshness({
+      progress: progress({ phase: 'ready' }),
+    }))).toBe(false);
+  });
+
+  it('stops active polling after the final report retires', () => {
+    expect(hasActiveCodeIndexBuild(freshness())).toBe(false);
+  });
+
+  it('does not invent activity for a ready empty scope', () => {
+    const result = freshness();
+    result.envelope.payload.worktrees = [];
+    expect(hasActiveCodeIndexBuild(result)).toBe(false);
+  });
+
+  it('does not invent activity before a response arrives', () => {
+    expect(hasActiveCodeIndexBuild(undefined)).toBe(false);
+  });
+
+  it('does not turn a transport failure into claimed build activity', () => {
+    expect(hasActiveCodeIndexBuild({ outcome: 'transport', state: 'error' })).toBe(false);
+  });
+});
+
+describe('code-index progress transitions', () => {
+  it('renders unreported capture, committed progress, and completion without inventing counters', async () => {
+    const cold = freshness({
+      latest_generation_id: null,
+      snapshot_content_identity: null,
+      sealed_at_micros: null,
+      rebuild_in_flight: true,
+      staleness_state: 'indexing',
+      code_graph_serving: { state: 'pending' },
+    }, 'loading');
+    const view = render(<CodeIndexPipeline result={cold} pending={false} scopeKey="project" />);
+    expect(screen.getByText('code-index build in progress; progress not yet reported')).toBeTruthy();
+    expect(screen.queryByText('no active code-index build')).toBeNull();
+    expect(screen.queryByRole('progressbar')).toBeNull();
+
+    const building = freshness({ rebuild_in_flight: true, progress: progress() }, 'loading');
+    view.rerender(<CodeIndexPipeline result={building} pending={false} scopeKey="project" />);
+    expect(await screen.findByText('bulk commit · 20.0%')).toBeTruthy();
+    expect(screen.getByRole('progressbar').getAttribute('value')).toBe('20');
+    expect(screen.queryByText('code-index build in progress; progress not yet reported')).toBeNull();
+
+    const completed = freshness({
+      progress: progress({
+        phase: 'ready',
+        progress_epoch: 2,
+        committed_pages: 10,
+        committed_chunks: 10,
+        completed_files: 10,
+        completed_lexical_units: 10,
+      }),
+    });
+    view.rerender(<CodeIndexPipeline result={completed} pending={false} scopeKey="project" />);
+    expect(await screen.findByText('ready · 100.0%')).toBeTruthy();
+    expect(hasActiveCodeIndexBuild(completed)).toBe(false);
+
+    view.rerender(<CodeIndexPipeline result={freshness()} pending={false} scopeKey="project" />);
+    expect(await screen.findByText('no active code-index build')).toBeTruthy();
+    expect(screen.queryByRole('progressbar')).toBeNull();
+  });
+
+  it('keeps restore checks separate from build counters and stops polling after restoration', async () => {
+    const restoring = freshness({ restore_progress: restoreProgress });
+    const view = render(<CodeIndexPipeline result={restoring} pending={false} scopeKey="project" />);
+    expect(screen.getByText('restoring lexical artifact')).toBeTruthy();
+    expect(screen.getByText('3 authentication checks remaining')).toBeTruthy();
+    expect(screen.getByRole('progressbar').getAttribute('value')).toBe('2');
+    expect(screen.getByRole('progressbar').getAttribute('max')).toBe('5');
+    expect(screen.queryByText('no active code-index build')).toBeNull();
+    expect(hasActiveCodeIndexBuild(restoring)).toBe(true);
+
+    const restored = freshness();
+    view.rerender(<CodeIndexPipeline result={restored} pending={false} scopeKey="project" />);
+    expect(await screen.findByText('no active code-index build')).toBeTruthy();
+    expect(screen.queryByRole('progressbar')).toBeNull();
+    expect(hasActiveCodeIndexBuild(restored)).toBe(false);
+  });
+});
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index 5a3704cdfe5..571d7eb4d38 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -74,7 +74,11 @@ export function CodeIndexPipeline({
       ) : null}
       {progress.length === 0 ? (
         worktrees.some((worktree) => worktree.restore_progress != null) ? null : (
-          <p className="mt-2 text-body text-text-muted">no active code-index build</p>
+          <p className="mt-2 text-body text-text-muted">
+            {worktrees.some((worktree) => worktree.rebuild_in_flight)
+              ? 'code-index build in progress; progress not yet reported'
+              : 'no active code-index build'}
+          </p>
         )
       ) : (
         <div className="mt-2 flex flex-col gap-2">
@@ -217,6 +221,9 @@ function CodeIndexBuildCard({ progress }: { progress: CodeIndexBuildProgressV1 }
   );
 }
 
+// Serving readiness can describe the previous generation while its successor
+// is still capturing sources, or while a lexical artifact is being restored.
+// Neither operation is required to have a committed build-progress report yet.
 export function hasActiveCodeIndexBuild(
   result: EnvelopeResult<CodeIndexFreshnessPayloadV1> | undefined,
 ): boolean {
@@ -224,7 +231,10 @@ export function hasActiveCodeIndexBuild(
     result?.outcome === 'envelope' &&
     (result.envelope.domain_state !== 'ready' ||
       result.envelope.payload.worktrees.some(
-        (worktree) => worktree.progress != null && worktree.progress.phase !== 'ready',
+        (worktree) =>
+          worktree.rebuild_in_flight ||
+          worktree.restore_progress != null ||
+          (worktree.progress != null && worktree.progress.phase !== 'ready'),
       ))
   );
 }

From 0fc10fed2121688077c5427072b495ee0f393690 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 19:37:43 -0800
Subject: [PATCH 07/80] fix(mcp): preserve indexing progress authority in
 search status

Carry daemon/producer epochs, generation, last-progress time, committed text counters and blocked reason into MCP search and graph-read summaries. Distinguish absent progress from reported zero work without inventing pre-seal authority. Add nonzero rendering regressions for repeated reads, blocked recovery and restart/remount epoch scope.

Refs #4508. Producer instrumentation and cold/restart end-to-end acceptance remain incomplete; no Bazel execution is claimed.
---
 .../src/handlers/graph/search_freshness.rs    | 213 +++++++++++++++---
 1 file changed, 181 insertions(+), 32 deletions(-)

diff --git a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
index 7229dbaaff8..9ca096af6a9 100644
--- a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
+++ b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
@@ -13,8 +13,8 @@
 use std::fmt::Write as _;
 
 use tracedecay_contracts::code_index_freshness::{
-    CodeIndexBuildPhaseV1, CodeIndexFreshnessPayloadV1, CodeIndexStalenessStateV1,
-    CodeIndexWorktreeFreshnessV1,
+    CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexFreshnessPayloadV1,
+    CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::retrieval::{
     CodeGraphReadFreshnessV1, PrimitiveFreshnessStateV1, PrimitiveIndexingStateV1,
@@ -65,6 +65,18 @@ fn phase_label(phase: CodeIndexBuildPhaseV1) -> &'static str {
     }
 }
 
+fn blocked_reason_label(reason: CodeIndexBuildBlockedReasonV1) -> &'static str {
+    match reason {
+        CodeIndexBuildBlockedReasonV1::ResidentMemory => "resident_memory",
+        CodeIndexBuildBlockedReasonV1::SourceUnavailable => "source_unavailable",
+        CodeIndexBuildBlockedReasonV1::ArtifactStoreUnavailable => "artifact_store_unavailable",
+        CodeIndexBuildBlockedReasonV1::RetryBackoff => "retry_backoff",
+        CodeIndexBuildBlockedReasonV1::PublicationAuthorityCorrupt => {
+            "publication_authority_corrupt"
+        }
+    }
+}
+
 fn stale_lanes(coverage: &CodeIndexSearchCoverageV1) -> Vec<String> {
     [
         ("exact", &coverage.exact),
@@ -201,13 +213,34 @@ pub(super) fn search_freshness(
             let _ = write!(summary, " pending_hook_hints={hints}");
         }
         if let Some(progress) = &state.progress {
+            // Keep the producer's identity and clock. Reading a response is
+            // not work, and an epoch is comparable only within its owner.
+            // These are text-artifact commits, not native graph writes even
+            // when graph publication is the phase currently being observed.
             let _ = write!(
                 summary,
-                " progress={} {}/{} files",
+                " progress={} {}/{} files progress_generation={} \
+                 progress_owner={}:{} progress_epoch={} last_progress_micros={} \
+                 committed_text_pages={} committed_text_chunks={} \
+                 committed_text_imports={} committed_text_payload_bytes={} blocked={}",
                 phase_label(progress.phase),
                 progress.completed_files,
-                progress.total_files
+                progress.total_files,
+                progress.generation_id,
+                progress.daemon_incarnation,
+                progress.producer_incarnation,
+                progress.progress_epoch,
+                progress.last_progress_micros,
+                progress.committed_pages,
+                progress.committed_chunks,
+                progress.committed_imports,
+                progress.committed_payload_bytes,
+                progress.blocked_reason.map_or("none", blocked_reason_label)
             );
+        } else if state.rebuild_in_flight {
+            // No sealed progress report exists during an initial capture.
+            // Do not fabricate a generation, count, clock, or running verdict.
+            summary.push_str(" progress=unreported");
         }
     }
     if !stale_lanes.is_empty() {
@@ -299,6 +332,52 @@ mod tests {
         }))
     }
 
+    fn committed_progress() -> CodeIndexBuildProgressV1 {
+        CodeIndexBuildProgressV1 {
+            generation_id: "generation.next".to_owned(),
+            daemon_incarnation: 3,
+            producer_incarnation: 7,
+            progress_epoch: 11,
+            sealed_source_digest: format!("sha256:{}", "a".repeat(64)),
+            phase: CodeIndexBuildPhaseV1::BulkCommit,
+            committed_pages: 2,
+            committed_chunks: 13,
+            committed_imports: 3,
+            committed_payload_bytes: 2048,
+            completed_files: 250,
+            total_files: 500,
+            completed_lexical_units: 250,
+            total_lexical_units: 500,
+            current_batch_pages: 0,
+            current_batch_payload_bytes: 0,
+            elapsed_micros: 100,
+            last_commit_latency_micros: Some(12),
+            files_per_second: None,
+            lexical_units_per_second: None,
+            estimated_remaining_seconds: None,
+            last_progress_micros: 120,
+            blocked_reason: None,
+        }
+    }
+
+    fn rendering_progress(progress: CodeIndexBuildProgressV1) -> String {
+        let state = CodeIndexWorktreeFreshnessV1 {
+            worktree_root: "/fixture".to_owned(),
+            staleness_state: Some(CodeIndexStalenessStateV1::Indexing),
+            rebuild_in_flight: true,
+            coverage: CodeIndexFreshnessCoverageV1::Complete,
+            progress: Some(progress),
+            ..CodeIndexWorktreeFreshnessV1::default()
+        };
+        freshness_lines(&search_freshness(
+            ServedGenerationV1::Unavailable {
+                reason: "generation_unavailable",
+            },
+            &CodeIndexSearchCoverageV1::unavailable("generation_rebuilding"),
+            &WorktreeFreshnessSourceV1::Worktree(Box::new(state)),
+        ))
+    }
+
     #[test]
     fn settled_generation_is_fresh_when_lanes_and_scheduler_agree() {
         let freshness = search_freshness(
@@ -347,7 +426,7 @@ mod tests {
                 .as_ref()
                 .map(|indexing| indexing.summary.as_str()),
             Some(
-                "state=refreshing rebuild_in_flight=true served_generation=generation.1 latest_generation=generation.1"
+                "state=refreshing rebuild_in_flight=true served_generation=generation.1 latest_generation=generation.1 progress=unreported"
             )
         );
 
@@ -379,39 +458,15 @@ mod tests {
 
     #[test]
     fn unavailable_search_reports_the_indexing_state_with_progress() {
-        let mut state = CodeIndexWorktreeFreshnessV1 {
+        let state = CodeIndexWorktreeFreshnessV1 {
             worktree_root: "/fixture".to_owned(),
             staleness_state: Some(CodeIndexStalenessStateV1::Indexing),
             rebuild_in_flight: true,
             hook_hint_count: Some(3),
             coverage: CodeIndexFreshnessCoverageV1::Complete,
+            progress: Some(committed_progress()),
             ..CodeIndexWorktreeFreshnessV1::default()
         };
-        state.progress = Some(CodeIndexBuildProgressV1 {
-            generation_id: "generation.next".to_owned(),
-            daemon_incarnation: 1,
-            producer_incarnation: 1,
-            progress_epoch: 1,
-            sealed_source_digest: "sha256:fixture".to_owned(),
-            phase: CodeIndexBuildPhaseV1::BulkCommit,
-            committed_pages: 0,
-            committed_chunks: 0,
-            committed_imports: 0,
-            committed_payload_bytes: 0,
-            completed_files: 250,
-            total_files: 500,
-            completed_lexical_units: 0,
-            total_lexical_units: 0,
-            current_batch_pages: 0,
-            current_batch_payload_bytes: 0,
-            elapsed_micros: 0,
-            last_commit_latency_micros: None,
-            files_per_second: None,
-            lexical_units_per_second: None,
-            estimated_remaining_seconds: None,
-            last_progress_micros: 0,
-            blocked_reason: None,
-        });
         let freshness = search_freshness(
             ServedGenerationV1::Unavailable {
                 reason: "generation_unavailable",
@@ -423,12 +478,106 @@ mod tests {
         let indexing = freshness.indexing.expect("indexing line");
         assert_eq!(
             indexing.summary,
-            "state=indexing rebuild_in_flight=true served_generation=none pending_hook_hints=3 progress=bulk_commit 250/500 files unavailable=generation_unavailable"
+            "state=indexing rebuild_in_flight=true served_generation=none \
+             pending_hook_hints=3 progress=bulk_commit 250/500 files \
+             progress_generation=generation.next progress_owner=3:7 progress_epoch=11 \
+             last_progress_micros=120 committed_text_pages=2 committed_text_chunks=13 \
+             committed_text_imports=3 committed_text_payload_bytes=2048 blocked=none \
+             unavailable=generation_unavailable"
         );
         assert_eq!(indexing.reason.as_deref(), Some("generation_unavailable"));
         assert_eq!(indexing.stale_lanes.len(), 0);
     }
 
+    #[test]
+    fn cold_unreported_work_has_no_fabricated_progress_authority() {
+        let freshness = search_freshness(
+            ServedGenerationV1::Unavailable {
+                reason: "generation_unavailable",
+            },
+            &CodeIndexSearchCoverageV1::unavailable("generation_rebuilding"),
+            &worktree("indexing", true, None),
+        );
+        assert_eq!(
+            freshness_lines(&freshness),
+            "freshness: possibly_stale\n\
+             indexing: state=indexing rebuild_in_flight=true served_generation=none \
+             progress=unreported unavailable=generation_unavailable\n"
+        );
+    }
+
+    #[test]
+    fn repeated_reads_do_not_turn_elapsed_time_into_progress() {
+        let mut progress = committed_progress();
+        let first = rendering_progress(progress.clone());
+        progress.elapsed_micros = 900_000_000;
+        progress.files_per_second = Some(0.1);
+        progress.estimated_remaining_seconds = Some(2_500);
+        assert_eq!(rendering_progress(progress.clone()), first);
+        assert_eq!(rendering_progress(progress.clone()), first);
+
+        progress.committed_pages += 1;
+        progress.committed_chunks += 2;
+        progress.committed_payload_bytes += 1024;
+        progress.progress_epoch += 1;
+        progress.last_progress_micros = 900_000_120;
+        let advanced = rendering_progress(progress);
+        assert_ne!(advanced, first);
+        assert!(advanced.contains("progress_epoch=12 last_progress_micros=900000120"));
+        assert!(advanced.contains("committed_text_pages=3 committed_text_chunks=15"));
+        assert!(advanced.contains("committed_text_payload_bytes=3072"));
+    }
+
+    #[test]
+    fn blocked_and_recovered_reports_preserve_work_and_name_the_real_phase() {
+        let mut progress = committed_progress();
+        progress.phase = CodeIndexBuildPhaseV1::GraphPublication;
+        progress.completed_files = progress.total_files;
+        progress.completed_lexical_units = progress.total_lexical_units;
+        progress.blocked_reason = Some(CodeIndexBuildBlockedReasonV1::ResidentMemory);
+        progress.progress_epoch += 1;
+        let blocked = rendering_progress(progress.clone());
+        assert!(blocked.contains("progress=graph_publication 500/500 files"));
+        assert!(blocked.contains("progress_epoch=12 last_progress_micros=120"));
+        assert!(blocked.contains("committed_text_pages=2 committed_text_chunks=13"));
+        assert!(blocked.contains("blocked=resident_memory"));
+        assert_eq!(rendering_progress(progress.clone()), blocked);
+
+        progress.blocked_reason = None;
+        progress.progress_epoch += 1;
+        let recovered = rendering_progress(progress.clone());
+        assert!(recovered.contains("progress_epoch=13 last_progress_micros=120"));
+        assert!(recovered.contains("blocked=none"));
+        assert_ne!(recovered, blocked);
+
+        progress.phase = CodeIndexBuildPhaseV1::Ready;
+        progress.progress_epoch += 1;
+        let ready = rendering_progress(progress);
+        assert!(ready.contains("progress=ready 500/500 files"));
+        assert!(ready.contains("progress_epoch=14 last_progress_micros=120"));
+        assert!(!ready.contains("blocked=resident_memory"));
+    }
+
+    #[test]
+    fn restart_and_remount_keep_epoch_scope_visible() {
+        let mut progress = committed_progress();
+        let original = rendering_progress(progress.clone());
+        progress.daemon_incarnation += 1;
+        progress.producer_incarnation = 1;
+        progress.progress_epoch = 1;
+        let restarted = rendering_progress(progress.clone());
+        assert_ne!(restarted, original);
+        assert!(restarted.contains("progress_owner=4:1 progress_epoch=1"));
+        assert!(restarted.contains("last_progress_micros=120 committed_text_pages=2"));
+
+        progress.producer_incarnation += 1;
+        progress.generation_id = "generation.replacement".to_owned();
+        let remounted = rendering_progress(progress);
+        assert_ne!(remounted, restarted);
+        assert!(remounted.contains("progress_generation=generation.replacement"));
+        assert!(remounted.contains("progress_owner=4:2 progress_epoch=1"));
+    }
+
     #[test]
     fn unavailable_search_reports_bounded_restore_progress_without_a_rebuild() {
         let state = CodeIndexWorktreeFreshnessV1 {

From 091bf9d86c8e7dbc1e9bd661fe60a06ea10366ae Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 20:34:44 -0800
Subject: [PATCH 08/80] feat(code-index): record real pre-seal capture and
 parser evidence

Refs #4508. Keep pre-seal work under separately typed attempt authority, not a fictional sealed generation. Capture on clean-HEAD and dirty paths; instrument actual staged parser-backed file work; reject stale, duplicate and delayed callbacks. Durable native-graph work, codegen/wire and restart e2e remain open.
---
 .../tracedecay-application/src/code_index.rs  |  22 +-
 .../src/code_index_scheduler.rs               |   1 +
 .../code_index_scheduler/attempt_progress.rs  | 212 ++++++++++++++++++
 .../code_index_scheduler/git_tree_capture.rs  |  22 +-
 .../src/code_index_scheduler/reconcile.rs     |  39 +++-
 .../tests/code_index_scheduler/reconcile.rs   |  27 +++
 .../src/production/mod.rs                     |  29 +++
 7 files changed, 346 insertions(+), 6 deletions(-)
 create mode 100644 crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs

diff --git a/crates/tracedecay-application/src/code_index.rs b/crates/tracedecay-application/src/code_index.rs
index 57f127399a3..da11de85a0e 100644
--- a/crates/tracedecay-application/src/code_index.rs
+++ b/crates/tracedecay-application/src/code_index.rs
@@ -9,7 +9,8 @@ use tracedecay_contracts::code_index_freshness::CodeIndexConvergenceParkedV1;
 use tracedecay_domain::CodeGenerationId;
 
 use tracedecay_code_index::{
-    chunks::CodeIndexImportEvidenceV1, production::CodeIndexExecutionControlV1,
+    chunks::CodeIndexImportEvidenceV1,
+    production::{CodeIndexExecutionControlV1, CodeIndexPresealWorkV1},
 };
 use tracedecay_runtime_core::resident_memory::{
     ResidentMemoryPressureStateV1, ResidentMemoryPressureV1,
@@ -99,6 +100,7 @@ pub struct DaemonCodeIndexControlV1 {
     pressure: Option<Arc<ResidentMemoryPressureV1>>,
     tripped: Arc<AtomicBool>,
     ignores_source_epoch: bool,
+    preseal_observer: Option<Arc<dyn Fn(CodeIndexPresealWorkV1) + Send + Sync>>,
 }
 
 impl Default for DaemonCodeIndexControlV1 {
@@ -120,6 +122,7 @@ impl DaemonCodeIndexControlV1 {
             pressure: None,
             tripped: Arc::new(AtomicBool::new(false)),
             ignores_source_epoch: false,
+            preseal_observer: None,
         }
     }
 
@@ -154,6 +157,17 @@ impl DaemonCodeIndexControlV1 {
         self
     }
 
+    /// The producer reports only to the separately scoped capture/parse
+    /// attempt, never to the sealed-generation text-progress authority.
+    #[must_use]
+    pub fn with_preseal_observer(
+        mut self,
+        observer: Arc<dyn Fn(CodeIndexPresealWorkV1) + Send + Sync>,
+    ) -> Self {
+        self.preseal_observer = Some(observer);
+        self
+    }
+
     pub fn advance(epoch: &AtomicU64) {
         epoch.fetch_add(1, Ordering::AcqRel);
     }
@@ -196,6 +210,12 @@ impl CodeIndexExecutionControlV1 for DaemonCodeIndexControlV1 {
     fn is_deadline_exceeded(&self) -> bool {
         false
     }
+
+    fn observed_preseal_work(&self, work: CodeIndexPresealWorkV1) {
+        if let Some(observer) = &self.preseal_observer {
+            observer(work);
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler.rs
index a325e598138..354b246d8ac 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler.rs
@@ -198,6 +198,7 @@ mod overlay_ephemerality_tests;
 mod tests;
 
 mod activation;
+mod attempt_progress;
 pub mod branch_generations;
 pub mod branch_publication;
 mod cadence;
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
new file mode 100644
index 00000000000..a4501b9abf7
--- /dev/null
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
@@ -0,0 +1,212 @@
+//! Separately typed progress authority before immutable generation sealing.
+//! A real capture/parse callback is the only source of work or timestamps.
+
+use std::sync::{Arc, PoisonError, RwLock};
+
+use tracedecay_code_index::production::{CodeIndexPresealWorkPhaseV1, CodeIndexPresealWorkV1};
+use tracedecay_contracts::now_micros;
+
+pub(crate) type CodeIndexBuildAttemptSlotV1 = Arc<RwLock<CodeIndexBuildAttemptSlotStateV1>>;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct CodeIndexBuildAttemptIdentityV1 {
+    daemon_incarnation: u64,
+    producer_incarnation: u64,
+    sequence: u64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct CodeIndexPresealAttemptProgressV1 {
+    pub daemon_incarnation: u64,
+    pub producer_incarnation: u64,
+    pub attempt_sequence: u64,
+    pub progress_epoch: u64,
+    pub phase: CodeIndexPresealWorkPhaseV1,
+    /// Accepted candidate decisions or parser-backed materializations.
+    /// Resets only when the actual producer transitions to parser evidence.
+    pub completed_items: u64,
+    pub total_items: Option<u64>,
+    /// None until actual work finishes; polling cannot update this value.
+    pub last_progress_micros: Option<i64>,
+    pub active: bool,
+}
+
+#[derive(Default)]
+pub(crate) struct CodeIndexBuildAttemptSlotStateV1 {
+    next_sequence: u64,
+    epoch: u64,
+    snapshot: Option<CodeIndexPresealAttemptProgressV1>,
+}
+
+impl CodeIndexBuildAttemptSlotStateV1 {
+    fn begin(&mut self, daemon_incarnation: u64, producer_incarnation: u64) -> CodeIndexBuildAttemptIdentityV1 {
+        self.next_sequence = self.next_sequence.saturating_add(1).max(1);
+        self.epoch = self.epoch.saturating_add(1).max(1);
+        let identity = CodeIndexBuildAttemptIdentityV1 {
+            daemon_incarnation,
+            producer_incarnation,
+            sequence: self.next_sequence,
+        };
+        self.snapshot = Some(CodeIndexPresealAttemptProgressV1 {
+            daemon_incarnation,
+            producer_incarnation,
+            attempt_sequence: identity.sequence,
+            progress_epoch: self.epoch,
+            phase: CodeIndexPresealWorkPhaseV1::Capture,
+            completed_items: 0,
+            total_items: None,
+            last_progress_micros: None,
+            active: true,
+        });
+        identity
+    }
+
+    fn owns(&self, identity: CodeIndexBuildAttemptIdentityV1) -> bool {
+        self.snapshot.as_ref().is_some_and(|it| {
+            it.active
+                && it.daemon_incarnation == identity.daemon_incarnation
+                && it.producer_incarnation == identity.producer_incarnation
+                && it.attempt_sequence == identity.sequence
+        })
+    }
+
+    fn observe(
+        &mut self,
+        identity: CodeIndexBuildAttemptIdentityV1,
+        work: CodeIndexPresealWorkV1,
+        observed_at_micros: i64,
+    ) -> bool {
+        if !self.owns(identity)
+            || work.completed_items == 0
+            || work.total_items.is_some_and(|total| work.completed_items > total)
+        {
+            return false;
+        }
+        let Some(current) = self.snapshot.as_ref() else {
+            return false;
+        };
+        let new_phase = current.phase != work.phase;
+        if (new_phase && work.phase != CodeIndexPresealWorkPhaseV1::ParseEvidence)
+            || (!new_phase && work.completed_items <= current.completed_items)
+        {
+            return false;
+        }
+        let mut next = current.clone();
+        next.phase = work.phase;
+        next.completed_items = work.completed_items;
+        next.total_items = work.total_items;
+        next.last_progress_micros =
+            Some(observed_at_micros.max(current.last_progress_micros.unwrap_or(observed_at_micros)));
+        self.epoch = self.epoch.saturating_add(1).max(1);
+        next.progress_epoch = self.epoch;
+        self.snapshot = Some(next);
+        true
+    }
+
+    fn finish(&mut self, identity: CodeIndexBuildAttemptIdentityV1) {
+        if !self.owns(identity) {
+            return;
+        }
+        if let Some(value) = self.snapshot.as_mut() {
+            value.active = false;
+            self.epoch = self.epoch.saturating_add(1).max(1);
+            value.progress_epoch = self.epoch;
+            // Finishing is a state transition, not completed source work.
+            // Its timestamp must remain the timestamp of the last real item.
+        }
+    }
+
+    pub(crate) fn snapshot(&self) -> Option<CodeIndexPresealAttemptProgressV1> {
+        self.snapshot.clone()
+    }
+}
+
+/// A stale or unwinding reconcile can never publish into its successor.
+/// Dropping this guard on every cancellation, retry, panic or return fences it.
+pub(super) struct CodeIndexPresealAttemptGuardV1 {
+    slot: CodeIndexBuildAttemptSlotV1,
+    identity: CodeIndexBuildAttemptIdentityV1,
+}
+
+impl CodeIndexPresealAttemptGuardV1 {
+    pub(super) fn begin(
+        slot: CodeIndexBuildAttemptSlotV1,
+        daemon_incarnation: u64,
+        producer_incarnation: u64,
+    ) -> Self {
+        let identity = slot.write().unwrap_or_else(PoisonError::into_inner)
+            .begin(daemon_incarnation, producer_incarnation);
+        Self { slot, identity }
+    }
+
+    pub(super) fn observer(&self) -> Arc<dyn Fn(CodeIndexPresealWorkV1) + Send + Sync> {
+        let slot = Arc::clone(&self.slot);
+        let identity = self.identity;
+        Arc::new(move |work| {
+            slot.write().unwrap_or_else(PoisonError::into_inner)
+                .observe(identity, work, now_micros().0);
+        })
+    }
+}
+
+impl Drop for CodeIndexPresealAttemptGuardV1 {
+    fn drop(&mut self) {
+        self.slot.write().unwrap_or_else(PoisonError::into_inner)
+            .finish(self.identity);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn work(phase: CodeIndexPresealWorkPhaseV1, n: u64, total: Option<u64>) -> CodeIndexPresealWorkV1 {
+        CodeIndexPresealWorkV1 { phase, completed_items: n, total_items: total }
+    }
+
+    #[test]
+    fn real_progress_never_renews_on_poll_or_regression() {
+        let mut slot = CodeIndexBuildAttemptSlotStateV1::default();
+        let id = slot.begin(7, 9);
+        assert_eq!(slot.snapshot().unwrap().last_progress_micros, None);
+        assert!(slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 2, Some(5)), 100));
+        let first = slot.snapshot().unwrap();
+        assert_eq!(first.completed_items, 2);
+        assert_eq!(first.last_progress_micros, Some(100));
+        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 2, Some(5)), 900));
+        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(5)), 950));
+        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 6, Some(5)), 990));
+        assert_eq!(slot.snapshot().unwrap(), first);
+        assert!(slot.observe(id, work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 1, Some(3)), 95));
+        let parsed = slot.snapshot().unwrap();
+        assert_eq!(parsed.last_progress_micros, Some(100));
+        assert!(parsed.progress_epoch > first.progress_epoch);
+        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 3, Some(5)), 150));
+        slot.finish(id);
+        let ended = slot.snapshot().unwrap();
+        assert!(!ended.active);
+        assert_eq!(ended.last_progress_micros, Some(100));
+        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 2, Some(3)), 200));
+        assert_eq!(slot.snapshot().unwrap(), ended);
+    }
+
+    #[test]
+    fn retry_and_remount_fence_old_producers_even_when_counters_match() {
+        let mut slot = CodeIndexBuildAttemptSlotStateV1::default();
+        let first = slot.begin(1, 11);
+        assert!(slot.observe(first, work(CodeIndexPresealWorkPhaseV1::Capture, 3, None), 100));
+        let second = slot.begin(1, 11);
+        assert_ne!(first.sequence, second.sequence);
+        assert!(!slot.observe(first, work(CodeIndexPresealWorkPhaseV1::Capture, 40, None), 800));
+        slot.finish(first);
+        assert!(slot.observe(second, work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(2)), 200));
+        let third = slot.begin(2, 1);
+        assert!(!slot.observe(second, work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 2, Some(2)), 700));
+        assert!(slot.observe(third, work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(3)), 400));
+        let visible = slot.snapshot().unwrap();
+        assert_eq!(visible.daemon_incarnation, 2);
+        assert_eq!(visible.producer_incarnation, 1);
+        assert_eq!(visible.completed_items, 1);
+        assert_eq!(visible.last_progress_micros, Some(400));
+    }
+}
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/git_tree_capture.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/git_tree_capture.rs
index 7db65b9c882..4d8d6dd9b33 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/git_tree_capture.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/git_tree_capture.rs
@@ -392,7 +392,7 @@ impl CodeIndexWorktreeSchedulerV1 {
         source: &ExactGitTreeSourceV1,
         control: &branch_generations::BranchGenerationReadControlV1,
     ) -> Result<CapturedSnapshotV1, CodeIndexSearchUnavailableReasonV1> {
-        self.capture_git_tree_snapshot(source, control, false)
+        self.capture_git_tree_snapshot(source, control, false, None)
     }
 
     /// HEAD's tree standing in for a clean checkout. Git stores a symlink as
@@ -404,8 +404,9 @@ impl CodeIndexWorktreeSchedulerV1 {
         &self,
         source: &ExactGitTreeSourceV1,
         control: &branch_generations::BranchGenerationReadControlV1,
+        work_observer: Option<&dyn CodeIndexExecutionControlV1>,
     ) -> Result<CapturedSnapshotV1, CodeIndexSearchUnavailableReasonV1> {
-        self.capture_git_tree_snapshot(source, control, true)
+        self.capture_git_tree_snapshot(source, control, true, work_observer)
     }
 
     fn capture_git_tree_snapshot(
@@ -413,6 +414,7 @@ impl CodeIndexWorktreeSchedulerV1 {
         source: &ExactGitTreeSourceV1,
         control: &branch_generations::BranchGenerationReadControlV1,
         refuse_source_links: bool,
+        work_observer: Option<&dyn CodeIndexExecutionControlV1>,
     ) -> Result<CapturedSnapshotV1, CodeIndexSearchUnavailableReasonV1> {
         control.termination().map_or(Ok(()), Err)?;
         let repository = tracedecay_runtime_core::git_open::open(&self.project_root)
@@ -457,6 +459,7 @@ impl CodeIndexWorktreeSchedulerV1 {
             Some(source.revision.clone()),
             source.tree.clone(),
             control,
+            work_observer,
             |visitor| {
                 for entry in entries {
                     control.termination().map_or(Ok(()), Err)?;
@@ -509,6 +512,7 @@ impl CodeIndexWorktreeSchedulerV1 {
             None,
             expected_tree.clone(),
             control,
+            None,
             |visitor| {
                 candidate.visit_blobs(|path| is_source_path(&registry, path), visitor).map_err(|error| match error {
                     tracedecay_runtime_core::git_repository::GitNativeCandidateTreeVisitError::Repository(_) => {
@@ -528,12 +532,14 @@ impl CodeIndexWorktreeSchedulerV1 {
         source_revision: Option<tracedecay_domain::CommitId>,
         tree: tracedecay_domain::TreeId,
         control: &branch_generations::BranchGenerationReadControlV1,
+        work_observer: Option<&dyn CodeIndexExecutionControlV1>,
         visit: impl FnOnce(
             &mut dyn FnMut(&[u8], &[u8]) -> Result<(), CodeIndexSearchUnavailableReasonV1>,
         ) -> Result<(), CodeIndexSearchUnavailableReasonV1>,
     ) -> Result<CapturedSnapshotV1, CodeIndexSearchUnavailableReasonV1> {
         let registry = StaticLanguageRegistry::new();
         let mut roster = CapturedFileRosterV1::default();
+        let mut completed_candidates = 0_u64;
         let _scan_batch = tracedecay_privacy::code_source_scan_batch();
         visit(&mut |git_path, raw_bytes| {
             control.termination().map_or(Ok(()), Err)?;
@@ -550,6 +556,18 @@ impl CodeIndexWorktreeSchedulerV1 {
                 }
             })?;
             roster.push(outcome);
+            // Clean HEAD-tree capture is the common cold path. Its visitor
+            // reports successful real decisions, with no invented total.
+            if let Some(observer) = work_observer {
+                completed_candidates = completed_candidates.saturating_add(1);
+                observer.observed_preseal_work(
+                    tracedecay_code_index::production::CodeIndexPresealWorkV1 {
+                        phase: tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Capture,
+                        completed_items: completed_candidates,
+                        total_items: None,
+                    },
+                );
+            }
             Ok(())
         })?;
         let CapturedFileRosterV1 {
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
index 9ca91320c7e..398b280836b 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
@@ -61,6 +61,9 @@ use tracedecay_code_index::{
     },
 };
 
+use super::attempt_progress::{
+    CodeIndexBuildAttemptSlotStateV1, CodeIndexBuildAttemptSlotV1, CodeIndexPresealAttemptGuardV1,
+};
 use super::freshness_witness::{
     ReconciledSourceWitnessV1, RestoreFreshnessWitnessV1, SourceContentManifestV1,
     SourceSweepCacheV1,
@@ -1060,6 +1063,8 @@ pub struct CodeIndexWorktreeSchedulerV1 {
     /// Immutable generation-scoped build snapshot. The registry clones this
     /// slot at mount so dashboard reads never acquire the scheduler mutex.
     build_progress: CodeIndexBuildProgressSlotV1,
+    /// Attempt-scoped pre-seal evidence has no sealed-generation identity.
+    preseal_attempt_progress: CodeIndexBuildAttemptSlotV1,
     /// Durable daemon-authority epoch bound by the process registry at mount.
     progress_daemon_incarnation: u64,
     /// Registry-minted scheduler-owner token. A same-daemon retire/remount gets
@@ -1396,6 +1401,7 @@ impl CodeIndexWorktreeSchedulerV1 {
             refused_ignored_source_paths: BTreeSet::new(),
             query_owners: Mutex::new(None),
             build_progress: Arc::new(RwLock::new(CodeIndexBuildProgressSlotStateV1::default())),
+            preseal_attempt_progress: Arc::new(RwLock::new(CodeIndexBuildAttemptSlotStateV1::default())),
             progress_daemon_incarnation: 1,
             progress_producer_incarnation: 1,
         };
@@ -1465,6 +1471,10 @@ impl CodeIndexWorktreeSchedulerV1 {
         Arc::clone(&self.build_progress)
     }
 
+    pub(crate) fn preseal_attempt_progress_slot(&self) -> CodeIndexBuildAttemptSlotV1 {
+        Arc::clone(&self.preseal_attempt_progress)
+    }
+
     pub fn last_reconciled_at_micros_slot(&self) -> Arc<AtomicI64> {
         Arc::clone(&self.freshness_fence.last_reconciled_at_micros)
     }
@@ -2951,7 +2961,12 @@ impl CodeIndexWorktreeSchedulerV1 {
         // move after this pre-capture sample stays visible to that probe.
         let mut overflow_reconciled = false;
         for retry in 0..=MAX_SUPERSEDED_RECONCILE_RETRIES {
-            let control = self.reconcile_control();
+            let attempt = CodeIndexPresealAttemptGuardV1::begin(
+                Arc::clone(&self.preseal_attempt_progress),
+                self.progress_daemon_incarnation,
+                self.progress_producer_incarnation,
+            );
+            let control = self.reconcile_control().with_preseal_observer(attempt.observer());
             // Every earlier attempt was cancelled by a newer source epoch. A
             // source that changes faster than a pass lasts would cancel this
             // one too, so it seals what it captured; the epoch that
@@ -4150,6 +4165,7 @@ impl CodeIndexWorktreeSchedulerV1 {
                         deadline: None,
                         cancellation: None,
                     },
+                    control,
                 ) {
                 Ok(captured) => {
                     *self
@@ -4246,6 +4262,10 @@ impl CodeIndexWorktreeSchedulerV1 {
             })
             .collect::<Vec<_>>();
         let admitted_paths = self.ignored_admission_paths();
+        // Counts only completed real candidate decisions. A retained row was
+        // not recaptured, and an unhandled failing candidate never advances.
+        let completed_candidates = AtomicU64::new(0);
+        let total_candidates = u64::try_from(candidates.len()).unwrap_or(u64::MAX);
         let _scan_batch = tracedecay_privacy::code_source_scan_batch();
         let outcomes = tracedecay_code_index::parallelism::install(|| {
             use rayon::prelude::*;
@@ -4257,12 +4277,25 @@ impl CodeIndexWorktreeSchedulerV1 {
                             return Err(cancelled_code_index_reconcile());
                         }
                         ignored_dependencies::checkpoint_if_present(control)?;
-                        self.capture_admitted_candidate(
+                        let outcome = self.capture_admitted_candidate(
                             &registry,
                             logical_path,
                             control,
                             admitted_paths.contains(logical_path.as_str()),
-                        )
+                        )?;
+                        if let Some(observer) = control {
+                            let completed = completed_candidates
+                                .fetch_add(1, Ordering::AcqRel)
+                                .saturating_add(1);
+                            observer.observed_preseal_work(
+                                tracedecay_code_index::production::CodeIndexPresealWorkV1 {
+                                    phase: tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Capture,
+                                    completed_items: completed,
+                                    total_items: Some(total_candidates),
+                                },
+                            );
+                        }
+                        Ok(outcome)
                     })
                 })
                 .collect::<Vec<_>>()
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
index 35ca13c8c1d..ac84ed5c9d7 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
@@ -107,6 +107,33 @@ const MIXED_SOURCE_ROSTER: &[(&str, &str)] = &[
     ("malformed.json", "{broken"),
 ];
 
+#[test]
+fn cold_build_reports_actual_preseal_capture_and_parser_evidence() {
+    let fixture = GitFixture::new(&[
+        ("src/a.rs", "pub fn a() -> u32 { 1 }\n"),
+        ("src/b.rs", "pub fn b() -> u32 { 2 }\n"),
+    ]);
+    let store = TempDir::new().expect("store root");
+    let mut owner = scheduler(
+        &fixture,
+        store.path().to_path_buf(),
+        Arc::new(SharedCodeIndexBytePoolV1::default()),
+    );
+    let slot = owner.preseal_attempt_progress_slot();
+    assert!(slot.read().unwrap().snapshot().is_none(), "no fabricated cold progress");
+    published(owner.reconcile_now().expect("real cold capture and publication"));
+    let observed = slot.read().unwrap().snapshot().expect("pre-seal observation");
+    assert!(!observed.active, "a finished attempt cannot appear stalled");
+    assert_eq!(
+        observed.phase,
+        tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::ParseEvidence
+    );
+    assert_eq!(observed.completed_items, 2);
+    assert_eq!(observed.total_items, Some(2));
+    assert!(observed.last_progress_micros.is_some_and(|at| at > 0));
+    assert!(observed.progress_epoch >= 5, "two captures and two parses plus start");
+}
+
 #[test]
 fn unchanged_mixed_roster_restart_retains_generation_pointer_and_artifact() {
     let fixture = GitFixture::new(MIXED_SOURCE_ROSTER);
diff --git a/crates/tracedecay-code-index/src/production/mod.rs b/crates/tracedecay-code-index/src/production/mod.rs
index b4b48db5acb..7065349d2c6 100644
--- a/crates/tracedecay-code-index/src/production/mod.rs
+++ b/crates/tracedecay-code-index/src/production/mod.rs
@@ -282,10 +282,32 @@ pub struct CodeIndexCapturedFileV1 {
     pub sensitivity_level: SensitivityLevelV1,
 }
 
+/// Successful pre-seal work observed before a generation ID/digest exists.
+/// Neither event represents a durable text or native graph commit.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum CodeIndexPresealWorkPhaseV1 {
+    Capture,
+    /// Parser evidence was materialized or authenticated for reuse, not
+    /// necessarily newly parsed (a retained parent may supply the evidence).
+    ParseEvidence,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct CodeIndexPresealWorkV1 {
+    pub phase: CodeIndexPresealWorkPhaseV1,
+    pub completed_items: u64,
+    /// None when a Git tree visitor has no authenticated source count yet.
+    pub total_items: Option<u64>,
+}
+
 /// Synchronous checkpoints exposed by an application/daemon request.
 pub trait CodeIndexExecutionControlV1: Sync {
     fn is_cancelled(&self) -> bool;
     fn is_deadline_exceeded(&self) -> bool;
+
+    /// Only a daemon-bound attempt has a progress owner. A benchmark,
+    /// historical read or standalone extraction has none to update.
+    fn observed_preseal_work(&self, _work: CodeIndexPresealWorkV1) {}
 }
 
 /// A control that never interrupts. Sealed seating uses it when the caller
@@ -2713,6 +2735,13 @@ where
                         chunk_policy.with_chunks_under(&chunk.sensitivity.policy_revision);
                 }
                 file_segments.push(descriptor);
+                // The file segment is staged, but no generation has sealed.
+                // Do not count this as a durable lexical or native graph page.
+                control.observed_preseal_work(CodeIndexPresealWorkV1 {
+                    phase: CodeIndexPresealWorkPhaseV1::ParseEvidence,
+                    completed_items: u64::try_from(file_segments.len()).unwrap_or(u64::MAX),
+                    total_items: Some(u64::try_from(present_count).unwrap_or(u64::MAX)),
+                });
                 captured_files.remove(&artifact.extraction.file_occurrence_id);
                 self.physical_artifacts.insert(reuse_key, &artifact);
                 // Both cache authorities are weak: dropping this artifact is

From b2c4997fb44bac0f9fa709840edc3b377fae4ef1 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 20:39:51 -0800
Subject: [PATCH 09/80] feat(graph): report committed stage pages and verified
 segments

Refs #4508. Distinguish real WAL-settled page transactions from adopted receipts; direct seal is one compact artifact, not invented durable pages. Add nonzero persistent write/replay/close-reopen regression. Status wiring and restart E2E remain open.
---
 .../src/generation_runtime.rs                 | 111 +++++++++++++++++-
 .../tracedecay-graph-db/src/sealed_store.rs   |  12 ++
 2 files changed, 117 insertions(+), 6 deletions(-)

diff --git a/crates/tracedecay-graph-db/src/generation_runtime.rs b/crates/tracedecay-graph-db/src/generation_runtime.rs
index d2fdd35dd58..ad0da38291a 100644
--- a/crates/tracedecay-graph-db/src/generation_runtime.rs
+++ b/crates/tracedecay-graph-db/src/generation_runtime.rs
@@ -128,6 +128,15 @@ enum GenerationStagePageKind {
     Relations,
 }
 
+/// Whether the native page transaction actually applied rows or replay
+/// adopted an already durable, matching receipt. This is a write verdict, not
+/// a read-side projection or a guessed number of graph pages.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum GenerationStagePageCommitV1 {
+    Applied,
+    Reused,
+}
+
 impl GenerationStagePageKind {
     fn as_str(self) -> &'static str {
         match self {
@@ -1068,10 +1077,10 @@ impl GraphDb {
         page: &GenerationStagePage,
         prepared: Option<PreparedGenerationStagePage>,
         check: &dyn Fn() -> Result<(), GraphDbError>,
-    ) -> Result<GraphCommit, GraphDbError> {
+    ) -> Result<(GraphCommit, GenerationStagePageCommitV1), GraphDbError> {
         let (idempotency_key, input_digest) =
             generation_stage_page_receipt(identity, expected, page)?;
-        self.run_gated_batch(
+        let (commit, outcome) = self.run_gated_batch(
             check,
             |database| {
                 let mut reuse_receipt = false;
@@ -1087,7 +1096,10 @@ impl GraphDb {
                         if !context.replay_every_page
                             && Self::generation_stage_page_rows_present(database, context, page)?
                         {
-                            return Ok(GraphBatchPlan::Settled(existing.commit, ()));
+                            return Ok(GraphBatchPlan::Settled(
+                                existing.commit,
+                                GenerationStagePageCommitV1::Reused,
+                            ));
                         }
                         // The receipt still binds this exact page to this
                         // identity and recovered digest, so re-applying it is
@@ -1173,11 +1185,27 @@ impl GraphDb {
                         },
                         endpoint_namespaces,
                     },
-                    (),
+                    GenerationStagePageCommitV1::Applied,
                 ))
             },
-            |_database, commit, ()| Ok(commit),
-        )
+            |_database, commit, outcome| Ok((commit, outcome)),
+        )?;
+        if outcome == GenerationStagePageCommitV1::Applied {
+            // run_gated_batch only returns after the real page transaction
+            // and its receipt have committed, including WAL settlement for
+            // persistent stores. A replayed receipt emits no new-write event.
+            tracing::info!(
+                event = "graph_native_stage_page_applied",
+                generation = %identity.generation,
+                ordinal = page.ordinal,
+                kind = page.kind.as_str(),
+                mutations = page.mutation_count(),
+                live_bytes = page.live_bytes(),
+                wal_synced = matches!(self.inner.durability, crate::GraphDurability::WalSync),
+                "native graph page transaction completed"
+            );
+        }
+        Ok((commit, outcome))
     }
 
     /// Binds the dependency metadata in one empty batch, after every page
@@ -3731,6 +3759,77 @@ mod tests {
         );
     }
 
+    #[test]
+    fn native_graph_page_reports_real_wal_commits_but_not_replayed_receipts() {
+        let manifest = large_manifest("native-write-observation");
+        let pages = generation_stage_pages(&manifest).expect("native page plan");
+        assert!(!pages.is_empty(), "nonzero source rows must produce a page");
+        let identity = manifest.identity();
+        let sealed = sealed_digest(&manifest);
+        let temp = TempDir::new().expect("graph store");
+        let (owner, database) = persistent_database(&temp);
+        let context = super::GenerationStageContext {
+            locator: GenerationLocator::new(
+                manifest.projection.clone(),
+                manifest.generation.clone(),
+            ),
+            physical_namespace: identity.physical_namespace().unwrap(),
+            dependency_namespaces: database.require_exact_dependencies(&identity).unwrap(),
+            dependency_digest: manifest.dependency_closure_digest(&|| Ok(())).unwrap(),
+            replay_every_page: false,
+        };
+        let prepared = super::construct_generation_stage_page(
+            &manifest,
+            &identity,
+            &context,
+            &pages[0],
+            &|| Ok(()),
+        )
+        .expect("actual native page preparation");
+        let (_, first) = database
+            .apply_prepared_generation_stage_page(
+                Some(&manifest),
+                &identity,
+                &sealed,
+                &context,
+                None,
+                &pages[0],
+                Some(prepared),
+                &|| Ok(()),
+            )
+            .expect("durably commit the first native page");
+        assert_eq!(first, super::GenerationStagePageCommitV1::Applied);
+        assert!(pages[0].mutation_count() > 0);
+        let (_, repeated) = database
+            .apply_prepared_generation_stage_page(
+                Some(&manifest),
+                &identity,
+                &sealed,
+                &context,
+                None,
+                &pages[0],
+                None,
+                &|| Ok(()),
+            )
+            .expect("reuse durable native page receipt");
+        assert_eq!(repeated, super::GenerationStagePageCommitV1::Reused);
+        drop(database);
+        owner.close().expect("close graph store");
+        let (reopened_owner, reopened) = persistent_database(&temp);
+        assert!(
+            reopened
+                .generation_stage_page_already_applied(
+                    &identity,
+                    &sealed,
+                    &context,
+                    &pages[0],
+                )
+                .expect("verify row receipt after restart"),
+            "a reported native page must survive a close/reopen, not merely staging memory"
+        );
+        reopened_owner.close().expect("close reopened graph store");
+    }
+
     #[test]
     fn pipelined_custom_pages_seal_the_same_digest() {
         let manifest = large_manifest("pipeline-page-apply");
diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index e6441489824..0030f2eb28c 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -1821,6 +1821,18 @@ fn build_or_open_sealed_store(
         // canonical bytes the reopen hashed.
         Ok(Some(store)) => {
             let staging_proof = staging_sourced.then_some(store.canonical_bytes);
+            // The direct manifest path writes a SINGLE compact container,
+            // not resumable row pages. Only the installed + reopened digest-
+            // verified segment is reportable as a completed durable write.
+            // A reused prior artifact returned above emits no new segment.
+            tracing::info!(
+                event = "graph_native_compact_segment_verified",
+                generation = %identity.generation,
+                entities = receipt.entities,
+                relations = receipt.relations,
+                canonical_bytes = store.canonical_bytes,
+                "installed and reopened the native graph compact segment"
+            );
             Ok((store, staging_proof))
         }
         Ok(None) => {

From bffaf6116dc0832345cb506ca39e15bcbf557384 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 21:26:35 -0800
Subject: [PATCH 10/80] fix(graph): do not report a lost compact-seal race as a
 new write

Refs #4508. A concurrent verified segment may be adopted after a losing staging install; only the writer that actually installed a new directory emits the native durable-segment event. Add real sealed-container collision, cleanup, and verified-reopen regression. Status wiring and interrupted-restart acceptance remain open.
---
 .../tracedecay-graph-db/src/sealed_store.rs   | 108 +++++++++++++++---
 1 file changed, 92 insertions(+), 16 deletions(-)

diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index 0030f2eb28c..8ab180224cc 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -1737,6 +1737,28 @@ pub(crate) enum SealedRowSource<'a> {
     Layered(&'a LayeredGraphGeneration),
 }
 
+/// Returns whether this writer installed a new sealed segment. A losing
+/// concurrent writer can adopt the winner only after the caller reopens and
+/// verifies its digest; existence alone is not a new durable write.
+fn install_staged_sealed_store(
+    staging: &Path,
+    directory: &Path,
+) -> Result<bool, GraphDbError> {
+    match std::fs::rename(staging, directory) {
+        Ok(()) => Ok(true),
+        Err(error) => {
+            remove_sealed_directory(staging);
+            if directory.exists() {
+                // A winner may have installed the same generation. The
+                // caller still requires a full identity/digest reopen proof.
+                Ok(false)
+            } else {
+                Err(sealed_store_io_failure("artifact install failed", error))
+            }
+        }
+    }
+}
+
 /// Builds (or adopts) the sealed store for `identity` and returns the
 /// reopened, digest-verified reader.
 ///
@@ -1796,14 +1818,10 @@ fn build_or_open_sealed_store(
     std::fs::write(staging.join(SEALED_STORE_RECEIPT_FILE), encoded)
         .inspect_err(|_| remove_sealed_directory(&staging))
         .map_err(|error| sealed_store_io_failure("receipt write failed", error))?;
-    if let Err(error) = std::fs::rename(&staging, &directory) {
-        remove_sealed_directory(&staging);
-        // A concurrent seal of the same generation may have installed the
-        // directory first; adopting it below keeps this path idempotent.
-        if !directory.exists() {
-            return Err(sealed_store_io_failure("artifact install failed", error));
-        }
-    }
+    // The transaction boundary matters to progress: a second writer can
+    // lose the destination race and verify the winner's sealed segment.
+    // Only the writer that installed this directory may report a new write.
+    let installed_here = install_staged_sealed_store(&staging, &directory)?;
     let match_result = {
         let _span = tracing::trace_span!("code_index.seal.verify").entered();
         open_sealed_store_checked(
@@ -1825,14 +1843,16 @@ fn build_or_open_sealed_store(
             // not resumable row pages. Only the installed + reopened digest-
             // verified segment is reportable as a completed durable write.
             // A reused prior artifact returned above emits no new segment.
-            tracing::info!(
-                event = "graph_native_compact_segment_verified",
-                generation = %identity.generation,
-                entities = receipt.entities,
-                relations = receipt.relations,
-                canonical_bytes = store.canonical_bytes,
-                "installed and reopened the native graph compact segment"
-            );
+            if installed_here {
+                tracing::info!(
+                    event = "graph_native_compact_segment_verified",
+                    generation = %identity.generation,
+                    entities = receipt.entities,
+                    relations = receipt.relations,
+                    canonical_bytes = store.canonical_bytes,
+                    "installed and reopened the native graph compact segment"
+                );
+            }
             Ok((store, staging_proof))
         }
         Ok(None) => {
@@ -3123,6 +3143,62 @@ mod build_tests {
         );
     }
 
+    /// A competing writer's already installed segment is read-only evidence,
+    /// not a new native write by this attempt. The loser must clean up its
+    /// staging directory and can adopt only the digest-verified real segment.
+    #[test]
+    fn concurrent_sealed_install_candidate_does_not_count_as_new_write() {
+        let check: &dyn Fn() -> Result<(), GraphDbError> = &|| Ok(());
+        let temp = tempfile::tempdir().expect("persistent sealed graph root");
+        let database_path = temp.path().join("source.grafeo");
+        let manifest = manifest(7, 9);
+        let identity = manifest.identity();
+        let expected = manifest.expected_recovered_digest(check).unwrap();
+        let (installed, _) = build_or_open_sealed_store(
+            SealedRowSource::Manifest(&manifest),
+            &identity,
+            &expected,
+            &database_path,
+            check,
+        )
+        .expect("install the actual winning native graph segment");
+        assert_eq!(installed.recovered_digest(), expected.as_str());
+        let _ = installed.database().close();
+
+        let root = sealed_store_root(&database_path);
+        let directory = sealed_generation_directory(
+            &root,
+            &identity.physical_namespace().expect("physical namespace"),
+        );
+        let staging = root.join(format!(
+            ".staging-{}",
+            directory.file_name().unwrap().to_str().unwrap()
+        ));
+        std::fs::create_dir_all(&staging).expect("losing writer staging");
+        std::fs::write(staging.join("loser.tmp"), b"uninstalled").unwrap();
+
+        let installed_by_loser = super::install_staged_sealed_store(&staging, &directory)
+            .expect("candidate exists after the install collision");
+        assert!(
+            !installed_by_loser,
+            "the losing writer committed no new native segment"
+        );
+        assert!(!staging.exists(), "the losing staging data must be removed");
+        assert!(!directory.join("loser.tmp").exists());
+        let reopened = super::open_sealed_store_checked(
+            &directory,
+            &identity,
+            &expected,
+            check,
+            None,
+        )
+        .expect("verify the actual winning native segment")
+        .expect("the winning segment remains installed");
+        assert_eq!(reopened.recovered_digest(), expected.as_str());
+        assert_eq!((reopened.entity_count, reopened.relation_count), (7, 9));
+        let _ = reopened.database().close();
+    }
+
     /// Two builds of the same staged rows write byte-identical section
     /// payloads: the build order is the recovered-digest order, and the
     /// compact serializer is deterministic, so every byte past the Grafeo

From de17fca27bd59d686516eb872d7cadcf8710fc9b Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sat, 7 Nov 2026 23:54:03 -0800
Subject: [PATCH 11/80] feat(code-index): surface pre-seal attempt work in
 daemon status

Refs #4508

Carry the real capture and parse attempt across the mounted scheduler,
canonical status wire, CLI wait display and MCP search. Preserve attempt
owner, epoch and work timestamp independently of sealed generation data.
Add nonzero wire and renderer regressions. No generated-contract edits.
---
 crates/tracedecay-cli/src/commands/index.rs   | 60 ++++++++++++++--
 .../code_index_scheduler/attempt_progress.rs  | 17 +----
 .../src/code_index_scheduler/registry.rs      |  3 +
 .../code_index_scheduler/registry/mount.rs    |  2 +
 .../registry/serving_reads.rs                 |  8 +++
 .../src/production/mod.rs                     |  8 +--
 .../src/code_index_freshness.rs               | 57 +++++++++++++++
 .../src/code_index_freshness_api.rs           |  1 +
 .../src/handlers/graph/search_freshness.rs    | 71 +++++++++++++++++--
 9 files changed, 195 insertions(+), 32 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index afcad1d7f1f..41d5798aac9 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -372,11 +372,14 @@ where
             Some(StatusCodeIndexFreshnessV1::Unavailable { reason }) => Err(reason),
             None => Err("status omitted code_index_freshness".to_owned()),
         };
-        let progress = worktree
-            .as_ref()
-            .ok()
-            .and_then(|worktree| worktree.progress.as_ref())
-            .map(build_progress_summary);
+        let progress = worktree.as_ref().ok().and_then(|worktree| {
+            worktree
+                .preseal_attempt
+                .as_ref()
+                .filter(|attempt| attempt.active)
+                .map(preseal_progress_summary)
+                .or_else(|| worktree.progress.as_ref().map(build_progress_summary))
+        });
         let progress_suffix = progress
             .as_deref()
             .map(|progress| format!(" ({progress})"))
@@ -477,6 +480,34 @@ impl std::fmt::Display for FirstGenerationStall {
     }
 }
 
+fn preseal_progress_summary(
+    progress: &tracedecay_contracts::code_index_freshness::CodeIndexPresealAttemptProgressV1,
+) -> String {
+    let phase = match progress.phase {
+        tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::Capture => {
+            "capturing"
+        }
+        tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::ParseEvidence => {
+            "parsing"
+        }
+    };
+    let total = progress
+        .total_items
+        .map_or_else(|| "unknown".to_owned(), |total| total.to_string());
+    format!(
+        "{phase} {}/{} items, attempt={}:{}:{} epoch={} last_work_micros={}",
+        progress.completed_items,
+        total,
+        progress.daemon_incarnation,
+        progress.producer_incarnation,
+        progress.attempt_sequence,
+        progress.progress_epoch,
+        progress
+            .last_progress_micros
+            .map_or_else(|| "unreported".to_owned(), |micros| micros.to_string()),
+    )
+}
+
 fn build_progress_summary(progress: &CodeIndexBuildProgressV1) -> String {
     format!(
         "{:?} {}/{} files",
@@ -732,6 +763,25 @@ mod daemon_precondition_tests {
         }
     }
 
+    #[test]
+    fn init_wait_preseal_summary_does_not_report_sealed_work() {
+        let attempt = tracedecay_contracts::code_index_freshness::CodeIndexPresealAttemptProgressV1 {
+            daemon_incarnation: 2,
+            producer_incarnation: 5,
+            attempt_sequence: 6,
+            progress_epoch: 11,
+            phase: tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::Capture,
+            completed_items: 16,
+            total_items: None,
+            last_progress_micros: Some(123),
+            active: true,
+        };
+        assert_eq!(
+            super::preseal_progress_summary(&attempt),
+            "capturing 16/unknown items, attempt=2:5:6 epoch=11 last_work_micros=123"
+        );
+    }
+
     fn progress(
         completed_files: u64,
         blocked_reason: Option<CodeIndexBuildBlockedReasonV1>,
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
index a4501b9abf7..6e8312af382 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
@@ -4,6 +4,7 @@
 use std::sync::{Arc, PoisonError, RwLock};
 
 use tracedecay_code_index::production::{CodeIndexPresealWorkPhaseV1, CodeIndexPresealWorkV1};
+use tracedecay_contracts::code_index_freshness::CodeIndexPresealAttemptProgressV1;
 use tracedecay_contracts::now_micros;
 
 pub(crate) type CodeIndexBuildAttemptSlotV1 = Arc<RwLock<CodeIndexBuildAttemptSlotStateV1>>;
@@ -15,22 +16,6 @@ struct CodeIndexBuildAttemptIdentityV1 {
     sequence: u64,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct CodeIndexPresealAttemptProgressV1 {
-    pub daemon_incarnation: u64,
-    pub producer_incarnation: u64,
-    pub attempt_sequence: u64,
-    pub progress_epoch: u64,
-    pub phase: CodeIndexPresealWorkPhaseV1,
-    /// Accepted candidate decisions or parser-backed materializations.
-    /// Resets only when the actual producer transitions to parser evidence.
-    pub completed_items: u64,
-    pub total_items: Option<u64>,
-    /// None until actual work finishes; polling cannot update this value.
-    pub last_progress_micros: Option<i64>,
-    pub active: bool,
-}
-
 #[derive(Default)]
 pub(crate) struct CodeIndexBuildAttemptSlotStateV1 {
     next_sequence: u64,
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry.rs
index 8e4b0a26fdb..526bd3ab86e 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry.rs
@@ -843,6 +843,7 @@ pub struct MountedCodeIndexWorktreeV1 {
     /// Immutable progress snapshot independently readable while the scheduler
     /// owns a long reconcile or text-artifact transaction.
     pub build_progress: super::CodeIndexBuildProgressSlotV1,
+    preseal_attempt_progress: super::attempt_progress::CodeIndexBuildAttemptSlotV1,
     /// Monotonic replacement epoch for the serving slot. It invalidates a
     /// branch-publication token even if a future worker re-seats an equal id.
     serving_generation_epoch: Arc<AtomicU64>,
@@ -919,6 +920,7 @@ const _: fn(&MountedCodeIndexWorktreeV1) = |value| {
         generation_recovery,
         serving_source_witness,
         build_progress,
+        preseal_attempt_progress,
         serving_generation_epoch,
         serving_generation_changed,
         serving_generation_installation,
@@ -957,6 +959,7 @@ const _: fn(&MountedCodeIndexWorktreeV1) = |value| {
     assert_send_sync(generation_recovery);
     assert_send_sync(serving_source_witness);
     assert_send_sync(build_progress);
+    assert_send_sync(preseal_attempt_progress);
     assert_send_sync(serving_generation_epoch);
     assert_send_sync(serving_generation_changed);
     assert_send_sync(serving_generation_installation);
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs
index 0da14f14b40..17f31789415 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs
@@ -671,6 +671,7 @@ impl CodeIndexSchedulerRegistryV1 {
         let generation_recovery = opened.generation_recovery();
         let active_generation_encoded_bytes = opened.active_generation_encoded_bytes();
         let build_progress = opened.build_progress_slot();
+        let preseal_attempt_progress = opened.preseal_attempt_progress_slot();
         let historical_generation_owner = opened.historical_generation_owner();
         let source_freshness = opened.freshness_fence();
         let last_reconciled_at_micros = opened.last_reconciled_at_micros_slot();
@@ -4080,6 +4081,7 @@ impl CodeIndexSchedulerRegistryV1 {
             generation_recovery,
             serving_source_witness,
             build_progress,
+            preseal_attempt_progress,
             serving_generation_epoch,
             serving_generation_changed,
             serving_generation_installation,
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/serving_reads.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/serving_reads.rs
index 320a9278cb1..45d3cfd777a 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/serving_reads.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/serving_reads.rs
@@ -288,6 +288,7 @@ impl CodeIndexSchedulerRegistryV1 {
             convergence_park,
             generation_recovery,
             build_progress,
+            preseal_attempt_progress,
             hints,
             pending_wake,
             source_freshness,
@@ -306,6 +307,7 @@ impl CodeIndexSchedulerRegistryV1 {
                 Arc::clone(&worktree.convergence_park),
                 Arc::clone(&worktree.generation_recovery),
                 Arc::clone(&worktree.build_progress),
+                Arc::clone(&worktree.preseal_attempt_progress),
                 Arc::clone(&worktree.hints),
                 Arc::clone(&worktree.pending_wake),
                 worktree.source_freshness.clone(),
@@ -324,6 +326,10 @@ impl CodeIndexSchedulerRegistryV1 {
                     .snapshot()
                     .map(|snapshot| snapshot.as_ref().clone())
             };
+            let preseal_attempt = preseal_attempt_progress
+                .read()
+                .unwrap_or_else(std::sync::PoisonError::into_inner)
+                .snapshot();
             let refresh_in_flight = reconcile_in_progress.running()
                 || pending_wake.lock()
                     .micros
@@ -443,6 +449,7 @@ impl CodeIndexSchedulerRegistryV1 {
                         hook_hint_count,
                         coverage: observation.coverage,
                         progress,
+                        preseal_attempt,
                         restore_progress,
                         parked,
                         generation_recovery,
@@ -531,6 +538,7 @@ impl CodeIndexSchedulerRegistryV1 {
                 hook_hint_count,
                 coverage: observation.coverage,
                 progress,
+                preseal_attempt,
                 restore_progress,
                 parked,
                 generation_recovery,
diff --git a/crates/tracedecay-code-index/src/production/mod.rs b/crates/tracedecay-code-index/src/production/mod.rs
index 7065349d2c6..3343da14743 100644
--- a/crates/tracedecay-code-index/src/production/mod.rs
+++ b/crates/tracedecay-code-index/src/production/mod.rs
@@ -284,13 +284,7 @@ pub struct CodeIndexCapturedFileV1 {
 
 /// Successful pre-seal work observed before a generation ID/digest exists.
 /// Neither event represents a durable text or native graph commit.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum CodeIndexPresealWorkPhaseV1 {
-    Capture,
-    /// Parser evidence was materialized or authenticated for reuse, not
-    /// necessarily newly parsed (a retained parent may supply the evidence).
-    ParseEvidence,
-}
+pub use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct CodeIndexPresealWorkV1 {
diff --git a/crates/tracedecay-contracts/src/code_index_freshness.rs b/crates/tracedecay-contracts/src/code_index_freshness.rs
index d8f7b0a2b97..a23f08be9f5 100644
--- a/crates/tracedecay-contracts/src/code_index_freshness.rs
+++ b/crates/tracedecay-contracts/src/code_index_freshness.rs
@@ -122,6 +122,29 @@ pub struct CodeIndexBuildProgressV1 {
     pub blocked_reason: Option<CodeIndexBuildBlockedReasonV1>,
 }
 
+/// Observed capture/parse work before a sealed generation exists.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum CodeIndexPresealWorkPhaseV1 {
+    Capture,
+    ParseEvidence,
+}
+
+/// Independently owned attempt work, not committed text or graph pages.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+pub struct CodeIndexPresealAttemptProgressV1 {
+    pub daemon_incarnation: u64,
+    pub producer_incarnation: u64,
+    pub attempt_sequence: u64,
+    pub progress_epoch: u64,
+    pub phase: CodeIndexPresealWorkPhaseV1,
+    pub completed_items: u64,
+    pub total_items: Option<u64>,
+    /// No timestamp is invented before actual work or by status polling.
+    pub last_progress_micros: Option<i64>,
+    pub active: bool,
+}
+
 /// A deterministic contract violation that parked background convergence.
 ///
 /// Parked is not dead: the worker keeps re-observing the violation on its
@@ -608,6 +631,8 @@ pub struct CodeIndexWorktreeFreshnessV1 {
     pub omitted_sources: Option<CodeIndexOmittedSourcesV1>,
     /// Latest committed progress for the active generation, if one is mounted.
     pub progress: Option<CodeIndexBuildProgressV1>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub preseal_attempt: Option<CodeIndexPresealAttemptProgressV1>,
     /// Bounded immutable-artifact restore work currently in flight. This is
     /// separate from build progress because restore commits no index data.
     #[serde(default)]
@@ -1391,4 +1416,36 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn preseal_freshness_wire_never_invents_a_generation() {
+        let expected = CodeIndexWorktreeFreshnessV1 {
+            worktree_root: "/repo".to_owned(),
+            rebuild_in_flight: true,
+            preseal_attempt: Some(CodeIndexPresealAttemptProgressV1 {
+                daemon_incarnation: 11,
+                producer_incarnation: 4,
+                attempt_sequence: 3,
+                progress_epoch: 8,
+                phase: CodeIndexPresealWorkPhaseV1::ParseEvidence,
+                completed_items: 7,
+                total_items: Some(9),
+                last_progress_micros: Some(1_234_567),
+                active: true,
+            }),
+            ..Default::default()
+        };
+        let value = serde_json::to_value(&expected).expect("encode freshness");
+        assert!(value["latest_generation_id"].is_null());
+        assert!(value["progress"].is_null());
+        assert_eq!(value["preseal_attempt"]["phase"], "parse_evidence");
+        assert_eq!(value["preseal_attempt"]["completed_items"], 7);
+        assert_eq!(value["preseal_attempt"]["last_progress_micros"], 1_234_567);
+        let decoded: CodeIndexWorktreeFreshnessV1 =
+            serde_json::from_value(value).expect("decode freshness");
+        assert_eq!(decoded, expected);
+        let no_attempt = serde_json::to_value(CodeIndexWorktreeFreshnessV1::default())
+            .expect("encode absent attempt");
+        assert!(no_attempt.get("preseal_attempt").is_none());
+    }
 }
diff --git a/crates/tracedecay-dashboard-api/src/code_index_freshness_api.rs b/crates/tracedecay-dashboard-api/src/code_index_freshness_api.rs
index 874b979c4e7..57475811be9 100644
--- a/crates/tracedecay-dashboard-api/src/code_index_freshness_api.rs
+++ b/crates/tracedecay-dashboard-api/src/code_index_freshness_api.rs
@@ -202,6 +202,7 @@ mod tests {
                     coverage: CodeIndexFreshnessCoverageV1::Complete,
                     omitted_sources: None,
                     progress: None,
+                    preseal_attempt: None,
                     restore_progress: None,
                     parked: None,
                     generation_recovery: None,
diff --git a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
index 9ca096af6a9..8bdaccdaf8c 100644
--- a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
+++ b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
@@ -14,7 +14,7 @@ use std::fmt::Write as _;
 
 use tracedecay_contracts::code_index_freshness::{
     CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexFreshnessPayloadV1,
-    CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
+    CodeIndexPresealWorkPhaseV1, CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::retrieval::{
     CodeGraphReadFreshnessV1, PrimitiveFreshnessStateV1, PrimitiveIndexingStateV1,
@@ -65,6 +65,13 @@ fn phase_label(phase: CodeIndexBuildPhaseV1) -> &'static str {
     }
 }
 
+fn preseal_phase_label(phase: CodeIndexPresealWorkPhaseV1) -> &'static str {
+    match phase {
+        CodeIndexPresealWorkPhaseV1::Capture => "capture",
+        CodeIndexPresealWorkPhaseV1::ParseEvidence => "parse_evidence",
+    }
+}
+
 fn blocked_reason_label(reason: CodeIndexBuildBlockedReasonV1) -> &'static str {
     match reason {
         CodeIndexBuildBlockedReasonV1::ResidentMemory => "resident_memory",
@@ -212,6 +219,26 @@ pub(super) fn search_freshness(
         if let Some(hints) = state.hook_hint_count.filter(|count| *count > 0) {
             let _ = write!(summary, " pending_hook_hints={hints}");
         }
+        if let Some(attempt) = &state.preseal_attempt {
+            let _ = write!(
+                summary,
+                " preseal_phase={} preseal_owner={}:{}:{} preseal_epoch={} \
+                 preseal_completed={} preseal_total={} preseal_last_progress_micros={} \
+                 preseal_active={}",
+                preseal_phase_label(attempt.phase),
+                attempt.daemon_incarnation,
+                attempt.producer_incarnation,
+                attempt.attempt_sequence,
+                attempt.progress_epoch,
+                attempt.completed_items,
+                attempt.total_items.map_or_else(|| "unknown".to_owned(), |n| n.to_string()),
+                attempt.last_progress_micros.map_or_else(
+                    || "unreported".to_owned(),
+                    |micros| micros.to_string()
+                ),
+                attempt.active,
+            );
+        }
         if let Some(progress) = &state.progress {
             // Keep the producer's identity and clock. Reading a response is
             // not work, and an epoch is comparable only within its owner.
@@ -238,9 +265,13 @@ pub(super) fn search_freshness(
                 progress.blocked_reason.map_or("none", blocked_reason_label)
             );
         } else if state.rebuild_in_flight {
-            // No sealed progress report exists during an initial capture.
-            // Do not fabricate a generation, count, clock, or running verdict.
-            summary.push_str(" progress=unreported");
+            if state.preseal_attempt.as_ref().is_some_and(|attempt| {
+                attempt.active && attempt.last_progress_micros.is_some()
+            }) {
+                summary.push_str(" progress=preseal");
+            } else {
+                summary.push_str(" progress=unreported");
+            }
         }
     }
     if !stale_lanes.is_empty() {
@@ -489,6 +520,38 @@ mod tests {
         assert_eq!(indexing.stale_lanes.len(), 0);
     }
 
+    #[test]
+    fn observed_preseal_progress_is_not_an_invented_generation() {
+        let state = CodeIndexWorktreeFreshnessV1 {
+            rebuild_in_flight: true,
+            preseal_attempt: Some(
+                tracedecay_contracts::code_index_freshness::CodeIndexPresealAttemptProgressV1 {
+                    daemon_incarnation: 4,
+                    producer_incarnation: 9,
+                    attempt_sequence: 3,
+                    progress_epoch: 14,
+                    phase: CodeIndexPresealWorkPhaseV1::Capture,
+                    completed_items: 24,
+                    total_items: Some(100),
+                    last_progress_micros: Some(1_234_567),
+                    active: true,
+                },
+            ),
+            ..CodeIndexWorktreeFreshnessV1::default()
+        };
+        let rendered = freshness_lines(&search_freshness(
+            ServedGenerationV1::Unavailable { reason: "generation_unavailable" },
+            &CodeIndexSearchCoverageV1::unavailable("generation_rebuilding"),
+            &WorktreeFreshnessSourceV1::Worktree(Box::new(state)),
+        ));
+        assert!(rendered.contains("preseal_phase=capture preseal_owner=4:9:3"));
+        assert!(rendered.contains("preseal_epoch=14 preseal_completed=24"));
+        assert!(rendered.contains("preseal_total=100 preseal_last_progress_micros=1234567"));
+        assert!(rendered.contains("preseal_active=true progress=preseal"));
+        assert!(!rendered.contains("progress_generation="));
+        assert!(!rendered.contains("committed_text_pages="));
+    }
+
     #[test]
     fn cold_unreported_work_has_no_fabricated_progress_authority() {
         let freshness = search_freshness(

From 1dc9527d3a0ac0ad6afe87a1bd52c19f113c77f3 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 00:23:50 -0800
Subject: [PATCH 12/80] fix(cli): detect silence in observed first-generation
 work

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 188 +++++++++++++++++++-
 1 file changed, 183 insertions(+), 5 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 41d5798aac9..e14a6f3a282 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -245,11 +245,10 @@ async fn brokered_init(
 const INIT_WAIT_SLICE_MS: u64 = 30_000;
 const INIT_WAIT_SLICE: Duration = Duration::from_millis(INIT_WAIT_SLICE_MS);
 
-/// How long `init --wait` keeps waiting once the daemon stops reporting work
-/// toward the first generation. Capture, extraction, and graph publication
-/// publish no build progress for minutes on a large repository, so liveness
-/// is the scheduler's own indexing, restore, or verification claim, not a
-/// progress counter.
+/// Maximum silence for an observed capture, parse, or committed text
+/// boundary, or for an unavailable readiness owner. Graph publication has no
+/// native write authority on the freshness wire yet, so its phase alone must
+/// not become a false no-progress timeout.
 const INIT_WAIT_STALL_WINDOW: Duration = Duration::from_secs(120);
 
 fn init_queued_not_ready_receipt(project_path: &Path) -> String {
@@ -333,6 +332,7 @@ where
     Fut: std::future::Future<Output = tracedecay_domain::errors::Result<serde_json::Value>>,
 {
     let mut idle_window = FirstGenerationIdleWindow::new(stall_window);
+    let mut progress_window = FirstGenerationProgressWindow::new(stall_window);
     loop {
         let payload = read_slice().await?;
         let last_state = match first_generation_wait_outcome(&payload)? {
@@ -397,6 +397,20 @@ where
                 ),
             ));
         }
+        if progress_window.observe(
+            FirstGenerationWorkMarker::of(worktree.as_deref().ok()),
+            Instant::now(),
+        ) {
+            return Err(first_generation_wait_refusal(
+                CODE_INDEX_READINESS_WAIT_TIMED_OUT,
+                format!(
+                    "init --wait stopped waiting for the first generation: no observed \
+                     capture, parse, or committed text work for {}s; last state: \
+                     {last_state}{progress_suffix}",
+                    stall_window.as_secs(),
+                ),
+            ));
+        }
         eprintln!("first generation not ready yet: {last_state}{progress_suffix}");
     }
 }
@@ -436,6 +450,100 @@ impl FirstGenerationStall {
     }
 }
 
+/// One real producer's last boundary. A polling read is never a heartbeat.
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum FirstGenerationWorkMarker {
+    Preseal {
+        owner: (u64, u64, u64),
+        epoch: u64,
+        last_work_micros: Option<i64>,
+    },
+    CommittedText {
+        generation: String,
+        owner: (u64, u64),
+        epoch: u64,
+        last_work_micros: i64,
+    },
+}
+
+impl FirstGenerationWorkMarker {
+    fn of(worktree: Option<&CodeIndexWorktreeFreshnessV1>) -> Option<Self> {
+        let worktree = worktree.filter(|state| state.rebuild_in_flight)?;
+        if let Some(progress) = &worktree.progress {
+            // Native writer events are not yet on the status wire. A graph
+            // publication phase cannot prove the graph writer has stalled.
+            if progress.phase == CodeIndexBuildPhaseV1::GraphPublication {
+                return None;
+            }
+            if !matches!(
+                progress.phase,
+                CodeIndexBuildPhaseV1::Ready | CodeIndexBuildPhaseV1::SourceScan
+            ) {
+                return Some(Self::CommittedText {
+                    generation: progress.generation_id.clone(),
+                    owner: (progress.daemon_incarnation, progress.producer_incarnation),
+                    epoch: progress.progress_epoch,
+                    last_work_micros: progress.last_progress_micros,
+                });
+            }
+        }
+        if let Some(attempt) = worktree.preseal_attempt.as_ref().filter(|a| a.active) {
+            return Some(Self::Preseal {
+                owner: (
+                    attempt.daemon_incarnation,
+                    attempt.producer_incarnation,
+                    attempt.attempt_sequence,
+                ),
+                epoch: attempt.progress_epoch,
+                last_work_micros: attempt.last_progress_micros,
+            });
+        }
+        worktree
+            .progress
+            .as_ref()
+            .filter(|progress| progress.phase == CodeIndexBuildPhaseV1::SourceScan)
+            .map(|progress| Self::CommittedText {
+                generation: progress.generation_id.clone(),
+                owner: (progress.daemon_incarnation, progress.producer_incarnation),
+                epoch: progress.progress_epoch,
+                last_work_micros: progress.last_progress_micros,
+            })
+    }
+}
+
+/// Compare work boundaries across status slices without renewing the clock
+/// on a read. A new owner or observed work epoch restarts the silence window.
+struct FirstGenerationProgressWindow {
+    last: Option<FirstGenerationWorkMarker>,
+    unchanged_since: Option<Instant>,
+    stall_window: Duration,
+}
+
+impl FirstGenerationProgressWindow {
+    fn new(stall_window: Duration) -> Self {
+        Self {
+            last: None,
+            unchanged_since: None,
+            stall_window,
+        }
+    }
+
+    fn observe(&mut self, marker: Option<FirstGenerationWorkMarker>, now: Instant) -> bool {
+        if marker.is_none() {
+            self.last = None;
+            self.unchanged_since = None;
+            return false;
+        }
+        if self.last != marker {
+            self.last = marker;
+            self.unchanged_since = Some(now);
+            return false;
+        }
+        let since = *self.unchanged_since.get_or_insert(now);
+        now.duration_since(since) >= self.stall_window
+    }
+}
+
 /// Only continuous idle observations spend the stall window. An active
 /// readiness owner clears the window even if it publishes no new progress.
 struct FirstGenerationIdleWindow {
@@ -782,6 +890,76 @@ mod daemon_precondition_tests {
         );
     }
 
+    fn attempt(phase: tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1,
+        epoch: u64, completed: u64, sequence: u64) -> CodeIndexWorktreeFreshnessV1 {
+        let mut result = building(true);
+        result.preseal_attempt = Some(
+            tracedecay_contracts::code_index_freshness::CodeIndexPresealAttemptProgressV1 {
+                daemon_incarnation: 3, producer_incarnation: 5,
+                attempt_sequence: sequence, progress_epoch: epoch, phase,
+                completed_items: completed, total_items: Some(50),
+                last_progress_micros: (completed > 0).then_some((completed * 100) as i64),
+                active: true,
+            },
+        );
+        result
+    }
+
+    #[test]
+    fn active_capture_without_work_is_not_an_infinite_wait() {
+        use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::Capture;
+        let source = attempt(Capture, 1, 0, 1);
+        let now = Instant::now();
+        let marker = super::FirstGenerationWorkMarker::of(Some(&source));
+        assert!(marker.is_some());
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        assert!(!window.observe(marker.clone(), now));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(119)));
+        assert!(window.observe(marker, now + Duration::from_secs(120)));
+    }
+
+    #[test]
+    fn real_capture_parse_and_successor_attempts_reset_the_silence_window() {
+        use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::{
+            Capture, ParseEvidence,
+        };
+        let now = Instant::now();
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        let capture = attempt(Capture, 2, 3, 1);
+        let marker = super::FirstGenerationWorkMarker::of(Some(&capture));
+        assert!(!window.observe(marker.clone(), now));
+        assert!(!window.observe(marker, now + Duration::from_secs(119)));
+        let parsed = attempt(ParseEvidence, 3, 1, 1);
+        let marker = super::FirstGenerationWorkMarker::of(Some(&parsed));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(119)));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(238)));
+        assert!(window.observe(marker, now + Duration::from_secs(239)));
+        let retry = attempt(Capture, 4, 0, 2);
+        let marker = super::FirstGenerationWorkMarker::of(Some(&retry));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(239)));
+        assert!(!window.observe(marker, now + Duration::from_secs(358)));
+    }
+
+    #[test]
+    fn committed_text_can_stall_but_unreported_graph_writes_cannot_fake_a_stall() {
+        let now = Instant::now();
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        let mut source = building(true);
+        source.progress = Some(progress(10, None));
+        let marker = super::FirstGenerationWorkMarker::of(Some(&source));
+        assert!(!window.observe(marker.clone(), now));
+        assert!(!window.observe(marker, now + Duration::from_secs(119)));
+        source.progress = Some(progress(12, None));
+        let marker = super::FirstGenerationWorkMarker::of(Some(&source));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(119)));
+        assert!(window.observe(marker, now + Duration::from_secs(239)));
+        source.progress.as_mut().unwrap().phase = CodeIndexBuildPhaseV1::GraphPublication;
+        assert_eq!(super::FirstGenerationWorkMarker::of(Some(&source)), None);
+        assert!(!window.observe(None, now + Duration::from_secs(1000)));
+        source.progress.as_mut().unwrap().phase = CodeIndexBuildPhaseV1::Ready;
+        assert_eq!(super::FirstGenerationWorkMarker::of(Some(&source)), None);
+    }
+
     fn progress(
         completed_files: u64,
         blocked_reason: Option<CodeIndexBuildBlockedReasonV1>,

From 3258ac2d522349ad69d4004fcefc5cf804ca6d26 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 00:25:12 -0800
Subject: [PATCH 13/80] fix(cli): exclude uninstrumented phases from stall
 detection

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 53 ++++++++++++++-------
 1 file changed, 36 insertions(+), 17 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index e14a6f3a282..504523f9d5e 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -475,16 +475,20 @@ impl FirstGenerationWorkMarker {
             if progress.phase == CodeIndexBuildPhaseV1::GraphPublication {
                 return None;
             }
-            if !matches!(
-                progress.phase,
-                CodeIndexBuildPhaseV1::Ready | CodeIndexBuildPhaseV1::SourceScan
-            ) {
-                return Some(Self::CommittedText {
-                    generation: progress.generation_id.clone(),
-                    owner: (progress.daemon_incarnation, progress.producer_incarnation),
-                    epoch: progress.progress_epoch,
-                    last_work_micros: progress.last_progress_micros,
-                });
+            match progress.phase {
+                CodeIndexBuildPhaseV1::BulkCommit => {
+                    return Some(Self::CommittedText {
+                        generation: progress.generation_id.clone(),
+                        owner: (progress.daemon_incarnation, progress.producer_incarnation),
+                        epoch: progress.progress_epoch,
+                        last_work_micros: progress.last_progress_micros,
+                    });
+                }
+                CodeIndexBuildPhaseV1::SourceScan => {}
+                // Preparing relations, building indexes and verifying the
+                // sealed source still lack an actual progress producer.
+                // Their phase labels alone cannot prove a stall either.
+                _ => return None,
             }
         }
         if let Some(attempt) = worktree.preseal_attempt.as_ref().filter(|a| a.active) {
@@ -890,14 +894,22 @@ mod daemon_precondition_tests {
         );
     }
 
-    fn attempt(phase: tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1,
-        epoch: u64, completed: u64, sequence: u64) -> CodeIndexWorktreeFreshnessV1 {
+    fn attempt(
+        phase: tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1,
+        epoch: u64,
+        completed: u64,
+        sequence: u64,
+    ) -> CodeIndexWorktreeFreshnessV1 {
         let mut result = building(true);
         result.preseal_attempt = Some(
             tracedecay_contracts::code_index_freshness::CodeIndexPresealAttemptProgressV1 {
-                daemon_incarnation: 3, producer_incarnation: 5,
-                attempt_sequence: sequence, progress_epoch: epoch, phase,
-                completed_items: completed, total_items: Some(50),
+                daemon_incarnation: 3,
+                producer_incarnation: 5,
+                attempt_sequence: sequence,
+                progress_epoch: epoch,
+                phase,
+                completed_items: completed,
+                total_items: Some(50),
                 last_progress_micros: (completed > 0).then_some((completed * 100) as i64),
                 active: true,
             },
@@ -953,8 +965,15 @@ mod daemon_precondition_tests {
         let marker = super::FirstGenerationWorkMarker::of(Some(&source));
         assert!(!window.observe(marker.clone(), now + Duration::from_secs(119)));
         assert!(window.observe(marker, now + Duration::from_secs(239)));
-        source.progress.as_mut().unwrap().phase = CodeIndexBuildPhaseV1::GraphPublication;
-        assert_eq!(super::FirstGenerationWorkMarker::of(Some(&source)), None);
+        for phase in [
+            CodeIndexBuildPhaseV1::RelationalPreparation,
+            CodeIndexBuildPhaseV1::IndexBuild,
+            CodeIndexBuildPhaseV1::Verification,
+            CodeIndexBuildPhaseV1::GraphPublication,
+        ] {
+            source.progress.as_mut().unwrap().phase = phase;
+            assert_eq!(super::FirstGenerationWorkMarker::of(Some(&source)), None);
+        }
         assert!(!window.observe(None, now + Duration::from_secs(1000)));
         source.progress.as_mut().unwrap().phase = CodeIndexBuildPhaseV1::Ready;
         assert_eq!(super::FirstGenerationWorkMarker::of(Some(&source)), None);

From 84e10bc6438add4f7689eaf914f334facc019f02 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 00:28:34 -0800
Subject: [PATCH 14/80] fix(code-index): observe retained restart capture and
 parse work

Refs #4508
---
 .../src/code_index_scheduler/reconcile.rs     | 16 +++++++-
 .../tests/code_index_scheduler/reconcile.rs   | 41 +++++++++++++++++++
 2 files changed, 56 insertions(+), 1 deletion(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
index 398b280836b..e2eec3e40f4 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
@@ -153,6 +153,9 @@ pub(super) struct RetainedReconcileCaptureV1 {
     captured: CapturedSnapshotV1,
     drained_hints: DrainedPendingHintsV1,
     control: DaemonCodeIndexControlV1,
+    // Keep this guard alive through retained parsing and publication. Any
+    // cancellation, early return, or unwind closes the exact attempt.
+    _attempt: CodeIndexPresealAttemptGuardV1,
     git_metadata: identity::GitMetadataFingerprintV1,
     stat_signature: Option<String>,
 }
@@ -2122,6 +2125,7 @@ impl CodeIndexWorktreeSchedulerV1 {
             captured,
             drained_hints,
             control,
+            _attempt,
             git_metadata,
             stat_signature,
         } = capture;
@@ -2349,7 +2353,15 @@ impl CodeIndexWorktreeSchedulerV1 {
     pub(super) fn capture_retained_reconcile_attempt(
         &self,
     ) -> Result<Option<RetainedReconcileCaptureV1>, CodeIndexSchedulerErrorV1> {
-        let control = self.reconcile_control();
+        // A retained generation still scans the source. Changed files may
+        // proceed into a real parser-backed publish; share one attempt
+        // authority across both rather than running an unobserved capture.
+        let attempt = CodeIndexPresealAttemptGuardV1::begin(
+            Arc::clone(&self.preseal_attempt_progress),
+            self.progress_daemon_incarnation,
+            self.progress_producer_incarnation,
+        );
+        let control = self.reconcile_control().with_preseal_observer(attempt.observer());
         let captured = self
             .capture_authoritative_snapshot_without_active_generation_reuse(Some(&control))
             .map_err(|error| prefer_resident_memory_refusal(&control, error))?;
@@ -2370,6 +2382,7 @@ impl CodeIndexWorktreeSchedulerV1 {
             captured,
             drained_hints,
             control,
+            _attempt: attempt,
             git_metadata,
             stat_signature,
         }))
@@ -2385,6 +2398,7 @@ impl CodeIndexWorktreeSchedulerV1 {
             mut captured,
             drained_hints,
             control,
+            _attempt,
             git_metadata,
             stat_signature,
         } = capture;
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
index ac84ed5c9d7..197585914ca 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
@@ -134,6 +134,47 @@ fn cold_build_reports_actual_preseal_capture_and_parser_evidence() {
     assert!(observed.progress_epoch >= 5, "two captures and two parses plus start");
 }
 
+/// A restart's retained-source verification is real work and must report
+/// capture without inventing a sealed generation or a polling heartbeat.
+#[test]
+fn retained_restart_capture_publishes_and_fences_preseal_attempt() {
+    let fixture = GitFixture::new(&[
+        ("src/a.rs", "pub fn a() -> u32 { 1 }\n"),
+        ("src/b.rs", "pub fn b() -> u32 { 2 }\n"),
+    ]);
+    let store = TempDir::new().expect("store root");
+    let pool = Arc::new(SharedCodeIndexBytePoolV1::default());
+    {
+        let mut initial = scheduler(&fixture, store.path().to_path_buf(), Arc::clone(&pool));
+        published(initial.reconcile_now().expect("initial generation"));
+    }
+    let reopened = scheduler(&fixture, store.path().to_path_buf(), pool);
+    let slot = reopened.preseal_attempt_progress_slot();
+    assert!(
+        slot.read().unwrap().snapshot().is_none(),
+        "reopening must not fabricate a live pre-seal attempt"
+    );
+    let capture = reopened
+        .capture_retained_reconcile_attempt()
+        .expect("retained capture succeeds")
+        .expect("the retained capture has a live owner");
+    let observed = slot.read().unwrap().snapshot().expect("real retained work");
+    assert!(observed.active);
+    assert_eq!(
+        observed.phase,
+        tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Capture
+    );
+    assert!(observed.completed_items >= 2, "two files were actually captured");
+    assert!(observed.progress_epoch > 1);
+    assert!(observed.last_progress_micros.is_some_and(|at| at > 0));
+    drop(capture);
+    let finished = slot.read().unwrap().snapshot().expect("finished attempt");
+    assert!(!finished.active, "dropping the retained owner fences callbacks");
+    assert_eq!(finished.completed_items, observed.completed_items);
+    assert_eq!(finished.last_progress_micros, observed.last_progress_micros);
+    assert!(finished.progress_epoch > observed.progress_epoch);
+}
+
 #[test]
 fn unchanged_mixed_roster_restart_retains_generation_pointer_and_artifact() {
     let fixture = GitFixture::new(MIXED_SOURCE_ROSTER);

From 9ac710a32381e79e926bdd85397cd5568dd39fc8 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 00:29:36 -0800
Subject: [PATCH 15/80] fix(cli): retain real pre-seal work through restoring
 states

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 504523f9d5e..d3cd44b25f5 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -468,7 +468,15 @@ enum FirstGenerationWorkMarker {
 
 impl FirstGenerationWorkMarker {
     fn of(worktree: Option<&CodeIndexWorktreeFreshnessV1>) -> Option<Self> {
-        let worktree = worktree.filter(|state| state.rebuild_in_flight)?;
+        let worktree = worktree?;
+        // Restoring and verifying are readiness work even when the canonical
+        // freshness ladder deliberately reports rebuild_in_flight=false.
+        // A real active attempt remains authoritative in either state.
+        if !worktree.rebuild_in_flight
+            && !worktree.preseal_attempt.as_ref().is_some_and(|a| a.active)
+        {
+            return None;
+        }
         if let Some(progress) = &worktree.progress {
             // Native writer events are not yet on the status wire. A graph
             // publication phase cannot prove the graph writer has stalled.
@@ -920,7 +928,10 @@ mod daemon_precondition_tests {
     #[test]
     fn active_capture_without_work_is_not_an_infinite_wait() {
         use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::Capture;
-        let source = attempt(Capture, 1, 0, 1);
+        let mut source = attempt(Capture, 1, 0, 1);
+        // Restore/verification may own real pre-seal work without counting
+        // as a rebuild in the canonical freshness ladder.
+        source.rebuild_in_flight = false;
         let now = Instant::now();
         let marker = super::FirstGenerationWorkMarker::of(Some(&source));
         assert!(marker.is_some());

From 70de8b355bb540e95f58f80fc1486df01d7a1f87 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 00:57:36 -0800
Subject: [PATCH 16/80] fix(cli): distinguish observed work from status
 publications

Refs #4508

Import the production phase type and require actual capture, parse or
text counters to advance before renewing init --wait's silence window.
Keep independent producer watermarks and reject retired-owner reports.
Empty retries, phase-only changes, blocked/recovered metadata and adopted
restart counters are not new work. Preserve uninstrumented graph phases
as unknown rather than reporting a fabricated writer stall.

Add six nonzero behavioral regressions, including three tests through the
real wait loop, and strengthen the existing empty-retry expectation.
No Bazel execution or complete cold/restart acceptance is claimed.
---
 crates/tracedecay-cli/src/commands/index.rs | 391 ++++++++++++++++++--
 1 file changed, 351 insertions(+), 40 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index d3cd44b25f5..1699838bfaf 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -6,8 +6,8 @@ use tracedecay_project::project::TraceDecay;
 
 use tracedecay_contracts::code_index_freshness::{
     CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
-    CodeIndexBuildBlockedReasonV1, CodeIndexBuildProgressV1, CodeIndexReadinessWaitOutcomeV1,
-    CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
+    CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexBuildProgressV1,
+    CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::graph_tool::GraphToolResultV1;
 use tracedecay_contracts::retrieval::{
@@ -450,19 +450,22 @@ impl FirstGenerationStall {
     }
 }
 
-/// One real producer's last boundary. A polling read is never a heartbeat.
+/// Observed work under one producer. Epochs order reports; they are not work.
 #[derive(Clone, Debug, PartialEq, Eq)]
 enum FirstGenerationWorkMarker {
     Preseal {
         owner: (u64, u64, u64),
         epoch: u64,
+        phase: tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1,
+        completed: u64,
         last_work_micros: Option<i64>,
     },
     CommittedText {
         generation: String,
+        sealed_source_digest: String,
         owner: (u64, u64),
         epoch: u64,
-        last_work_micros: i64,
+        completed: [u64; 6],
     },
 }
 
@@ -478,24 +481,12 @@ impl FirstGenerationWorkMarker {
             return None;
         }
         if let Some(progress) = &worktree.progress {
-            // Native writer events are not yet on the status wire. A graph
-            // publication phase cannot prove the graph writer has stalled.
-            if progress.phase == CodeIndexBuildPhaseV1::GraphPublication {
-                return None;
-            }
             match progress.phase {
-                CodeIndexBuildPhaseV1::BulkCommit => {
-                    return Some(Self::CommittedText {
-                        generation: progress.generation_id.clone(),
-                        owner: (progress.daemon_incarnation, progress.producer_incarnation),
-                        epoch: progress.progress_epoch,
-                        last_work_micros: progress.last_progress_micros,
-                    });
-                }
+                CodeIndexBuildPhaseV1::BulkCommit => return Some(Self::text(progress)),
                 CodeIndexBuildPhaseV1::SourceScan => {}
-                // Preparing relations, building indexes and verifying the
-                // sealed source still lack an actual progress producer.
-                // Their phase labels alone cannot prove a stall either.
+                // Graph publication, relational preparation, index builds
+                // and verification lack work observations on this wire. Do
+                // not infer a writer stall from their phase labels alone.
                 _ => return None,
             }
         }
@@ -507,6 +498,8 @@ impl FirstGenerationWorkMarker {
                     attempt.attempt_sequence,
                 ),
                 epoch: attempt.progress_epoch,
+                phase: attempt.phase,
+                completed: attempt.completed_items,
                 last_work_micros: attempt.last_progress_micros,
             });
         }
@@ -514,19 +507,118 @@ impl FirstGenerationWorkMarker {
             .progress
             .as_ref()
             .filter(|progress| progress.phase == CodeIndexBuildPhaseV1::SourceScan)
-            .map(|progress| Self::CommittedText {
-                generation: progress.generation_id.clone(),
-                owner: (progress.daemon_incarnation, progress.producer_incarnation),
-                epoch: progress.progress_epoch,
-                last_work_micros: progress.last_progress_micros,
-            })
+            .map(Self::text)
+    }
+
+    fn text(progress: &CodeIndexBuildProgressV1) -> Self {
+        Self::CommittedText {
+            generation: progress.generation_id.clone(),
+            sealed_source_digest: progress.sealed_source_digest.clone(),
+            owner: (progress.daemon_incarnation, progress.producer_incarnation),
+            epoch: progress.progress_epoch,
+            completed: [
+                progress.completed_files,
+                progress.completed_lexical_units,
+                progress.committed_pages,
+                progress.committed_chunks,
+                progress.committed_imports,
+                progress.committed_payload_bytes,
+            ],
+        }
+    }
+
+    fn owner(&self) -> (u64, u64) {
+        match self {
+            Self::Preseal { owner, .. } => (owner.0, owner.1),
+            Self::CommittedText { owner, .. } => *owner,
+        }
+    }
+
+    /// Accept a newer report and say whether actual work advanced. A newer
+    /// refusal, retry, timestamp or daemon incarnation is not itself work.
+    /// `None` rejects a duplicate or stale report without lowering the fence.
+    fn advance_from(&self, previous: &Self) -> Option<bool> {
+        match (self, previous) {
+            (
+                Self::Preseal {
+                    owner,
+                    epoch,
+                    phase,
+                    completed,
+                    last_work_micros,
+                },
+                Self::Preseal {
+                    owner: prior_owner,
+                    epoch: prior_epoch,
+                    phase: prior_phase,
+                    completed: prior_completed,
+                    ..
+                },
+            ) => {
+                use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::{
+                    Capture, ParseEvidence,
+                };
+                if (owner, epoch) <= (prior_owner, prior_epoch) {
+                    return None;
+                }
+                if owner == prior_owner {
+                    if matches!((prior_phase, phase), (ParseEvidence, Capture))
+                        || (phase == prior_phase && completed < prior_completed)
+                    {
+                        return None;
+                    }
+                    if phase == prior_phase {
+                        return Some(completed > prior_completed && last_work_micros.is_some());
+                    }
+                }
+                Some(*completed > 0 && last_work_micros.is_some())
+            }
+            (
+                Self::CommittedText {
+                    generation,
+                    sealed_source_digest,
+                    owner,
+                    epoch,
+                    completed,
+                },
+                Self::CommittedText {
+                    generation: prior_generation,
+                    sealed_source_digest: prior_digest,
+                    owner: prior_owner,
+                    epoch: prior_epoch,
+                    completed: prior_completed,
+                },
+            ) => {
+                if (owner, epoch) <= (prior_owner, prior_epoch) {
+                    return None;
+                }
+                if generation != prior_generation {
+                    return Some(completed.iter().any(|count| *count > 0));
+                }
+                if sealed_source_digest != prior_digest {
+                    return None;
+                }
+                // A verified staging restart may reset counters. Adopt that
+                // newer baseline, but only subsequent work renews the wait.
+                Some(
+                    completed != prior_completed
+                        && completed
+                            .iter()
+                            .zip(prior_completed)
+                            .all(|(now, prior)| now >= prior),
+                )
+            }
+            _ => None,
+        }
     }
 }
 
-/// Compare work boundaries across status slices without renewing the clock
-/// on a read. A new owner or observed work epoch restarts the silence window.
+/// Maintain independent watermarks for pre-seal and text work. Polling,
+/// status changes and empty retries cannot renew an observed silence window.
 struct FirstGenerationProgressWindow {
-    last: Option<FirstGenerationWorkMarker>,
+    preseal: Option<FirstGenerationWorkMarker>,
+    text: Option<FirstGenerationWorkMarker>,
+    owner: Option<(u64, u64)>,
     unchanged_since: Option<Instant>,
     stall_window: Duration,
 }
@@ -534,25 +626,58 @@ struct FirstGenerationProgressWindow {
 impl FirstGenerationProgressWindow {
     fn new(stall_window: Duration) -> Self {
         Self {
-            last: None,
+            preseal: None,
+            text: None,
+            owner: None,
             unchanged_since: None,
             stall_window,
         }
     }
 
     fn observe(&mut self, marker: Option<FirstGenerationWorkMarker>, now: Instant) -> bool {
-        if marker.is_none() {
-            self.last = None;
+        let Some(marker) = marker else {
+            // Uninstrumented work is unknown, not stalled. Keep watermarks
+            // so returning to an old report cannot fabricate new work.
             self.unchanged_since = None;
             return false;
-        }
-        if self.last != marker {
-            self.last = marker;
+        };
+        let advanced = self.record(marker);
+        if advanced || self.unchanged_since.is_none() {
             self.unchanged_since = Some(now);
             return false;
         }
-        let since = *self.unchanged_since.get_or_insert(now);
-        now.duration_since(since) >= self.stall_window
+        self.unchanged_since
+            .is_some_and(|since| now.duration_since(since) >= self.stall_window)
+    }
+
+    fn record(&mut self, marker: FirstGenerationWorkMarker) -> bool {
+        let owner = marker.owner();
+        if self.owner.is_some_and(|current| owner < current) {
+            return false;
+        }
+        self.owner = Some(owner);
+        let previous = match &marker {
+            FirstGenerationWorkMarker::Preseal { .. } => &mut self.preseal,
+            FirstGenerationWorkMarker::CommittedText { .. } => &mut self.text,
+        };
+        let advanced = match previous.as_ref() {
+            Some(prior) => match marker.advance_from(prior) {
+                Some(advanced) => advanced,
+                None => return false,
+            },
+            None => match &marker {
+                FirstGenerationWorkMarker::Preseal {
+                    completed,
+                    last_work_micros,
+                    ..
+                } => *completed > 0 && last_work_micros.is_some(),
+                FirstGenerationWorkMarker::CommittedText { completed, .. } => {
+                    completed.iter().any(|count| *count > 0)
+                }
+            },
+        };
+        *previous = Some(marker);
+        advanced
     }
 }
 
@@ -942,7 +1067,7 @@ mod daemon_precondition_tests {
     }
 
     #[test]
-    fn real_capture_parse_and_successor_attempts_reset_the_silence_window() {
+    fn real_capture_parse_and_resumed_work_reset_the_silence_window() {
         use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::{
             Capture, ParseEvidence,
         };
@@ -959,8 +1084,12 @@ mod daemon_precondition_tests {
         assert!(window.observe(marker, now + Duration::from_secs(239)));
         let retry = attempt(Capture, 4, 0, 2);
         let marker = super::FirstGenerationWorkMarker::of(Some(&retry));
-        assert!(!window.observe(marker.clone(), now + Duration::from_secs(239)));
-        assert!(!window.observe(marker, now + Duration::from_secs(358)));
+        assert!(window.observe(marker, now + Duration::from_secs(239)));
+        let resumed = attempt(Capture, 5, 1, 2);
+        let marker = super::FirstGenerationWorkMarker::of(Some(&resumed));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(240)));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(359)));
+        assert!(window.observe(marker, now + Duration::from_secs(360)));
     }
 
     #[test]
@@ -990,6 +1119,188 @@ mod daemon_precondition_tests {
         assert_eq!(super::FirstGenerationWorkMarker::of(Some(&source)), None);
     }
 
+    #[test]
+    fn status_epochs_timestamps_and_recovery_do_not_renew_work() {
+        let now = Instant::now();
+        let mut source = building(true);
+        let mut report = progress(40, None);
+        report.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        source.progress = Some(report.clone());
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        assert!(!window.observe(
+            super::FirstGenerationWorkMarker::of(Some(&source)),
+            now,
+        ));
+        for (seconds, blocked) in [
+            (40, Some(CodeIndexBuildBlockedReasonV1::ResidentMemory)),
+            (80, None),
+            (120, Some(CodeIndexBuildBlockedReasonV1::RetryBackoff)),
+        ] {
+            report.progress_epoch += 1;
+            report.last_progress_micros += 100;
+            report.elapsed_micros += 100;
+            report.current_batch_pages += 1;
+            report.current_batch_payload_bytes += 4096;
+            report.files_per_second = Some(42.0);
+            report.blocked_reason = blocked;
+            source.progress = Some(report.clone());
+            assert_eq!(
+                window.observe(
+                    super::FirstGenerationWorkMarker::of(Some(&source)),
+                    now + Duration::from_secs(seconds),
+                ),
+                seconds == 120,
+                "metadata and blocked/recovered state are not completed work",
+            );
+        }
+        report.blocked_reason = None;
+        report.progress_epoch += 1;
+        report.committed_pages += 1;
+        report.committed_payload_bytes += 1024;
+        source.progress = Some(report);
+        let marker = super::FirstGenerationWorkMarker::of(Some(&source));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(121)));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(240)));
+        assert!(window.observe(marker, now + Duration::from_secs(241)));
+    }
+
+    #[test]
+    fn preseal_phase_only_changes_and_delayed_callbacks_do_not_renew_work() {
+        use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::{
+            Capture, ParseEvidence,
+        };
+        let now = Instant::now();
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        let capture = attempt(Capture, 2, 3, 1);
+        assert!(!window.observe(
+            super::FirstGenerationWorkMarker::of(Some(&capture)),
+            now,
+        ));
+        let entered_parse = attempt(ParseEvidence, 3, 0, 1);
+        assert!(!window.observe(
+            super::FirstGenerationWorkMarker::of(Some(&entered_parse)),
+            now + Duration::from_secs(119),
+        ));
+        let stale_capture = attempt(Capture, 99, 50, 1);
+        assert!(window.observe(
+            super::FirstGenerationWorkMarker::of(Some(&stale_capture)),
+            now + Duration::from_secs(120),
+        ));
+        let parsed = attempt(ParseEvidence, 4, 1, 1);
+        let marker = super::FirstGenerationWorkMarker::of(Some(&parsed));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(121)));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(240)));
+        assert!(window.observe(marker, now + Duration::from_secs(241)));
+    }
+
+    #[test]
+    fn restart_adoption_is_not_work_and_old_daemon_reports_stay_fenced() {
+        let now = Instant::now();
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        let mut source = building(true);
+        source.progress = Some(progress(40, None));
+        assert!(!window.observe(
+            super::FirstGenerationWorkMarker::of(Some(&source)),
+            now,
+        ));
+        let mut adopted = progress(40, None);
+        adopted.daemon_incarnation = 2;
+        adopted.progress_epoch = 1;
+        source.progress = Some(adopted.clone());
+        assert!(!window.observe(
+            super::FirstGenerationWorkMarker::of(Some(&source)),
+            now + Duration::from_secs(119),
+        ));
+        source.progress = Some(progress(500, None));
+        assert!(window.observe(
+            super::FirstGenerationWorkMarker::of(Some(&source)),
+            now + Duration::from_secs(120),
+        ));
+        adopted.completed_files += 1;
+        adopted.committed_pages += 1;
+        adopted.progress_epoch += 1;
+        source.progress = Some(adopted);
+        let marker = super::FirstGenerationWorkMarker::of(Some(&source));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(121)));
+        assert!(window.observe(marker, now + Duration::from_secs(241)));
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn wait_loop_refuses_epoch_only_changes_before_a_later_ready() {
+        let mut first = building(true);
+        let mut report = progress(40, None);
+        report.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        first.progress = Some(report.clone());
+        let mut unchanged = first.clone();
+        report.progress_epoch += 1;
+        report.last_progress_micros += 1000;
+        report.elapsed_micros += 1000;
+        unchanged.progress = Some(report);
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(first)),
+                status(timed_out(), warming(unchanged)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2, "do not consume a later ready after a real stall");
+        let (code, message) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(message.contains("no observed capture, parse, or committed text work"));
+        assert!(message.contains("40/6136 files"));
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn wait_loop_empty_retries_cannot_hide_frozen_preseal_work() {
+        use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::Capture;
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(attempt(Capture, 2, 3, 1))),
+                status(timed_out(), warming(attempt(Capture, 3, 0, 2))),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2);
+        let (code, message) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(message.contains("attempt=3:5:2"));
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn wait_loop_requires_work_across_capture_parse_and_text_handoff() {
+        use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::{
+            Capture, ParseEvidence,
+        };
+        let mut first_text = building(true);
+        let mut report = progress(2, None);
+        report.daemon_incarnation = 3;
+        report.producer_incarnation = 5;
+        report.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        first_text.progress = Some(report.clone());
+        let mut next_text = first_text.clone();
+        report.progress_epoch += 1;
+        report.committed_chunks = 7;
+        report.committed_payload_bytes = 1024;
+        next_text.progress = Some(report);
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(attempt(Capture, 2, 3, 1))),
+                status(timed_out(), warming(attempt(ParseEvidence, 3, 1, 1))),
+                status(timed_out(), warming(first_text)),
+                status(timed_out(), warming(next_text)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert!(result.is_ok(), "real work must keep the wait alive: {result:?}");
+        assert_eq!(reads, 5, "only the reached proof ends a progressing wait");
+    }
+
     fn progress(
         completed_files: u64,
         blocked_reason: Option<CodeIndexBuildBlockedReasonV1>,

From b599014aeb322bfdbd51bddff0aa831d2d0fd00b Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 01:51:54 -0800
Subject: [PATCH 17/80] feat(graph): report real direct-seal row encoding
 windows

Refs #4508

Record actual completed compact builder windows during cold native graph
publication. Distinguish accepted in-memory rows from durable page and
verified segment commits; do not emit status-poll heartbeats.

Add a nonzero real-manifest regression covering monotonic entity/relation
windows and cancellation without a fabricated completed window.

This remains only operator tracing; owner-scoped status propagation,
Bazel verification and full cold/restart acceptance are still required.
---
 .../tracedecay-graph-db/src/sealed_store.rs   | 134 ++++++++++++++++++
 1 file changed, 134 insertions(+)

diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index 8ab180224cc..97a204d07b6 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -1976,6 +1976,21 @@ fn build_sealed_container(
                         &physical_namespace,
                         &mut sealed,
                         check,
+                        &|boundary| {
+                            // Direct sealing bypasses native staging pages.
+                            // Report each real row-window boundary while the
+                            // compact container is being assembled, but do
+                            // NOT count it as a committed native page/segment.
+                            tracing::info!(
+                                event = "graph_native_compact_rows_encoded",
+                                generation = %identity.generation,
+                                kind = boundary.kind.as_str(),
+                                completed_rows = boundary.completed_rows,
+                                total_rows = boundary.total_rows,
+                                durable = false,
+                                "native compact builder accepted a row window"
+                            );
+                        },
                     )?;
                     Ok((counts.0, counts.1, BTreeMap::new()))
                 }
@@ -2039,6 +2054,29 @@ fn build_sealed_container(
     Ok((entity_count, relation_count))
 }
 
+/// An accepted in-memory row window, not a durable graph page or segment.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum NativeCompactEncodeKindV1 {
+    Entities,
+    Relations,
+}
+
+impl NativeCompactEncodeKindV1 {
+    const fn as_str(self) -> &'static str {
+        match self {
+            Self::Entities => "entities",
+            Self::Relations => "relations",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct NativeCompactEncodeBoundaryV1 {
+    kind: NativeCompactEncodeKindV1,
+    completed_rows: usize,
+    total_rows: usize,
+}
+
 /// Pushes a dependency-free generation's rows straight from its verified
 /// manifest: the entities in identity order, then the relations in identity
 /// order, each endpoint resolved by binary search over the entity identities.
@@ -2055,6 +2093,7 @@ fn push_manifest_rows(
     physical_namespace: &GraphNamespace,
     sealed: &mut SealedCompactRows,
     check: &dyn Fn() -> Result<(), GraphDbError>,
+    observe: &dyn Fn(NativeCompactEncodeBoundaryV1),
 ) -> Result<(usize, usize), GraphDbError> {
     if !identity.dependencies.is_empty() {
         return Err(GraphDbError::invalid(
@@ -2100,6 +2139,13 @@ fn push_manifest_rows(
                         });
                     }
                 }
+                // This is actual accepted native builder work. The final
+                // compact container is not yet written, installed or verified.
+                observe(NativeCompactEncodeBoundaryV1 {
+                    kind: NativeCompactEncodeKindV1::Entities,
+                    completed_rows: start.saturating_add(window.len()),
+                    total_rows: entities.len(),
+                });
             }
             Ok::<(), GraphDbError>(())
         }
@@ -2161,6 +2207,11 @@ fn push_manifest_rows(
                 for (prepared, endpoints) in prepared {
                     sealed.push_prepared_relation(prepared, endpoints[0], endpoints[1])?;
                 }
+                observe(NativeCompactEncodeBoundaryV1 {
+                    kind: NativeCompactEncodeKindV1::Relations,
+                    completed_rows: start.saturating_add(window.len()),
+                    total_rows: relations.len(),
+                });
             }
             Ok::<(), GraphDbError>(())
         }
@@ -2891,6 +2942,89 @@ mod build_tests {
         );
     }
 
+    /// Cold dependency-free graph publication uses this writer rather than
+    /// native stage pages. Require real intermediate row boundaries, with a
+    /// final count equal to the input and no forged completed relation window.
+    #[test]
+    fn direct_compact_encoding_reports_only_accepted_row_windows() {
+        use std::sync::Mutex;
+
+        use super::{
+            NativeCompactEncodeBoundaryV1, NativeCompactEncodeKindV1, SealedCompactRows,
+            push_manifest_rows,
+        };
+
+        let fixture = manifest(1_101, 1_143);
+        let identity = fixture.identity();
+        let namespace = identity.physical_namespace().unwrap();
+        let staging = tempfile::tempdir().unwrap();
+        let rows = Mutex::new(Vec::<NativeCompactEncodeBoundaryV1>::new());
+        let pool = ThreadPoolBuilder::new().num_threads(1).build().unwrap();
+        let counts = pool
+            .install(|| {
+                let mut writer = SealedCompactRows::new(staging.path())?;
+                push_manifest_rows(
+                    &fixture,
+                    &identity,
+                    &namespace,
+                    &mut writer,
+                    &|| Ok(()),
+                    &|boundary| rows.lock().unwrap().push(boundary),
+                )
+            })
+            .expect("encode real manifest rows");
+        assert_eq!(counts, (1_101, 1_143));
+        let recorded = rows.into_inner().unwrap();
+        let entities: Vec<_> = recorded
+            .iter()
+            .filter(|event| event.kind == NativeCompactEncodeKindV1::Entities)
+            .collect();
+        let relations: Vec<_> = recorded
+            .iter()
+            .filter(|event| event.kind == NativeCompactEncodeKindV1::Relations)
+            .collect();
+        assert!(entities.len() >= 2, "must record multiple real entity windows");
+        assert!(relations.len() >= 2, "must record multiple real relation windows");
+        for (events, total) in [(entities, 1_101), (relations, 1_143)] {
+            let mut prior = 0;
+            for event in events {
+                assert_eq!(event.total_rows, total);
+                assert!(event.completed_rows > prior, "no retry heartbeat");
+                assert!(event.completed_rows <= total);
+                prior = event.completed_rows;
+            }
+            assert_eq!(prior, total, "the final observed window must be complete");
+        }
+
+        // A real cancellation midway through the second entity window must
+        // not report the failed window, any relations, or a full generation.
+        let failed = Mutex::new(Vec::<NativeCompactEncodeBoundaryV1>::new());
+        let calls = AtomicUsize::new(0);
+        let staging = tempfile::tempdir().unwrap();
+        let result = pool.install(|| {
+            let mut writer = SealedCompactRows::new(staging.path())?;
+            push_manifest_rows(
+                &fixture,
+                &identity,
+                &namespace,
+                &mut writer,
+                &|| {
+                    if calls.fetch_add(1, Ordering::AcqRel) >= 550 {
+                        return Err(GraphDbError::Cancelled);
+                    }
+                    Ok(())
+                },
+                &|boundary| failed.lock().unwrap().push(boundary),
+            )
+        });
+        assert!(matches!(result, Err(GraphDbError::Cancelled)));
+        let failed = failed.into_inner().unwrap();
+        assert_eq!(failed.len(), 1, "only the first complete window advanced");
+        assert_eq!(failed[0].kind, NativeCompactEncodeKindV1::Entities);
+        assert_eq!(failed[0].completed_rows, 512);
+        assert_eq!(failed[0].total_rows, 1_101);
+    }
+
     /// A reopened sealed generation serves its rows in place: opening it
     /// leaves a small fraction of the container resident, a point read
     /// answers exactly, and a page that fails verification refuses the read

From 14c1637f63488886a9534531093b5067a57277b8 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 02:34:15 -0800
Subject: [PATCH 18/80] feat(graph): publish typed native stage work boundaries

Refs #4508

Provide an explicit graph publication observer and emit authenticated native
page completion only after the real transaction settles. Replayed receipts
do not count as work. Preserve graph operation context across commit grants.
Add a nonzero real-persistent-stage regression. Status bridging remains open.
---
 .../src/generation_runtime.rs                 | 85 ++++++++++++++++++-
 .../src/registry/publication.rs               | 10 ++-
 crates/tracedecay-store/src/lib.rs            |  1 +
 .../src/runtime/graph_publication.rs          |  1 +
 .../runtime/graph_publication/operation.rs    | 50 ++++++++++-
 crates/tracedecay-store/src/runtime/mod.rs    |  1 +
 6 files changed, 141 insertions(+), 7 deletions(-)

diff --git a/crates/tracedecay-graph-db/src/generation_runtime.rs b/crates/tracedecay-graph-db/src/generation_runtime.rs
index ad0da38291a..7a6c44e8113 100644
--- a/crates/tracedecay-graph-db/src/generation_runtime.rs
+++ b/crates/tracedecay-graph-db/src/generation_runtime.rs
@@ -8,7 +8,9 @@ use std::vec::IntoIter;
 
 use grafeo_core::graph::Direction;
 use parking_lot::RwLockWriteGuard as ParkingRwLockWriteGuard;
-use tracedecay_store::runtime::GraphRecoveredGenerationDigestV1;
+use tracedecay_store::runtime::{
+    GraphNativeWorkKindV1, GraphNativeWorkV1, GraphRecoveredGenerationDigestV1,
+};
 
 use crate::generation::verify_recovered_generation;
 use crate::lease::{
@@ -181,6 +183,7 @@ struct GenerationStagePlan<'a> {
     context: &'a GenerationStageContext,
     pages: &'a [GenerationStagePage],
     restaging_sealed_only: bool,
+    observe: Option<&'a dyn Fn(GraphNativeWorkV1)>,
 }
 
 /// CPU-only page batch, built outside the exclusive snapshot gate so the next
@@ -607,6 +610,18 @@ impl GraphDb {
         manifest: Arc<GraphGenerationManifest>,
         expected: &GraphRecoveredGenerationDigestV1,
         check: &dyn Fn() -> Result<(), GraphDbError>,
+    ) -> Result<GenerationStageOutcome, GraphDbError> {
+        self.apply_generation_unverified_with_digest_and_work(manifest, expected, check, None)
+    }
+
+    /// Observable native stage work is emitted only after the real page
+    /// transaction and matching receipt have settled, never on read/replay.
+    pub(crate) fn apply_generation_unverified_with_digest_and_work(
+        &self,
+        manifest: Arc<GraphGenerationManifest>,
+        expected: &GraphRecoveredGenerationDigestV1,
+        check: &dyn Fn() -> Result<(), GraphDbError>,
+        observe: Option<&dyn Fn(GraphNativeWorkV1)>,
     ) -> Result<GenerationStageOutcome, GraphDbError> {
         check()?;
         manifest.validate_checked(check)?;
@@ -651,6 +666,7 @@ impl GraphDb {
             context: &context,
             pages: &pages,
             restaging_sealed_only,
+            observe,
         };
         match Arc::try_unwrap(manifest) {
             Ok(mut manifest) => {
@@ -782,6 +798,7 @@ impl GraphDb {
             context,
             pages,
             restaging_sealed_only,
+            observe,
         } = plan;
         let mut prepared_next = None;
         for (index, page) in pages.iter().enumerate() {
@@ -822,7 +839,7 @@ impl GraphDb {
                                 )
                             })
                         });
-                self.apply_prepared_generation_stage_page(
+                let (_, outcome) = self.apply_prepared_generation_stage_page(
                     Some(manifest),
                     identity,
                     expected,
@@ -832,6 +849,19 @@ impl GraphDb {
                     current,
                     check,
                 )?;
+                if let (GenerationStagePageCommitV1::Applied, Some(observer)) =
+                    (outcome, observe)
+                {
+                    observer(GraphNativeWorkV1::StagePageApplied {
+                        ordinal: u64::try_from(page.ordinal).unwrap_or(u64::MAX),
+                        kind: match page.kind {
+                            GenerationStagePageKind::Entities => GraphNativeWorkKindV1::Entities,
+                            GenerationStagePageKind::Relations => GraphNativeWorkKindV1::Relations,
+                        },
+                        mutations: u64::try_from(page.mutation_count()).unwrap_or(u64::MAX),
+                        live_bytes: u64::try_from(page.live_bytes()).unwrap_or(u64::MAX),
+                    });
+                }
                 // This is the exact cancellation boundary: the page transaction
                 // and receipt are durable, while no verified lease/head exists.
                 check()?;
@@ -869,6 +899,7 @@ impl GraphDb {
             context,
             pages,
             restaging_sealed_only,
+            observe,
         } = plan;
         let mut rows = OwnedGenerationStageRows::new(entities, relations);
         let Some(first_page) = pages.first() else {
@@ -931,7 +962,7 @@ impl GraphDb {
                         ));
                     }
                 };
-                self.apply_prepared_generation_stage_page(
+                let (_, outcome) = self.apply_prepared_generation_stage_page(
                     None,
                     identity,
                     expected,
@@ -941,6 +972,19 @@ impl GraphDb {
                     current.take(),
                     check,
                 )?;
+                if let (GenerationStagePageCommitV1::Applied, Some(observer)) =
+                    (outcome, observe)
+                {
+                    observer(GraphNativeWorkV1::StagePageApplied {
+                        ordinal: u64::try_from(page.ordinal).unwrap_or(u64::MAX),
+                        kind: match page.kind {
+                            GenerationStagePageKind::Entities => GraphNativeWorkKindV1::Entities,
+                            GenerationStagePageKind::Relations => GraphNativeWorkKindV1::Relations,
+                        },
+                        mutations: u64::try_from(page.mutation_count()).unwrap_or(u64::MAX),
+                        live_bytes: u64::try_from(page.live_bytes()).unwrap_or(u64::MAX),
+                    });
+                }
                 check()?;
                 successor_handle
                     .map(|handle| {
@@ -3759,6 +3803,41 @@ mod tests {
         );
     }
 
+    #[test]
+    fn native_stage_observer_reports_applied_pages_not_replayed_receipts() {
+        let manifest = large_manifest("native-stage-observer");
+        let expected = sealed_digest(&manifest);
+        let pages = generation_stage_pages(&manifest).expect("nonempty native pages");
+        assert!(!pages.is_empty());
+        let temp = TempDir::new().expect("persistent native graph store");
+        let (owner, db) = persistent_database(&temp);
+        let observed = std::sync::Mutex::new(Vec::new());
+        let observe = |event| observed.lock().unwrap().push(event);
+        let result = db
+            .apply_generation_unverified_with_digest_and_work(
+                Arc::new(manifest),
+                &expected,
+                &|| Ok(()),
+                Some(&observe),
+            )
+            .expect("real native stage");
+        assert!(matches!(result, super::GenerationStageOutcome::Applied(_)));
+        let observations = observed.lock().unwrap().clone();
+        assert!(
+            !observations.is_empty(),
+            "a real native stage with rows must report committed work"
+        );
+        assert!(observations.iter().all(|event| matches!(
+            event,
+            GraphNativeWorkV1::StagePageApplied {
+                mutations: 1..,
+                live_bytes: 1..,
+                ..
+            }
+        )));
+        owner.close().expect("close native graph store");
+    }
+
     #[test]
     fn native_graph_page_reports_real_wal_commits_but_not_replayed_receipts() {
         let manifest = large_manifest("native-write-observation");
diff --git a/crates/tracedecay-graph-db/src/registry/publication.rs b/crates/tracedecay-graph-db/src/registry/publication.rs
index ba88c179681..21c5ba84338 100644
--- a/crates/tracedecay-graph-db/src/registry/publication.rs
+++ b/crates/tracedecay-graph-db/src/registry/publication.rs
@@ -1478,6 +1478,7 @@ impl GraphDbRegistry {
         let database = operation.database().clone();
         database.record_memory_checkpoint(crate::observe::GrafeoMemoryPhase::PublishStart);
         let check = || operation.check(self, context);
+        let native_work = |work| context.observe_native_work(work);
         let replay = authority
             .replay(publication_key, context)
             .map_err(GraphDbError::from)?;
@@ -1705,10 +1706,11 @@ impl GraphDbRegistry {
                                 BTreeMap::new(),
                             );
                             database.remember_sealed_only_generation(&repair_lease)?;
-                            database.apply_generation_unverified_with_digest_observed(
+                            database.apply_generation_unverified_with_digest_and_work(
                                 manifest.into_manifest(&repair_check)?,
                                 sealed_digest,
                                 &repair_check,
+                                Some(&native_work),
                             )?;
                             database.reopen_and_verify_existing_generation(
                                 &identity,
@@ -1762,10 +1764,11 @@ impl GraphDbRegistry {
                                 (commit, sealed_digest.clone())
                             } else {
                                 let staged = database
-                                    .apply_generation_unverified_with_digest_observed(
+                                    .apply_generation_unverified_with_digest_and_work(
                                         manifest.into_manifest(&check)?,
                                         sealed_digest,
                                         &check,
+                                        Some(&native_work),
                                     )?;
                                 match staged {
                                     GenerationStageOutcome::Applied(commit) => {
@@ -1910,10 +1913,11 @@ impl GraphDbRegistry {
                         Ok((commit, sealed_digest.clone()))
                     }
                     Ok(None) => {
-                        let staged = database.apply_generation_unverified_with_digest_observed(
+                        let staged = database.apply_generation_unverified_with_digest_and_work(
                             manifest.into_manifest(&check)?,
                             sealed_digest,
                             &check,
+                            Some(&native_work),
                         )?;
                         let commit = staged.commit();
                         database
diff --git a/crates/tracedecay-store/src/lib.rs b/crates/tracedecay-store/src/lib.rs
index 2975c5fbfe2..e062bc5327c 100644
--- a/crates/tracedecay-store/src/lib.rs
+++ b/crates/tracedecay-store/src/lib.rs
@@ -184,6 +184,7 @@ pub use runtime::{
     GraphDependencyGenerationIdentityV1, GraphGenerationIdV1, GraphNamespaceV1, GraphNodeV1,
     GraphPendingReplayDiscardOutcomeV1, GraphPendingReplayDiscardV1, GraphProjectionIdV1,
     GraphProjectionIdentityV1, GraphPublicationIdempotencyKeyV1, GraphPublicationInputDigestV1,
+    GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
     GraphPublicationKeyV1, GraphPublicationOperationContextV1,
     GraphPublicationProjectionPageRequestV1, GraphPublicationProjectionPageV1,
     GraphPublicationReplayCursorV1, GraphPublicationReplayLookupV1,
diff --git a/crates/tracedecay-store/src/runtime/graph_publication.rs b/crates/tracedecay-store/src/runtime/graph_publication.rs
index 9541d32d2aa..14b00297557 100644
--- a/crates/tracedecay-store/src/runtime/graph_publication.rs
+++ b/crates/tracedecay-store/src/runtime/graph_publication.rs
@@ -23,6 +23,7 @@ pub use cleanup::{
 #[path = "graph_publication/operation.rs"]
 mod operation;
 pub use operation::{
+    GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
     GraphPublicationOperationContextV1, GraphPublicationStoreErrorV1, GraphPublicationStoreResultV1,
 };
 #[path = "graph_publication/store.rs"]
diff --git a/crates/tracedecay-store/src/runtime/graph_publication/operation.rs b/crates/tracedecay-store/src/runtime/graph_publication/operation.rs
index e2d95dfd1a8..8bc8bd29260 100644
--- a/crates/tracedecay-store/src/runtime/graph_publication/operation.rs
+++ b/crates/tracedecay-store/src/runtime/graph_publication/operation.rs
@@ -1,4 +1,7 @@
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering},
+};
 
 use thiserror::Error;
 
@@ -25,10 +28,41 @@ pub enum GraphPublicationStoreErrorV1 {
 
 pub type GraphPublicationStoreResultV1<T> = Result<T, GraphPublicationStoreErrorV1>;
 
+/// A real graph writer event. Encoding is never a durable page/segment;
+/// applied stage pages and verified installed segments are durable boundaries.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum GraphNativeWorkKindV1 {
+    Entities,
+    Relations,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum GraphNativeWorkV1 {
+    CompactRowsEncoded {
+        kind: GraphNativeWorkKindV1,
+        completed_rows: u64,
+        total_rows: u64,
+    },
+    StagePageApplied {
+        ordinal: u64,
+        kind: GraphNativeWorkKindV1,
+        mutations: u64,
+        live_bytes: u64,
+    },
+    CompactSegmentVerified {
+        entities: u64,
+        relations: u64,
+        canonical_bytes: u64,
+    },
+}
+
+pub type GraphNativeWorkObserverV1 = Arc<dyn Fn(GraphNativeWorkV1) + Send + Sync>;
+
 /// Existing caller-owned cancellation and monotonic deadline authority.
 pub struct GraphPublicationOperationContextV1<'a> {
     probe: &'a dyn RuntimeRequestProbeV1,
     commit_started: AtomicBool,
+    native_work_observer: Option<GraphNativeWorkObserverV1>,
 }
 
 impl<'a> GraphPublicationOperationContextV1<'a> {
@@ -50,9 +84,22 @@ impl<'a> GraphPublicationOperationContextV1<'a> {
         Ok(Self {
             probe,
             commit_started: AtomicBool::new(false),
+            native_work_observer: None,
         })
     }
 
+    #[must_use]
+    pub fn with_native_work_observer(mut self, observer: GraphNativeWorkObserverV1) -> Self {
+        self.native_work_observer = Some(observer);
+        self
+    }
+
+    pub fn observe_native_work(&self, work: GraphNativeWorkV1) {
+        if let Some(observer) = &self.native_work_observer {
+            observer(work);
+        }
+    }
+
     pub fn interruption(&self) -> Option<RuntimeInterruptionV1> {
         self.probe.interruption()
     }
@@ -72,6 +119,7 @@ impl<'a> GraphPublicationOperationContextV1<'a> {
         Self {
             probe: self.probe,
             commit_started: AtomicBool::new(false),
+            native_work_observer: self.native_work_observer.clone(),
         }
     }
 
diff --git a/crates/tracedecay-store/src/runtime/mod.rs b/crates/tracedecay-store/src/runtime/mod.rs
index 0ed05602369..41fbd7e5c9a 100644
--- a/crates/tracedecay-store/src/runtime/mod.rs
+++ b/crates/tracedecay-store/src/runtime/mod.rs
@@ -34,6 +34,7 @@ pub use graph_publication::{
     GraphDependencyGenerationIdentityV1, GraphGenerationIdV1, GraphNamespaceV1,
     GraphPendingReplayDiscardOutcomeV1, GraphPendingReplayDiscardV1, GraphProjectionIdV1,
     GraphProjectionIdentityV1, GraphPublicationIdempotencyKeyV1, GraphPublicationInputDigestV1,
+    GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
     GraphPublicationKeyV1, GraphPublicationOperationContextV1,
     GraphPublicationProjectionPageRequestV1, GraphPublicationProjectionPageV1,
     GraphPublicationReplayCursorV1, GraphPublicationReplayLookupV1,

From 37577a8f37fe76ceb9a67f70b79948b1d823d1aa Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 02:36:29 -0800
Subject: [PATCH 19/80] feat(graph): propagate typed compact writer milestones

Refs #4508

Report accepted direct-seal encoding windows as non-durable physical work.
Report only installed and digest-verified native compact segments as durable.
Replay adoption and losing installs must not claim fresh writes. Add a real
writer/reopen regression and correct the test module import boundary.
Graph-status and daemon propagation remain incomplete.
---
 .../src/registry/publication.rs               |   5 +-
 .../tracedecay-graph-db/src/sealed_store.rs   | 144 ++++++++++++++++--
 2 files changed, 133 insertions(+), 16 deletions(-)

diff --git a/crates/tracedecay-graph-db/src/registry/publication.rs b/crates/tracedecay-graph-db/src/registry/publication.rs
index 21c5ba84338..f6ed9788721 100644
--- a/crates/tracedecay-graph-db/src/registry/publication.rs
+++ b/crates/tracedecay-graph-db/src/registry/publication.rs
@@ -1759,6 +1759,7 @@ impl GraphDbRegistry {
                                 sealed_digest,
                                 direct_seal_eligible,
                                 &check,
+                                Some(&native_work),
                             )? {
                                 drop(manifest);
                                 (commit, sealed_digest.clone())
@@ -1906,6 +1907,7 @@ impl GraphDbRegistry {
                     sealed_digest,
                     direct_seal_eligible,
                     &check,
+                    Some(&native_work),
                 );
                 match direct {
                     Ok(Some(commit)) => {
@@ -2603,11 +2605,12 @@ fn direct_seal(
     expected: &GraphRecoveredGenerationDigestV1,
     eligible: bool,
     check: &dyn Fn() -> Result<(), GraphDbError>,
+    observe: Option<&dyn Fn(tracedecay_store::runtime::GraphNativeWorkV1)>,
 ) -> Result<Option<GraphCommit>, GraphDbError> {
     if !eligible {
         return Ok(None);
     }
-    database.seal_generation_directly(rows, expected, check)
+    database.seal_generation_directly(rows, expected, check, observe)
 }
 
 /// A row spill under `database`'s own scratch root for the generation a
diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index 97a204d07b6..c12ce33351f 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -54,7 +54,9 @@ use grafeo_core::graph::compact::IncrementalCompactStoreBuilder;
 use grafeo_engine::GrafeoDB;
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
-use tracedecay_store::runtime::GraphRecoveredGenerationDigestV1;
+use tracedecay_store::runtime::{
+    GraphNativeWorkKindV1, GraphNativeWorkV1, GraphRecoveredGenerationDigestV1,
+};
 
 use crate::generation::{
     GraphRowDigestSum, physical_namespace_projection_map, recovered_digest_from_row_sum,
@@ -1252,6 +1254,7 @@ impl GraphDb {
         rows: &GraphGenerationRows,
         expected: &GraphRecoveredGenerationDigestV1,
         check: &dyn Fn() -> Result<(), GraphDbError>,
+        observe: Option<&dyn Fn(GraphNativeWorkV1)>,
     ) -> Result<Option<GraphCommit>, GraphDbError> {
         if sealed_store_disabled() {
             return Ok(None);
@@ -1288,8 +1291,14 @@ impl GraphDb {
             // restage gets, not a silent rebuild underneath its readers.
             return Err(refusal);
         }
-        let (store, _) =
-            build_or_open_sealed_store(source, &identity, expected, &database_path, check)?;
+        let (store, _) = build_or_open_sealed_store_with_work(
+            source,
+            &identity,
+            expected,
+            &database_path,
+            check,
+            observe,
+        )?;
         self.install_sealed_generation_store(locator.clone(), store)?;
         // The generation normally exists only as this sealed artifact: it is
         // sealed-only from its first instant, and no lease remembered for it
@@ -1773,6 +1782,19 @@ fn build_or_open_sealed_store(
     expected: &GraphRecoveredGenerationDigestV1,
     database_path: &Path,
     check: &dyn Fn() -> Result<(), GraphDbError>,
+) -> Result<(Arc<SealedGenerationStore>, Option<u64>), GraphDbError> {
+    build_or_open_sealed_store_with_work(rows, identity, expected, database_path, check, None)
+}
+
+/// The caller-owned observer is bound to the exact publication operation.
+/// Reopening an existing segment emits no new completion event.
+fn build_or_open_sealed_store_with_work(
+    rows: SealedRowSource<'_>,
+    identity: &GraphGenerationManifestIdentity,
+    expected: &GraphRecoveredGenerationDigestV1,
+    database_path: &Path,
+    check: &dyn Fn() -> Result<(), GraphDbError>,
+    observe: Option<&dyn Fn(GraphNativeWorkV1)>,
 ) -> Result<(Arc<SealedGenerationStore>, Option<u64>), GraphDbError> {
     let staging_sourced = matches!(rows, SealedRowSource::Staging(_));
     let physical_namespace = identity.physical_namespace()?;
@@ -1811,7 +1833,7 @@ fn build_or_open_sealed_store(
     remove_sealed_directory(&staging);
     std::fs::create_dir_all(&staging)
         .map_err(|error| sealed_store_io_failure("staging directory create failed", error))?;
-    let receipt = stage_sealed_artifact(rows, identity, expected, &staging, check)
+    let receipt = stage_sealed_artifact(rows, identity, expected, &staging, check, observe)
         .inspect_err(|_| remove_sealed_directory(&staging))?;
     let encoded = serde_json::to_vec_pretty(&receipt)
         .map_err(|error| GraphDbError::unavailable(format!("sealed receipt encode: {error}")))?;
@@ -1852,6 +1874,13 @@ fn build_or_open_sealed_store(
                     canonical_bytes = store.canonical_bytes,
                     "installed and reopened the native graph compact segment"
                 );
+                if let Some(observer) = observe {
+                    observer(GraphNativeWorkV1::CompactSegmentVerified {
+                        entities: u64::try_from(receipt.entities).unwrap_or(u64::MAX),
+                        relations: u64::try_from(receipt.relations).unwrap_or(u64::MAX),
+                        canonical_bytes: store.canonical_bytes,
+                    });
+                }
             }
             Ok((store, staging_proof))
         }
@@ -1877,6 +1906,7 @@ fn stage_sealed_artifact(
     expected: &GraphRecoveredGenerationDigestV1,
     staging: &Path,
     check: &dyn Fn() -> Result<(), GraphDbError>,
+    observe: Option<&dyn Fn(GraphNativeWorkV1)>,
 ) -> Result<SealedStoreReceiptV1, GraphDbError> {
     let (row_sum, base_files, layered) = match rows {
         SealedRowSource::Spilled(spilled) => (
@@ -1901,7 +1931,7 @@ fn stage_sealed_artifact(
         rows => rows,
     };
     let (mut entities, mut relations) =
-        build_sealed_container(container_rows, identity, staging, check)?;
+        build_sealed_container_with_work(container_rows, identity, staging, check, observe)?;
     if let Some(layered) = layered {
         layered.install_base_files(staging)?;
         (entities, relations) = layered.row_counts();
@@ -1959,6 +1989,16 @@ fn build_sealed_container(
     identity: &GraphGenerationManifestIdentity,
     staging: &Path,
     check: &dyn Fn() -> Result<(), GraphDbError>,
+) -> Result<(usize, usize), GraphDbError> {
+    build_sealed_container_with_work(rows, identity, staging, check, None)
+}
+
+fn build_sealed_container_with_work(
+    rows: SealedRowSource<'_>,
+    identity: &GraphGenerationManifestIdentity,
+    staging: &Path,
+    check: &dyn Fn() -> Result<(), GraphDbError>,
+    observe: Option<&dyn Fn(GraphNativeWorkV1)>,
 ) -> Result<(usize, usize), GraphDbError> {
     let physical_namespace = identity.physical_namespace()?;
     let mut sealed = SealedCompactRows::new(staging)?;
@@ -1990,6 +2030,22 @@ fn build_sealed_container(
                                 durable = false,
                                 "native compact builder accepted a row window"
                             );
+                            if let Some(observer) = observe {
+                                observer(GraphNativeWorkV1::CompactRowsEncoded {
+                                    kind: match boundary.kind {
+                                        NativeCompactEncodeKindV1::Entities => {
+                                            GraphNativeWorkKindV1::Entities
+                                        }
+                                        NativeCompactEncodeKindV1::Relations => {
+                                            GraphNativeWorkKindV1::Relations
+                                        }
+                                    },
+                                    completed_rows: u64::try_from(boundary.completed_rows)
+                                        .unwrap_or(u64::MAX),
+                                    total_rows: u64::try_from(boundary.total_rows)
+                                        .unwrap_or(u64::MAX),
+                                });
+                            }
                         },
                     )?;
                     Ok((counts.0, counts.1, BTreeMap::new()))
@@ -2816,16 +2872,20 @@ pub(crate) fn sealed_copy_proof(
 #[cfg(test)]
 mod build_tests {
     use std::collections::{BTreeMap, BTreeSet};
-    use std::sync::Arc;
+    use std::sync::{Arc, Mutex};
     use std::sync::atomic::{AtomicUsize, Ordering};
 
     use rayon::ThreadPoolBuilder;
 
     use super::{
-        SEALED_STORE_DATABASE_FILE, SealedRowSource, build_or_open_sealed_store,
-        build_sealed_container, sealed_artifact_database_options, sealed_copy_proof,
+        NativeCompactEncodeBoundaryV1, NativeCompactEncodeKindV1, SEALED_STORE_DATABASE_FILE,
+        SealedCompactRows, SealedRowSource, build_or_open_sealed_store,
+        build_or_open_sealed_store_with_work, build_sealed_container,
+        push_manifest_rows, sealed_artifact_database_options, sealed_copy_proof,
         sealed_generation_directory, sealed_store_root,
     };
+    use tracedecay_store::runtime::{GraphNativeWorkKindV1, GraphNativeWorkV1};
+
     use crate::location::PersistentGraphStoreState;
     use crate::{
         GraphDb, GraphDbError, GraphDbLocation, GraphDbOpenOptions, GraphDbOwner, GraphDurability,
@@ -2947,13 +3007,6 @@ mod build_tests {
     /// final count equal to the input and no forged completed relation window.
     #[test]
     fn direct_compact_encoding_reports_only_accepted_row_windows() {
-        use std::sync::Mutex;
-
-        use super::{
-            NativeCompactEncodeBoundaryV1, NativeCompactEncodeKindV1, SealedCompactRows,
-            push_manifest_rows,
-        };
-
         let fixture = manifest(1_101, 1_143);
         let identity = fixture.identity();
         let namespace = identity.physical_namespace().unwrap();
@@ -3280,6 +3333,67 @@ mod build_tests {
     /// A competing writer's already installed segment is read-only evidence,
     /// not a new native write by this attempt. The loser must clean up its
     /// staging directory and can adopt only the digest-verified real segment.
+    /// Actual direct seal emits accepted row windows and one verified install,
+    /// but adopting that exact durable segment on retry emits nothing.
+    #[test]
+    fn direct_seal_native_observer_separates_encoding_and_durable_segment() {
+        let fixture = manifest(7, 9);
+        let identity = fixture.identity();
+        let expected = fixture.expected_recovered_digest(&|| Ok(())).unwrap();
+        let temp = tempfile::tempdir().unwrap();
+        let database_path = temp.path().join("native.grafeo");
+        let observed = Mutex::new(Vec::new());
+        let record = |event| observed.lock().unwrap().push(event);
+        let (first, _) = build_or_open_sealed_store_with_work(
+            SealedRowSource::Manifest(&fixture),
+            &identity,
+            &expected,
+            &database_path,
+            &|| Ok(()),
+            Some(&record),
+        )
+        .expect("install and verify real native segment");
+        assert_eq!(first.recovered_digest(), expected.as_str());
+        let events = observed.lock().unwrap().clone();
+        assert!(events.iter().any(|event| matches!(
+            event,
+            GraphNativeWorkV1::CompactRowsEncoded {
+                kind: GraphNativeWorkKindV1::Entities,
+                completed_rows: 7,
+                total_rows: 7,
+            }
+        )));
+        assert!(events.iter().any(|event| matches!(
+            event,
+            GraphNativeWorkV1::CompactRowsEncoded {
+                kind: GraphNativeWorkKindV1::Relations,
+                completed_rows: 9,
+                total_rows: 9,
+            }
+        )));
+        assert!(events.iter().any(|event| matches!(
+            event,
+            GraphNativeWorkV1::CompactSegmentVerified {
+                entities: 7,
+                relations: 9,
+                canonical_bytes: 1..,
+            }
+        )));
+        let _ = first.database().close();
+        let (adopted, _) = build_or_open_sealed_store_with_work(
+            SealedRowSource::Manifest(&fixture),
+            &identity,
+            &expected,
+            &database_path,
+            &|| Ok(()),
+            Some(&record),
+        )
+        .expect("adopt existing verified segment without new writes");
+        assert_eq!(adopted.recovered_digest(), expected.as_str());
+        assert_eq!(*observed.lock().unwrap(), events);
+        let _ = adopted.database().close();
+    }
+
     #[test]
     fn concurrent_sealed_install_candidate_does_not_count_as_new_write() {
         let check: &dyn Fn() -> Result<(), GraphDbError> = &|| Ok(());

From 2e373a0e347b7363630801f64c93bdb2ba0ce071 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 03:08:13 -0800
Subject: [PATCH 20/80] feat(code-index): propagate native graph writer
 progress

Refs #4508

Bind real native graph page and compact writer events to one leased
worktree publication attempt. Preserve physical encoding separately from
durable stage-page receipts and digest-verified compact installs; carry
owner-scoped work epochs and original timestamps through daemon freshness,
CLI wait and MCP summaries. Add nonzero slot and wire regressions.

Dashboard generated contracts and full Bazel restart acceptance remain open.
---
 crates/tracedecay-cli/src/commands/index.rs   | 172 +++++++++-
 .../src/code_graph_seat.rs                    |   3 +
 .../code_index_scheduler/graph_activation.rs  |  11 +-
 .../src/code_index_scheduler/registry.rs      |   4 +
 .../registry/graph_progress.rs                | 301 ++++++++++++++++++
 .../code_index_scheduler/registry/mount.rs    |  21 ++
 .../registry/serving_reads.rs                 |   8 +
 .../src/code_index_freshness.rs               |  80 +++++
 .../src/code_index_freshness_api.rs           |   1 +
 .../src/handlers/graph/search_freshness.rs    |  84 ++++-
 .../src/session_registry/code_graph.rs        |  23 +-
 11 files changed, 698 insertions(+), 10 deletions(-)
 create mode 100644 crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 1699838bfaf..74dccc97204 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -378,6 +378,13 @@ where
                 .as_ref()
                 .filter(|attempt| attempt.active)
                 .map(preseal_progress_summary)
+                .or_else(|| {
+                    worktree
+                        .native_graph_progress
+                        .as_ref()
+                        .filter(|graph| graph.active)
+                        .map(native_graph_progress_summary)
+                })
                 .or_else(|| worktree.progress.as_ref().map(build_progress_summary))
         });
         let progress_suffix = progress
@@ -405,7 +412,7 @@ where
                 CODE_INDEX_READINESS_WAIT_TIMED_OUT,
                 format!(
                     "init --wait stopped waiting for the first generation: no observed \
-                     capture, parse, or committed text work for {}s; last state: \
+                     capture, parse, text, or native graph work for {}s; last state: \
                      {last_state}{progress_suffix}",
                     stall_window.as_secs(),
                 ),
@@ -460,6 +467,13 @@ enum FirstGenerationWorkMarker {
         completed: u64,
         last_work_micros: Option<i64>,
     },
+    NativeGraph {
+        generation: String,
+        sealed_graph_digest: String,
+        owner: (u64, u64, u64),
+        epoch: u64,
+        completed: [u64; 6],
+    },
     CommittedText {
         generation: String,
         sealed_source_digest: String,
@@ -477,9 +491,15 @@ impl FirstGenerationWorkMarker {
         // A real active attempt remains authoritative in either state.
         if !worktree.rebuild_in_flight
             && !worktree.preseal_attempt.as_ref().is_some_and(|a| a.active)
+            && !worktree.native_graph_progress.as_ref().is_some_and(|g| g.active)
         {
             return None;
         }
+        if let Some(graph) = worktree.native_graph_progress.as_ref().filter(|g| {
+            g.active && g.last_progress_micros.is_some()
+        }) {
+            return Some(Self::native_graph(graph));
+        }
         if let Some(progress) = &worktree.progress {
             match progress.phase {
                 CodeIndexBuildPhaseV1::BulkCommit => return Some(Self::text(progress)),
@@ -510,6 +530,29 @@ impl FirstGenerationWorkMarker {
             .map(Self::text)
     }
 
+    fn native_graph(
+        graph: &tracedecay_contracts::code_index_freshness::CodeIndexNativeGraphProgressV1,
+    ) -> Self {
+        Self::NativeGraph {
+            generation: graph.generation_id.clone(),
+            sealed_graph_digest: graph.sealed_graph_digest.clone(),
+            owner: (
+                graph.daemon_incarnation,
+                graph.producer_incarnation,
+                graph.attempt_sequence,
+            ),
+            epoch: graph.progress_epoch,
+            completed: [
+                graph.encoded_entities,
+                graph.encoded_relations,
+                graph.committed_stage_pages,
+                graph.committed_stage_mutations,
+                graph.committed_stage_bytes,
+                graph.committed_compact_segments,
+            ],
+        }
+    }
+
     fn text(progress: &CodeIndexBuildProgressV1) -> Self {
         Self::CommittedText {
             generation: progress.generation_id.clone(),
@@ -530,6 +573,7 @@ impl FirstGenerationWorkMarker {
     fn owner(&self) -> (u64, u64) {
         match self {
             Self::Preseal { owner, .. } => (owner.0, owner.1),
+            Self::NativeGraph { owner, .. } => (owner.0, owner.1),
             Self::CommittedText { owner, .. } => *owner,
         }
     }
@@ -573,6 +617,41 @@ impl FirstGenerationWorkMarker {
                 }
                 Some(*completed > 0 && last_work_micros.is_some())
             }
+            (
+                Self::NativeGraph {
+                    generation,
+                    sealed_graph_digest,
+                    owner,
+                    epoch,
+                    completed,
+                },
+                Self::NativeGraph {
+                    generation: prior_generation,
+                    sealed_graph_digest: prior_digest,
+                    owner: prior_owner,
+                    epoch: prior_epoch,
+                    completed: prior_completed,
+                },
+            ) => {
+                if (owner, epoch) <= (prior_owner, prior_epoch) {
+                    return None;
+                }
+                if owner == prior_owner
+                    && (generation != prior_generation || sealed_graph_digest != prior_digest)
+                {
+                    return None;
+                }
+                if owner != prior_owner {
+                    return Some(completed.iter().any(|count| *count > 0));
+                }
+                Some(
+                    completed != prior_completed
+                        && completed
+                            .iter()
+                            .zip(prior_completed)
+                            .all(|(now, prior)| now >= prior),
+                )
+            }
             (
                 Self::CommittedText {
                     generation,
@@ -618,6 +697,7 @@ impl FirstGenerationWorkMarker {
 struct FirstGenerationProgressWindow {
     preseal: Option<FirstGenerationWorkMarker>,
     text: Option<FirstGenerationWorkMarker>,
+    native_graph: Option<FirstGenerationWorkMarker>,
     owner: Option<(u64, u64)>,
     unchanged_since: Option<Instant>,
     stall_window: Duration,
@@ -628,6 +708,7 @@ impl FirstGenerationProgressWindow {
         Self {
             preseal: None,
             text: None,
+            native_graph: None,
             owner: None,
             unchanged_since: None,
             stall_window,
@@ -658,6 +739,7 @@ impl FirstGenerationProgressWindow {
         self.owner = Some(owner);
         let previous = match &marker {
             FirstGenerationWorkMarker::Preseal { .. } => &mut self.preseal,
+            FirstGenerationWorkMarker::NativeGraph { .. } => &mut self.native_graph,
             FirstGenerationWorkMarker::CommittedText { .. } => &mut self.text,
         };
         let advanced = match previous.as_ref() {
@@ -671,7 +753,8 @@ impl FirstGenerationProgressWindow {
                     last_work_micros,
                     ..
                 } => *completed > 0 && last_work_micros.is_some(),
-                FirstGenerationWorkMarker::CommittedText { completed, .. } => {
+                FirstGenerationWorkMarker::NativeGraph { completed, .. }
+                | FirstGenerationWorkMarker::CommittedText { completed, .. } => {
                     completed.iter().any(|count| *count > 0)
                 }
             },
@@ -753,6 +836,32 @@ fn preseal_progress_summary(
     )
 }
 
+fn native_graph_progress_summary(
+    graph: &tracedecay_contracts::code_index_freshness::CodeIndexNativeGraphProgressV1,
+) -> String {
+    format!(
+        "native graph {:?}: encoded={}/{} entities and {}/{} relations, \
+         durable_pages={} durable_mutations={} verified_segments={}, \
+         attempt={}:{}:{} epoch={} last_work_micros={}",
+        graph.phase,
+        graph.encoded_entities,
+        graph.total_entities.map_or_else(|| "unknown".to_owned(), |n| n.to_string()),
+        graph.encoded_relations,
+        graph.total_relations.map_or_else(|| "unknown".to_owned(), |n| n.to_string()),
+        graph.committed_stage_pages,
+        graph.committed_stage_mutations,
+        graph.committed_compact_segments,
+        graph.daemon_incarnation,
+        graph.producer_incarnation,
+        graph.attempt_sequence,
+        graph.progress_epoch,
+        graph.last_progress_micros.map_or_else(
+            || "unreported".to_owned(),
+            |micros| micros.to_string(),
+        )
+    )
+}
+
 fn build_progress_summary(progress: &CodeIndexBuildProgressV1) -> String {
     format!(
         "{:?} {}/{} files",
@@ -1301,6 +1410,65 @@ mod daemon_precondition_tests {
         assert_eq!(reads, 5, "only the reached proof ends a progressing wait");
     }
 
+
+    #[test]
+    fn native_graph_real_counts_refresh_wait_but_duplicate_epochs_and_stale_owners_do_not() {
+        let now = Instant::now();
+        let mut worktree = building(true);
+        worktree.progress = Some(CodeIndexBuildProgressV1 {
+            phase: CodeIndexBuildPhaseV1::GraphPublication,
+            ..progress(6_136, None)
+        });
+        let mut graph =
+            tracedecay_contracts::code_index_freshness::CodeIndexNativeGraphProgressV1 {
+                generation_id: "generation.v1.first".to_owned(),
+                sealed_graph_digest: "sha256:sealed".to_owned(),
+                daemon_incarnation: 3,
+                producer_incarnation: 4,
+                attempt_sequence: 1,
+                progress_epoch: 1,
+                phase: None,
+                encoded_entities: 0,
+                total_entities: None,
+                encoded_relations: 0,
+                total_relations: None,
+                committed_stage_pages: 0,
+                committed_stage_mutations: 0,
+                committed_stage_bytes: 0,
+                committed_compact_segments: 0,
+                committed_compact_bytes: 0,
+                last_progress_micros: None,
+                active: true,
+            };
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        worktree.native_graph_progress = Some(graph.clone());
+        let first = super::FirstGenerationWorkMarker::of(Some(&worktree));
+        assert!(!window.observe(first, now));
+        graph.encoded_entities = 512;
+        graph.total_entities = Some(1_100);
+        graph.progress_epoch += 1;
+        graph.last_progress_micros = Some(100);
+        worktree.native_graph_progress = Some(graph.clone());
+        let advanced = super::FirstGenerationWorkMarker::of(Some(&worktree));
+        assert!(!window.observe(advanced, now + Duration::from_secs(119)));
+        graph.progress_epoch += 1;
+        // A phase or progress-epoch update without accepted rows is not work.
+        worktree.native_graph_progress = Some(graph.clone());
+        let unchanged = super::FirstGenerationWorkMarker::of(Some(&worktree));
+        assert!(window.observe(unchanged, now + Duration::from_secs(239)));
+        graph.committed_stage_pages = 1;
+        graph.committed_stage_mutations = 100;
+        graph.progress_epoch += 1;
+        worktree.native_graph_progress = Some(graph.clone());
+        let committed = super::FirstGenerationWorkMarker::of(Some(&worktree));
+        assert!(!window.observe(committed, now + Duration::from_secs(239)));
+        graph.daemon_incarnation = 2;
+        graph.progress_epoch += 1;
+        graph.committed_stage_pages = 100;
+        worktree.native_graph_progress = Some(graph);
+        let stale = super::FirstGenerationWorkMarker::of(Some(&worktree));
+        assert!(window.observe(stale, now + Duration::from_secs(359)));
+    }
     fn progress(
         completed_files: u64,
         blocked_reason: Option<CodeIndexBuildBlockedReasonV1>,
diff --git a/crates/tracedecay-code-index-runtime/src/code_graph_seat.rs b/crates/tracedecay-code-index-runtime/src/code_graph_seat.rs
index adf573b560e..67d82fa1ae1 100644
--- a/crates/tracedecay-code-index-runtime/src/code_graph_seat.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_graph_seat.rs
@@ -25,6 +25,7 @@ use tracedecay_domain::errors::Result;
 use tracedecay_domain::{CodeGenerationId, ProjectId, RefId, RepositoryId, WorktreeId};
 use tracedecay_graph_db::{GraphDbError, SealedGraphStateDigest, VerifiedGraphSnapshot};
 use tracedecay_runtime_core::db::Database;
+use tracedecay_store::GraphNativeWorkObserverV1;
 use tracedecay_runtime_core::shard_runtime::registry::CanonicalCodeGraphStoreLeaseV1;
 
 /// Sealed-generation replay identity the seat port needs to retain a runtime.
@@ -55,12 +56,14 @@ pub trait CodeGraphSeatLeaseV1: Send {
     fn publish_verified_snapshot(
         &self,
         request_cancelled: Arc<AtomicBool>,
+        native_work: GraphNativeWorkObserverV1,
     ) -> std::result::Result<VerifiedGraphSnapshot, GraphDbError>;
 
     fn publish_verified_snapshot_admitted(
         &self,
         request_cancelled: Arc<AtomicBool>,
         admission: Arc<dyn CodeGraphBuildAdmissionV1>,
+        native_work: GraphNativeWorkObserverV1,
     ) -> std::result::Result<VerifiedGraphSnapshot, GraphDbError>;
 
     fn recover_verified_snapshot_from_head(
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/graph_activation.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/graph_activation.rs
index 078a8d5f56c..cddd262a4ad 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/graph_activation.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/graph_activation.rs
@@ -24,6 +24,7 @@ use tracedecay_code_index::production::{
 };
 use tracedecay_runtime_core::native_runtime;
 use tracedecay_runtime_core::resident_memory::ProcessResidentMemoryV1;
+use tracedecay_store::GraphNativeWorkObserverV1;
 
 /// Test-only graph activation faults, keyed by worktree id. The worktree id
 /// is unique per test fixture, while generation ids are content-derived and
@@ -450,6 +451,7 @@ impl CodeGraphActivationAuthorityV1 {
         replay_binding: CodeGraphReplayBindingV1,
         admission: Option<Arc<dyn CodeGraphBuildAdmissionV1>>,
         cancellation: Arc<AtomicBool>,
+        native_work: GraphNativeWorkObserverV1,
     ) -> Result<bool, CodeIndexSchedulerErrorV1> {
         if self.policy() == CodeGraphActivationPolicyV1::RefusedByConfiguration {
             return Ok(false);
@@ -477,9 +479,9 @@ impl CodeGraphActivationAuthorityV1 {
                 .map_err(|error| CodeIndexSchedulerErrorV1::GraphActivation(error.to_string()))?;
                 native_runtime::spawn_blocking(move || match admission {
                     Some(admission) => retained
-                        .publish_verified_snapshot_admitted(cancellation, admission)
+                        .publish_verified_snapshot_admitted(cancellation, admission, native_work)
                         .map(drop),
-                    None => retained.publish_verified_snapshot(cancellation).map(drop),
+                    None => retained.publish_verified_snapshot(cancellation, native_work).map(drop),
                 })
                 .await
                 .map_err(|error| {
@@ -510,6 +512,7 @@ impl CodeGraphActivationAuthorityV1 {
         predecessor: Option<Arc<CodeGraphProjectionStore>>,
         replay_binding: CodeGraphReplayBindingV1,
         cancellation: Arc<AtomicBool>,
+        native_work: GraphNativeWorkObserverV1,
     ) -> Result<Option<CodeGraphCatalogWarmV1>, CodeIndexSchedulerErrorV1> {
         let policy = self.policy();
         if policy == CodeGraphActivationPolicyV1::RefusedByConfiguration {
@@ -551,6 +554,7 @@ impl CodeGraphActivationAuthorityV1 {
                         resident_memory,
                         predecessor,
                         cancellation,
+                        native_work,
                     )
                 })
                 .await
@@ -844,6 +848,7 @@ impl LatestCompleteCodeIndexV1 {
         resident_memory: Arc<ProcessResidentMemoryV1>,
         predecessor: Option<Arc<CodeGraphProjectionStore>>,
         cancellation: Arc<AtomicBool>,
+        native_work: GraphNativeWorkObserverV1,
     ) -> Result<Option<PendingInteractiveCatalogWarmV1>, CodeIndexSchedulerErrorV1> {
         let generation_id = self.generation.manifest().generation_id.clone();
         let authority = retained.authority();
@@ -851,7 +856,7 @@ impl LatestCompleteCodeIndexV1 {
             let _span =
                 tracing::trace_span!("code_graph.activation.publish_verified_snapshot").entered();
             retained
-                .publish_verified_snapshot(Arc::clone(&cancellation))
+                .publish_verified_snapshot(Arc::clone(&cancellation), native_work)
                 .map_err(CodeGraphProjectionError::from)
                 .inspect_err(|error| {
                     // The publication stopped at the measured-RSS watermark.
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry.rs
index 526bd3ab86e..ebdc6c37f69 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry.rs
@@ -58,6 +58,7 @@ mod cold_read_wake_tests;
 #[cfg(all(test, unix))]
 mod convergence_park_tests;
 pub(super) mod graph_cursor_retention;
+mod graph_progress;
 mod ignored_dependencies;
 mod lsp_projection;
 mod mount;
@@ -844,6 +845,7 @@ pub struct MountedCodeIndexWorktreeV1 {
     /// owns a long reconcile or text-artifact transaction.
     pub build_progress: super::CodeIndexBuildProgressSlotV1,
     preseal_attempt_progress: super::attempt_progress::CodeIndexBuildAttemptSlotV1,
+    native_graph_progress: graph_progress::CodeIndexNativeGraphProgressSlotV1,
     /// Monotonic replacement epoch for the serving slot. It invalidates a
     /// branch-publication token even if a future worker re-seats an equal id.
     serving_generation_epoch: Arc<AtomicU64>,
@@ -921,6 +923,7 @@ const _: fn(&MountedCodeIndexWorktreeV1) = |value| {
         serving_source_witness,
         build_progress,
         preseal_attempt_progress,
+        native_graph_progress,
         serving_generation_epoch,
         serving_generation_changed,
         serving_generation_installation,
@@ -960,6 +963,7 @@ const _: fn(&MountedCodeIndexWorktreeV1) = |value| {
     assert_send_sync(serving_source_witness);
     assert_send_sync(build_progress);
     assert_send_sync(preseal_attempt_progress);
+    assert_send_sync(native_graph_progress);
     assert_send_sync(serving_generation_epoch);
     assert_send_sync(serving_generation_changed);
     assert_send_sync(serving_generation_installation);
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
new file mode 100644
index 00000000000..464f195f6fd
--- /dev/null
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
@@ -0,0 +1,301 @@
+//! Real native graph writer observations for one mounted worktree.
+//! A callback is bound to one sealed source and one publication attempt.
+//! No poll, phase projection, or replayed receipt can refresh its work clock.
+
+use std::sync::{Arc, PoisonError, RwLock};
+use tracedecay_contracts::code_index_freshness::{
+    CodeIndexNativeGraphPhaseV1, CodeIndexNativeGraphProgressV1,
+};
+use tracedecay_store::{
+    GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
+};
+
+pub(super) type CodeIndexNativeGraphProgressSlotV1 =
+    Arc<RwLock<CodeIndexNativeGraphProgressSlotStateV1>>;
+
+#[derive(Clone, Copy)]
+struct GraphAttemptOwnerV1 {
+    daemon: u64,
+    producer: u64,
+    sequence: u64,
+}
+
+#[derive(Default)]
+pub(super) struct CodeIndexNativeGraphProgressSlotStateV1 {
+    sequence: u64,
+    epoch: u64,
+    snapshot: Option<CodeIndexNativeGraphProgressV1>,
+    last_stage_ordinal: Option<u64>,
+}
+
+impl CodeIndexNativeGraphProgressSlotStateV1 {
+    fn begin(
+        &mut self,
+        daemon: u64,
+        producer: u64,
+        generation_id: String,
+        sealed_graph_digest: String,
+    ) -> GraphAttemptOwnerV1 {
+        self.sequence = self.sequence.saturating_add(1).max(1);
+        self.epoch = self.epoch.saturating_add(1).max(1);
+        self.last_stage_ordinal = None;
+        let owner = GraphAttemptOwnerV1 {
+            daemon,
+            producer,
+            sequence: self.sequence,
+        };
+        self.snapshot = Some(CodeIndexNativeGraphProgressV1 {
+            generation_id,
+            sealed_graph_digest,
+            daemon_incarnation: daemon,
+            producer_incarnation: producer,
+            attempt_sequence: self.sequence,
+            progress_epoch: self.epoch,
+            phase: None,
+            encoded_entities: 0,
+            total_entities: None,
+            encoded_relations: 0,
+            total_relations: None,
+            committed_stage_pages: 0,
+            committed_stage_mutations: 0,
+            committed_stage_bytes: 0,
+            committed_compact_segments: 0,
+            committed_compact_bytes: 0,
+            last_progress_micros: None,
+            active: true,
+        });
+        owner
+    }
+
+    fn owns(&self, owner: GraphAttemptOwnerV1) -> bool {
+        self.snapshot.as_ref().is_some_and(|state| {
+            state.active
+                && state.daemon_incarnation == owner.daemon
+                && state.producer_incarnation == owner.producer
+                && state.attempt_sequence == owner.sequence
+        })
+    }
+
+    fn observe(&mut self, owner: GraphAttemptOwnerV1, work: GraphNativeWorkV1, now: i64) -> bool {
+        if !self.owns(owner) {
+            return false;
+        }
+        let Some(current) = self.snapshot.as_ref() else {
+            return false;
+        };
+        let mut next = current.clone();
+        match work {
+            GraphNativeWorkV1::CompactRowsEncoded {
+                kind,
+                completed_rows,
+                total_rows,
+            } => {
+                if completed_rows == 0 || completed_rows > total_rows
+                    || next.committed_compact_segments != 0
+                {
+                    return false;
+                }
+                let (completed, total) = match kind {
+                    GraphNativeWorkKindV1::Entities => {
+                        if next.encoded_relations != 0 {
+                            return false;
+                        }
+                        (&mut next.encoded_entities, &mut next.total_entities)
+                    }
+                    GraphNativeWorkKindV1::Relations => {
+                        (&mut next.encoded_relations, &mut next.total_relations)
+                    }
+                };
+                if completed_rows <= *completed
+                    || total.is_some_and(|prior| prior != total_rows)
+                {
+                    return false;
+                }
+                *completed = completed_rows;
+                *total = Some(total_rows);
+                next.phase = Some(CodeIndexNativeGraphPhaseV1::CompactEncoding);
+            }
+            GraphNativeWorkV1::StagePageApplied {
+                ordinal,
+                mutations,
+                live_bytes,
+                ..
+            } => {
+                if mutations == 0
+                    || self.last_stage_ordinal.is_some_and(|last| ordinal <= last)
+                {
+                    return false;
+                }
+                self.last_stage_ordinal = Some(ordinal);
+                next.committed_stage_pages = next.committed_stage_pages.saturating_add(1);
+                next.committed_stage_mutations =
+                    next.committed_stage_mutations.saturating_add(mutations);
+                next.committed_stage_bytes =
+                    next.committed_stage_bytes.saturating_add(live_bytes);
+                next.phase = Some(CodeIndexNativeGraphPhaseV1::StagePageCommit);
+            }
+            GraphNativeWorkV1::CompactSegmentVerified {
+                canonical_bytes,
+                ..
+            } => {
+                if canonical_bytes == 0 || next.committed_compact_segments != 0 {
+                    return false;
+                }
+                next.committed_compact_segments = 1;
+                next.committed_compact_bytes = canonical_bytes;
+                next.phase = Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified);
+            }
+        }
+        self.epoch = self.epoch.saturating_add(1).max(1);
+        next.progress_epoch = self.epoch;
+        next.last_progress_micros = Some(
+            current.last_progress_micros.map_or(now, |prior| prior.max(now)),
+        );
+        self.snapshot = Some(next);
+        true
+    }
+
+    fn finish(&mut self, owner: GraphAttemptOwnerV1) {
+        if !self.owns(owner) {
+            return;
+        }
+        if let Some(current) = self.snapshot.as_mut() {
+            current.active = false;
+            self.epoch = self.epoch.saturating_add(1).max(1);
+            current.progress_epoch = self.epoch;
+            // Completion of an attempt is not proof of any additional work.
+        }
+    }
+
+    pub(super) fn snapshot(&self) -> Option<CodeIndexNativeGraphProgressV1> {
+        self.snapshot.clone()
+    }
+}
+
+/// Always retires the exact attempt when the publication ends or is cancelled.
+pub(super) struct CodeIndexNativeGraphProgressGuardV1 {
+    slot: CodeIndexNativeGraphProgressSlotV1,
+    owner: GraphAttemptOwnerV1,
+}
+
+impl CodeIndexNativeGraphProgressGuardV1 {
+    pub(super) fn begin(
+        slot: CodeIndexNativeGraphProgressSlotV1,
+        daemon: u64,
+        producer: u64,
+        generation_id: String,
+        sealed_graph_digest: String,
+    ) -> Self {
+        let owner = slot.write().unwrap_or_else(PoisonError::into_inner)
+            .begin(daemon, producer, generation_id, sealed_graph_digest);
+        Self { slot, owner }
+    }
+
+    pub(super) fn observer(&self) -> GraphNativeWorkObserverV1 {
+        let slot = Arc::clone(&self.slot);
+        let owner = self.owner;
+        Arc::new(move |work| {
+            slot.write().unwrap_or_else(PoisonError::into_inner)
+                .observe(owner, work, tracedecay_contracts::now_micros().0);
+        })
+    }
+}
+
+impl Drop for CodeIndexNativeGraphProgressGuardV1 {
+    fn drop(&mut self) {
+        self.slot.write().unwrap_or_else(PoisonError::into_inner)
+            .finish(self.owner);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn real_native_work_distinguishes_encoding_receipted_pages_and_verified_segment() {
+        let slot = Arc::new(RwLock::new(CodeIndexNativeGraphProgressSlotStateV1::default()));
+        let attempt = CodeIndexNativeGraphProgressGuardV1::begin(
+            Arc::clone(&slot), 4, 6, "generation.a".into(), "digest.a".into(),
+        );
+        let observer = attempt.observer();
+        let initial = slot.read().unwrap().snapshot().unwrap();
+        assert_eq!(initial.last_progress_micros, None);
+        observer(GraphNativeWorkV1::CompactRowsEncoded {
+            kind: GraphNativeWorkKindV1::Entities, completed_rows: 512, total_rows: 1101,
+        });
+        let encoded = slot.read().unwrap().snapshot().unwrap();
+        assert_eq!(encoded.encoded_entities, 512);
+        assert_eq!(encoded.committed_stage_pages, 0);
+        assert_eq!(encoded.committed_compact_segments, 0);
+        assert!(encoded.last_progress_micros.is_some());
+        observer(GraphNativeWorkV1::CompactRowsEncoded {
+            kind: GraphNativeWorkKindV1::Entities, completed_rows: 512, total_rows: 1101,
+        });
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), encoded);
+        observer(GraphNativeWorkV1::CompactRowsEncoded {
+            kind: GraphNativeWorkKindV1::Relations, completed_rows: 143, total_rows: 1143,
+        });
+        let parsed = slot.read().unwrap().snapshot().unwrap();
+        assert!(parsed.progress_epoch > encoded.progress_epoch);
+        observer(GraphNativeWorkV1::StagePageApplied {
+            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 36, live_bytes: 4096,
+        });
+        let durable = slot.read().unwrap().snapshot().unwrap();
+        assert_eq!(durable.committed_stage_pages, 1);
+        assert_eq!(durable.committed_stage_mutations, 36);
+        assert_eq!(durable.committed_stage_bytes, 4096);
+        observer(GraphNativeWorkV1::StagePageApplied {
+            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 36, live_bytes: 4096,
+        });
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), durable);
+        observer(GraphNativeWorkV1::CompactSegmentVerified {
+            entities: 1101, relations: 1143, canonical_bytes: 67890,
+        });
+        let installed = slot.read().unwrap().snapshot().unwrap();
+        assert_eq!(installed.committed_compact_segments, 1);
+        assert_eq!(installed.committed_compact_bytes, 67890);
+        assert!(installed.progress_epoch > durable.progress_epoch);
+        drop(attempt);
+        let finished = slot.read().unwrap().snapshot().unwrap();
+        assert!(!finished.active);
+        assert_eq!(finished.last_progress_micros, installed.last_progress_micros);
+        observer(GraphNativeWorkV1::CompactSegmentVerified {
+            entities: 1101, relations: 1143, canonical_bytes: 67890,
+        });
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), finished);
+    }
+
+    #[test]
+    fn restarted_native_publication_fences_old_callbacks_and_resets_attempt_counters() {
+        let slot = Arc::new(RwLock::new(CodeIndexNativeGraphProgressSlotStateV1::default()));
+        let stale = CodeIndexNativeGraphProgressGuardV1::begin(
+            Arc::clone(&slot), 1, 9, "generation.a".into(), "digest.a".into(),
+        );
+        let old_observer = stale.observer();
+        old_observer(GraphNativeWorkV1::StagePageApplied {
+            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 2, live_bytes: 18,
+        });
+        let old_epoch = slot.read().unwrap().snapshot().unwrap().progress_epoch;
+        let current = CodeIndexNativeGraphProgressGuardV1::begin(
+            Arc::clone(&slot), 2, 1, "generation.a".into(), "digest.a".into(),
+        );
+        let current_observer = current.observer();
+        old_observer(GraphNativeWorkV1::StagePageApplied {
+            ordinal: 1, kind: GraphNativeWorkKindV1::Entities, mutations: 100, live_bytes: 1000,
+        });
+        drop(stale);
+        let reopened = slot.read().unwrap().snapshot().unwrap();
+        assert_eq!(reopened.committed_stage_pages, 0);
+        assert_eq!(reopened.daemon_incarnation, 2);
+        assert!(reopened.progress_epoch > old_epoch);
+        assert_eq!(reopened.last_progress_micros, None);
+        current_observer(GraphNativeWorkV1::StagePageApplied {
+            ordinal: 0, kind: GraphNativeWorkKindV1::Relations, mutations: 3, live_bytes: 120,
+        });
+        let resumed = slot.read().unwrap().snapshot().unwrap();
+        assert_eq!(resumed.committed_stage_pages, 1);
+        assert_eq!(resumed.committed_stage_mutations, 3);
+        assert!(resumed.active);
+    }
+}
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs
index 17f31789415..8937741afda 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs
@@ -672,6 +672,9 @@ impl CodeIndexSchedulerRegistryV1 {
         let active_generation_encoded_bytes = opened.active_generation_encoded_bytes();
         let build_progress = opened.build_progress_slot();
         let preseal_attempt_progress = opened.preseal_attempt_progress_slot();
+        let native_graph_progress = Arc::new(RwLock::new(
+            super::graph_progress::CodeIndexNativeGraphProgressSlotStateV1::default(),
+        ));
         let historical_generation_owner = opened.historical_generation_owner();
         let source_freshness = opened.freshness_fence();
         let last_reconciled_at_micros = opened.last_reconciled_at_micros_slot();
@@ -714,6 +717,7 @@ impl CodeIndexSchedulerRegistryV1 {
         let worker_scheduler = Arc::clone(&scheduler);
         let worker_reconcile_in_progress = Arc::clone(&reconcile_in_progress);
         let worker_build_progress = Arc::clone(&build_progress);
+        let worker_native_graph_progress = Arc::clone(&native_graph_progress);
         let worker_serving_generation = Arc::clone(&serving_generation);
         let worker_complete_generation_requested = Arc::clone(&complete_generation_requested);
         let worker_text_generation = Arc::clone(&text_generation);
@@ -2316,6 +2320,13 @@ impl CodeIndexSchedulerRegistryV1 {
                                         &worker_phase_signal,
                                         super::CodeIndexWorkerPhaseV1::PublishingGraph,
                                     );
+                                    let graph_attempt = super::graph_progress::CodeIndexNativeGraphProgressGuardV1::begin(
+                                        Arc::clone(&worker_native_graph_progress),
+                                        progress_daemon_incarnation,
+                                        progress_producer_incarnation,
+                                        text.metadata().manifest().generation_id.as_str().to_owned(),
+                                        replay_binding.sealed_state_digest.as_str().to_owned(),
+                                    );
                                     let published = worker_graph_activation
                                         .publish_sealed_graph(
                                             &worker_project_id,
@@ -2325,6 +2336,7 @@ impl CodeIndexSchedulerRegistryV1 {
                                             replay_binding,
                                             admission,
                                             Arc::clone(&worker_shutting_down),
+                                            graph_attempt.observer(),
                                         )
                                         .await;
                                     super::CodeIndexWorkerPhaseV1::enter(
@@ -2681,6 +2693,13 @@ impl CodeIndexSchedulerRegistryV1 {
                         .unwrap_or_else(std::sync::PoisonError::into_inner)
                         .as_ref()
                         .and_then(|serving| serving.interactive_graph_store().ok());
+                    let graph_attempt = super::graph_progress::CodeIndexNativeGraphProgressGuardV1::begin(
+                        Arc::clone(&worker_native_graph_progress),
+                        progress_daemon_incarnation,
+                        progress_producer_incarnation,
+                        latest.generation().manifest().generation_id.as_str().to_owned(),
+                        replay_binding.sealed_state_digest.as_str().to_owned(),
+                    );
                     let activation = worker_graph_activation
                         .activate(
                             &worker_project_id,
@@ -2690,6 +2709,7 @@ impl CodeIndexSchedulerRegistryV1 {
                             predecessor,
                             replay_binding.clone(),
                             Arc::clone(&worker_shutting_down),
+                            graph_attempt.observer(),
                         )
                         .await;
                     super::CodeIndexWorkerPhaseV1::enter(
@@ -4082,6 +4102,7 @@ impl CodeIndexSchedulerRegistryV1 {
             serving_source_witness,
             build_progress,
             preseal_attempt_progress,
+            native_graph_progress,
             serving_generation_epoch,
             serving_generation_changed,
             serving_generation_installation,
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/serving_reads.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/serving_reads.rs
index 45d3cfd777a..5814a5dbddf 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/serving_reads.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/serving_reads.rs
@@ -289,6 +289,7 @@ impl CodeIndexSchedulerRegistryV1 {
             generation_recovery,
             build_progress,
             preseal_attempt_progress,
+            native_graph_progress,
             hints,
             pending_wake,
             source_freshness,
@@ -308,6 +309,7 @@ impl CodeIndexSchedulerRegistryV1 {
                 Arc::clone(&worktree.generation_recovery),
                 Arc::clone(&worktree.build_progress),
                 Arc::clone(&worktree.preseal_attempt_progress),
+                Arc::clone(&worktree.native_graph_progress),
                 Arc::clone(&worktree.hints),
                 Arc::clone(&worktree.pending_wake),
                 worktree.source_freshness.clone(),
@@ -330,6 +332,10 @@ impl CodeIndexSchedulerRegistryV1 {
                 .read()
                 .unwrap_or_else(std::sync::PoisonError::into_inner)
                 .snapshot();
+            let native_graph_progress = native_graph_progress
+                .read()
+                .unwrap_or_else(std::sync::PoisonError::into_inner)
+                .snapshot();
             let refresh_in_flight = reconcile_in_progress.running()
                 || pending_wake.lock()
                     .micros
@@ -450,6 +456,7 @@ impl CodeIndexSchedulerRegistryV1 {
                         coverage: observation.coverage,
                         progress,
                         preseal_attempt,
+                        native_graph_progress,
                         restore_progress,
                         parked,
                         generation_recovery,
@@ -539,6 +546,7 @@ impl CodeIndexSchedulerRegistryV1 {
                 coverage: observation.coverage,
                 progress,
                 preseal_attempt,
+                native_graph_progress,
                 restore_progress,
                 parked,
                 generation_recovery,
diff --git a/crates/tracedecay-contracts/src/code_index_freshness.rs b/crates/tracedecay-contracts/src/code_index_freshness.rs
index a23f08be9f5..c50b6621ce0 100644
--- a/crates/tracedecay-contracts/src/code_index_freshness.rs
+++ b/crates/tracedecay-contracts/src/code_index_freshness.rs
@@ -145,6 +145,40 @@ pub struct CodeIndexPresealAttemptProgressV1 {
     pub active: bool,
 }
 
+/// Native graph writer progress is independent of text-artifact commit counts.
+/// Encoded rows are physical work, never a durable page. Stage-page commits
+/// and installed + digest-verified compact segments are durable work.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum CodeIndexNativeGraphPhaseV1 {
+    CompactEncoding,
+    StagePageCommit,
+    CompactSegmentVerified,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+pub struct CodeIndexNativeGraphProgressV1 {
+    pub generation_id: String,
+    pub sealed_graph_digest: String,
+    pub daemon_incarnation: u64,
+    pub producer_incarnation: u64,
+    pub attempt_sequence: u64,
+    pub progress_epoch: u64,
+    pub phase: Option<CodeIndexNativeGraphPhaseV1>,
+    pub encoded_entities: u64,
+    pub total_entities: Option<u64>,
+    pub encoded_relations: u64,
+    pub total_relations: Option<u64>,
+    pub committed_stage_pages: u64,
+    pub committed_stage_mutations: u64,
+    pub committed_stage_bytes: u64,
+    pub committed_compact_segments: u64,
+    pub committed_compact_bytes: u64,
+    /// The time of the last actual native writer callback, not a status read.
+    pub last_progress_micros: Option<i64>,
+    pub active: bool,
+}
+
 /// A deterministic contract violation that parked background convergence.
 ///
 /// Parked is not dead: the worker keeps re-observing the violation on its
@@ -633,6 +667,8 @@ pub struct CodeIndexWorktreeFreshnessV1 {
     pub progress: Option<CodeIndexBuildProgressV1>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub preseal_attempt: Option<CodeIndexPresealAttemptProgressV1>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub native_graph_progress: Option<CodeIndexNativeGraphProgressV1>,
     /// Bounded immutable-artifact restore work currently in flight. This is
     /// separate from build progress because restore commits no index data.
     #[serde(default)]
@@ -1448,4 +1484,48 @@ mod tests {
             .expect("encode absent attempt");
         assert!(no_attempt.get("preseal_attempt").is_none());
     }
+    #[test]
+    fn native_graph_freshness_wire_keeps_physical_work_separate_from_durable_writes() {
+        let graph = CodeIndexNativeGraphProgressV1 {
+            generation_id: "generation.real".to_owned(),
+            sealed_graph_digest: "sha256:native".to_owned(),
+            daemon_incarnation: 3,
+            producer_incarnation: 5,
+            attempt_sequence: 7,
+            progress_epoch: 13,
+            phase: Some(CodeIndexNativeGraphPhaseV1::CompactEncoding),
+            encoded_entities: 512,
+            total_entities: Some(1024),
+            encoded_relations: 0,
+            total_relations: None,
+            committed_stage_pages: 0,
+            committed_stage_mutations: 0,
+            committed_stage_bytes: 0,
+            committed_compact_segments: 0,
+            committed_compact_bytes: 0,
+            last_progress_micros: Some(12345),
+            active: true,
+        };
+        let wire = CodeIndexWorktreeFreshnessV1 {
+            native_graph_progress: Some(graph.clone()),
+            ..Default::default()
+        };
+        let value = serde_json::to_value(&wire).expect("serialize real native progress");
+        assert!(value["progress"].is_null());
+        assert_eq!(value["native_graph_progress"]["encoded_entities"], 512);
+        assert_eq!(value["native_graph_progress"]["committed_stage_pages"], 0);
+        assert_eq!(value["native_graph_progress"]["phase"], "compact_encoding");
+        assert_eq!(
+            serde_json::from_value::<CodeIndexWorktreeFreshnessV1>(value)
+                .expect("roundtrip native progress"),
+            wire
+        );
+        assert!(
+            serde_json::to_value(CodeIndexWorktreeFreshnessV1::default())
+                .expect("serialize absent graph progress")
+                .get("native_graph_progress")
+                .is_none()
+        );
+    }
+
 }
diff --git a/crates/tracedecay-dashboard-api/src/code_index_freshness_api.rs b/crates/tracedecay-dashboard-api/src/code_index_freshness_api.rs
index 57475811be9..ad4d8d67723 100644
--- a/crates/tracedecay-dashboard-api/src/code_index_freshness_api.rs
+++ b/crates/tracedecay-dashboard-api/src/code_index_freshness_api.rs
@@ -203,6 +203,7 @@ mod tests {
                     omitted_sources: None,
                     progress: None,
                     preseal_attempt: None,
+                    native_graph_progress: None,
                     restore_progress: None,
                     parked: None,
                     generation_recovery: None,
diff --git a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
index 8bdaccdaf8c..0661af6cc1a 100644
--- a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
+++ b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
@@ -239,6 +239,38 @@ pub(super) fn search_freshness(
                 attempt.active,
             );
         }
+        if let Some(graph) = &state.native_graph_progress {
+            // These are owned writer callbacks. Encoding is explicitly not a
+            // graph commit; native staging receipts and verified installs are.
+            let _ = write!(
+                summary,
+                " native_graph_generation={} native_graph_owner={}:{}:{} \
+                 native_graph_epoch={} native_graph_phase={:?} \
+                 native_encoded_entities={} native_encoded_relations={} \
+                 native_committed_pages={} native_committed_mutations={} \
+                 native_committed_bytes={} native_verified_segments={} \
+                 native_verified_bytes={} native_last_progress_micros={} \
+                 native_graph_active={}",
+                graph.generation_id,
+                graph.daemon_incarnation,
+                graph.producer_incarnation,
+                graph.attempt_sequence,
+                graph.progress_epoch,
+                graph.phase,
+                graph.encoded_entities,
+                graph.encoded_relations,
+                graph.committed_stage_pages,
+                graph.committed_stage_mutations,
+                graph.committed_stage_bytes,
+                graph.committed_compact_segments,
+                graph.committed_compact_bytes,
+                graph.last_progress_micros.map_or_else(
+                    || "unreported".to_owned(),
+                    |micros| micros.to_string()
+                ),
+                graph.active,
+            );
+        }
         if let Some(progress) = &state.progress {
             // Keep the producer's identity and clock. Reading a response is
             // not work, and an epoch is comparable only within its owner.
@@ -265,7 +297,11 @@ pub(super) fn search_freshness(
                 progress.blocked_reason.map_or("none", blocked_reason_label)
             );
         } else if state.rebuild_in_flight {
-            if state.preseal_attempt.as_ref().is_some_and(|attempt| {
+            if state.native_graph_progress.as_ref().is_some_and(|graph| {
+                graph.active && graph.last_progress_micros.is_some()
+            }) {
+                summary.push_str(" progress=native_graph");
+            } else if state.preseal_attempt.as_ref().is_some_and(|attempt| {
                 attempt.active && attempt.last_progress_micros.is_some()
             }) {
                 summary.push_str(" progress=preseal");
@@ -717,4 +753,50 @@ mod tests {
             "a park every wake re-checks is not terminal"
         );
     }
+    #[test]
+    fn native_graph_summary_does_not_conflate_encoded_rows_and_committed_pages() {
+        let state = CodeIndexWorktreeFreshnessV1 {
+            rebuild_in_flight: true,
+            native_graph_progress: Some(
+                tracedecay_contracts::code_index_freshness::CodeIndexNativeGraphProgressV1 {
+                    generation_id: "generation.native".to_owned(),
+                    sealed_graph_digest: "sha256:real".to_owned(),
+                    daemon_incarnation: 3,
+                    producer_incarnation: 5,
+                    attempt_sequence: 8,
+                    progress_epoch: 12,
+                    phase: Some(
+                        tracedecay_contracts::code_index_freshness::CodeIndexNativeGraphPhaseV1::CompactEncoding,
+                    ),
+                    encoded_entities: 512,
+                    total_entities: Some(1024),
+                    encoded_relations: 17,
+                    total_relations: Some(200),
+                    committed_stage_pages: 0,
+                    committed_stage_mutations: 0,
+                    committed_stage_bytes: 0,
+                    committed_compact_segments: 0,
+                    committed_compact_bytes: 0,
+                    last_progress_micros: Some(123),
+                    active: true,
+                },
+            ),
+            ..CodeIndexWorktreeFreshnessV1::default()
+        };
+        let rendered = freshness_lines(&search_freshness(
+            ServedGenerationV1::Unavailable { reason: "generation_unavailable" },
+            &CodeIndexSearchCoverageV1::unavailable("generation_rebuilding"),
+            &WorktreeFreshnessSourceV1::Worktree(Box::new(state)),
+        ));
+        assert!(rendered.contains("native_graph_generation=generation.native"));
+        assert!(rendered.contains("native_graph_owner=3:5:8"));
+        assert!(rendered.contains("native_graph_epoch=12"));
+        assert!(rendered.contains("native_encoded_entities=512 native_encoded_relations=17"));
+        assert!(rendered.contains("native_committed_pages=0"));
+        assert!(rendered.contains("native_verified_segments=0"));
+        assert!(rendered.contains("native_last_progress_micros=123"));
+        assert!(rendered.contains("progress=native_graph"));
+        assert!(!rendered.contains("committed_text_pages="));
+    }
+
 }
diff --git a/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs b/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
index db002f31bc2..022a313c47b 100644
--- a/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
+++ b/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
@@ -25,6 +25,7 @@ use tracedecay_store::{
     CodeShardScopeV1, FactReadControl, GraphGenerationIdV1, GraphPendingReplayDiscardOutcomeV1,
     GraphProjectionIdV1, GraphProjectionIdentityV1, GraphPublicationIdempotencyKeyV1,
     GraphPublicationInputDigestV1, GraphPublicationKeyV1, GraphPublicationOperationContextV1,
+    GraphNativeWorkObserverV1,
     GraphPublicationProjectionPageRequestV1, GraphPublicationReplayLookupV1,
     GraphPublicationReplayRecordV1, GraphPublicationStoreV1, GraphReplayAppendOutcomeV1,
     GraphVerifiedHeadV1, ProjectId, RetainedGraphStoreLeaseV1, RuntimeCancellationIdV1,
@@ -1290,13 +1291,14 @@ impl RetainedCodeGraphRuntimeV1 {
         &self,
         request_cancelled: Arc<AtomicBool>,
     ) -> std::result::Result<VerifiedGraphSnapshot, GraphDbError> {
-        self.publish_verified_snapshot_with_admission(request_cancelled, None)
+        self.publish_verified_snapshot_with_admission(request_cancelled, None, None)
     }
 
     fn publish_verified_snapshot_with_admission(
         &self,
         request_cancelled: Arc<AtomicBool>,
         admission: Option<Arc<dyn CodeGraphBuildAdmissionV1>>,
+        native_work: Option<GraphNativeWorkObserverV1>,
     ) -> std::result::Result<VerifiedGraphSnapshot, GraphDbError> {
         // The project-shard build permit is claimed before any row is built
         // and held through publication so 1/2/4/8 worktree scopes cannot
@@ -1347,8 +1349,11 @@ impl RetainedCodeGraphRuntimeV1 {
             deadline: deadline_identity,
             cancellation: cancellation_identity,
         };
-        let context = GraphPublicationOperationContextV1::new(&control, &probe)
+        let mut context = GraphPublicationOperationContextV1::new(&control, &probe)
             .map_err(|error| GraphDbError::invalid(error.to_string()))?;
+        if let Some(observer) = native_work {
+            context = context.with_native_work_observer(observer);
+        }
         let interruption = || match probe.interruption() {
             Some(RuntimeInterruptionV1::Cancelled) => Err(GraphDbError::Cancelled),
             Some(RuntimeInterruptionV1::DeadlineExceeded) => Err(GraphDbError::DeadlineExceeded),
@@ -3103,22 +3108,32 @@ impl CodeGraphSeatLeaseV1 for RetainedCodeGraphRuntimeV1 {
     fn publish_verified_snapshot(
         &self,
         request_cancelled: Arc<AtomicBool>,
+        native_work: GraphNativeWorkObserverV1,
     ) -> std::result::Result<
         tracedecay_graph_db::VerifiedGraphSnapshot,
         tracedecay_graph_db::GraphDbError,
     > {
-        Self::publish_verified_snapshot(self, request_cancelled)
+        self.publish_verified_snapshot_with_admission(
+            request_cancelled,
+            None,
+            Some(native_work),
+        )
     }
 
     fn publish_verified_snapshot_admitted(
         &self,
         request_cancelled: Arc<AtomicBool>,
         admission: Arc<dyn CodeGraphBuildAdmissionV1>,
+        native_work: GraphNativeWorkObserverV1,
     ) -> std::result::Result<
         tracedecay_graph_db::VerifiedGraphSnapshot,
         tracedecay_graph_db::GraphDbError,
     > {
-        self.publish_verified_snapshot_with_admission(request_cancelled, Some(admission))
+        self.publish_verified_snapshot_with_admission(
+            request_cancelled,
+            Some(admission),
+            Some(native_work),
+        )
     }
 
     fn recover_verified_snapshot_from_head(

From 949b80daec7656a19186a710913ddb974c25714e Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 03:14:52 -0800
Subject: [PATCH 21/80] fix(cli): avoid false stalls during compact graph
 finalization

Refs #4508

Once actual direct-seal encoding windows complete, the single native
compact-container write and digest verification have no intermediate
progress callbacks. Mark that window unknown rather than timing it out
as a stalled publisher. Prefer active native graph work in status output;
add a nonzero regression for the final uninstrumented writer phase.

Bazel and full daemon restart acceptance remain unverified.
---
 crates/tracedecay-cli/src/commands/index.rs | 83 +++++++++++++++++----
 1 file changed, 70 insertions(+), 13 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 74dccc97204..5c71676e408 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -7,7 +7,8 @@ use tracedecay_project::project::TraceDecay;
 use tracedecay_contracts::code_index_freshness::{
     CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
     CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexBuildProgressV1,
-    CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
+    CodeIndexNativeGraphPhaseV1, CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1,
+    CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::graph_tool::GraphToolResultV1;
 use tracedecay_contracts::retrieval::{
@@ -374,16 +375,16 @@ where
         };
         let progress = worktree.as_ref().ok().and_then(|worktree| {
             worktree
-                .preseal_attempt
+                .native_graph_progress
                 .as_ref()
-                .filter(|attempt| attempt.active)
-                .map(preseal_progress_summary)
+                .filter(|graph| graph.active && graph.last_progress_micros.is_some())
+                .map(native_graph_progress_summary)
                 .or_else(|| {
                     worktree
-                        .native_graph_progress
+                        .preseal_attempt
                         .as_ref()
-                        .filter(|graph| graph.active)
-                        .map(native_graph_progress_summary)
+                        .filter(|attempt| attempt.active)
+                        .map(preseal_progress_summary)
                 })
                 .or_else(|| worktree.progress.as_ref().map(build_progress_summary))
         });
@@ -495,10 +496,22 @@ impl FirstGenerationWorkMarker {
         {
             return None;
         }
-        if let Some(graph) = worktree.native_graph_progress.as_ref().filter(|g| {
-            g.active && g.last_progress_micros.is_some()
-        }) {
-            return Some(Self::native_graph(graph));
+        if let Some(graph) = worktree.native_graph_progress.as_ref().filter(|g| g.active) {
+            // Direct seal has one final Grafeo compact-container write and
+            // digest verification AFTER all accepted row windows. That work
+            // has no intermediate native milestone. Never call a healthy
+            // final write a stall merely because the last encode clock froze.
+            let encoding_finished = graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactEncoding)
+                && graph.total_entities == Some(graph.encoded_entities)
+                && graph.total_relations.is_none_or(|total| total == graph.encoded_relations);
+            if encoding_finished
+                || graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified)
+            {
+                return None;
+            }
+            if graph.last_progress_micros.is_some() {
+                return Some(Self::native_graph(graph));
+            }
         }
         if let Some(progress) = &worktree.progress {
             match progress.phase {
@@ -979,8 +992,9 @@ mod daemon_precondition_tests {
         CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
         CodeGraphServingReadinessV1, CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1,
         CodeIndexBuildProgressV1, CodeIndexFreshnessLadderInputsV1, CodeIndexFreshnessLadderV1,
-        CodeIndexReadinessTargetV1, CodeIndexReadinessV1, CodeIndexReadinessWaitOutcomeV1,
-        CodeIndexReadinessWaitReadV1, CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
+        CodeIndexNativeGraphPhaseV1, CodeIndexReadinessTargetV1, CodeIndexReadinessV1,
+        CodeIndexReadinessWaitOutcomeV1, CodeIndexReadinessWaitReadV1,
+        CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
     };
     use tracedecay_contracts::retrieval::StatusCodeIndexFreshnessV1;
     use tracedecay_domain::errors::TraceDecayError;
@@ -1469,6 +1483,49 @@ mod daemon_precondition_tests {
         let stale = super::FirstGenerationWorkMarker::of(Some(&worktree));
         assert!(window.observe(stale, now + Duration::from_secs(359)));
     }
+
+    #[test]
+    fn final_compact_write_is_uninstrumented_not_a_false_stall() {
+        let mut worktree = building(true);
+        worktree.progress = Some(CodeIndexBuildProgressV1 {
+            phase: CodeIndexBuildPhaseV1::GraphPublication,
+            ..progress(6_136, None)
+        });
+        let mut graph =
+            tracedecay_contracts::code_index_freshness::CodeIndexNativeGraphProgressV1 {
+                generation_id: "generation.v1.first".to_owned(),
+                sealed_graph_digest: "sha256:sealed".to_owned(),
+                daemon_incarnation: 3,
+                producer_incarnation: 5,
+                attempt_sequence: 2,
+                progress_epoch: 7,
+                phase: Some(CodeIndexNativeGraphPhaseV1::CompactEncoding),
+                encoded_entities: 512,
+                total_entities: Some(1024),
+                encoded_relations: 0,
+                total_relations: None,
+                committed_stage_pages: 0,
+                committed_stage_mutations: 0,
+                committed_stage_bytes: 0,
+                committed_compact_segments: 0,
+                committed_compact_bytes: 0,
+                last_progress_micros: Some(20),
+                active: true,
+            };
+        worktree.native_graph_progress = Some(graph.clone());
+        assert!(super::FirstGenerationWorkMarker::of(Some(&worktree)).is_some());
+        graph.encoded_entities = 1024;
+        // Zero relations cannot emit a positive row window. The writer is
+        // about to perform its single non-progress-reporting compact write.
+        worktree.native_graph_progress = Some(graph.clone());
+        assert_eq!(super::FirstGenerationWorkMarker::of(Some(&worktree)), None);
+        graph.phase = Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified);
+        graph.committed_compact_segments = 1;
+        graph.committed_compact_bytes = 50_000;
+        worktree.native_graph_progress = Some(graph);
+        assert_eq!(super::FirstGenerationWorkMarker::of(Some(&worktree)), None);
+    }
+
     fn progress(
         completed_files: u64,
         blocked_reason: Option<CodeIndexBuildBlockedReasonV1>,

From bb3a2f83308b4ed235b52cbc2a076a0134cfb3fc Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 03:28:47 -0800
Subject: [PATCH 22/80] fix(graph): retain relation bound during native
 encoding

Refs #4508

Carry the immutable manifest relation count on every accepted compact
row window, including an actual zero count. The owner-scoped progress
snapshot therefore knows relation work remains after entities finish.
Do not suspend init --wait stall detection before the first relation
window. Preserve unknown final compact container writes as uninstrumented.

Strengthen real native writer and progress-slot tests and add an
observable frozen-relation-window regression. Bazel tests are pending.
---
 crates/tracedecay-cli/src/commands/index.rs   | 57 ++++++++++++++++++-
 .../registry/graph_progress.rs                | 39 ++++++++++++-
 .../tracedecay-graph-db/src/sealed_store.rs   |  4 ++
 .../runtime/graph_publication/operation.rs    |  3 +
 4 files changed, 97 insertions(+), 6 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 5c71676e408..b6afa90278a 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -503,7 +503,7 @@ impl FirstGenerationWorkMarker {
             // final write a stall merely because the last encode clock froze.
             let encoding_finished = graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactEncoding)
                 && graph.total_entities == Some(graph.encoded_entities)
-                && graph.total_relations.is_none_or(|total| total == graph.encoded_relations);
+                && graph.total_relations.is_some_and(|total| total == graph.encoded_relations);
             if encoding_finished
                 || graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified)
             {
@@ -1515,8 +1515,9 @@ mod daemon_precondition_tests {
         worktree.native_graph_progress = Some(graph.clone());
         assert!(super::FirstGenerationWorkMarker::of(Some(&worktree)).is_some());
         graph.encoded_entities = 1024;
-        // Zero relations cannot emit a positive row window. The writer is
-        // about to perform its single non-progress-reporting compact write.
+        graph.total_relations = Some(0);
+        // The manifest declared zero relations, so completed entity encoding
+        // really does precede the uninstrumented final container write.
         worktree.native_graph_progress = Some(graph.clone());
         assert_eq!(super::FirstGenerationWorkMarker::of(Some(&worktree)), None);
         graph.phase = Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified);
@@ -1526,6 +1527,56 @@ mod daemon_precondition_tests {
         assert_eq!(super::FirstGenerationWorkMarker::of(Some(&worktree)), None);
     }
 
+    /// A completed entity stream is not an encoding-complete proof when the
+    /// immutable manifest still has relations. Waiting must expose a stalled
+    /// first relation window instead of silently dropping its work marker.
+    #[test]
+    fn completed_entities_cannot_hide_a_stalled_relation_encoder() {
+        let mut worktree = building(true);
+        worktree.progress = Some(CodeIndexBuildProgressV1 {
+            phase: CodeIndexBuildPhaseV1::GraphPublication,
+            ..progress(6_136, None)
+        });
+        let mut graph =
+            tracedecay_contracts::code_index_freshness::CodeIndexNativeGraphProgressV1 {
+                generation_id: "generation.v1.first".to_owned(),
+                sealed_graph_digest: "sha256:sealed".to_owned(),
+                daemon_incarnation: 3,
+                producer_incarnation: 5,
+                attempt_sequence: 3,
+                progress_epoch: 4,
+                phase: Some(CodeIndexNativeGraphPhaseV1::CompactEncoding),
+                encoded_entities: 1_024,
+                total_entities: Some(1_024),
+                encoded_relations: 0,
+                total_relations: Some(10_000),
+                committed_stage_pages: 0,
+                committed_stage_mutations: 0,
+                committed_stage_bytes: 0,
+                committed_compact_segments: 0,
+                committed_compact_bytes: 0,
+                last_progress_micros: Some(1_000),
+                active: true,
+            };
+        worktree.native_graph_progress = Some(graph.clone());
+        let marker = super::FirstGenerationWorkMarker::of(Some(&worktree));
+        assert!(marker.is_some(), "a pending relation stream is still observable work");
+        let now = Instant::now();
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        assert!(!window.observe(marker.clone(), now));
+        assert!(!window.observe(marker.clone(), now + Duration::from_secs(119)));
+        assert!(window.observe(marker, now + Duration::from_secs(120)));
+
+        graph.encoded_relations = 10_000;
+        graph.progress_epoch += 1;
+        worktree.native_graph_progress = Some(graph);
+        assert_eq!(
+            super::FirstGenerationWorkMarker::of(Some(&worktree)),
+            None,
+            "only both completed streams may enter the uninstrumented final write"
+        );
+    }
+
     fn progress(
         completed_files: u64,
         blocked_reason: Option<CodeIndexBuildBlockedReasonV1>,
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
index 464f195f6fd..df8fea8cd39 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
@@ -89,12 +89,22 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
                 kind,
                 completed_rows,
                 total_rows,
+                total_relations,
             } => {
                 if completed_rows == 0 || completed_rows > total_rows
                     || next.committed_compact_segments != 0
                 {
                     return false;
                 }
+                // The manifest already authenticates the relation count,
+                // including zero, while entity windows are still being encoded.
+                // Never treat an unknown relation bound as completed work.
+                if next.total_relations.is_some_and(|known| known != total_relations)
+                    || (kind == GraphNativeWorkKindV1::Relations
+                        && total_rows != total_relations)
+                {
+                    return false;
+                }
                 let (completed, total) = match kind {
                     GraphNativeWorkKindV1::Entities => {
                         if next.encoded_relations != 0 {
@@ -113,6 +123,7 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
                 }
                 *completed = completed_rows;
                 *total = Some(total_rows);
+                next.total_relations = Some(total_relations);
                 next.phase = Some(CodeIndexNativeGraphPhaseV1::CompactEncoding);
             }
             GraphNativeWorkV1::StagePageApplied {
@@ -222,22 +233,44 @@ mod tests {
         let initial = slot.read().unwrap().snapshot().unwrap();
         assert_eq!(initial.last_progress_micros, None);
         observer(GraphNativeWorkV1::CompactRowsEncoded {
-            kind: GraphNativeWorkKindV1::Entities, completed_rows: 512, total_rows: 1101,
+            kind: GraphNativeWorkKindV1::Entities,
+            completed_rows: 512,
+            total_rows: 1101,
+            total_relations: 1143,
         });
         let encoded = slot.read().unwrap().snapshot().unwrap();
         assert_eq!(encoded.encoded_entities, 512);
+        assert_eq!(encoded.total_relations, Some(1143));
+        assert_eq!(encoded.encoded_relations, 0);
         assert_eq!(encoded.committed_stage_pages, 0);
         assert_eq!(encoded.committed_compact_segments, 0);
         assert!(encoded.last_progress_micros.is_some());
         observer(GraphNativeWorkV1::CompactRowsEncoded {
-            kind: GraphNativeWorkKindV1::Entities, completed_rows: 512, total_rows: 1101,
+            kind: GraphNativeWorkKindV1::Entities,
+            completed_rows: 512,
+            total_rows: 1101,
+            total_relations: 1143,
         });
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), encoded);
         observer(GraphNativeWorkV1::CompactRowsEncoded {
-            kind: GraphNativeWorkKindV1::Relations, completed_rows: 143, total_rows: 1143,
+            kind: GraphNativeWorkKindV1::Relations,
+            completed_rows: 143,
+            total_rows: 1143,
+            total_relations: 1143,
         });
         let parsed = slot.read().unwrap().snapshot().unwrap();
         assert!(parsed.progress_epoch > encoded.progress_epoch);
+        observer(GraphNativeWorkV1::CompactRowsEncoded {
+            kind: GraphNativeWorkKindV1::Relations,
+            completed_rows: 200,
+            total_rows: 1143,
+            total_relations: 9000,
+        });
+        assert_eq!(
+            slot.read().unwrap().snapshot().unwrap(),
+            parsed,
+            "changing the sealed relation bound cannot renew progress"
+        );
         observer(GraphNativeWorkV1::StagePageApplied {
             ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 36, live_bytes: 4096,
         });
diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index c12ce33351f..c3505e1ea79 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -2044,6 +2044,8 @@ fn build_sealed_container_with_work(
                                         .unwrap_or(u64::MAX),
                                     total_rows: u64::try_from(boundary.total_rows)
                                         .unwrap_or(u64::MAX),
+                                    total_relations: u64::try_from(manifest.relations.len())
+                                        .unwrap_or(u64::MAX),
                                 });
                             }
                         },
@@ -3361,6 +3363,7 @@ mod build_tests {
                 kind: GraphNativeWorkKindV1::Entities,
                 completed_rows: 7,
                 total_rows: 7,
+                total_relations: 9,
             }
         )));
         assert!(events.iter().any(|event| matches!(
@@ -3369,6 +3372,7 @@ mod build_tests {
                 kind: GraphNativeWorkKindV1::Relations,
                 completed_rows: 9,
                 total_rows: 9,
+                total_relations: 9,
             }
         )));
         assert!(events.iter().any(|event| matches!(
diff --git a/crates/tracedecay-store/src/runtime/graph_publication/operation.rs b/crates/tracedecay-store/src/runtime/graph_publication/operation.rs
index 8bc8bd29260..da44d74655d 100644
--- a/crates/tracedecay-store/src/runtime/graph_publication/operation.rs
+++ b/crates/tracedecay-store/src/runtime/graph_publication/operation.rs
@@ -42,6 +42,9 @@ pub enum GraphNativeWorkV1 {
         kind: GraphNativeWorkKindV1,
         completed_rows: u64,
         total_rows: u64,
+        /// The sealed manifest's relation bound is known before any relation
+        /// window completes. Zero is distinct from a bound not yet reported.
+        total_relations: u64,
     },
     StagePageApplied {
         ordinal: u64,

From 9d1cb37c2e6810af2557ccd8725ca098606baf60 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 04:39:10 -0800
Subject: [PATCH 23/80] fix(graph): retain native observer through commit grant

Refs #4508

The real sealed-graph writer uses a fresh one-shot commit context after
journal classification. Preserve its generation-bound native observer
there instead of silently discarding compact encoding, durable stage-page,
and verified segment observations. Keep the distinct commit probe/grant.

Exercise the actual persistent sealed publication path with nonzero native
encoding and a verified compact segment, then verify idempotent replay
emits no new native work. This is not cold daemon/restart acceptance.
---
 .../src/session_registry/code_graph.rs        | 12 ++-
 .../code_graph/sealed_publication_tests.rs    | 73 ++++++++++++++++++-
 .../runtime/graph_publication/operation.rs    | 12 +++
 3 files changed, 92 insertions(+), 5 deletions(-)

diff --git a/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs b/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
index 022a313c47b..bff402d5a37 100644
--- a/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
+++ b/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
@@ -2118,8 +2118,12 @@ impl RetainedCodeGraphRuntimeV1 {
                 deadline: deadline_identity,
                 cancellation: cancellation_identity,
             };
-            let context = GraphPublicationOperationContextV1::new(&control, &probe)
-                .map_err(|error| GraphDbError::invalid(error.to_string()))?;
+            // The journal read's context already carries the scheduler's
+            // owner-scoped observer. Native writes run under this separate
+            // one-shot commit probe; do not silently drop their real milestones.
+            let publish_context = GraphPublicationOperationContextV1::new(&control, &probe)
+                .map_err(|error| GraphDbError::invalid(error.to_string()))?
+                .inheriting_native_work_from(context);
             let publish_registration = || GraphDbRegistration {
                 authority_lease: Arc::clone(&authority_lease),
                 cancellation: Arc::clone(&request_cancellation),
@@ -2155,7 +2159,7 @@ impl RetainedCodeGraphRuntimeV1 {
             let preparation = self.graph_registry.prepare_verified_publication(
                 publish_registration(),
                 storage,
-                &context,
+                &publish_context,
                 key,
                 Some(manifest),
             )?;
@@ -2172,7 +2176,7 @@ impl RetainedCodeGraphRuntimeV1 {
                         tracing::trace_span!("daemon.session_registry.publish_snapshot.gate_hold")
                             .entered();
                     self.graph_registry
-                        .complete_verified_publication(completion, storage, &context, *proven)
+                        .complete_verified_publication(completion, storage, &publish_context, *proven)
                 }
             }
         };
diff --git a/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs b/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
index 1a28299141c..550ae3320ef 100644
--- a/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
+++ b/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
@@ -29,7 +29,8 @@ use tracedecay_graph_db::{
     GraphProjectorRevision, SealedCodeGenerationReplay, SealedGraphStateDigest,
 };
 use tracedecay_store::{
-    GraphGenerationIdV1, GraphProjectionIdV1, GraphProjectionIdentityV1,
+    GraphGenerationIdV1, GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
+    GraphProjectionIdV1, GraphProjectionIdentityV1,
     GraphPublicationIdempotencyKeyV1, GraphPublicationInputDigestV1, GraphPublicationKeyV1,
     GraphPublicationOperationContextV1, GraphPublicationReplayLookupV1, GraphPublicationReplayV1,
     GraphPublicationStoreV1, GraphReplayAppendOutcomeV1, RetainedGraphStoreLeaseV1,
@@ -1252,6 +1253,76 @@ async fn sealed_generation_fixture(project: &str, source: &str) -> SealedGenerat
     }
 }
 
+/// The real sealed graph writer runs under a new commit probe after its
+/// journal lookup. Native work must reach the code-index observer through
+/// that second context, not disappear between journal and durable publication.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sealed_graph_writer_reports_native_work_through_journal_commit_boundary() {
+    let fixture = sealed_generation_fixture(
+        "project.native-graph-work",
+        "pub fn observed_graph_symbol() -> usize { 43 }\n",
+    )
+    .await;
+    let observed = Arc::new(Mutex::new(Vec::<GraphNativeWorkV1>::new()));
+    let observer: GraphNativeWorkObserverV1 = {
+        let observed = Arc::clone(&observed);
+        Arc::new(move |work| {
+            observed.lock().expect("native graph observation lock").push(work);
+        })
+    };
+    let first_snapshot = fixture
+        .runtime
+        .publish_verified_snapshot_with_admission(
+            Arc::new(AtomicBool::new(false)),
+            None,
+            Some(Arc::clone(&observer)),
+        )
+        .expect("real sealed graph publication");
+    let first_head = first_snapshot.verified_head().clone();
+    let first = observed.lock().expect("first native graph events").clone();
+    assert!(
+        first.iter().any(|work| matches!(
+            work,
+            GraphNativeWorkV1::CompactRowsEncoded {
+                kind: GraphNativeWorkKindV1::Entities,
+                completed_rows,
+                ..
+            } if *completed_rows > 0
+        )),
+        "native entity encoding must cross the nested commit context: {first:?}"
+    );
+    let verified_segments = first
+        .iter()
+        .filter(|work| {
+            matches!(
+                work,
+                GraphNativeWorkV1::CompactSegmentVerified { canonical_bytes, .. }
+                    if *canonical_bytes > 0
+            )
+        })
+        .count();
+    assert_eq!(
+        verified_segments, 1,
+        "exactly one installed and digest-verified graph segment must reach the observer: {first:?}"
+    );
+
+    drop(first_snapshot);
+    let resumed = fixture
+        .runtime
+        .publish_verified_snapshot_with_admission(
+            Arc::new(AtomicBool::new(false)),
+            None,
+            Some(observer),
+        )
+        .expect("same sealed graph publication reuses the durable head");
+    assert_eq!(resumed.verified_head(), &first_head);
+    assert_eq!(
+        *observed.lock().expect("replay native graph events"),
+        first,
+        "replaying the already verified head must report no new native work"
+    );
+}
+
 /// The graph store is the only owner of symbol, file, and import records:
 /// sealing writes no second copy of them beside the generation, and the
 /// interactive catalog is derived from the sealed projection itself.
diff --git a/crates/tracedecay-store/src/runtime/graph_publication/operation.rs b/crates/tracedecay-store/src/runtime/graph_publication/operation.rs
index da44d74655d..3e50de5fe3d 100644
--- a/crates/tracedecay-store/src/runtime/graph_publication/operation.rs
+++ b/crates/tracedecay-store/src/runtime/graph_publication/operation.rs
@@ -97,6 +97,18 @@ impl<'a> GraphPublicationOperationContextV1<'a> {
         self
     }
 
+    /// A journaled publication replaces its one-shot commit probe before
+    /// writing native rows. Carry the same writer observation authority into
+    /// that new commit context without carrying its spent commit grant.
+    #[must_use]
+    pub fn inheriting_native_work_from(
+        mut self,
+        original: &GraphPublicationOperationContextV1<'_>,
+    ) -> Self {
+        self.native_work_observer = original.native_work_observer.clone();
+        self
+    }
+
     pub fn observe_native_work(&self, work: GraphNativeWorkV1) {
         if let Some(observer) = &self.native_work_observer {
             observer(work);

From c9c70eefaf1dbbed4b8675c89fdb0e6bd5624598 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 05:16:58 -0800
Subject: [PATCH 24/80] fix(graph): retain writer evidence across serving
 activation

Refs #4508

An initial sealed graph publication can emit a verified native segment,
then a decoded-graph activation reopens the same head without writing.
Preserve the original real work and timestamp until activation produces a
new physical write; reject stale and invalid callbacks on both paths.

Exercise the real daemon freshness/search journey through cold generation,
graceful restart, and a new post-restart generation. This is not crash or
interruption-resume acceptance. Bazel execution and dashboard generation
remain required.
---
 .../registry/graph_progress.rs                | 157 +++++++++++++++++-
 .../code_index_scheduler/registry/mount.rs    |   2 +-
 .../tests/daemon_suite/git_watch_test.rs      |  56 +++++++
 3 files changed, 205 insertions(+), 10 deletions(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
index df8fea8cd39..37139f49441 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
@@ -13,19 +13,27 @@ use tracedecay_store::{
 pub(super) type CodeIndexNativeGraphProgressSlotV1 =
     Arc<RwLock<CodeIndexNativeGraphProgressSlotStateV1>>;
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 struct GraphAttemptOwnerV1 {
     daemon: u64,
     producer: u64,
     sequence: u64,
 }
 
-#[derive(Default)]
+#[derive(Clone)]
+struct PendingNativeGraphActivationV1 {
+    owner: GraphAttemptOwnerV1,
+    generation_id: String,
+    sealed_graph_digest: String,
+}
+
+#[derive(Clone, Default)]
 pub(super) struct CodeIndexNativeGraphProgressSlotStateV1 {
     sequence: u64,
     epoch: u64,
     snapshot: Option<CodeIndexNativeGraphProgressV1>,
     last_stage_ordinal: Option<u64>,
+    pending_activation: Option<PendingNativeGraphActivationV1>,
 }
 
 impl CodeIndexNativeGraphProgressSlotStateV1 {
@@ -37,19 +45,65 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
         sealed_graph_digest: String,
     ) -> GraphAttemptOwnerV1 {
         self.sequence = self.sequence.saturating_add(1).max(1);
-        self.epoch = self.epoch.saturating_add(1).max(1);
-        self.last_stage_ordinal = None;
         let owner = GraphAttemptOwnerV1 {
             daemon,
             producer,
             sequence: self.sequence,
         };
+        self.pending_activation = None;
+        self.start_with_owner(owner, generation_id, sealed_graph_digest);
+        owner
+    }
+
+    /// A serving activation often reopens the graph that the same worker
+    /// already published. Only its first actual native write can replace the
+    /// previous writer's completed report.
+    fn begin_on_first_work(
+        &mut self,
+        daemon: u64,
+        producer: u64,
+        generation_id: String,
+        sealed_graph_digest: String,
+    ) -> GraphAttemptOwnerV1 {
+        let retain_previous = self.snapshot.as_ref().is_some_and(|current| {
+            !current.active
+                && current.daemon_incarnation == daemon
+                && current.producer_incarnation == producer
+                && current.generation_id == generation_id
+                && current.sealed_graph_digest == sealed_graph_digest
+                && current.last_progress_micros.is_some()
+        });
+        if !retain_previous {
+            return self.begin(daemon, producer, generation_id, sealed_graph_digest);
+        }
+        self.sequence = self.sequence.saturating_add(1).max(1);
+        let owner = GraphAttemptOwnerV1 {
+            daemon,
+            producer,
+            sequence: self.sequence,
+        };
+        self.pending_activation = Some(PendingNativeGraphActivationV1 {
+            owner,
+            generation_id,
+            sealed_graph_digest,
+        });
+        owner
+    }
+
+    fn start_with_owner(
+        &mut self,
+        owner: GraphAttemptOwnerV1,
+        generation_id: String,
+        sealed_graph_digest: String,
+    ) {
+        self.epoch = self.epoch.saturating_add(1).max(1);
+        self.last_stage_ordinal = None;
         self.snapshot = Some(CodeIndexNativeGraphProgressV1 {
             generation_id,
             sealed_graph_digest,
-            daemon_incarnation: daemon,
-            producer_incarnation: producer,
-            attempt_sequence: self.sequence,
+            daemon_incarnation: owner.daemon,
+            producer_incarnation: owner.producer,
+            attempt_sequence: owner.sequence,
             progress_epoch: self.epoch,
             phase: None,
             encoded_entities: 0,
@@ -64,11 +118,10 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
             last_progress_micros: None,
             active: true,
         });
-        owner
     }
 
     fn owns(&self, owner: GraphAttemptOwnerV1) -> bool {
-        self.snapshot.as_ref().is_some_and(|state| {
+        self.sequence == owner.sequence && self.snapshot.as_ref().is_some_and(|state| {
             state.active
                 && state.daemon_incarnation == owner.daemon
                 && state.producer_incarnation == owner.producer
@@ -77,6 +130,26 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
     }
 
     fn observe(&mut self, owner: GraphAttemptOwnerV1, work: GraphNativeWorkV1, now: i64) -> bool {
+        if let Some(pending) = self.pending_activation.as_ref() {
+            if pending.owner != owner {
+                return false;
+            }
+            // Rejected callbacks cannot erase a prior verified publication.
+            // Stage the new owner and accept the first genuine write atomically.
+            let pending = pending.clone();
+            let mut candidate = self.clone();
+            candidate.pending_activation = None;
+            candidate.start_with_owner(
+                owner,
+                pending.generation_id,
+                pending.sealed_graph_digest,
+            );
+            if !candidate.observe(owner, work, now) {
+                return false;
+            }
+            *self = candidate;
+            return true;
+        }
         if !self.owns(owner) {
             return false;
         }
@@ -167,6 +240,10 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
     }
 
     fn finish(&mut self, owner: GraphAttemptOwnerV1) {
+        if self.pending_activation.as_ref().is_some_and(|pending| pending.owner == owner) {
+            self.pending_activation = None;
+            return;
+        }
         if !self.owns(owner) {
             return;
         }
@@ -202,6 +279,18 @@ impl CodeIndexNativeGraphProgressGuardV1 {
         Self { slot, owner }
     }
 
+    pub(super) fn begin_for_activation(
+        slot: CodeIndexNativeGraphProgressSlotV1,
+        daemon: u64,
+        producer: u64,
+        generation_id: String,
+        sealed_graph_digest: String,
+    ) -> Self {
+        let owner = slot.write().unwrap_or_else(PoisonError::into_inner)
+            .begin_on_first_work(daemon, producer, generation_id, sealed_graph_digest);
+        Self { slot, owner }
+    }
+
     pub(super) fn observer(&self) -> GraphNativeWorkObserverV1 {
         let slot = Arc::clone(&self.slot);
         let owner = self.owner;
@@ -299,6 +388,56 @@ mod tests {
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), finished);
     }
 
+    #[test]
+    fn read_only_activation_keeps_verified_native_milestones_until_real_write() {
+        let slot = Arc::new(RwLock::new(CodeIndexNativeGraphProgressSlotStateV1::default()));
+        let publication = CodeIndexNativeGraphProgressGuardV1::begin(
+            Arc::clone(&slot), 3, 8, "generation.a".into(), "digest.a".into(),
+        );
+        publication.observer()(GraphNativeWorkV1::CompactSegmentVerified {
+            entities: 11, relations: 9, canonical_bytes: 4096,
+        });
+        drop(publication);
+        let verified = slot.read().unwrap().snapshot().unwrap();
+        assert_eq!(verified.committed_compact_segments, 1);
+        assert!(!verified.active);
+
+        // The worker publishes from sealed rows, then activates the decoded
+        // serving generation. Reopening its verified head writes no segment.
+        let activation = CodeIndexNativeGraphProgressGuardV1::begin_for_activation(
+            Arc::clone(&slot), 3, 8, "generation.a".into(), "digest.a".into(),
+        );
+        let callback = activation.observer();
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), verified);
+        callback(GraphNativeWorkV1::CompactSegmentVerified {
+            entities: 0, relations: 0, canonical_bytes: 0,
+        });
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), verified);
+        drop(activation);
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), verified);
+        callback(GraphNativeWorkV1::StagePageApplied {
+            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 5, live_bytes: 120,
+        });
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), verified);
+
+        let retry = CodeIndexNativeGraphProgressGuardV1::begin_for_activation(
+            Arc::clone(&slot), 3, 8, "generation.a".into(), "digest.a".into(),
+        );
+        retry.observer()(GraphNativeWorkV1::StagePageApplied {
+            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 5, live_bytes: 120,
+        });
+        let restarted = slot.read().unwrap().snapshot().unwrap();
+        assert!(restarted.active);
+        assert!(restarted.progress_epoch > verified.progress_epoch);
+        assert!(restarted.attempt_sequence > verified.attempt_sequence);
+        assert_eq!(restarted.committed_stage_pages, 1);
+        assert_eq!(restarted.committed_compact_segments, 0);
+        assert_eq!(restarted.committed_stage_mutations, 5);
+        assert!(restarted.last_progress_micros.is_some());
+        drop(retry);
+        assert!(!slot.read().unwrap().snapshot().unwrap().active);
+    }
+
     #[test]
     fn restarted_native_publication_fences_old_callbacks_and_resets_attempt_counters() {
         let slot = Arc::new(RwLock::new(CodeIndexNativeGraphProgressSlotStateV1::default()));
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs
index 8937741afda..9cb83b2ec2c 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/mount.rs
@@ -2693,7 +2693,7 @@ impl CodeIndexSchedulerRegistryV1 {
                         .unwrap_or_else(std::sync::PoisonError::into_inner)
                         .as_ref()
                         .and_then(|serving| serving.interactive_graph_store().ok());
-                    let graph_attempt = super::graph_progress::CodeIndexNativeGraphProgressGuardV1::begin(
+                    let graph_attempt = super::graph_progress::CodeIndexNativeGraphProgressGuardV1::begin_for_activation(
                         Arc::clone(&worker_native_graph_progress),
                         progress_daemon_incarnation,
                         progress_producer_incarnation,
diff --git a/crates/tracedecay/tests/daemon_suite/git_watch_test.rs b/crates/tracedecay/tests/daemon_suite/git_watch_test.rs
index 6037142faff..5b2d42face2 100644
--- a/crates/tracedecay/tests/daemon_suite/git_watch_test.rs
+++ b/crates/tracedecay/tests/daemon_suite/git_watch_test.rs
@@ -421,3 +421,59 @@ async fn concurrent_reconciliations_converge_on_one_sealed_generation() {
     assert_eq!(generation_index_len(&data_root, &project), before + 1);
     harness.shutdown().await;
 }
+
+#[tokio::test]
+async fn cold_and_restarted_daemon_status_retains_actual_native_graph_writes() {
+    let (root, project, harness) = indexed_repo().await;
+    let first = wait_for_symbol(&harness, &project, "refs/heads/main", None, "on_main").await;
+    let cold = status(&harness, &project).await;
+    let native = &cold["code_index_freshness"]["worktree"]["native_graph_progress"];
+    assert_eq!(native["generation_id"], first, "cold publication owner: {cold}");
+    assert_eq!(native["committed_compact_segments"], 1, "{cold}");
+    assert_eq!(native["active"], false, "{cold}");
+    assert!(
+        native["encoded_entities"].as_u64().is_some_and(|count| count > 0),
+        "the actual direct writer must report nonzero accepted entity rows: {cold}"
+    );
+    assert!(
+        native["committed_compact_bytes"].as_u64().is_some_and(|bytes| bytes > 0),
+        "only a real installed, digest-verified container is a commit: {cold}"
+    );
+    assert!(
+        native["last_progress_micros"].as_i64().is_some_and(|when| when > 0),
+        "read-side readiness must not replace the native writer clock: {cold}"
+    );
+    let original_digest = native["sealed_graph_digest"].clone();
+    harness.shutdown().await;
+
+    // A new daemon over the same durable store must serve the same original
+    // generation, without an invented second native graph publication.
+    let harness = ProductionProjectCompositionHarnessV1::open(root.path(), [project.clone()])
+        .await
+        .expect("restart the real project composition");
+    let retained = wait_for_symbol(&harness, &project, "refs/heads/main", None, "on_main").await;
+    assert_eq!(retained, first, "a read-only restart must retain the first seal");
+
+    fs::write(project.join("src/successor.rs"), "pub fn successor_after_restart() {}\n")
+        .expect("write changed source");
+    commit_all(&project, "successor after restart");
+    request_refresh(&harness, &project).await;
+    let successor = wait_for_symbol(
+        &harness,
+        &project,
+        "refs/heads/main",
+        Some(&first),
+        "successor_after_restart",
+    )
+    .await;
+    let latest = status(&harness, &project).await;
+    let native = &latest["code_index_freshness"]["worktree"]["native_graph_progress"];
+    assert_eq!(native["generation_id"], successor, "{latest}");
+    assert_ne!(native["sealed_graph_digest"], original_digest, "{latest}");
+    assert_eq!(native["committed_compact_segments"], 1, "{latest}");
+    assert!(
+        native["committed_compact_bytes"].as_u64().is_some_and(|bytes| bytes > 0),
+        "successor must emit its own verified native commit: {latest}"
+    );
+    harness.shutdown().await;
+}

From 75bab3fb37a151fbdf08a8d9d41e5b6a80ad3a59 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 05:36:00 -0800
Subject: [PATCH 25/80] fix(cli): detect stalled native graph before first
 write

Refs #4508

An active native graph attempt with zero actual work used to fall through
to an uninstrumented phase and clear the wait silence window forever.
Observe its owner as an uncredited zero-work baseline, timing out sustained
silence while preserving concurrent real text progress and the monolithic
compact-write exception. Add nonzero serialized status wait and deterministic
work-handoff regressions. Move the reported inline import to module scope.

Bazel/native execution remains unverified.
---
 crates/tracedecay-cli/src/commands/index.rs | 122 ++++++++++++++++++--
 1 file changed, 115 insertions(+), 7 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index b6afa90278a..c32473c86db 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -7,7 +7,8 @@ use tracedecay_project::project::TraceDecay;
 use tracedecay_contracts::code_index_freshness::{
     CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
     CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexBuildProgressV1,
-    CodeIndexNativeGraphPhaseV1, CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1,
+    CodeIndexNativeGraphPhaseV1, CodeIndexPresealWorkPhaseV1, CodeIndexReadinessWaitOutcomeV1,
+    CodeIndexStalenessStateV1,
     CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::graph_tool::GraphToolResultV1;
@@ -509,9 +510,21 @@ impl FirstGenerationWorkMarker {
             {
                 return None;
             }
-            if graph.last_progress_micros.is_some() {
-                return Some(Self::native_graph(graph));
+            // Starting the native attempt proves only that there is an owner,
+            // not that it has written any rows. A silent initial window must
+            // be timed from the first status read, not treated as unknown
+            // forever or credited with an invented progress timestamp.
+            // Continue using real text commits if they are advancing
+            // concurrently before the graph reports its first boundary.
+            if graph.last_progress_micros.is_none()
+                && let Some(progress) = worktree
+                    .progress
+                    .as_ref()
+                    .filter(|progress| progress.phase == CodeIndexBuildPhaseV1::BulkCommit)
+            {
+                return Some(Self::text(progress));
             }
+            return Some(Self::native_graph(graph));
         }
         if let Some(progress) = &worktree.progress {
             match progress.phase {
@@ -612,14 +625,17 @@ impl FirstGenerationWorkMarker {
                     ..
                 },
             ) => {
-                use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::{
-                    Capture, ParseEvidence,
-                };
                 if (owner, epoch) <= (prior_owner, prior_epoch) {
                     return None;
                 }
                 if owner == prior_owner {
-                    if matches!((prior_phase, phase), (ParseEvidence, Capture))
+                    if matches!(
+                        (prior_phase, phase),
+                        (
+                            CodeIndexPresealWorkPhaseV1::ParseEvidence,
+                            CodeIndexPresealWorkPhaseV1::Capture
+                        )
+                    )
                         || (phase == prior_phase && completed < prior_completed)
                     {
                         return None;
@@ -1424,6 +1440,98 @@ mod daemon_precondition_tests {
         assert_eq!(reads, 5, "only the reached proof ends a progressing wait");
     }
 
+    fn native_graph_without_writes() -> CodeIndexWorktreeFreshnessV1 {
+        let mut worktree = building(true);
+        worktree.progress = Some(CodeIndexBuildProgressV1 {
+            phase: CodeIndexBuildPhaseV1::GraphPublication,
+            ..progress(6_136, None)
+        });
+        worktree.native_graph_progress = Some(
+            tracedecay_contracts::code_index_freshness::CodeIndexNativeGraphProgressV1 {
+                generation_id: "generation.v1.first".to_owned(),
+                sealed_graph_digest: "sha256:sealed".to_owned(),
+                daemon_incarnation: 3,
+                producer_incarnation: 5,
+                attempt_sequence: 1,
+                progress_epoch: 1,
+                phase: None,
+                encoded_entities: 0,
+                total_entities: None,
+                encoded_relations: 0,
+                total_relations: None,
+                committed_stage_pages: 0,
+                committed_stage_mutations: 0,
+                committed_stage_bytes: 0,
+                committed_compact_segments: 0,
+                committed_compact_bytes: 0,
+                last_progress_micros: None,
+                active: true,
+            },
+        );
+        worktree
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn wait_loop_refuses_a_silent_native_writer_before_later_ready() {
+        let cold = native_graph_without_writes();
+        assert!(matches!(
+            super::FirstGenerationWorkMarker::of(Some(&cold)),
+            Some(super::FirstGenerationWorkMarker::NativeGraph {
+                completed: [0, 0, 0, 0, 0, 0],
+                ..
+            })
+        ));
+        let mut repeated = cold.clone();
+        repeated.native_graph_progress.as_mut().unwrap().progress_epoch += 1;
+        // A changed status epoch without a physical row or durable page
+        // must not turn the initial unreported native attempt into progress.
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(cold)),
+                status(timed_out(), warming(repeated)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2, "the frozen writer must refuse before a later ready");
+        let (code, reason) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(
+            reason.contains("no observed capture, parse, text, or native graph work"),
+            "{reason}"
+        );
+    }
+
+    #[test]
+    fn first_native_write_advances_silence_but_parallel_text_commits_are_not_hidden() {
+        let mut cold = native_graph_without_writes();
+        let mut text = progress(30, None);
+        text.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        cold.progress = Some(text);
+        assert!(matches!(
+            super::FirstGenerationWorkMarker::of(Some(&cold)),
+            Some(super::FirstGenerationWorkMarker::CommittedText { .. })
+        ));
+
+        cold.progress.as_mut().unwrap().phase = CodeIndexBuildPhaseV1::GraphPublication;
+        let start = Instant::now();
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        let before = super::FirstGenerationWorkMarker::of(Some(&cold));
+        assert!(!window.observe(before.clone(), start));
+        assert!(!window.observe(before, start + Duration::from_secs(119)));
+        let graph = cold.native_graph_progress.as_mut().unwrap();
+        graph.encoded_entities = 512;
+        graph.total_entities = Some(1024);
+        graph.total_relations = Some(4096);
+        graph.phase = Some(CodeIndexNativeGraphPhaseV1::CompactEncoding);
+        graph.progress_epoch += 1;
+        graph.last_progress_micros = Some(10);
+        let progressed = super::FirstGenerationWorkMarker::of(Some(&cold));
+        assert!(!window.observe(progressed.clone(), start + Duration::from_secs(119)));
+        assert!(!window.observe(progressed.clone(), start + Duration::from_secs(238)));
+        assert!(window.observe(progressed, start + Duration::from_secs(239)));
+    }
 
     #[test]
     fn native_graph_real_counts_refresh_wait_but_duplicate_epochs_and_stale_owners_do_not() {

From e3c262e8e95db75ef124fa7dc4b05a16decaf2d9 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 06:43:40 -0800
Subject: [PATCH 26/80] test(daemon): prove cold pre-seal recovery after hard
 kill

Refs #4508

Exercise a real paused first-generation parse through physical daemon
status, hard-kill before any seal, then restart and require a verified
native graph segment and a readable newly sealed generation.
Polling while held must not fabricate a progress epoch. Bazel execution
and broader interrupted-stage acceptance remain outstanding.
---
 .../daemon_suite/indexing_lifecycle_test.rs   | 141 ++++++++++++++++++
 1 file changed, 141 insertions(+)

diff --git a/crates/tracedecay/tests/daemon_suite/indexing_lifecycle_test.rs b/crates/tracedecay/tests/daemon_suite/indexing_lifecycle_test.rs
index da13e1944c4..5344cae052a 100644
--- a/crates/tracedecay/tests/daemon_suite/indexing_lifecycle_test.rs
+++ b/crates/tracedecay/tests/daemon_suite/indexing_lifecycle_test.rs
@@ -303,6 +303,147 @@ fn assert_exact_ignored_dependency_roster(generation: &CodeIndexPublishedGenerat
     }));
 }
 
+/// A first generation has no sealed identity while the extraction worker is
+/// paused. Killing that daemon must not turn its attempt into a completed
+/// generation; the next daemon must build, seal and verify its own native graph.
+#[tokio::test]
+async fn hard_killed_cold_preseal_attempt_recovers_a_verified_native_graph() {
+    let (environment, project) = IsolatedHome::new();
+    let project = canonical_existing_identity(&project).expect("canonical fixture project");
+    let (main_revision, _) = initialize_repository(&project);
+    let hold = environment.scratch().join("hold-initial-cold-extraction");
+    let entered = PathBuf::from(format!("{}.entered", hold.display()));
+    fs::write(&hold, b"hold").expect("arm cold extraction hold");
+    let socket = daemon_socket_path(environment.home());
+    let mut daemon = spawn_tracedecay_daemon_with(environment.home(), |command| {
+        command.env("TRACEDECAY_TEST_HOLD_AFTER_COLD_EXTRACTION", &hold);
+    });
+    let project_id = initialize_tracedecay(environment.home(), &project);
+    let identity = exact_identity(&project, project_id);
+    tracedecay_project::product_runtime::register_fixture_product_runtime();
+    let handshake = crate::common::handshake_for_current_client(
+        environment.profile(),
+        Some(project.clone()),
+        None,
+        false,
+        false,
+    )
+    .expect("production daemon handshake");
+    poll_until(
+        Instant::now() + RECEIPT_TIMEOUT,
+        Duration::from_millis(20),
+        || entered.is_file().then_some(()),
+        || "the cold capture never reached its post-extraction hold".to_owned(),
+    );
+
+    // This status comes from the physical daemon while the parser-backed
+    // segments are prepared, before any sealed generation can exist.
+    let in_flight = tokio::time::timeout(RECEIPT_TIMEOUT, async {
+        loop {
+            let receipt = status(&socket, &handshake).await;
+            let attempt = &receipt["code_index_freshness"]["worktree"]["preseal_attempt"];
+            if attempt["active"] == true
+                && attempt["phase"] == "parse_evidence"
+                && attempt["completed_items"].as_u64().is_some_and(|count| count > 0)
+            {
+                return receipt;
+            }
+            tokio::time::sleep(Duration::from_millis(25)).await;
+        }
+    })
+    .await
+    .expect("cold daemon never reported real pre-seal parser work");
+    let cold = &in_flight["code_index_freshness"]["worktree"];
+    let attempt = &cold["preseal_attempt"];
+    assert_eq!(
+        cold["latest_generation_id"],
+        json!(null),
+        "unsealed capture cannot claim an immutable generation: {in_flight}"
+    );
+    assert_eq!(cold["progress"], json!(null));
+    assert_eq!(cold["native_graph_progress"], json!(null));
+    assert!(
+        attempt.get("generation_id").is_none() && attempt.get("sealed_source_digest").is_none(),
+        "pre-seal attempt cannot claim a nonexistent sealed authority: {in_flight}"
+    );
+    assert!(
+        attempt["last_progress_micros"]
+            .as_i64()
+            .is_some_and(|micros| micros > 0),
+        "a positive parse count must carry its original work timestamp: {in_flight}"
+    );
+    assert!(
+        attempt["progress_epoch"]
+            .as_u64()
+            .is_some_and(|epoch| epoch > 0),
+        "the active attempt must have an observed work epoch: {in_flight}"
+    );
+    let repeat = status(&socket, &handshake).await;
+    assert_eq!(
+        repeat["code_index_freshness"]["worktree"]["preseal_attempt"],
+        *attempt,
+        "status polling under a paused producer must not invent new work"
+    );
+
+    let killed = daemon.kill_and_wait().expect("hard-kill the cold daemon");
+    assert!(!killed.success(), "cold interruption must be a real process kill");
+
+    // The hold is deliberately not propagated to the new daemon. It has to
+    // capture, parse, seal, and publish from the surviving real Git tree.
+    daemon = spawn_tracedecay_daemon_with(environment.home(), |_| {});
+    let recovered = wait_for_terminal_generation(
+        &socket,
+        &handshake,
+        &project,
+        &identity,
+        "refs/heads/main",
+        Some(&main_revision),
+        None,
+        "lifecycle_main_symbol",
+        Some("src/lib.rs"),
+    )
+    .await;
+    let mut last = Value::Null;
+    let completed_status = tokio::time::timeout(RECEIPT_TIMEOUT, async {
+        loop {
+            last = status(&socket, &handshake).await;
+            let native = &last["code_index_freshness"]["worktree"]["native_graph_progress"];
+            if native["generation_id"].as_str() == Some(recovered.generation_id.as_str())
+                && native["committed_compact_segments"] == 1
+                && native["active"] == false
+            {
+                return last.clone();
+            }
+            tokio::time::sleep(Duration::from_millis(25)).await;
+        }
+    })
+    .await
+    .unwrap_or_else(|_| panic!("restarted native graph progress missing: {last}"));
+    let native = &completed_status["code_index_freshness"]["worktree"]["native_graph_progress"];
+    assert!(
+        native["committed_compact_bytes"]
+            .as_u64()
+            .is_some_and(|bytes| bytes > 0),
+        "native completion must name nonzero installed bytes: {native}"
+    );
+    assert!(
+        native["last_progress_micros"]
+            .as_i64()
+            .is_some_and(|micros| micros > 0),
+        "verified native completion must preserve its genuine work time: {native}"
+    );
+
+    let sealed = read_active_generation(environment.home(), &project);
+    assert_sealed_generation_identity(
+        &sealed,
+        &identity,
+        "refs/heads/main",
+        Some(&main_revision),
+        &recovered.generation_id,
+    );
+    stop_daemon_gracefully(&mut daemon);
+}
+
 #[tokio::test]
 async fn ignored_dependency_admission_survives_physical_daemon_restart_without_widening() {
     let (environment, project) = IsolatedHome::new();

From 080260de85fdb7b07a92e41340ebb397b12e1dff Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 06:58:18 -0800
Subject: [PATCH 27/80] test(graph): prove native page recovery across
 interrupted writer

Refs #4508

Exercise the real persistent native graph stage, cancelling after the
first receipted entity page and reopening the store. Require only the
newly committed relation page to emit a write event, then verify the
recovered graph digest and silent idempotent replay. Import native work
types explicitly in the graph-db test module.
---
 .../src/generation_runtime.rs                 | 134 +++++++++++++++++-
 1 file changed, 128 insertions(+), 6 deletions(-)

diff --git a/crates/tracedecay-graph-db/src/generation_runtime.rs b/crates/tracedecay-graph-db/src/generation_runtime.rs
index 7a6c44e8113..f4f185737ba 100644
--- a/crates/tracedecay-graph-db/src/generation_runtime.rs
+++ b/crates/tracedecay-graph-db/src/generation_runtime.rs
@@ -2844,12 +2844,14 @@ mod tests {
 
     use std::cell::Cell;
     use std::collections::{BTreeMap, BTreeSet};
-    use std::sync::Arc;
-    use std::sync::mpsc;
+    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::{Arc, Mutex, mpsc};
     use std::time::{Duration, Instant};
 
     use tempfile::TempDir;
-    use tracedecay_store::runtime::GraphRecoveredGenerationDigestV1;
+    use tracedecay_store::runtime::{
+        GraphNativeWorkKindV1, GraphNativeWorkV1, GraphRecoveredGenerationDigestV1,
+    };
 
     use crate::generation::{
         canonical_buffer_allocation_growths, manifest_canonicalizations,
@@ -2864,9 +2866,10 @@ mod tests {
     };
     use crate::{
         GraphDbError, GraphDbLocation, GraphDbOpenOptions, GraphDbOwner, GraphDurability,
-        GraphEntity, GraphEntityId, GraphFormatVersion, GraphGenerationDependency,
-        GraphGenerationId, GraphGenerationManifest, GraphIdempotencyKey, GraphNamespace,
-        GraphProjectionId, GraphProjectionIdentity, GraphWatermark,
+        GraphEntity, GraphEntityId, GraphEntityRef, GraphFormatVersion,
+        GraphGenerationDependency, GraphGenerationId, GraphGenerationManifest,
+        GraphGenerationRelation, GraphIdempotencyKey, GraphNamespace, GraphProjectionId,
+        GraphProjectionIdentity, GraphRelationId, GraphRelationKind, GraphWatermark,
         MAX_VERIFIED_GENERATION_BATCH_MUTATIONS, NeverCancelled, SourceGeneration,
     };
 
@@ -3838,6 +3841,125 @@ mod tests {
         owner.close().expect("close native graph store");
     }
 
+    /// The callback follows the durable page transaction, not final generation
+    /// verification. An interrupted writer must retain that page across
+    /// a physical store reopen, then report only the newly committed successor.
+    #[test]
+    fn interrupted_native_stage_resumes_receipts_without_fabricating_writes() {
+        let mut manifest = large_manifest("interrupted-native-stage");
+        let projection = manifest.projection.clone();
+        manifest.relations.push(
+            GraphGenerationRelation::new(
+                GraphRelationId::new("relation:00000").unwrap(),
+                GraphEntityRef::new(
+                    projection.clone(),
+                    GraphEntityId::new("entity:00000").unwrap(),
+                ),
+                GraphEntityRef::new(
+                    projection,
+                    GraphEntityId::new("entity:00001").unwrap(),
+                ),
+                GraphRelationKind::new("calls").unwrap(),
+                BTreeMap::new(),
+            )
+            .unwrap(),
+        );
+        let pages = generation_stage_pages(&manifest).expect("real page plan");
+        assert_eq!(pages.len(), 2, "entities and relations must use distinct pages");
+        let expected = sealed_digest(&manifest);
+        let temp = TempDir::new().expect("persistent graph store");
+        let (owner, database) = persistent_database(&temp);
+        let cancel = AtomicBool::new(false);
+        let first_events = Mutex::new(Vec::new());
+        let first_observer = |event| {
+            first_events.lock().unwrap().push(event);
+            cancel.store(true, Ordering::Release);
+        };
+        let check = || {
+            if cancel.load(Ordering::Acquire) {
+                Err(GraphDbError::Cancelled)
+            } else {
+                Ok(())
+            }
+        };
+        let interrupted = database.apply_generation_unverified_with_digest_and_work(
+            arc_manifest(&manifest),
+            &expected,
+            &check,
+            Some(&first_observer),
+        );
+        assert!(
+            matches!(interrupted, Err(GraphDbError::Cancelled)),
+            "a real post-page cancellation must prevent finalization"
+        );
+        let committed_before_kill = first_events.lock().unwrap().clone();
+        assert_eq!(committed_before_kill.len(), 1, "one real page must commit");
+        assert!(matches!(
+            &committed_before_kill[0],
+            GraphNativeWorkV1::StagePageApplied {
+                ordinal: 0,
+                kind: GraphNativeWorkKindV1::Entities,
+                mutations: 1..,
+                live_bytes: 1..,
+            }
+        ));
+        drop(database);
+        owner.close().expect("settle durable page before restart");
+
+        let (reopened_owner, reopened) = persistent_database(&temp);
+        let resumed_events = Mutex::new(Vec::new());
+        let resume_observer = |event| resumed_events.lock().unwrap().push(event);
+        let outcome = reopened
+            .apply_generation_unverified_with_digest_and_work(
+                arc_manifest(&manifest),
+                &expected,
+                &|| Ok(()),
+                Some(&resume_observer),
+            )
+            .expect("recover the durable first page and commit relation page");
+        assert!(matches!(outcome, GenerationStageOutcome::Applied(_)));
+        let resumed = resumed_events.lock().unwrap().clone();
+        assert_eq!(
+            resumed.len(),
+            1,
+            "the resumed writer must not count a reused entity receipt as new work"
+        );
+        assert!(matches!(
+            &resumed[0],
+            GraphNativeWorkV1::StagePageApplied {
+                ordinal: 1,
+                kind: GraphNativeWorkKindV1::Relations,
+                mutations: 1,
+                live_bytes: 1..,
+            }
+        ));
+
+        let (_, recovered) = reopened
+            .reopen_and_verify_existing_generation(
+                &manifest.identity(),
+                &expected,
+                manifest.row_counts(),
+                &|| Ok(()),
+            )
+            .expect("the resumed native graph must survive a recovered digest proof");
+        assert_eq!(recovered, expected);
+        let replay = reopened
+            .apply_generation_unverified_with_digest_and_work(
+                arc_manifest(&manifest),
+                &expected,
+                &|| Ok(()),
+                Some(&resume_observer),
+            )
+            .expect("idempotent replay after completed recovery");
+        assert!(matches!(replay, GenerationStageOutcome::Reseated(_)));
+        assert_eq!(
+            resumed_events.lock().unwrap().as_slice(),
+            resumed.as_slice(),
+            "replaying an already verified graph cannot invent new page writes"
+        );
+        reopened_owner.close().expect("close recovered graph store");
+    }
+
     #[test]
     fn native_graph_page_reports_real_wal_commits_but_not_replayed_receipts() {
         let manifest = large_manifest("native-write-observation");

From 680ae00baaa76787ed14066868135596291919f6 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 09:24:07 -0800
Subject: [PATCH 28/80] fix(code-index): repair native progress compilation
 paths

Refs #4508

Retain actual native progress on query-driven graph activation by binding
its observer to the mounted scheduler's incarnation and sealed graph digest.
Preserve the distinct write-attempt boundary through activation.

Remove unused legacy staging and sealed-container wrappers; call the real
observed production implementations from existing tests. Fix the missing
stage plan observer initializer and both updated graph activation callers.
No assertions, checks, or validation gates are weakened.
---
 .../src/code_index_scheduler/reconcile.rs     |  9 ++++
 .../registry/ignored_dependencies.rs          | 21 +++++++-
 .../tests/code_index_scheduler/reconcile.rs   |  2 +
 .../src/generation_runtime.rs                 | 50 +++++++++++--------
 .../tracedecay-graph-db/src/sealed_store.rs   | 18 +++----
 5 files changed, 65 insertions(+), 35 deletions(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
index e2eec3e40f4..63858ae8533 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
@@ -1462,6 +1462,15 @@ impl CodeIndexWorktreeSchedulerV1 {
         self.progress_producer_incarnation = producer_incarnation.max(1);
     }
 
+    /// Exact daemon/producer identity of this mounted scheduler, reused by
+    /// query-driven graph activation after its durable generation commit.
+    pub(crate) const fn progress_incarnations(&self) -> (u64, u64) {
+        (
+            self.progress_daemon_incarnation,
+            self.progress_producer_incarnation,
+        )
+    }
+
     #[cfg(test)]
     pub const fn progress_incarnations_for_test(&self) -> (u64, u64) {
         (
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/ignored_dependencies.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/ignored_dependencies.rs
index 20114d064f3..33075085452 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/ignored_dependencies.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/ignored_dependencies.rs
@@ -11,6 +11,7 @@ use std::sync::{
 use tracedecay_code_index::graph_projection::CodeGraphProjectionStore;
 use tracedecay_code_index::production::{CodeIndexExecutionControlV1, CodeIndexProductionErrorV1};
 use tracedecay_domain::canonical_sha256;
+use tracedecay_store::GraphNativeWorkObserverV1;
 
 use super::super::control_poll;
 use super::{
@@ -601,6 +602,7 @@ impl CodeIndexSchedulerRegistryV1 {
             serving_generation_epoch,
             serving_generation_changed,
             graph_activation,
+            native_graph_progress,
             build_publication_lock,
             shutting_down,
             wake,
@@ -624,6 +626,7 @@ impl CodeIndexSchedulerRegistryV1 {
                 Arc::clone(&worktree.serving_generation_epoch),
                 worktree.serving_generation_changed.clone(),
                 worktree.graph_activation.clone(),
+                Arc::clone(&worktree.native_graph_progress),
                 Arc::clone(&worktree.build_publication_lock),
                 Arc::clone(&worktree.shutting_down),
                 Arc::clone(&worktree.wake),
@@ -706,7 +709,20 @@ impl CodeIndexSchedulerRegistryV1 {
             return Err(CodeIndexIgnoredDependencyRefusalV1::StaleGeneration.into());
         }
         let project_id = build.latest.generation().manifest().project_id.clone();
-
+        // This admission published a durable successor; graph activation may
+        // still write native pages. Observe them under the exact mounted owner
+        // instead of silently discarding the new graph observer parameter.
+        let (daemon_incarnation, producer_incarnation) = scheduler
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .progress_incarnations();
+        let graph_attempt = super::graph_progress::CodeIndexNativeGraphProgressGuardV1::begin_for_activation(
+            native_graph_progress,
+            daemon_incarnation,
+            producer_incarnation,
+            build.latest.generation().manifest().generation_id.as_str().to_owned(),
+            replay_binding.sealed_state_digest.as_str().to_owned(),
+        );
         let activation = activate_committed_generation(
             &graph_activation,
             &project_id,
@@ -715,6 +731,7 @@ impl CodeIndexSchedulerRegistryV1 {
             build.latest.clone(),
             serving.interactive_graph_store().ok(),
             replay_binding,
+            graph_attempt.observer(),
         )
         .await;
         let catalog_warm = match activation {
@@ -899,6 +916,7 @@ async fn activate_committed_generation(
     latest: LatestCompleteCodeIndexV1,
     predecessor: Option<Arc<CodeGraphProjectionStore>>,
     replay_binding: CodeGraphReplayBindingV1,
+    native_work: GraphNativeWorkObserverV1,
 ) -> Result<Option<CodeGraphCatalogWarmV1>, CodeIndexSchedulerErrorV1> {
     graph_activation
         .activate(
@@ -909,6 +927,7 @@ async fn activate_committed_generation(
             predecessor,
             replay_binding,
             Arc::new(AtomicBool::new(false)),
+            native_work,
         )
         .await
 }
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
index 197585914ca..e38420833bb 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
@@ -2677,6 +2677,8 @@ async fn graph_activation_does_not_wait_for_bounded_text_projection() {
             None,
             replay_binding,
             Arc::new(std::sync::atomic::AtomicBool::new(false)),
+            // In-memory test activation has no native graph writer.
+            Arc::new(|_| {}),
         )
         .await
         .expect("graph activation must not wait for the independently bounded text projection");
diff --git a/crates/tracedecay-graph-db/src/generation_runtime.rs b/crates/tracedecay-graph-db/src/generation_runtime.rs
index f4f185737ba..d34bd94785a 100644
--- a/crates/tracedecay-graph-db/src/generation_runtime.rs
+++ b/crates/tracedecay-graph-db/src/generation_runtime.rs
@@ -591,7 +591,7 @@ impl GraphDb {
         expected: &GraphRecoveredGenerationDigestV1,
         check: &dyn Fn() -> Result<(), GraphDbError>,
     ) -> Result<GraphCommit, GraphDbError> {
-        self.apply_generation_unverified_with_digest_observed(manifest, expected, check)
+        self.apply_generation_unverified_with_digest_and_work(manifest, expected, check, None)
             .map(GenerationStageOutcome::commit)
     }
 
@@ -604,18 +604,9 @@ impl GraphDb {
     /// caller is about to close, reopen, and rebuild the in-RAM store -- the
     /// overlap that made publication the peak-RSS moment. Every later stage
     /// reads only the identity, which the caller keeps.
-    #[tracing::instrument(name = "graph_db.generation.stage", level = "trace", skip_all)]
-    pub(crate) fn apply_generation_unverified_with_digest_observed(
-        &self,
-        manifest: Arc<GraphGenerationManifest>,
-        expected: &GraphRecoveredGenerationDigestV1,
-        check: &dyn Fn() -> Result<(), GraphDbError>,
-    ) -> Result<GenerationStageOutcome, GraphDbError> {
-        self.apply_generation_unverified_with_digest_and_work(manifest, expected, check, None)
-    }
-
     /// Observable native stage work is emitted only after the real page
     /// transaction and matching receipt have settled, never on read/replay.
+    #[tracing::instrument(name = "graph_db.generation.stage", level = "trace", skip_all)]
     pub(crate) fn apply_generation_unverified_with_digest_and_work(
         &self,
         manifest: Arc<GraphGenerationManifest>,
@@ -3289,10 +3280,11 @@ mod tests {
         let manifest = large_manifest("retry-admission");
         let sealed = sealed_digest(&manifest);
         let first = database
-            .apply_generation_unverified_with_digest_observed(
+            .apply_generation_unverified_with_digest_and_work(
                 arc_manifest(&manifest),
                 &sealed,
                 &|| Ok(()),
+                None,
             )
             .unwrap();
         let GenerationStageOutcome::Applied(first) = first else {
@@ -3306,10 +3298,11 @@ mod tests {
         reset_manifest_canonicalizations();
         reset_batch_canonicalizations();
         let reapplied = database
-            .apply_generation_unverified_with_digest_observed(
+            .apply_generation_unverified_with_digest_and_work(
                 arc_manifest(&manifest),
                 &sealed,
                 &|| Ok(()),
+                None,
             )
             .unwrap();
         let GenerationStageOutcome::Reseated(reapplied) = reapplied else {
@@ -3364,10 +3357,11 @@ mod tests {
             GenerationLocator::new(manifest.projection.clone(), manifest.generation.clone());
         let (owner, database) = persistent_database(&temp);
         database
-            .apply_generation_unverified_with_digest_observed(
+            .apply_generation_unverified_with_digest_and_work(
                 arc_manifest(&manifest),
                 &sealed,
                 &|| Ok(()),
+                None,
             )
             .unwrap();
         crate::state::reset_retirement_page_record_reads();
@@ -3405,10 +3399,11 @@ mod tests {
             GenerationLocator::new(manifest.projection.clone(), manifest.generation.clone());
         let (owner, database) = persistent_database(&temp);
         let staged = database
-            .apply_generation_unverified_with_digest_observed(
+            .apply_generation_unverified_with_digest_and_work(
                 Arc::clone(&retained_manifest),
                 &sealed,
                 &|| Ok(()),
+                None,
             )
             .unwrap();
         assert!(matches!(staged, GenerationStageOutcome::Applied(_)));
@@ -3428,10 +3423,11 @@ mod tests {
 
         let (reopened_owner, reopened) = persistent_database(&temp);
         let replayed = reopened
-            .apply_generation_unverified_with_digest_observed(
+            .apply_generation_unverified_with_digest_and_work(
                 Arc::clone(&retained_manifest),
                 &sealed,
                 &|| Ok(()),
+                None,
             )
             .unwrap();
         assert!(matches!(replayed, GenerationStageOutcome::Applied(_)));
@@ -3498,10 +3494,11 @@ mod tests {
         let retained_manifest = arc_manifest(&manifest);
         let (owner, database) = persistent_database(&temp);
         database
-            .apply_generation_unverified_with_digest_observed(
+            .apply_generation_unverified_with_digest_and_work(
                 Arc::clone(&retained_manifest),
                 &sealed,
                 &|| Ok(()),
+                None,
             )
             .unwrap();
 
@@ -3536,7 +3533,12 @@ mod tests {
             retained_manifest
         };
         reopened
-            .apply_generation_unverified_with_digest_observed(replay_manifest, &sealed, &|| Ok(()))
+            .apply_generation_unverified_with_digest_and_work(
+                replay_manifest,
+                &sealed,
+                &|| Ok(()),
+                None,
+            )
             .expect("a retained generation must replay after a partial durable row release");
         let (_, recovered) = reopened
             .reopen_and_verify_existing_generation(
@@ -4065,6 +4067,7 @@ mod tests {
                     context: &context,
                     pages: &pages,
                     restaging_sealed_only: false,
+                    observe: None,
                 },
                 &|| Ok(()),
             )
@@ -4121,10 +4124,11 @@ mod tests {
             }
         };
         assert!(matches!(
-            second_database.apply_generation_unverified_with_digest_observed(
+            second_database.apply_generation_unverified_with_digest_and_work(
                 arc_manifest(&manifest),
                 &sealed,
-                &cancel_after_first_page
+                &cancel_after_first_page,
+                None,
             ),
             Err(GraphDbError::Cancelled)
         ));
@@ -4148,10 +4152,11 @@ mod tests {
 
         reset_batch_canonicalizations();
         let resumed = second_database
-            .apply_generation_unverified_with_digest_observed(
+            .apply_generation_unverified_with_digest_and_work(
                 arc_manifest(&manifest),
                 &sealed,
                 &|| Ok(()),
+                None,
             )
             .unwrap();
         let GenerationStageOutcome::Applied(resumed) = resumed else {
@@ -4166,10 +4171,11 @@ mod tests {
         reset_recovered_generation_enumerations();
         reset_batch_canonicalizations();
         let exact = second_database
-            .apply_generation_unverified_with_digest_observed(
+            .apply_generation_unverified_with_digest_and_work(
                 arc_manifest(&manifest),
                 &sealed,
                 &|| Ok(()),
+                None,
             )
             .unwrap();
         let GenerationStageOutcome::Reseated(exact) = exact else {
diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index c3505e1ea79..447a451071c 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -1984,15 +1984,6 @@ fn stage_sealed_artifact(
 /// has written nothing under `staging` that the caller keeps, the container
 /// appears complete or not at all, and the next attempt rebuilds from the
 /// same source.
-fn build_sealed_container(
-    rows: SealedRowSource<'_>,
-    identity: &GraphGenerationManifestIdentity,
-    staging: &Path,
-    check: &dyn Fn() -> Result<(), GraphDbError>,
-) -> Result<(usize, usize), GraphDbError> {
-    build_sealed_container_with_work(rows, identity, staging, check, None)
-}
-
 fn build_sealed_container_with_work(
     rows: SealedRowSource<'_>,
     identity: &GraphGenerationManifestIdentity,
@@ -2980,11 +2971,12 @@ mod build_tests {
         let staging = tempfile::tempdir().unwrap();
 
         let (built, peak) = crate::thread_allocation::peak_above_start(|| {
-            build_sealed_container(
+            build_sealed_container_with_work(
                 SealedRowSource::Manifest(&manifest),
                 &identity,
                 staging.path(),
                 check,
+                None,
             )
         });
         eprintln!("SEALED BUILD peak {peak}");
@@ -3093,11 +3085,12 @@ mod build_tests {
         let identity = manifest.identity();
         let namespace = identity.physical_namespace().unwrap();
         let staging = tempfile::tempdir().unwrap();
-        build_sealed_container(
+        build_sealed_container_with_work(
             SealedRowSource::Manifest(&manifest),
             &identity,
             staging.path(),
             check,
+            None,
         )
         .unwrap();
         let path = staging.path().join(SEALED_STORE_DATABASE_FILE);
@@ -3175,11 +3168,12 @@ mod build_tests {
         let expected = manifest.expected_recovered_digest(check).unwrap();
         let namespace = identity.physical_namespace().unwrap();
         let staging = tempfile::tempdir().unwrap();
-        build_sealed_container(
+        build_sealed_container_with_work(
             SealedRowSource::Manifest(&manifest),
             &identity,
             staging.path(),
             check,
+            None,
         )
         .unwrap();
         let path = staging.path().join(SEALED_STORE_DATABASE_FILE);

From e48f432f4dd0268ee5f9f7245acc82fb5538140d Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 10:47:41 -0800
Subject: [PATCH 29/80] fix(graph): repair native observer Rust test and Clippy
 gates

Refs #4508

Preserve the canonical observed publication path and move its tracing span
from the now-dead one-argument facade. Keep existing nonzero layered and
sealed publication assertions on the work-aware method, correct the native
encoder test import, and provide explicit inert graph callbacks in unrelated
daemon tests. No production observer is replaced with a no-op.
---
 .../tests/code_index_graph_activation.rs      | 12 ++++-
 .../tracedecay-graph-db/src/sealed_store.rs   |  2 +-
 .../src/session_registry/code_graph.rs        |  7 ---
 .../code_graph/layered_refresh_tests.rs       | 42 ++++++++--------
 .../code_graph/sealed_publication_tests.rs    | 48 +++++++++----------
 5 files changed, 56 insertions(+), 55 deletions(-)

diff --git a/crates/tracedecay-daemon-service/tests/code_index_graph_activation.rs b/crates/tracedecay-daemon-service/tests/code_index_graph_activation.rs
index c6681f1982d..8ab06fbe819 100644
--- a/crates/tracedecay-daemon-service/tests/code_index_graph_activation.rs
+++ b/crates/tracedecay-daemon-service/tests/code_index_graph_activation.rs
@@ -437,6 +437,7 @@ async fn persistent_graph_activation_publishes_a_small_generation() {
             None,
             replay_binding,
             Arc::new(std::sync::atomic::AtomicBool::new(false)),
+            Arc::new(|_| {}),
         )
         .await
         .expect("small persistent generation must activate");
@@ -561,6 +562,7 @@ async fn persistent_callers_cursor_keeps_generation_a_without_repointing_generat
             None,
             replay_a,
             Arc::new(std::sync::atomic::AtomicBool::new(false)),
+            Arc::new(|_| {}),
         )
         .await
         .expect("activate generation A");
@@ -899,7 +901,10 @@ async fn restart_status_case(corrupt_graph: bool, dirty_before_restart: bool) {
         .await
         .expect("retain seeded graph runtime");
     let seeded_graph = retained
-        .publish_verified_snapshot(Arc::new(std::sync::atomic::AtomicBool::new(false)))
+        .publish_verified_snapshot(
+            Arc::new(std::sync::atomic::AtomicBool::new(false)),
+            Arc::new(|_| {}),
+        )
         .expect("publish graph head before restart");
     drop(seeded_graph);
     drop(retained);
@@ -1672,7 +1677,10 @@ async fn restart_with_published_graph_head(
         .expect("retain seeded graph runtime");
     drop(
         retained
-            .publish_verified_snapshot(Arc::new(std::sync::atomic::AtomicBool::new(false)))
+            .publish_verified_snapshot(
+                Arc::new(std::sync::atomic::AtomicBool::new(false)),
+                Arc::new(|_| {}),
+            )
             .expect("publish graph head before restart"),
     );
     drop(retained);
diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index 447a451071c..ae2f6cc2b06 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -2873,7 +2873,7 @@ mod build_tests {
     use super::{
         NativeCompactEncodeBoundaryV1, NativeCompactEncodeKindV1, SEALED_STORE_DATABASE_FILE,
         SealedCompactRows, SealedRowSource, build_or_open_sealed_store,
-        build_or_open_sealed_store_with_work, build_sealed_container,
+        build_or_open_sealed_store_with_work, build_sealed_container_with_work,
         push_manifest_rows, sealed_artifact_database_options, sealed_copy_proof,
         sealed_generation_directory, sealed_store_root,
     };
diff --git a/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs b/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
index bff402d5a37..64df72ec859 100644
--- a/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
+++ b/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
@@ -1287,13 +1287,6 @@ impl RetainedCodeGraphRuntimeV1 {
         level = "trace",
         skip_all
     )]
-    pub fn publish_verified_snapshot(
-        &self,
-        request_cancelled: Arc<AtomicBool>,
-    ) -> std::result::Result<VerifiedGraphSnapshot, GraphDbError> {
-        self.publish_verified_snapshot_with_admission(request_cancelled, None, None)
-    }
-
     fn publish_verified_snapshot_with_admission(
         &self,
         request_cancelled: Arc<AtomicBool>,
diff --git a/crates/tracedecay-store-runtime/src/session_registry/code_graph/layered_refresh_tests.rs b/crates/tracedecay-store-runtime/src/session_registry/code_graph/layered_refresh_tests.rs
index 260672f78c7..75aa3670f3f 100644
--- a/crates/tracedecay-store-runtime/src/session_registry/code_graph/layered_refresh_tests.rs
+++ b/crates/tracedecay-store-runtime/src/session_registry/code_graph/layered_refresh_tests.rs
@@ -469,7 +469,7 @@ async fn assert_matches_cold_build(
         .await
         .expect("retain the cold graph runtime");
     let cold = cold_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the generation cold");
     let (_, cold_receipt) = receipt_for(&fixture.root.join(profile), cold.generation().as_str());
     assert_eq!(cold_receipt["form"], "compact");
@@ -592,7 +592,7 @@ async fn small_refreshes_seal_deltas_that_serve_like_their_cold_builds() {
         .await
         .expect("retain the base graph runtime");
     let base = base_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the base graph cold");
     let profile = root.join("profile");
     let (base_directory, base_receipt) = receipt_for(&profile, base.generation().as_str());
@@ -614,7 +614,7 @@ async fn small_refreshes_seal_deltas_that_serve_like_their_cold_builds() {
         .await
         .expect("retain the base graph runtime after a restart");
     let base = base_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("recover the base graph after a restart");
 
     // A three-file edit.
@@ -648,7 +648,7 @@ async fn small_refreshes_seal_deltas_that_serve_like_their_cold_builds() {
         "the edit must produce a nonempty graph delta: {child_report:?}"
     );
     let child = child_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the refresh");
     assert_layered_over(
         &profile,
@@ -707,7 +707,7 @@ async fn small_refreshes_seal_deltas_that_serve_like_their_cold_builds() {
         "the cumulative edit must produce a nonempty graph delta: {grandchild_report:?}"
     );
     let grandchild = grandchild_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the second refresh");
     assert_layered_over(
         &profile,
@@ -758,7 +758,7 @@ async fn a_linked_worktree_at_the_same_tree_layers_over_its_siblings_sealed_grap
         .await
         .expect("retain the primary graph runtime");
     let primary = primary_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the primary graph cold");
     let profile = root.join("profile");
     let (primary_directory, _) =
@@ -787,7 +787,7 @@ async fn a_linked_worktree_at_the_same_tree_layers_over_its_siblings_sealed_grap
     assert_eq!(report.reextracted_files, 0, "{report:?}");
     assert_eq!(report.removed_files, 0, "{report:?}");
     let linked = linked_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the linked worktree's graph");
     assert_ne!(linked.projection(), primary.projection());
     let (linked_directory, receipt) =
@@ -834,7 +834,7 @@ async fn a_linked_worktree_at_the_same_tree_layers_over_its_siblings_sealed_grap
         .await
         .expect("retain the edited linked graph runtime");
     let edited = edited_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the linked worktree's edit");
     let edited_rows = scan_rows(&edited);
     assert_layered_over(
@@ -1043,7 +1043,7 @@ async fn a_growing_catalog_carry_accounts_for_its_peak_and_releases_on_cancellat
         .await
         .expect("retain base");
     let base = base_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("base snapshot");
     let parent = warmed_store(base, &base_generation, None);
 
@@ -1061,7 +1061,7 @@ async fn a_growing_catalog_carry_accounts_for_its_peak_and_releases_on_cancellat
         .await
         .expect("retain successor");
     let snapshot = runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("successor snapshot");
     assert!(
         snapshot.layered_rows().is_some(),
@@ -1136,7 +1136,7 @@ async fn a_catalog_carry_accounts_for_many_rebuilt_lookup_lists() {
         .await
         .expect("retain base");
     let base = base_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("base snapshot");
     let parent = warmed_store(base, &base_generation, None);
 
@@ -1154,7 +1154,7 @@ async fn a_catalog_carry_accounts_for_many_rebuilt_lookup_lists() {
         .await
         .expect("retain successor");
     let snapshot = runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("successor snapshot");
     assert!(
         snapshot.layered_rows().is_some(),
@@ -1209,7 +1209,7 @@ async fn a_catalog_scan_accounts_for_unique_names_and_file_dependency_finalizati
         .await
         .expect("retain graph");
     let snapshot = runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("cold snapshot");
     assert_catalog_build_accounts_for_its_peak(&snapshot, &generation, None);
 }
@@ -1237,7 +1237,7 @@ async fn a_small_refresh_carries_its_catalog_from_the_generation_it_replaces() {
         .await
         .expect("retain the base graph runtime");
     let base = base_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the base graph cold");
     let base_store = warmed_store(base, &base_generation, None);
     assert_eq!(base_store.interactive_catalog_scan_builds(), 1);
@@ -1255,7 +1255,7 @@ async fn a_small_refresh_carries_its_catalog_from_the_generation_it_replaces() {
         .await
         .expect("retain the child graph runtime");
     let child = child_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the refresh");
     let measured_carry =
         CodeGraphProjectionStore::from_verified_snapshot(child.clone(), child_generation.clone())
@@ -1347,7 +1347,7 @@ async fn a_small_refresh_carries_its_catalog_from_the_generation_it_replaces() {
         .await
         .expect("retain the grandchild graph runtime");
     let grandchild = grandchild_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the second refresh");
     let scanned_grandchild = warmed_store(grandchild.clone(), &grandchild_generation, None);
     assert_eq!(scanned_grandchild.interactive_catalog_scan_builds(), 1);
@@ -1390,7 +1390,7 @@ async fn a_small_refresh_carries_its_catalog_from_the_generation_it_replaces() {
         .await
         .expect("retain the cold child graph runtime");
     let cold_child = cold_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the child cold");
     let cold_child_store = warmed_store(cold_child, &child_generation, Some(&base_store));
     assert_eq!(
@@ -1430,7 +1430,7 @@ async fn three_file_refresh_report(modules: usize, epoch: u64) -> CodeGraphLayer
         .await
         .expect("retain the base graph runtime");
     let _base = base_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("publish the base graph cold");
     edit_three_files(&fixture.project_root, modules);
     fixture.commit("edit three files");
@@ -1512,7 +1512,7 @@ async fn layered_refresh_peak_probe() {
             .retain(&registry, &database, &base_generation, base_binding.clone())
             .await
             .expect("retain the base graph runtime")
-            .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+            .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
             .expect("publish the base graph cold");
     }
     edit_three_files(&fixture.project_root, modules);
@@ -1531,7 +1531,7 @@ async fn layered_refresh_peak_probe() {
         .expect("retain the child graph runtime");
     let (child, layered_kib) = peak_kib_during(|| {
         child_runtime
-            .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+            .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
             .expect("publish the refresh")
     });
     let (_, receipt) = receipt_for(&root.join("profile"), child.generation().as_str());
@@ -1545,7 +1545,7 @@ async fn layered_refresh_peak_probe() {
         .expect("retain the cold graph runtime");
     let (cold, cold_kib) = peak_kib_during(|| {
         cold_runtime
-            .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+            .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
             .expect("publish the generation cold")
     });
     let (_, receipt) = receipt_for(&root.join("profile-cold"), cold.generation().as_str());
diff --git a/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs b/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
index 550ae3320ef..66d9e358a30 100644
--- a/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
+++ b/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
@@ -572,7 +572,7 @@ async fn unreadable_pending_replay_is_discarded_before_fresh_publication() {
     });
 
     let snapshot = runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("fresh publication discards the permanently incompatible predecessor");
     assert_eq!(snapshot.verified_head().key, fresh_key);
     with_publication_context("inspect-historical-pending-replay", |context| {
@@ -741,7 +741,7 @@ async fn a_pending_predecessor_pooled_by_retention_yields_to_the_next_generation
             }
         })
     };
-    let published = successor_runtime.publish_verified_snapshot(Arc::clone(&cancelled));
+    let published = successor_runtime.publish_verified_snapshot_with_admission(Arc::clone(&cancelled), None, None);
     drop(finished);
     watchdog.join().expect("publication watchdog");
     let snapshot = published.expect("the successor publishes past its pooled pending predecessor");
@@ -878,7 +878,7 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
 
     std::fs::write(&canonical_seal, &mutated_seal).expect("mutate sealed generation in place");
     assert!(matches!(
-        runtime.publish_verified_snapshot(Arc::new(AtomicBool::new(false))),
+        runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None),
         Err(GraphDbError::Corrupt { .. })
     ));
     assert_unverified_publication_state(&runtime, false);
@@ -888,7 +888,7 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
     std::fs::rename(&canonical_seal, &retained_seal).expect("retain original sealed inode");
     std::fs::write(&canonical_seal, &mutated_seal).expect("replace canonical sealed inode");
     assert!(matches!(
-        runtime.publish_verified_snapshot(Arc::new(AtomicBool::new(false))),
+        runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None),
         Err(GraphDbError::Corrupt { .. })
     ));
     assert_unverified_publication_state(&runtime, false);
@@ -902,7 +902,7 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
         std::fs::rename(&canonical_seal, &retained_seal).expect("retain symlink target evidence");
         symlink(&retained_seal, &canonical_seal).expect("swap canonical seal for symlink");
         assert!(matches!(
-            runtime.publish_verified_snapshot(Arc::new(AtomicBool::new(false))),
+            runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None),
             Err(GraphDbError::Corrupt { .. })
         ));
         assert_unverified_publication_state(&runtime, false);
@@ -915,7 +915,7 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
     std::fs::write(&canonical_seal, &mutated_seal)
         .expect("mutate source before active replay completion");
     assert!(matches!(
-        runtime.publish_verified_snapshot(Arc::new(AtomicBool::new(false))),
+        runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None),
         Err(GraphDbError::Corrupt { .. })
     ));
     assert_unverified_publication_state(&runtime, true);
@@ -929,7 +929,7 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
     // manufactured stage-boundary `DeadlineExceeded`, no scheduler retry
     // pass, no conflict against its own journal.
     let snapshot = runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("first activation must resume the journaled replay and publish in one call");
     let expected_generation = tracedecay_code_index::graph_projection::code_graph_generation_id(
         &generation_id,
@@ -986,7 +986,7 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
         .await
         .expect("retain code graph runtime again");
     let resumed = retried
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("a repeated activation must resume the exact publication");
     assert_eq!(resumed.generation(), &expected_generation);
     assert_eq!(resumed.verified_head(), &head);
@@ -1063,7 +1063,7 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
         .await
         .expect("retain next code graph runtime");
     let next_snapshot = next_runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("a fresh small projection must publish in one call");
     assert_eq!(
         next_snapshot.generation().as_str(),
@@ -1339,7 +1339,7 @@ async fn sealing_keeps_symbol_records_only_in_the_graph_store() {
     .await;
     let snapshot = fixture
         .runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("seal the code graph");
 
     let file_names = |root: &Path| {
@@ -1437,7 +1437,7 @@ async fn an_oversized_symbol_record_seals_and_serves_whole() {
     let fixture = sealed_generation_fixture("project.long-record", &source).await;
     let snapshot = fixture
         .runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("seal a code graph with an oversized record");
     let store =
         tracedecay_code_index::graph_projection::CodeGraphProjectionStore::from_verified_snapshot(
@@ -1505,7 +1505,7 @@ async fn graph_reads_during_engine_warm_up_are_typed_pending_and_warmed_reads_su
     .await;
     let snapshot = fixture
         .runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("seal the code graph");
     let store =
         CodeGraphProjectionStore::from_verified_snapshot(snapshot, fixture.generation_id.clone())
@@ -1583,7 +1583,7 @@ async fn a_released_serving_engine_closes_and_rewarms_on_the_next_read() {
     .await;
     let snapshot = fixture
         .runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("seal the code graph");
     let store =
         CodeGraphProjectionStore::from_verified_snapshot(snapshot, fixture.generation_id.clone())
@@ -1660,7 +1660,7 @@ async fn a_read_waiting_on_a_finishing_rewarm_wakes_when_it_ends() {
     .await;
     let snapshot = fixture
         .runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("seal the code graph");
     let store =
         CodeGraphProjectionStore::from_verified_snapshot(snapshot, fixture.generation_id.clone())
@@ -1750,7 +1750,7 @@ async fn serving_graph_owners_charge_the_heap_they_hold() {
         sealed_generation_fixture("project.graph-owner-accounting", &accounting_source(600)).await;
     let snapshot = fixture
         .runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("seal the code graph");
     let store =
         CodeGraphProjectionStore::from_verified_snapshot(snapshot, fixture.generation_id.clone())
@@ -2119,7 +2119,7 @@ async fn concurrent_sealed_publishers_share_one_gate_and_converge_on_one_head()
         .lock()
         .expect("hold the publication gate");
     let outcome = std::thread::scope(|scope| {
-        let worker = scope.spawn(|| reconcile.publish_verified_snapshot(Arc::clone(&cancelled)));
+        let worker = scope.spawn(|| reconcile.publish_verified_snapshot_with_admission(Arc::clone(&cancelled), None, None));
         cancelled.store(true, Ordering::Release);
         drop(held);
         worker.join().expect("join the cancelled publisher")
@@ -2132,9 +2132,9 @@ async fn concurrent_sealed_publishers_share_one_gate_and_converge_on_one_head()
     // the winner's exact publication instead of conflicting.
     let (seat_outcome, reconcile_outcome) = std::thread::scope(|scope| {
         let seat_worker =
-            scope.spawn(|| seat.publish_verified_snapshot(Arc::new(AtomicBool::new(false))));
+            scope.spawn(|| seat.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None));
         let reconcile_worker =
-            scope.spawn(|| reconcile.publish_verified_snapshot(Arc::new(AtomicBool::new(false))));
+            scope.spawn(|| reconcile.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None));
         (
             seat_worker.join().expect("join the seat publisher"),
             reconcile_worker
@@ -2324,7 +2324,7 @@ async fn sealed_publication_refuses_over_the_resident_memory_watermark() {
 
     set_sample(&sample, pressure.low_watermark_bytes());
     let not_cancelled = Arc::new(AtomicBool::new(false));
-    let refused = runtime.publish_verified_snapshot(Arc::clone(&not_cancelled));
+    let refused = runtime.publish_verified_snapshot_with_admission(Arc::clone(&not_cancelled), None, None);
     // The projection peak is process-global and other cases reset it; this
     // cell's own sampler is what saw the crossing.
     assert!(
@@ -2368,7 +2368,7 @@ async fn sealed_publication_refuses_over_the_resident_memory_watermark() {
     // keeps its own identity: the caller cancelled, so it is told so.
     let cancelled = Arc::new(AtomicBool::new(true));
     assert!(matches!(
-        runtime.publish_verified_snapshot(cancelled),
+        runtime.publish_verified_snapshot_with_admission(cancelled, None, None),
         Err(GraphDbError::Cancelled)
     ));
 
@@ -2377,7 +2377,7 @@ async fn sealed_publication_refuses_over_the_resident_memory_watermark() {
     set_sample(&sample, pressure.low_watermark_bytes());
     std::thread::sleep(RESIDENT_MEMORY_CHECKPOINT_SAMPLE_INTERVAL_V1);
     let published = runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("nominal measured RSS publishes the sealed generation");
     let projector_revision = GraphProjectorRevision::try_from(
         tracedecay_code_index::graph_projection::CODE_GRAPH_PROJECTOR_REVISION.to_owned(),
@@ -2469,7 +2469,7 @@ async fn sealed_publication_samples_resident_memory_per_interval_not_per_row() {
 
     let started = Instant::now();
     let snapshot = runtime
-        .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+        .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
         .expect("the sealed generation publishes");
     let elapsed = started.elapsed();
     let samples = samples.load(Ordering::Acquire);
@@ -3061,7 +3061,7 @@ async fn concurrent_worktree_scopes_publish_with_one_corpus_build_and_bounded_rs
             workers.push(thread_scope.spawn(move || {
                 worker_barrier.wait();
                 let started = Instant::now();
-                let result = runtime.publish_verified_snapshot(Arc::new(AtomicBool::new(false)));
+                let result = runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None);
                 let elapsed_ms =
                     u64::try_from(started.elapsed().as_millis()).expect("publish milliseconds");
                 (scope_index, result, elapsed_ms)
@@ -3357,7 +3357,7 @@ async fn catalog_builds_reserve_the_heap_they_hold() {
     let snapshot = || {
         fixture
             .runtime
-            .publish_verified_snapshot(Arc::new(AtomicBool::new(false)))
+            .publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None)
             .expect("seal the code graph")
     };
     let warm = |store: &CodeGraphProjectionStore| {

From 8440c86e2ec62fd8d0152455368c101cfe6bf76c Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 11:19:16 -0800
Subject: [PATCH 30/80] feat(code-index): observe real cold reference
 resolution

Refs #4508

Report actual per-file fact materialization, cross-file binding decisions,
file evidence, and staged code-graph pages as non-durable pre-seal
resolution work. Fence stale phase callbacks and preserve the last real
work timestamp. Add real cold-reconcile and attempt-state regressions.

No native graph durability is claimed by these source-resolution events.
Rust/Bazel tests and generated dashboard contracts remain outstanding.
---
 crates/tracedecay-cli/src/commands/index.rs   | 11 ++-
 .../code_index_scheduler/attempt_progress.rs  | 67 ++++++++++++++++++-
 .../tests/code_index_scheduler/reconcile.rs   | 17 +++--
 .../src/production/helpers.rs                 |  6 ++
 .../src/production/mod.rs                     |  4 +-
 .../production/sparse_differential_tests.rs   |  8 ++-
 .../src/production/sparse_successor.rs        | 37 +++++++++-
 .../src/code_index_freshness.rs               |  5 +-
 .../src/handlers/graph/search_freshness.rs    |  1 +
 9 files changed, 134 insertions(+), 22 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index c32473c86db..33bb6989922 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -629,13 +629,7 @@ impl FirstGenerationWorkMarker {
                     return None;
                 }
                 if owner == prior_owner {
-                    if matches!(
-                        (prior_phase, phase),
-                        (
-                            CodeIndexPresealWorkPhaseV1::ParseEvidence,
-                            CodeIndexPresealWorkPhaseV1::Capture
-                        )
-                    )
+                    if phase < prior_phase
                         || (phase == prior_phase && completed < prior_completed)
                     {
                         return None;
@@ -847,6 +841,9 @@ fn preseal_progress_summary(
         tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::ParseEvidence => {
             "parsing"
         }
+        tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::Resolution => {
+            "resolving references"
+        }
     };
     let total = progress
         .total_items
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
index 6e8312af382..278a97cef5d 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
@@ -1,5 +1,5 @@
 //! Separately typed progress authority before immutable generation sealing.
-//! A real capture/parse callback is the only source of work or timestamps.
+//! Real capture, parse, and resolution callbacks alone advance the work clock.
 
 use std::sync::{Arc, PoisonError, RwLock};
 
@@ -71,7 +71,19 @@ impl CodeIndexBuildAttemptSlotStateV1 {
             return false;
         };
         let new_phase = current.phase != work.phase;
-        if (new_phase && work.phase != CodeIndexPresealWorkPhaseV1::ParseEvidence)
+        // Each phase owns different physical units. Admit only its real next
+        // stage; an earlier delayed callback must not roll resolution back.
+        if (new_phase
+            && !matches!(
+                (current.phase, work.phase),
+                (
+                    CodeIndexPresealWorkPhaseV1::Capture,
+                    CodeIndexPresealWorkPhaseV1::ParseEvidence
+                ) | (
+                    CodeIndexPresealWorkPhaseV1::ParseEvidence,
+                    CodeIndexPresealWorkPhaseV1::Resolution
+                )
+            ))
             || (!new_phase && work.completed_items <= current.completed_items)
         {
             return false;
@@ -175,6 +187,57 @@ mod tests {
         assert_eq!(slot.snapshot().unwrap(), ended);
     }
 
+    #[test]
+    fn resolution_carries_real_work_without_accepting_stale_parser_reports() {
+        let mut slot = CodeIndexBuildAttemptSlotStateV1::default();
+        let attempt = slot.begin(4, 7);
+        assert!(slot.observe(
+            attempt,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 2, Some(2)),
+            100,
+        ));
+        assert!(slot.observe(
+            attempt,
+            work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 2, Some(2)),
+            200,
+        ));
+        let parsed = slot.snapshot().unwrap();
+        assert!(slot.observe(
+            attempt,
+            work(CodeIndexPresealWorkPhaseV1::Resolution, 1, None),
+            300,
+        ));
+        let resolved = slot.snapshot().unwrap();
+        assert_eq!(resolved.phase, CodeIndexPresealWorkPhaseV1::Resolution);
+        assert_eq!(resolved.completed_items, 1);
+        assert_eq!(resolved.total_items, None);
+        assert!(resolved.progress_epoch > parsed.progress_epoch);
+        assert_eq!(resolved.last_progress_micros, Some(300));
+        assert!(!slot.observe(
+            attempt,
+            work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 3, Some(3)),
+            900,
+        ));
+        assert!(!slot.observe(
+            attempt,
+            work(CodeIndexPresealWorkPhaseV1::Resolution, 1, None),
+            901,
+        ));
+        assert_eq!(slot.snapshot().unwrap(), resolved);
+        assert!(slot.observe(
+            attempt,
+            work(CodeIndexPresealWorkPhaseV1::Resolution, 2, None),
+            400,
+        ));
+        assert_eq!(slot.snapshot().unwrap().last_progress_micros, Some(400));
+        slot.finish(attempt);
+        assert!(!slot.observe(
+            attempt,
+            work(CodeIndexPresealWorkPhaseV1::Resolution, 3, None),
+            999,
+        ));
+    }
+
     #[test]
     fn retry_and_remount_fence_old_producers_even_when_counters_match() {
         let mut slot = CodeIndexBuildAttemptSlotStateV1::default();
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
index e38420833bb..c3a8c4604fe 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
@@ -126,12 +126,21 @@ fn cold_build_reports_actual_preseal_capture_and_parser_evidence() {
     assert!(!observed.active, "a finished attempt cannot appear stalled");
     assert_eq!(
         observed.phase,
-        tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::ParseEvidence
+        tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Resolution
+    );
+    assert!(
+        observed.completed_items >= 2,
+        "real cold resolution must process both files"
+    );
+    assert_eq!(
+        observed.total_items, None,
+        "heterogeneous resolution work has no denominator"
     );
-    assert_eq!(observed.completed_items, 2);
-    assert_eq!(observed.total_items, Some(2));
     assert!(observed.last_progress_micros.is_some_and(|at| at > 0));
-    assert!(observed.progress_epoch >= 5, "two captures and two parses plus start");
+    assert!(
+        observed.progress_epoch >= 7,
+        "two captures, two parser-backed files, two resolution facts and attempt start"
+    );
 }
 
 /// A restart's retained-source verification is real work and must report
diff --git a/crates/tracedecay-code-index/src/production/helpers.rs b/crates/tracedecay-code-index/src/production/helpers.rs
index 3acd19ab6c3..a639273bc6a 100644
--- a/crates/tracedecay-code-index/src/production/helpers.rs
+++ b/crates/tracedecay-code-index/src/production/helpers.rs
@@ -313,6 +313,7 @@ pub(super) fn resolution_hash_capacity(entries: usize) -> usize {
 pub(super) fn resolve_cross_file_references_charged<T: ResolutionFileV1>(
     files: &[T],
     retain_output: &mut dyn FnMut(u64) -> Result<(), CodeIndexProductionErrorV1>,
+    mut observe_file: Option<&mut dyn FnMut()>,
 ) -> Result<CrossFileResolutionV1, CodeIndexProductionErrorV1> {
     #[cfg(test)]
     SEAL_REFERENCE_RESOLUTIONS.with(|resolutions| resolutions.set(resolutions.get() + 1));
@@ -385,6 +386,11 @@ pub(super) fn resolve_cross_file_references_charged<T: ResolutionFileV1>(
         reserve_resolution_vec(&mut gaps, file_gaps.len(), &mut reserve)?;
         edges.extend(file_edges);
         gaps.extend(file_gaps);
+        // A real file's cross-reference decisions and their admitted output
+        // are complete. This is not a durable graph page or a timer wake.
+        if let Some(observe) = observe_file.as_deref_mut() {
+            observe();
+        }
     }
     let mut has_go = false;
     for file in files {
diff --git a/crates/tracedecay-code-index/src/production/mod.rs b/crates/tracedecay-code-index/src/production/mod.rs
index 3343da14743..bb1d05496da 100644
--- a/crates/tracedecay-code-index/src/production/mod.rs
+++ b/crates/tracedecay-code-index/src/production/mod.rs
@@ -282,8 +282,8 @@ pub struct CodeIndexCapturedFileV1 {
     pub sensitivity_level: SensitivityLevelV1,
 }
 
-/// Successful pre-seal work observed before a generation ID/digest exists.
-/// Neither event represents a durable text or native graph commit.
+/// Successful pre-seal capture, parse, or resolution work before a generation seals.
+/// These observations never represent durable text or native graph commits.
 pub use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
diff --git a/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs b/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
index a2c9ef309a8..c459e34791b 100644
--- a/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
+++ b/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
@@ -433,8 +433,12 @@ fn a_restored_parent_and_the_edit_over_it_resolve_nothing_whole() {
             .decode_active(&scope)
             .expect("the edit restores")
             .expect("an active edit");
-        let full_resolution = resolve_cross_file_references_charged(&edited.files, &mut |_| Ok(()))
-            .expect("whole reference resolution");
+        let full_resolution = resolve_cross_file_references_charged(
+            &edited.files,
+            &mut |_| Ok(()),
+            None,
+        )
+        .expect("whole reference resolution");
         let (full_edges, _) =
             edge_evidence(&edited.files, full_resolution.edges).expect("whole edge evidence");
         assert_eq!(
diff --git a/crates/tracedecay-code-index/src/production/sparse_successor.rs b/crates/tracedecay-code-index/src/production/sparse_successor.rs
index 895eead4f55..5f4c71af016 100644
--- a/crates/tracedecay-code-index/src/production/sparse_successor.rs
+++ b/crates/tracedecay-code-index/src/production/sparse_successor.rs
@@ -687,6 +687,10 @@ pub(super) fn resolve_staged_generation(
     let mut coverage = super::helpers::coverage_summary(snapshot, &[]);
     let mut source_total_bytes = 0_u64;
     let mut symbol_count = 0_u64;
+    // Counts completed, separately typed pre-seal resolution units. The
+    // denominator is intentionally absent: decoded facts, bound references,
+    // file evidence and graph-page staging are distinct kinds of work.
+    let mut resolution_work = 0_u64;
     let facts_loaded = (|| -> Result<(), CodeIndexProductionErrorV1> {
         for descriptor in &ordered {
             super::lexical_page_source::checkpoint(control)?;
@@ -755,6 +759,12 @@ pub(super) fn resolve_staged_generation(
             }
             facts.push(compact);
             retain_facts(settled)?;
+            resolution_work = resolution_work.saturating_add(1);
+            control.observed_preseal_work(super::CodeIndexPresealWorkV1 {
+                phase: super::CodeIndexPresealWorkPhaseV1::Resolution,
+                completed_items: resolution_work,
+                total_items: None,
+            });
         }
         Ok(())
     })();
@@ -777,9 +787,18 @@ pub(super) fn resolve_staged_generation(
         retained_facts_bytes = facts_bytes,
         "cold resolution phase started"
     );
-    let resolved = super::helpers::resolve_cross_file_references_charged(&facts, &mut |bytes| {
-        retain_facts(count(facts_bytes)?.saturating_add(bytes))
-    })?;
+    let resolved = super::helpers::resolve_cross_file_references_charged(
+        &facts,
+        &mut |bytes| retain_facts(count(facts_bytes)?.saturating_add(bytes)),
+        Some(&mut || {
+            resolution_work = resolution_work.saturating_add(1);
+            control.observed_preseal_work(super::CodeIndexPresealWorkV1 {
+                phase: super::CodeIndexPresealWorkPhaseV1::Resolution,
+                completed_items: resolution_work,
+                total_items: None,
+            });
+        }),
+    )?;
     let super::helpers::CrossFileResolutionV1 {
         mut edges,
         gaps,
@@ -943,6 +962,12 @@ pub(super) fn resolve_staged_generation(
                 bytes: &bytes,
             })?;
             file_evidence.push(descriptor);
+            resolution_work = resolution_work.saturating_add(1);
+            control.observed_preseal_work(super::CodeIndexPresealWorkV1 {
+                phase: super::CodeIndexPresealWorkPhaseV1::Resolution,
+                completed_items: resolution_work,
+                total_items: None,
+            });
             Ok(())
         },
     )?;
@@ -1091,6 +1116,12 @@ pub(super) fn resolve_staged_generation(
         &mut |page| {
             super::lexical_page_source::checkpoint(control)?;
             code_graph_pages.push(publish_code_graph_page(page, &BTreeSet::new(), publish)?);
+            resolution_work = resolution_work.saturating_add(1);
+            control.observed_preseal_work(super::CodeIndexPresealWorkV1 {
+                phase: super::CodeIndexPresealWorkPhaseV1::Resolution,
+                completed_items: resolution_work,
+                total_items: None,
+            });
             if code_graph_pages.len().is_power_of_two() {
                 tracing::trace!(
                     phase = "graph",
diff --git a/crates/tracedecay-contracts/src/code_index_freshness.rs b/crates/tracedecay-contracts/src/code_index_freshness.rs
index c50b6621ce0..020d04c5707 100644
--- a/crates/tracedecay-contracts/src/code_index_freshness.rs
+++ b/crates/tracedecay-contracts/src/code_index_freshness.rs
@@ -122,12 +122,13 @@ pub struct CodeIndexBuildProgressV1 {
     pub blocked_reason: Option<CodeIndexBuildBlockedReasonV1>,
 }
 
-/// Observed capture/parse work before a sealed generation exists.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+/// Observed capture, parse, and source-reference resolution before sealing.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum CodeIndexPresealWorkPhaseV1 {
     Capture,
     ParseEvidence,
+    Resolution,
 }
 
 /// Independently owned attempt work, not committed text or graph pages.
diff --git a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
index 0661af6cc1a..7c5d48ed7a7 100644
--- a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
+++ b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
@@ -69,6 +69,7 @@ fn preseal_phase_label(phase: CodeIndexPresealWorkPhaseV1) -> &'static str {
     match phase {
         CodeIndexPresealWorkPhaseV1::Capture => "capture",
         CodeIndexPresealWorkPhaseV1::ParseEvidence => "parse_evidence",
+        CodeIndexPresealWorkPhaseV1::Resolution => "resolution",
     }
 }
 

From f0ae95c7f41412cb2e2ed63e6ac625f0726a4563 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 12:01:54 -0800
Subject: [PATCH 31/80] fix(code-index): report staged resolution index page
 work

Refs #4508

Report a non-durable resolution work unit only after each real definition,
reference or alias index segment publication succeeds. A large cold index
otherwise goes silent while serially encoding its resolution-index pages.

Exercise the real production publisher and decode its authenticated manifest
to derive the exact count of accepted fact, binding, evidence, index-segment
and graph-page observations. Do not credit failed publications or status polls.

Bazel Rust tests and generated dashboard contracts remain outstanding.
---
 .../production/sparse_differential_tests.rs   | 83 +++++++++++++++++++
 .../src/production/sparse_successor.rs        | 13 ++-
 2 files changed, 95 insertions(+), 1 deletion(-)

diff --git a/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs b/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
index c459e34791b..378b45e4c68 100644
--- a/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
+++ b/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
@@ -299,6 +299,89 @@ fn differential_counts(language: &str) -> DifferentialCounts {
     counts
 }
 
+/// The actual cold publisher must account for every accepted resolution
+/// index segment, in addition to completed fact, binding, evidence and graph
+/// page work. Decoding the published manifest supplies the physical page count
+/// rather than a test-authored approximation.
+#[test]
+fn cold_resolution_index_publication_advances_actual_work_counts() {
+    #[derive(Default)]
+    struct ResolutionWork(std::sync::Mutex<Vec<u64>>);
+
+    impl CodeIndexExecutionControlV1 for ResolutionWork {
+        fn is_cancelled(&self) -> bool {
+            false
+        }
+
+        fn is_deadline_exceeded(&self) -> bool {
+            false
+        }
+
+        fn observed_preseal_work(&self, work: CodeIndexPresealWorkV1) {
+            if work.phase == CodeIndexPresealWorkPhaseV1::Resolution {
+                self.0
+                    .lock()
+                    .expect("resolution observations")
+                    .push(work.completed_items);
+            }
+        }
+    }
+
+    let files = vec![
+        (
+            "src/alpha.rs".to_owned(),
+            "pub fn alpha() { crate::beta::beta(); }\n".to_owned(),
+        ),
+        (
+            "src/beta.rs".to_owned(),
+            "pub fn beta() {}\n".to_owned(),
+        ),
+    ];
+    let store = WorkerPublicationStore::default();
+    let mut owner =
+        CodeIndexProductionOwnerV1::new(worker_config(), store.clone()).expect("production owner");
+    let observer = ResolutionWork::default();
+    let published = owner
+        .build_and_publish(fixture_request(&files, None, false, 1_500_000), &observer)
+        .expect("real cold reference resolution");
+    let manifest = super::partitioned_codec::parse_partitioned_manifest(
+        published.manifest_bytes().as_ref(),
+    )
+    .expect("verified published index manifest");
+
+    let index_segments = manifest.resolution_index.segments().count();
+    assert!(
+        index_segments >= 3,
+        "the cold resolution index actually publishes definition, reference and alias segments"
+    );
+    let expected = u64::try_from(
+        files.len() * 2
+            + manifest.file_evidence.len()
+            + manifest.code_graph_pages.len()
+            + index_segments,
+    )
+    .expect("bounded cold resolution work");
+    let observed = observer
+        .0
+        .lock()
+        .expect("resolution observations")
+        .clone();
+    assert_eq!(
+        observed,
+        (1..=expected).collect::<Vec<_>>(),
+        "only accepted fact, binding, evidence, index-segment and graph-page work advances the observed cursor"
+    );
+    assert!(
+        store
+            .decode_active(&CodeIndexGenerationScopeV1::for_snapshot(
+                published.snapshot(),
+            ))
+            .expect("read the committed cold generation")
+            .is_some(),
+        "counted index segments must produce a readable published generation"
+    );
+}
+
 #[test]
 fn rust_edits_seal_over_the_parent_like_a_cold_build() {
     assert_eq!(
diff --git a/crates/tracedecay-code-index/src/production/sparse_successor.rs b/crates/tracedecay-code-index/src/production/sparse_successor.rs
index 5f4c71af016..2168b53e220 100644
--- a/crates/tracedecay-code-index/src/production/sparse_successor.rs
+++ b/crates/tracedecay-code-index/src/production/sparse_successor.rs
@@ -988,7 +988,18 @@ pub(super) fn resolve_staged_generation(
     let resolution_index = super::resolution_index::seal_resolution_index_charged(
         &facts,
         &mut |workspace| retain_facts(count(phase_base)?.saturating_add(workspace)),
-        &mut *publish,
+        &mut |segment| {
+            publish(segment)?;
+            // An accepted resolution-index segment is genuine staged work,
+            // not a committed native graph page or a status-read heartbeat.
+            resolution_work = resolution_work.saturating_add(1);
+            control.observed_preseal_work(super::CodeIndexPresealWorkV1 {
+                phase: super::CodeIndexPresealWorkPhaseV1::Resolution,
+                completed_items: resolution_work,
+                total_items: None,
+            });
+            Ok(())
+        },
     )?;
     tracing::trace!(
         phase = "resolution_index",

From 36b58e3f9f9e10159e34ad18f462c348f999634c Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 12:26:12 -0800
Subject: [PATCH 32/80] style(code-index): format progress publication changes

---
 crates/tracedecay-cli/src/commands/index.rs   |  97 ++++++----
 .../src/code_graph_seat.rs                    |   2 +-
 .../code_index_scheduler/attempt_progress.rs  | 110 +++++++++--
 .../code_index_scheduler/git_tree_capture.rs  |   3 +-
 .../code_index_scheduler/graph_activation.rs  |   4 +-
 .../src/code_index_scheduler/reconcile.rs     |  12 +-
 .../registry/graph_progress.rs                | 180 ++++++++++++------
 .../registry/ignored_dependencies.rs          |  21 +-
 .../tests/code_index_scheduler/reconcile.rs   |  27 ++-
 .../production/sparse_differential_tests.rs   |  27 +--
 .../src/code_index_freshness.rs               |   5 +-
 .../src/generation_runtime.rs                 |  36 ++--
 .../tracedecay-graph-db/src/sealed_store.rs   |  36 ++--
 .../src/handlers/graph/search_freshness.rs    |  43 +++--
 .../src/session_registry/code_graph.rs        |  32 ++--
 .../code_graph/sealed_publication_tests.rs    |  77 ++++++--
 crates/tracedecay-store/src/lib.rs            |   4 +-
 .../src/runtime/graph_publication.rs          |   3 +-
 crates/tracedecay-store/src/runtime/mod.rs    |   2 +-
 .../tests/daemon_suite/git_watch_test.rs      |  33 +++-
 .../daemon_suite/indexing_lifecycle_test.rs   |  12 +-
 21 files changed, 498 insertions(+), 268 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 33bb6989922..bf8d9df4012 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -8,8 +8,7 @@ use tracedecay_contracts::code_index_freshness::{
     CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
     CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexBuildProgressV1,
     CodeIndexNativeGraphPhaseV1, CodeIndexPresealWorkPhaseV1, CodeIndexReadinessWaitOutcomeV1,
-    CodeIndexStalenessStateV1,
-    CodeIndexWorktreeFreshnessV1,
+    CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::graph_tool::GraphToolResultV1;
 use tracedecay_contracts::retrieval::{
@@ -493,7 +492,10 @@ impl FirstGenerationWorkMarker {
         // A real active attempt remains authoritative in either state.
         if !worktree.rebuild_in_flight
             && !worktree.preseal_attempt.as_ref().is_some_and(|a| a.active)
-            && !worktree.native_graph_progress.as_ref().is_some_and(|g| g.active)
+            && !worktree
+                .native_graph_progress
+                .as_ref()
+                .is_some_and(|g| g.active)
         {
             return None;
         }
@@ -502,9 +504,12 @@ impl FirstGenerationWorkMarker {
             // digest verification AFTER all accepted row windows. That work
             // has no intermediate native milestone. Never call a healthy
             // final write a stall merely because the last encode clock froze.
-            let encoding_finished = graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactEncoding)
+            let encoding_finished = graph.phase
+                == Some(CodeIndexNativeGraphPhaseV1::CompactEncoding)
                 && graph.total_entities == Some(graph.encoded_entities)
-                && graph.total_relations.is_some_and(|total| total == graph.encoded_relations);
+                && graph
+                    .total_relations
+                    .is_some_and(|total| total == graph.encoded_relations);
             if encoding_finished
                 || graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified)
             {
@@ -629,8 +634,7 @@ impl FirstGenerationWorkMarker {
                     return None;
                 }
                 if owner == prior_owner {
-                    if phase < prior_phase
-                        || (phase == prior_phase && completed < prior_completed)
+                    if phase < prior_phase || (phase == prior_phase && completed < prior_completed)
                     {
                         return None;
                     }
@@ -871,9 +875,13 @@ fn native_graph_progress_summary(
          attempt={}:{}:{} epoch={} last_work_micros={}",
         graph.phase,
         graph.encoded_entities,
-        graph.total_entities.map_or_else(|| "unknown".to_owned(), |n| n.to_string()),
+        graph
+            .total_entities
+            .map_or_else(|| "unknown".to_owned(), |n| n.to_string()),
         graph.encoded_relations,
-        graph.total_relations.map_or_else(|| "unknown".to_owned(), |n| n.to_string()),
+        graph
+            .total_relations
+            .map_or_else(|| "unknown".to_owned(), |n| n.to_string()),
         graph.committed_stage_pages,
         graph.committed_stage_mutations,
         graph.committed_compact_segments,
@@ -881,10 +889,9 @@ fn native_graph_progress_summary(
         graph.producer_incarnation,
         graph.attempt_sequence,
         graph.progress_epoch,
-        graph.last_progress_micros.map_or_else(
-            || "unreported".to_owned(),
-            |micros| micros.to_string(),
-        )
+        graph
+            .last_progress_micros
+            .map_or_else(|| "unreported".to_owned(), |micros| micros.to_string(),)
     )
 }
 
@@ -1006,8 +1013,8 @@ mod daemon_precondition_tests {
         CodeGraphServingReadinessV1, CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1,
         CodeIndexBuildProgressV1, CodeIndexFreshnessLadderInputsV1, CodeIndexFreshnessLadderV1,
         CodeIndexNativeGraphPhaseV1, CodeIndexReadinessTargetV1, CodeIndexReadinessV1,
-        CodeIndexReadinessWaitOutcomeV1, CodeIndexReadinessWaitReadV1,
-        CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
+        CodeIndexReadinessWaitOutcomeV1, CodeIndexReadinessWaitReadV1, CodeIndexStalenessStateV1,
+        CodeIndexWorktreeFreshnessV1,
     };
     use tracedecay_contracts::retrieval::StatusCodeIndexFreshnessV1;
     use tracedecay_domain::errors::TraceDecayError;
@@ -1146,17 +1153,19 @@ mod daemon_precondition_tests {
 
     #[test]
     fn init_wait_preseal_summary_does_not_report_sealed_work() {
-        let attempt = tracedecay_contracts::code_index_freshness::CodeIndexPresealAttemptProgressV1 {
-            daemon_incarnation: 2,
-            producer_incarnation: 5,
-            attempt_sequence: 6,
-            progress_epoch: 11,
-            phase: tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::Capture,
-            completed_items: 16,
-            total_items: None,
-            last_progress_micros: Some(123),
-            active: true,
-        };
+        let attempt =
+            tracedecay_contracts::code_index_freshness::CodeIndexPresealAttemptProgressV1 {
+                daemon_incarnation: 2,
+                producer_incarnation: 5,
+                attempt_sequence: 6,
+                progress_epoch: 11,
+                phase:
+                    tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::Capture,
+                completed_items: 16,
+                total_items: None,
+                last_progress_micros: Some(123),
+                active: true,
+            };
         assert_eq!(
             super::preseal_progress_summary(&attempt),
             "capturing 16/unknown items, attempt=2:5:6 epoch=11 last_work_micros=123"
@@ -1263,10 +1272,7 @@ mod daemon_precondition_tests {
         report.phase = CodeIndexBuildPhaseV1::BulkCommit;
         source.progress = Some(report.clone());
         let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
-        assert!(!window.observe(
-            super::FirstGenerationWorkMarker::of(Some(&source)),
-            now,
-        ));
+        assert!(!window.observe(super::FirstGenerationWorkMarker::of(Some(&source)), now,));
         for (seconds, blocked) in [
             (40, Some(CodeIndexBuildBlockedReasonV1::ResidentMemory)),
             (80, None),
@@ -1308,10 +1314,7 @@ mod daemon_precondition_tests {
         let now = Instant::now();
         let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
         let capture = attempt(Capture, 2, 3, 1);
-        assert!(!window.observe(
-            super::FirstGenerationWorkMarker::of(Some(&capture)),
-            now,
-        ));
+        assert!(!window.observe(super::FirstGenerationWorkMarker::of(Some(&capture)), now,));
         let entered_parse = attempt(ParseEvidence, 3, 0, 1);
         assert!(!window.observe(
             super::FirstGenerationWorkMarker::of(Some(&entered_parse)),
@@ -1335,10 +1338,7 @@ mod daemon_precondition_tests {
         let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
         let mut source = building(true);
         source.progress = Some(progress(40, None));
-        assert!(!window.observe(
-            super::FirstGenerationWorkMarker::of(Some(&source)),
-            now,
-        ));
+        assert!(!window.observe(super::FirstGenerationWorkMarker::of(Some(&source)), now,));
         let mut adopted = progress(40, None);
         adopted.daemon_incarnation = 2;
         adopted.progress_epoch = 1;
@@ -1433,7 +1433,10 @@ mod daemon_precondition_tests {
             Duration::ZERO,
         )
         .await;
-        assert!(result.is_ok(), "real work must keep the wait alive: {result:?}");
+        assert!(
+            result.is_ok(),
+            "real work must keep the wait alive: {result:?}"
+        );
         assert_eq!(reads, 5, "only the reached proof ends a progressing wait");
     }
 
@@ -1479,7 +1482,11 @@ mod daemon_precondition_tests {
             })
         ));
         let mut repeated = cold.clone();
-        repeated.native_graph_progress.as_mut().unwrap().progress_epoch += 1;
+        repeated
+            .native_graph_progress
+            .as_mut()
+            .unwrap()
+            .progress_epoch += 1;
         // A changed status epoch without a physical row or durable page
         // must not turn the initial unreported native attempt into progress.
         let (result, reads) = hold_over(
@@ -1491,7 +1498,10 @@ mod daemon_precondition_tests {
             Duration::ZERO,
         )
         .await;
-        assert_eq!(reads, 2, "the frozen writer must refuse before a later ready");
+        assert_eq!(
+            reads, 2,
+            "the frozen writer must refuse before a later ready"
+        );
         let (code, reason) = refusal(result);
         assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
         assert!(
@@ -1665,7 +1675,10 @@ mod daemon_precondition_tests {
             };
         worktree.native_graph_progress = Some(graph.clone());
         let marker = super::FirstGenerationWorkMarker::of(Some(&worktree));
-        assert!(marker.is_some(), "a pending relation stream is still observable work");
+        assert!(
+            marker.is_some(),
+            "a pending relation stream is still observable work"
+        );
         let now = Instant::now();
         let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
         assert!(!window.observe(marker.clone(), now));
diff --git a/crates/tracedecay-code-index-runtime/src/code_graph_seat.rs b/crates/tracedecay-code-index-runtime/src/code_graph_seat.rs
index 67d82fa1ae1..1ccb8d11e97 100644
--- a/crates/tracedecay-code-index-runtime/src/code_graph_seat.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_graph_seat.rs
@@ -25,8 +25,8 @@ use tracedecay_domain::errors::Result;
 use tracedecay_domain::{CodeGenerationId, ProjectId, RefId, RepositoryId, WorktreeId};
 use tracedecay_graph_db::{GraphDbError, SealedGraphStateDigest, VerifiedGraphSnapshot};
 use tracedecay_runtime_core::db::Database;
-use tracedecay_store::GraphNativeWorkObserverV1;
 use tracedecay_runtime_core::shard_runtime::registry::CanonicalCodeGraphStoreLeaseV1;
+use tracedecay_store::GraphNativeWorkObserverV1;
 
 /// Sealed-generation replay identity the seat port needs to retain a runtime.
 #[derive(Clone, Debug, Eq, PartialEq)]
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
index 278a97cef5d..4e3aa2f6e67 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
@@ -24,7 +24,11 @@ pub(crate) struct CodeIndexBuildAttemptSlotStateV1 {
 }
 
 impl CodeIndexBuildAttemptSlotStateV1 {
-    fn begin(&mut self, daemon_incarnation: u64, producer_incarnation: u64) -> CodeIndexBuildAttemptIdentityV1 {
+    fn begin(
+        &mut self,
+        daemon_incarnation: u64,
+        producer_incarnation: u64,
+    ) -> CodeIndexBuildAttemptIdentityV1 {
         self.next_sequence = self.next_sequence.saturating_add(1).max(1);
         self.epoch = self.epoch.saturating_add(1).max(1);
         let identity = CodeIndexBuildAttemptIdentityV1 {
@@ -63,7 +67,9 @@ impl CodeIndexBuildAttemptSlotStateV1 {
     ) -> bool {
         if !self.owns(identity)
             || work.completed_items == 0
-            || work.total_items.is_some_and(|total| work.completed_items > total)
+            || work
+                .total_items
+                .is_some_and(|total| work.completed_items > total)
         {
             return false;
         }
@@ -92,8 +98,9 @@ impl CodeIndexBuildAttemptSlotStateV1 {
         next.phase = work.phase;
         next.completed_items = work.completed_items;
         next.total_items = work.total_items;
-        next.last_progress_micros =
-            Some(observed_at_micros.max(current.last_progress_micros.unwrap_or(observed_at_micros)));
+        next.last_progress_micros = Some(
+            observed_at_micros.max(current.last_progress_micros.unwrap_or(observed_at_micros)),
+        );
         self.epoch = self.epoch.saturating_add(1).max(1);
         next.progress_epoch = self.epoch;
         self.snapshot = Some(next);
@@ -131,7 +138,9 @@ impl CodeIndexPresealAttemptGuardV1 {
         daemon_incarnation: u64,
         producer_incarnation: u64,
     ) -> Self {
-        let identity = slot.write().unwrap_or_else(PoisonError::into_inner)
+        let identity = slot
+            .write()
+            .unwrap_or_else(PoisonError::into_inner)
             .begin(daemon_incarnation, producer_incarnation);
         Self { slot, identity }
     }
@@ -140,7 +149,8 @@ impl CodeIndexPresealAttemptGuardV1 {
         let slot = Arc::clone(&self.slot);
         let identity = self.identity;
         Arc::new(move |work| {
-            slot.write().unwrap_or_else(PoisonError::into_inner)
+            slot.write()
+                .unwrap_or_else(PoisonError::into_inner)
                 .observe(identity, work, now_micros().0);
         })
     }
@@ -148,7 +158,9 @@ impl CodeIndexPresealAttemptGuardV1 {
 
 impl Drop for CodeIndexPresealAttemptGuardV1 {
     fn drop(&mut self) {
-        self.slot.write().unwrap_or_else(PoisonError::into_inner)
+        self.slot
+            .write()
+            .unwrap_or_else(PoisonError::into_inner)
             .finish(self.identity);
     }
 }
@@ -157,8 +169,16 @@ impl Drop for CodeIndexPresealAttemptGuardV1 {
 mod tests {
     use super::*;
 
-    fn work(phase: CodeIndexPresealWorkPhaseV1, n: u64, total: Option<u64>) -> CodeIndexPresealWorkV1 {
-        CodeIndexPresealWorkV1 { phase, completed_items: n, total_items: total }
+    fn work(
+        phase: CodeIndexPresealWorkPhaseV1,
+        n: u64,
+        total: Option<u64>,
+    ) -> CodeIndexPresealWorkV1 {
+        CodeIndexPresealWorkV1 {
+            phase,
+            completed_items: n,
+            total_items: total,
+        }
     }
 
     #[test]
@@ -166,24 +186,52 @@ mod tests {
         let mut slot = CodeIndexBuildAttemptSlotStateV1::default();
         let id = slot.begin(7, 9);
         assert_eq!(slot.snapshot().unwrap().last_progress_micros, None);
-        assert!(slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 2, Some(5)), 100));
+        assert!(slot.observe(
+            id,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 2, Some(5)),
+            100
+        ));
         let first = slot.snapshot().unwrap();
         assert_eq!(first.completed_items, 2);
         assert_eq!(first.last_progress_micros, Some(100));
-        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 2, Some(5)), 900));
-        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(5)), 950));
-        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 6, Some(5)), 990));
+        assert!(!slot.observe(
+            id,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 2, Some(5)),
+            900
+        ));
+        assert!(!slot.observe(
+            id,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(5)),
+            950
+        ));
+        assert!(!slot.observe(
+            id,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 6, Some(5)),
+            990
+        ));
         assert_eq!(slot.snapshot().unwrap(), first);
-        assert!(slot.observe(id, work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 1, Some(3)), 95));
+        assert!(slot.observe(
+            id,
+            work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 1, Some(3)),
+            95
+        ));
         let parsed = slot.snapshot().unwrap();
         assert_eq!(parsed.last_progress_micros, Some(100));
         assert!(parsed.progress_epoch > first.progress_epoch);
-        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::Capture, 3, Some(5)), 150));
+        assert!(!slot.observe(
+            id,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 3, Some(5)),
+            150
+        ));
         slot.finish(id);
         let ended = slot.snapshot().unwrap();
         assert!(!ended.active);
         assert_eq!(ended.last_progress_micros, Some(100));
-        assert!(!slot.observe(id, work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 2, Some(3)), 200));
+        assert!(!slot.observe(
+            id,
+            work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 2, Some(3)),
+            200
+        ));
         assert_eq!(slot.snapshot().unwrap(), ended);
     }
 
@@ -242,15 +290,35 @@ mod tests {
     fn retry_and_remount_fence_old_producers_even_when_counters_match() {
         let mut slot = CodeIndexBuildAttemptSlotStateV1::default();
         let first = slot.begin(1, 11);
-        assert!(slot.observe(first, work(CodeIndexPresealWorkPhaseV1::Capture, 3, None), 100));
+        assert!(slot.observe(
+            first,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 3, None),
+            100
+        ));
         let second = slot.begin(1, 11);
         assert_ne!(first.sequence, second.sequence);
-        assert!(!slot.observe(first, work(CodeIndexPresealWorkPhaseV1::Capture, 40, None), 800));
+        assert!(!slot.observe(
+            first,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 40, None),
+            800
+        ));
         slot.finish(first);
-        assert!(slot.observe(second, work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(2)), 200));
+        assert!(slot.observe(
+            second,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(2)),
+            200
+        ));
         let third = slot.begin(2, 1);
-        assert!(!slot.observe(second, work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 2, Some(2)), 700));
-        assert!(slot.observe(third, work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(3)), 400));
+        assert!(!slot.observe(
+            second,
+            work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 2, Some(2)),
+            700
+        ));
+        assert!(slot.observe(
+            third,
+            work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(3)),
+            400
+        ));
         let visible = slot.snapshot().unwrap();
         assert_eq!(visible.daemon_incarnation, 2);
         assert_eq!(visible.producer_incarnation, 1);
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/git_tree_capture.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/git_tree_capture.rs
index 4d8d6dd9b33..b5fed132b5e 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/git_tree_capture.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/git_tree_capture.rs
@@ -562,7 +562,8 @@ impl CodeIndexWorktreeSchedulerV1 {
                 completed_candidates = completed_candidates.saturating_add(1);
                 observer.observed_preseal_work(
                     tracedecay_code_index::production::CodeIndexPresealWorkV1 {
-                        phase: tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Capture,
+                        phase:
+                            tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Capture,
                         completed_items: completed_candidates,
                         total_items: None,
                     },
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/graph_activation.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/graph_activation.rs
index cddd262a4ad..3e0b43e2cc8 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/graph_activation.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/graph_activation.rs
@@ -481,7 +481,9 @@ impl CodeGraphActivationAuthorityV1 {
                     Some(admission) => retained
                         .publish_verified_snapshot_admitted(cancellation, admission, native_work)
                         .map(drop),
-                    None => retained.publish_verified_snapshot(cancellation, native_work).map(drop),
+                    None => retained
+                        .publish_verified_snapshot(cancellation, native_work)
+                        .map(drop),
                 })
                 .await
                 .map_err(|error| {
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
index 63858ae8533..6c81029062c 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
@@ -1404,7 +1404,9 @@ impl CodeIndexWorktreeSchedulerV1 {
             refused_ignored_source_paths: BTreeSet::new(),
             query_owners: Mutex::new(None),
             build_progress: Arc::new(RwLock::new(CodeIndexBuildProgressSlotStateV1::default())),
-            preseal_attempt_progress: Arc::new(RwLock::new(CodeIndexBuildAttemptSlotStateV1::default())),
+            preseal_attempt_progress: Arc::new(RwLock::new(
+                CodeIndexBuildAttemptSlotStateV1::default(),
+            )),
             progress_daemon_incarnation: 1,
             progress_producer_incarnation: 1,
         };
@@ -2370,7 +2372,9 @@ impl CodeIndexWorktreeSchedulerV1 {
             self.progress_daemon_incarnation,
             self.progress_producer_incarnation,
         );
-        let control = self.reconcile_control().with_preseal_observer(attempt.observer());
+        let control = self
+            .reconcile_control()
+            .with_preseal_observer(attempt.observer());
         let captured = self
             .capture_authoritative_snapshot_without_active_generation_reuse(Some(&control))
             .map_err(|error| prefer_resident_memory_refusal(&control, error))?;
@@ -2989,7 +2993,9 @@ impl CodeIndexWorktreeSchedulerV1 {
                 self.progress_daemon_incarnation,
                 self.progress_producer_incarnation,
             );
-            let control = self.reconcile_control().with_preseal_observer(attempt.observer());
+            let control = self
+                .reconcile_control()
+                .with_preseal_observer(attempt.observer());
             // Every earlier attempt was cancelled by a newer source epoch. A
             // source that changes faster than a pass lasts would cancel this
             // one too, so it seals what it captured; the epoch that
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
index 37139f49441..b481207ff8c 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
@@ -6,9 +6,7 @@ use std::sync::{Arc, PoisonError, RwLock};
 use tracedecay_contracts::code_index_freshness::{
     CodeIndexNativeGraphPhaseV1, CodeIndexNativeGraphProgressV1,
 };
-use tracedecay_store::{
-    GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
-};
+use tracedecay_store::{GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1};
 
 pub(super) type CodeIndexNativeGraphProgressSlotV1 =
     Arc<RwLock<CodeIndexNativeGraphProgressSlotStateV1>>;
@@ -121,12 +119,13 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
     }
 
     fn owns(&self, owner: GraphAttemptOwnerV1) -> bool {
-        self.sequence == owner.sequence && self.snapshot.as_ref().is_some_and(|state| {
-            state.active
-                && state.daemon_incarnation == owner.daemon
-                && state.producer_incarnation == owner.producer
-                && state.attempt_sequence == owner.sequence
-        })
+        self.sequence == owner.sequence
+            && self.snapshot.as_ref().is_some_and(|state| {
+                state.active
+                    && state.daemon_incarnation == owner.daemon
+                    && state.producer_incarnation == owner.producer
+                    && state.attempt_sequence == owner.sequence
+            })
     }
 
     fn observe(&mut self, owner: GraphAttemptOwnerV1, work: GraphNativeWorkV1, now: i64) -> bool {
@@ -139,11 +138,7 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
             let pending = pending.clone();
             let mut candidate = self.clone();
             candidate.pending_activation = None;
-            candidate.start_with_owner(
-                owner,
-                pending.generation_id,
-                pending.sealed_graph_digest,
-            );
+            candidate.start_with_owner(owner, pending.generation_id, pending.sealed_graph_digest);
             if !candidate.observe(owner, work, now) {
                 return false;
             }
@@ -164,7 +159,8 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
                 total_rows,
                 total_relations,
             } => {
-                if completed_rows == 0 || completed_rows > total_rows
+                if completed_rows == 0
+                    || completed_rows > total_rows
                     || next.committed_compact_segments != 0
                 {
                     return false;
@@ -172,9 +168,10 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
                 // The manifest already authenticates the relation count,
                 // including zero, while entity windows are still being encoded.
                 // Never treat an unknown relation bound as completed work.
-                if next.total_relations.is_some_and(|known| known != total_relations)
-                    || (kind == GraphNativeWorkKindV1::Relations
-                        && total_rows != total_relations)
+                if next
+                    .total_relations
+                    .is_some_and(|known| known != total_relations)
+                    || (kind == GraphNativeWorkKindV1::Relations && total_rows != total_relations)
                 {
                     return false;
                 }
@@ -189,9 +186,7 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
                         (&mut next.encoded_relations, &mut next.total_relations)
                     }
                 };
-                if completed_rows <= *completed
-                    || total.is_some_and(|prior| prior != total_rows)
-                {
+                if completed_rows <= *completed || total.is_some_and(|prior| prior != total_rows) {
                     return false;
                 }
                 *completed = completed_rows;
@@ -205,22 +200,18 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
                 live_bytes,
                 ..
             } => {
-                if mutations == 0
-                    || self.last_stage_ordinal.is_some_and(|last| ordinal <= last)
-                {
+                if mutations == 0 || self.last_stage_ordinal.is_some_and(|last| ordinal <= last) {
                     return false;
                 }
                 self.last_stage_ordinal = Some(ordinal);
                 next.committed_stage_pages = next.committed_stage_pages.saturating_add(1);
                 next.committed_stage_mutations =
                     next.committed_stage_mutations.saturating_add(mutations);
-                next.committed_stage_bytes =
-                    next.committed_stage_bytes.saturating_add(live_bytes);
+                next.committed_stage_bytes = next.committed_stage_bytes.saturating_add(live_bytes);
                 next.phase = Some(CodeIndexNativeGraphPhaseV1::StagePageCommit);
             }
             GraphNativeWorkV1::CompactSegmentVerified {
-                canonical_bytes,
-                ..
+                canonical_bytes, ..
             } => {
                 if canonical_bytes == 0 || next.committed_compact_segments != 0 {
                     return false;
@@ -233,14 +224,20 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
         self.epoch = self.epoch.saturating_add(1).max(1);
         next.progress_epoch = self.epoch;
         next.last_progress_micros = Some(
-            current.last_progress_micros.map_or(now, |prior| prior.max(now)),
+            current
+                .last_progress_micros
+                .map_or(now, |prior| prior.max(now)),
         );
         self.snapshot = Some(next);
         true
     }
 
     fn finish(&mut self, owner: GraphAttemptOwnerV1) {
-        if self.pending_activation.as_ref().is_some_and(|pending| pending.owner == owner) {
+        if self
+            .pending_activation
+            .as_ref()
+            .is_some_and(|pending| pending.owner == owner)
+        {
             self.pending_activation = None;
             return;
         }
@@ -274,8 +271,12 @@ impl CodeIndexNativeGraphProgressGuardV1 {
         generation_id: String,
         sealed_graph_digest: String,
     ) -> Self {
-        let owner = slot.write().unwrap_or_else(PoisonError::into_inner)
-            .begin(daemon, producer, generation_id, sealed_graph_digest);
+        let owner = slot.write().unwrap_or_else(PoisonError::into_inner).begin(
+            daemon,
+            producer,
+            generation_id,
+            sealed_graph_digest,
+        );
         Self { slot, owner }
     }
 
@@ -286,7 +287,9 @@ impl CodeIndexNativeGraphProgressGuardV1 {
         generation_id: String,
         sealed_graph_digest: String,
     ) -> Self {
-        let owner = slot.write().unwrap_or_else(PoisonError::into_inner)
+        let owner = slot
+            .write()
+            .unwrap_or_else(PoisonError::into_inner)
             .begin_on_first_work(daemon, producer, generation_id, sealed_graph_digest);
         Self { slot, owner }
     }
@@ -295,7 +298,8 @@ impl CodeIndexNativeGraphProgressGuardV1 {
         let slot = Arc::clone(&self.slot);
         let owner = self.owner;
         Arc::new(move |work| {
-            slot.write().unwrap_or_else(PoisonError::into_inner)
+            slot.write()
+                .unwrap_or_else(PoisonError::into_inner)
                 .observe(owner, work, tracedecay_contracts::now_micros().0);
         })
     }
@@ -303,7 +307,9 @@ impl CodeIndexNativeGraphProgressGuardV1 {
 
 impl Drop for CodeIndexNativeGraphProgressGuardV1 {
     fn drop(&mut self) {
-        self.slot.write().unwrap_or_else(PoisonError::into_inner)
+        self.slot
+            .write()
+            .unwrap_or_else(PoisonError::into_inner)
             .finish(self.owner);
     }
 }
@@ -314,9 +320,15 @@ mod tests {
 
     #[test]
     fn real_native_work_distinguishes_encoding_receipted_pages_and_verified_segment() {
-        let slot = Arc::new(RwLock::new(CodeIndexNativeGraphProgressSlotStateV1::default()));
+        let slot = Arc::new(RwLock::new(
+            CodeIndexNativeGraphProgressSlotStateV1::default(),
+        ));
         let attempt = CodeIndexNativeGraphProgressGuardV1::begin(
-            Arc::clone(&slot), 4, 6, "generation.a".into(), "digest.a".into(),
+            Arc::clone(&slot),
+            4,
+            6,
+            "generation.a".into(),
+            "digest.a".into(),
         );
         let observer = attempt.observer();
         let initial = slot.read().unwrap().snapshot().unwrap();
@@ -361,18 +373,26 @@ mod tests {
             "changing the sealed relation bound cannot renew progress"
         );
         observer(GraphNativeWorkV1::StagePageApplied {
-            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 36, live_bytes: 4096,
+            ordinal: 0,
+            kind: GraphNativeWorkKindV1::Entities,
+            mutations: 36,
+            live_bytes: 4096,
         });
         let durable = slot.read().unwrap().snapshot().unwrap();
         assert_eq!(durable.committed_stage_pages, 1);
         assert_eq!(durable.committed_stage_mutations, 36);
         assert_eq!(durable.committed_stage_bytes, 4096);
         observer(GraphNativeWorkV1::StagePageApplied {
-            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 36, live_bytes: 4096,
+            ordinal: 0,
+            kind: GraphNativeWorkKindV1::Entities,
+            mutations: 36,
+            live_bytes: 4096,
         });
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), durable);
         observer(GraphNativeWorkV1::CompactSegmentVerified {
-            entities: 1101, relations: 1143, canonical_bytes: 67890,
+            entities: 1101,
+            relations: 1143,
+            canonical_bytes: 67890,
         });
         let installed = slot.read().unwrap().snapshot().unwrap();
         assert_eq!(installed.committed_compact_segments, 1);
@@ -381,21 +401,34 @@ mod tests {
         drop(attempt);
         let finished = slot.read().unwrap().snapshot().unwrap();
         assert!(!finished.active);
-        assert_eq!(finished.last_progress_micros, installed.last_progress_micros);
+        assert_eq!(
+            finished.last_progress_micros,
+            installed.last_progress_micros
+        );
         observer(GraphNativeWorkV1::CompactSegmentVerified {
-            entities: 1101, relations: 1143, canonical_bytes: 67890,
+            entities: 1101,
+            relations: 1143,
+            canonical_bytes: 67890,
         });
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), finished);
     }
 
     #[test]
     fn read_only_activation_keeps_verified_native_milestones_until_real_write() {
-        let slot = Arc::new(RwLock::new(CodeIndexNativeGraphProgressSlotStateV1::default()));
+        let slot = Arc::new(RwLock::new(
+            CodeIndexNativeGraphProgressSlotStateV1::default(),
+        ));
         let publication = CodeIndexNativeGraphProgressGuardV1::begin(
-            Arc::clone(&slot), 3, 8, "generation.a".into(), "digest.a".into(),
+            Arc::clone(&slot),
+            3,
+            8,
+            "generation.a".into(),
+            "digest.a".into(),
         );
         publication.observer()(GraphNativeWorkV1::CompactSegmentVerified {
-            entities: 11, relations: 9, canonical_bytes: 4096,
+            entities: 11,
+            relations: 9,
+            canonical_bytes: 4096,
         });
         drop(publication);
         let verified = slot.read().unwrap().snapshot().unwrap();
@@ -405,26 +438,42 @@ mod tests {
         // The worker publishes from sealed rows, then activates the decoded
         // serving generation. Reopening its verified head writes no segment.
         let activation = CodeIndexNativeGraphProgressGuardV1::begin_for_activation(
-            Arc::clone(&slot), 3, 8, "generation.a".into(), "digest.a".into(),
+            Arc::clone(&slot),
+            3,
+            8,
+            "generation.a".into(),
+            "digest.a".into(),
         );
         let callback = activation.observer();
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), verified);
         callback(GraphNativeWorkV1::CompactSegmentVerified {
-            entities: 0, relations: 0, canonical_bytes: 0,
+            entities: 0,
+            relations: 0,
+            canonical_bytes: 0,
         });
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), verified);
         drop(activation);
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), verified);
         callback(GraphNativeWorkV1::StagePageApplied {
-            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 5, live_bytes: 120,
+            ordinal: 0,
+            kind: GraphNativeWorkKindV1::Entities,
+            mutations: 5,
+            live_bytes: 120,
         });
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), verified);
 
         let retry = CodeIndexNativeGraphProgressGuardV1::begin_for_activation(
-            Arc::clone(&slot), 3, 8, "generation.a".into(), "digest.a".into(),
+            Arc::clone(&slot),
+            3,
+            8,
+            "generation.a".into(),
+            "digest.a".into(),
         );
         retry.observer()(GraphNativeWorkV1::StagePageApplied {
-            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 5, live_bytes: 120,
+            ordinal: 0,
+            kind: GraphNativeWorkKindV1::Entities,
+            mutations: 5,
+            live_bytes: 120,
         });
         let restarted = slot.read().unwrap().snapshot().unwrap();
         assert!(restarted.active);
@@ -440,21 +489,37 @@ mod tests {
 
     #[test]
     fn restarted_native_publication_fences_old_callbacks_and_resets_attempt_counters() {
-        let slot = Arc::new(RwLock::new(CodeIndexNativeGraphProgressSlotStateV1::default()));
+        let slot = Arc::new(RwLock::new(
+            CodeIndexNativeGraphProgressSlotStateV1::default(),
+        ));
         let stale = CodeIndexNativeGraphProgressGuardV1::begin(
-            Arc::clone(&slot), 1, 9, "generation.a".into(), "digest.a".into(),
+            Arc::clone(&slot),
+            1,
+            9,
+            "generation.a".into(),
+            "digest.a".into(),
         );
         let old_observer = stale.observer();
         old_observer(GraphNativeWorkV1::StagePageApplied {
-            ordinal: 0, kind: GraphNativeWorkKindV1::Entities, mutations: 2, live_bytes: 18,
+            ordinal: 0,
+            kind: GraphNativeWorkKindV1::Entities,
+            mutations: 2,
+            live_bytes: 18,
         });
         let old_epoch = slot.read().unwrap().snapshot().unwrap().progress_epoch;
         let current = CodeIndexNativeGraphProgressGuardV1::begin(
-            Arc::clone(&slot), 2, 1, "generation.a".into(), "digest.a".into(),
+            Arc::clone(&slot),
+            2,
+            1,
+            "generation.a".into(),
+            "digest.a".into(),
         );
         let current_observer = current.observer();
         old_observer(GraphNativeWorkV1::StagePageApplied {
-            ordinal: 1, kind: GraphNativeWorkKindV1::Entities, mutations: 100, live_bytes: 1000,
+            ordinal: 1,
+            kind: GraphNativeWorkKindV1::Entities,
+            mutations: 100,
+            live_bytes: 1000,
         });
         drop(stale);
         let reopened = slot.read().unwrap().snapshot().unwrap();
@@ -463,7 +528,10 @@ mod tests {
         assert!(reopened.progress_epoch > old_epoch);
         assert_eq!(reopened.last_progress_micros, None);
         current_observer(GraphNativeWorkV1::StagePageApplied {
-            ordinal: 0, kind: GraphNativeWorkKindV1::Relations, mutations: 3, live_bytes: 120,
+            ordinal: 0,
+            kind: GraphNativeWorkKindV1::Relations,
+            mutations: 3,
+            live_bytes: 120,
         });
         let resumed = slot.read().unwrap().snapshot().unwrap();
         assert_eq!(resumed.committed_stage_pages, 1);
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/ignored_dependencies.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/ignored_dependencies.rs
index 33075085452..1fc21e0505e 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/ignored_dependencies.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/ignored_dependencies.rs
@@ -716,13 +716,20 @@ impl CodeIndexSchedulerRegistryV1 {
             .lock()
             .unwrap_or_else(std::sync::PoisonError::into_inner)
             .progress_incarnations();
-        let graph_attempt = super::graph_progress::CodeIndexNativeGraphProgressGuardV1::begin_for_activation(
-            native_graph_progress,
-            daemon_incarnation,
-            producer_incarnation,
-            build.latest.generation().manifest().generation_id.as_str().to_owned(),
-            replay_binding.sealed_state_digest.as_str().to_owned(),
-        );
+        let graph_attempt =
+            super::graph_progress::CodeIndexNativeGraphProgressGuardV1::begin_for_activation(
+                native_graph_progress,
+                daemon_incarnation,
+                producer_incarnation,
+                build
+                    .latest
+                    .generation()
+                    .manifest()
+                    .generation_id
+                    .as_str()
+                    .to_owned(),
+                replay_binding.sealed_state_digest.as_str().to_owned(),
+            );
         let activation = activate_committed_generation(
             &graph_activation,
             &project_id,
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
index c3a8c4604fe..61395cd0f3b 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
@@ -120,9 +120,20 @@ fn cold_build_reports_actual_preseal_capture_and_parser_evidence() {
         Arc::new(SharedCodeIndexBytePoolV1::default()),
     );
     let slot = owner.preseal_attempt_progress_slot();
-    assert!(slot.read().unwrap().snapshot().is_none(), "no fabricated cold progress");
-    published(owner.reconcile_now().expect("real cold capture and publication"));
-    let observed = slot.read().unwrap().snapshot().expect("pre-seal observation");
+    assert!(
+        slot.read().unwrap().snapshot().is_none(),
+        "no fabricated cold progress"
+    );
+    published(
+        owner
+            .reconcile_now()
+            .expect("real cold capture and publication"),
+    );
+    let observed = slot
+        .read()
+        .unwrap()
+        .snapshot()
+        .expect("pre-seal observation");
     assert!(!observed.active, "a finished attempt cannot appear stalled");
     assert_eq!(
         observed.phase,
@@ -173,12 +184,18 @@ fn retained_restart_capture_publishes_and_fences_preseal_attempt() {
         observed.phase,
         tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Capture
     );
-    assert!(observed.completed_items >= 2, "two files were actually captured");
+    assert!(
+        observed.completed_items >= 2,
+        "two files were actually captured"
+    );
     assert!(observed.progress_epoch > 1);
     assert!(observed.last_progress_micros.is_some_and(|at| at > 0));
     drop(capture);
     let finished = slot.read().unwrap().snapshot().expect("finished attempt");
-    assert!(!finished.active, "dropping the retained owner fences callbacks");
+    assert!(
+        !finished.active,
+        "dropping the retained owner fences callbacks"
+    );
     assert_eq!(finished.completed_items, observed.completed_items);
     assert_eq!(finished.last_progress_micros, observed.last_progress_micros);
     assert!(finished.progress_epoch > observed.progress_epoch);
diff --git a/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs b/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
index 378b45e4c68..894948bb504 100644
--- a/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
+++ b/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
@@ -332,10 +332,7 @@ fn cold_resolution_index_publication_advances_actual_work_counts() {
             "src/alpha.rs".to_owned(),
             "pub fn alpha() { crate::beta::beta(); }\n".to_owned(),
         ),
-        (
-            "src/beta.rs".to_owned(),
-            "pub fn beta() {}\n".to_owned(),
-        ),
+        ("src/beta.rs".to_owned(), "pub fn beta() {}\n".to_owned()),
     ];
     let store = WorkerPublicationStore::default();
     let mut owner =
@@ -344,10 +341,9 @@ fn cold_resolution_index_publication_advances_actual_work_counts() {
     let published = owner
         .build_and_publish(fixture_request(&files, None, false, 1_500_000), &observer)
         .expect("real cold reference resolution");
-    let manifest = super::partitioned_codec::parse_partitioned_manifest(
-        published.manifest_bytes().as_ref(),
-    )
-    .expect("verified published index manifest");
+    let manifest =
+        super::partitioned_codec::parse_partitioned_manifest(published.manifest_bytes().as_ref())
+            .expect("verified published index manifest");
 
     let index_segments = manifest.resolution_index.segments().count();
     assert!(
@@ -361,11 +357,7 @@ fn cold_resolution_index_publication_advances_actual_work_counts() {
             + index_segments,
     )
     .expect("bounded cold resolution work");
-    let observed = observer
-        .0
-        .lock()
-        .expect("resolution observations")
-        .clone();
+    let observed = observer.0.lock().expect("resolution observations").clone();
     assert_eq!(
         observed,
         (1..=expected).collect::<Vec<_>>(),
@@ -516,12 +508,9 @@ fn a_restored_parent_and_the_edit_over_it_resolve_nothing_whole() {
             .decode_active(&scope)
             .expect("the edit restores")
             .expect("an active edit");
-        let full_resolution = resolve_cross_file_references_charged(
-            &edited.files,
-            &mut |_| Ok(()),
-            None,
-        )
-        .expect("whole reference resolution");
+        let full_resolution =
+            resolve_cross_file_references_charged(&edited.files, &mut |_| Ok(()), None)
+                .expect("whole reference resolution");
         let (full_edges, _) =
             edge_evidence(&edited.files, full_resolution.edges).expect("whole edge evidence");
         assert_eq!(
diff --git a/crates/tracedecay-contracts/src/code_index_freshness.rs b/crates/tracedecay-contracts/src/code_index_freshness.rs
index 020d04c5707..a0bbbad6889 100644
--- a/crates/tracedecay-contracts/src/code_index_freshness.rs
+++ b/crates/tracedecay-contracts/src/code_index_freshness.rs
@@ -123,7 +123,9 @@ pub struct CodeIndexBuildProgressV1 {
 }
 
 /// Observed capture, parse, and source-reference resolution before sealing.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, JsonSchema)]
+#[derive(
+    Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, JsonSchema,
+)]
 #[serde(rename_all = "snake_case")]
 pub enum CodeIndexPresealWorkPhaseV1 {
     Capture,
@@ -1528,5 +1530,4 @@ mod tests {
                 .is_none()
         );
     }
-
 }
diff --git a/crates/tracedecay-graph-db/src/generation_runtime.rs b/crates/tracedecay-graph-db/src/generation_runtime.rs
index d34bd94785a..cd9e1575b32 100644
--- a/crates/tracedecay-graph-db/src/generation_runtime.rs
+++ b/crates/tracedecay-graph-db/src/generation_runtime.rs
@@ -840,9 +840,7 @@ impl GraphDb {
                     current,
                     check,
                 )?;
-                if let (GenerationStagePageCommitV1::Applied, Some(observer)) =
-                    (outcome, observe)
-                {
+                if let (GenerationStagePageCommitV1::Applied, Some(observer)) = (outcome, observe) {
                     observer(GraphNativeWorkV1::StagePageApplied {
                         ordinal: u64::try_from(page.ordinal).unwrap_or(u64::MAX),
                         kind: match page.kind {
@@ -963,9 +961,7 @@ impl GraphDb {
                     current.take(),
                     check,
                 )?;
-                if let (GenerationStagePageCommitV1::Applied, Some(observer)) =
-                    (outcome, observe)
-                {
+                if let (GenerationStagePageCommitV1::Applied, Some(observer)) = (outcome, observe) {
                     observer(GraphNativeWorkV1::StagePageApplied {
                         ordinal: u64::try_from(page.ordinal).unwrap_or(u64::MAX),
                         kind: match page.kind {
@@ -2857,11 +2853,11 @@ mod tests {
     };
     use crate::{
         GraphDbError, GraphDbLocation, GraphDbOpenOptions, GraphDbOwner, GraphDurability,
-        GraphEntity, GraphEntityId, GraphEntityRef, GraphFormatVersion,
-        GraphGenerationDependency, GraphGenerationId, GraphGenerationManifest,
-        GraphGenerationRelation, GraphIdempotencyKey, GraphNamespace, GraphProjectionId,
-        GraphProjectionIdentity, GraphRelationId, GraphRelationKind, GraphWatermark,
-        MAX_VERIFIED_GENERATION_BATCH_MUTATIONS, NeverCancelled, SourceGeneration,
+        GraphEntity, GraphEntityId, GraphEntityRef, GraphFormatVersion, GraphGenerationDependency,
+        GraphGenerationId, GraphGenerationManifest, GraphGenerationRelation, GraphIdempotencyKey,
+        GraphNamespace, GraphProjectionId, GraphProjectionIdentity, GraphRelationId,
+        GraphRelationKind, GraphWatermark, MAX_VERIFIED_GENERATION_BATCH_MUTATIONS, NeverCancelled,
+        SourceGeneration,
     };
 
     use super::{
@@ -3857,17 +3853,18 @@ mod tests {
                     projection.clone(),
                     GraphEntityId::new("entity:00000").unwrap(),
                 ),
-                GraphEntityRef::new(
-                    projection,
-                    GraphEntityId::new("entity:00001").unwrap(),
-                ),
+                GraphEntityRef::new(projection, GraphEntityId::new("entity:00001").unwrap()),
                 GraphRelationKind::new("calls").unwrap(),
                 BTreeMap::new(),
             )
             .unwrap(),
         );
         let pages = generation_stage_pages(&manifest).expect("real page plan");
-        assert_eq!(pages.len(), 2, "entities and relations must use distinct pages");
+        assert_eq!(
+            pages.len(),
+            2,
+            "entities and relations must use distinct pages"
+        );
         let expected = sealed_digest(&manifest);
         let temp = TempDir::new().expect("persistent graph store");
         let (owner, database) = persistent_database(&temp);
@@ -4021,12 +4018,7 @@ mod tests {
         let (reopened_owner, reopened) = persistent_database(&temp);
         assert!(
             reopened
-                .generation_stage_page_already_applied(
-                    &identity,
-                    &sealed,
-                    &context,
-                    &pages[0],
-                )
+                .generation_stage_page_already_applied(&identity, &sealed, &context, &pages[0],)
                 .expect("verify row receipt after restart"),
             "a reported native page must survive a close/reopen, not merely staging memory"
         );
diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index ae2f6cc2b06..ff665c2e776 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -1749,10 +1749,7 @@ pub(crate) enum SealedRowSource<'a> {
 /// Returns whether this writer installed a new sealed segment. A losing
 /// concurrent writer can adopt the winner only after the caller reopens and
 /// verifies its digest; existence alone is not a new durable write.
-fn install_staged_sealed_store(
-    staging: &Path,
-    directory: &Path,
-) -> Result<bool, GraphDbError> {
+fn install_staged_sealed_store(staging: &Path, directory: &Path) -> Result<bool, GraphDbError> {
     match std::fs::rename(staging, directory) {
         Ok(()) => Ok(true),
         Err(error) => {
@@ -2865,17 +2862,17 @@ pub(crate) fn sealed_copy_proof(
 #[cfg(test)]
 mod build_tests {
     use std::collections::{BTreeMap, BTreeSet};
-    use std::sync::{Arc, Mutex};
     use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::{Arc, Mutex};
 
     use rayon::ThreadPoolBuilder;
 
     use super::{
         NativeCompactEncodeBoundaryV1, NativeCompactEncodeKindV1, SEALED_STORE_DATABASE_FILE,
         SealedCompactRows, SealedRowSource, build_or_open_sealed_store,
-        build_or_open_sealed_store_with_work, build_sealed_container_with_work,
-        push_manifest_rows, sealed_artifact_database_options, sealed_copy_proof,
-        sealed_generation_directory, sealed_store_root,
+        build_or_open_sealed_store_with_work, build_sealed_container_with_work, push_manifest_rows,
+        sealed_artifact_database_options, sealed_copy_proof, sealed_generation_directory,
+        sealed_store_root,
     };
     use tracedecay_store::runtime::{GraphNativeWorkKindV1, GraphNativeWorkV1};
 
@@ -3030,8 +3027,14 @@ mod build_tests {
             .iter()
             .filter(|event| event.kind == NativeCompactEncodeKindV1::Relations)
             .collect();
-        assert!(entities.len() >= 2, "must record multiple real entity windows");
-        assert!(relations.len() >= 2, "must record multiple real relation windows");
+        assert!(
+            entities.len() >= 2,
+            "must record multiple real entity windows"
+        );
+        assert!(
+            relations.len() >= 2,
+            "must record multiple real relation windows"
+        );
         for (events, total) in [(entities, 1_101), (relations, 1_143)] {
             let mut prior = 0;
             for event in events {
@@ -3431,15 +3434,10 @@ mod build_tests {
         );
         assert!(!staging.exists(), "the losing staging data must be removed");
         assert!(!directory.join("loser.tmp").exists());
-        let reopened = super::open_sealed_store_checked(
-            &directory,
-            &identity,
-            &expected,
-            check,
-            None,
-        )
-        .expect("verify the actual winning native segment")
-        .expect("the winning segment remains installed");
+        let reopened =
+            super::open_sealed_store_checked(&directory, &identity, &expected, check, None)
+                .expect("verify the actual winning native segment")
+                .expect("the winning segment remains installed");
         assert_eq!(reopened.recovered_digest(), expected.as_str());
         assert_eq!((reopened.entity_count, reopened.relation_count), (7, 9));
         let _ = reopened.database().close();
diff --git a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
index 7c5d48ed7a7..9189e831952 100644
--- a/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
+++ b/crates/tracedecay-mcp/src/handlers/graph/search_freshness.rs
@@ -232,11 +232,12 @@ pub(super) fn search_freshness(
                 attempt.attempt_sequence,
                 attempt.progress_epoch,
                 attempt.completed_items,
-                attempt.total_items.map_or_else(|| "unknown".to_owned(), |n| n.to_string()),
-                attempt.last_progress_micros.map_or_else(
-                    || "unreported".to_owned(),
-                    |micros| micros.to_string()
-                ),
+                attempt
+                    .total_items
+                    .map_or_else(|| "unknown".to_owned(), |n| n.to_string()),
+                attempt
+                    .last_progress_micros
+                    .map_or_else(|| "unreported".to_owned(), |micros| micros.to_string()),
                 attempt.active,
             );
         }
@@ -265,10 +266,9 @@ pub(super) fn search_freshness(
                 graph.committed_stage_bytes,
                 graph.committed_compact_segments,
                 graph.committed_compact_bytes,
-                graph.last_progress_micros.map_or_else(
-                    || "unreported".to_owned(),
-                    |micros| micros.to_string()
-                ),
+                graph
+                    .last_progress_micros
+                    .map_or_else(|| "unreported".to_owned(), |micros| micros.to_string()),
                 graph.active,
             );
         }
@@ -298,13 +298,17 @@ pub(super) fn search_freshness(
                 progress.blocked_reason.map_or("none", blocked_reason_label)
             );
         } else if state.rebuild_in_flight {
-            if state.native_graph_progress.as_ref().is_some_and(|graph| {
-                graph.active && graph.last_progress_micros.is_some()
-            }) {
+            if state
+                .native_graph_progress
+                .as_ref()
+                .is_some_and(|graph| graph.active && graph.last_progress_micros.is_some())
+            {
                 summary.push_str(" progress=native_graph");
-            } else if state.preseal_attempt.as_ref().is_some_and(|attempt| {
-                attempt.active && attempt.last_progress_micros.is_some()
-            }) {
+            } else if state
+                .preseal_attempt
+                .as_ref()
+                .is_some_and(|attempt| attempt.active && attempt.last_progress_micros.is_some())
+            {
                 summary.push_str(" progress=preseal");
             } else {
                 summary.push_str(" progress=unreported");
@@ -577,7 +581,9 @@ mod tests {
             ..CodeIndexWorktreeFreshnessV1::default()
         };
         let rendered = freshness_lines(&search_freshness(
-            ServedGenerationV1::Unavailable { reason: "generation_unavailable" },
+            ServedGenerationV1::Unavailable {
+                reason: "generation_unavailable",
+            },
             &CodeIndexSearchCoverageV1::unavailable("generation_rebuilding"),
             &WorktreeFreshnessSourceV1::Worktree(Box::new(state)),
         ));
@@ -785,7 +791,9 @@ mod tests {
             ..CodeIndexWorktreeFreshnessV1::default()
         };
         let rendered = freshness_lines(&search_freshness(
-            ServedGenerationV1::Unavailable { reason: "generation_unavailable" },
+            ServedGenerationV1::Unavailable {
+                reason: "generation_unavailable",
+            },
             &CodeIndexSearchCoverageV1::unavailable("generation_rebuilding"),
             &WorktreeFreshnessSourceV1::Worktree(Box::new(state)),
         ));
@@ -799,5 +807,4 @@ mod tests {
         assert!(rendered.contains("progress=native_graph"));
         assert!(!rendered.contains("committed_text_pages="));
     }
-
 }
diff --git a/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs b/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
index 64df72ec859..6c8eb4b1d57 100644
--- a/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
+++ b/crates/tracedecay-store-runtime/src/session_registry/code_graph.rs
@@ -22,15 +22,15 @@ use tracedecay_runtime_core::shard_runtime::registry::{
     CanonicalCodeGraphStoreLeaseV1, CanonicalGraphStoreOwnerRetirementTargetV1, StoreRuntimeKey,
 };
 use tracedecay_store::{
-    CodeShardScopeV1, FactReadControl, GraphGenerationIdV1, GraphPendingReplayDiscardOutcomeV1,
-    GraphProjectionIdV1, GraphProjectionIdentityV1, GraphPublicationIdempotencyKeyV1,
-    GraphPublicationInputDigestV1, GraphPublicationKeyV1, GraphPublicationOperationContextV1,
-    GraphNativeWorkObserverV1,
-    GraphPublicationProjectionPageRequestV1, GraphPublicationReplayLookupV1,
-    GraphPublicationReplayRecordV1, GraphPublicationStoreV1, GraphReplayAppendOutcomeV1,
-    GraphVerifiedHeadV1, ProjectId, RetainedGraphStoreLeaseV1, RuntimeCancellationIdV1,
-    RuntimeCancellationIdentityV1, RuntimeDeadlineIdV1, RuntimeDeadlineV1, RuntimeInterruptionV1,
-    RuntimeRequestControlV1, RuntimeRequestProbeV1, StoreShardIdV1, StoreShardScopeV1,
+    CodeShardScopeV1, FactReadControl, GraphGenerationIdV1, GraphNativeWorkObserverV1,
+    GraphPendingReplayDiscardOutcomeV1, GraphProjectionIdV1, GraphProjectionIdentityV1,
+    GraphPublicationIdempotencyKeyV1, GraphPublicationInputDigestV1, GraphPublicationKeyV1,
+    GraphPublicationOperationContextV1, GraphPublicationProjectionPageRequestV1,
+    GraphPublicationReplayLookupV1, GraphPublicationReplayRecordV1, GraphPublicationStoreV1,
+    GraphReplayAppendOutcomeV1, GraphVerifiedHeadV1, ProjectId, RetainedGraphStoreLeaseV1,
+    RuntimeCancellationIdV1, RuntimeCancellationIdentityV1, RuntimeDeadlineIdV1, RuntimeDeadlineV1,
+    RuntimeInterruptionV1, RuntimeRequestControlV1, RuntimeRequestProbeV1, StoreShardIdV1,
+    StoreShardScopeV1,
 };
 
 use super::{DaemonSessionRuntimeRegistryV1, Result, session_registry_error};
@@ -2168,8 +2168,12 @@ impl RetainedCodeGraphRuntimeV1 {
                     let _span =
                         tracing::trace_span!("daemon.session_registry.publish_snapshot.gate_hold")
                             .entered();
-                    self.graph_registry
-                        .complete_verified_publication(completion, storage, &publish_context, *proven)
+                    self.graph_registry.complete_verified_publication(
+                        completion,
+                        storage,
+                        &publish_context,
+                        *proven,
+                    )
                 }
             }
         };
@@ -3110,11 +3114,7 @@ impl CodeGraphSeatLeaseV1 for RetainedCodeGraphRuntimeV1 {
         tracedecay_graph_db::VerifiedGraphSnapshot,
         tracedecay_graph_db::GraphDbError,
     > {
-        self.publish_verified_snapshot_with_admission(
-            request_cancelled,
-            None,
-            Some(native_work),
-        )
+        self.publish_verified_snapshot_with_admission(request_cancelled, None, Some(native_work))
     }
 
     fn publish_verified_snapshot_admitted(
diff --git a/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs b/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
index 66d9e358a30..8b70651b227 100644
--- a/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
+++ b/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
@@ -30,12 +30,11 @@ use tracedecay_graph_db::{
 };
 use tracedecay_store::{
     GraphGenerationIdV1, GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
-    GraphProjectionIdV1, GraphProjectionIdentityV1,
-    GraphPublicationIdempotencyKeyV1, GraphPublicationInputDigestV1, GraphPublicationKeyV1,
-    GraphPublicationOperationContextV1, GraphPublicationReplayLookupV1, GraphPublicationReplayV1,
-    GraphPublicationStoreV1, GraphReplayAppendOutcomeV1, RetainedGraphStoreLeaseV1,
-    RuntimeCancellationIdV1, RuntimeCancellationIdentityV1, RuntimeDeadlineIdV1, RuntimeDeadlineV1,
-    RuntimeRequestControlV1,
+    GraphProjectionIdV1, GraphProjectionIdentityV1, GraphPublicationIdempotencyKeyV1,
+    GraphPublicationInputDigestV1, GraphPublicationKeyV1, GraphPublicationOperationContextV1,
+    GraphPublicationReplayLookupV1, GraphPublicationReplayV1, GraphPublicationStoreV1,
+    GraphReplayAppendOutcomeV1, RetainedGraphStoreLeaseV1, RuntimeCancellationIdV1,
+    RuntimeCancellationIdentityV1, RuntimeDeadlineIdV1, RuntimeDeadlineV1, RuntimeRequestControlV1,
 };
 
 use sha2::{Digest as _, Sha256};
@@ -741,7 +740,11 @@ async fn a_pending_predecessor_pooled_by_retention_yields_to_the_next_generation
             }
         })
     };
-    let published = successor_runtime.publish_verified_snapshot_with_admission(Arc::clone(&cancelled), None, None);
+    let published = successor_runtime.publish_verified_snapshot_with_admission(
+        Arc::clone(&cancelled),
+        None,
+        None,
+    );
     drop(finished);
     watchdog.join().expect("publication watchdog");
     let snapshot = published.expect("the successor publishes past its pooled pending predecessor");
@@ -878,7 +881,11 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
 
     std::fs::write(&canonical_seal, &mutated_seal).expect("mutate sealed generation in place");
     assert!(matches!(
-        runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None),
+        runtime.publish_verified_snapshot_with_admission(
+            Arc::new(AtomicBool::new(false)),
+            None,
+            None
+        ),
         Err(GraphDbError::Corrupt { .. })
     ));
     assert_unverified_publication_state(&runtime, false);
@@ -888,7 +895,11 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
     std::fs::rename(&canonical_seal, &retained_seal).expect("retain original sealed inode");
     std::fs::write(&canonical_seal, &mutated_seal).expect("replace canonical sealed inode");
     assert!(matches!(
-        runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None),
+        runtime.publish_verified_snapshot_with_admission(
+            Arc::new(AtomicBool::new(false)),
+            None,
+            None
+        ),
         Err(GraphDbError::Corrupt { .. })
     ));
     assert_unverified_publication_state(&runtime, false);
@@ -902,7 +913,11 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
         std::fs::rename(&canonical_seal, &retained_seal).expect("retain symlink target evidence");
         symlink(&retained_seal, &canonical_seal).expect("swap canonical seal for symlink");
         assert!(matches!(
-            runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None),
+            runtime.publish_verified_snapshot_with_admission(
+                Arc::new(AtomicBool::new(false)),
+                None,
+                None
+            ),
             Err(GraphDbError::Corrupt { .. })
         ));
         assert_unverified_publication_state(&runtime, false);
@@ -915,7 +930,11 @@ async fn sealed_generation_publishes_and_republishes_without_eager_replay_payloa
     std::fs::write(&canonical_seal, &mutated_seal)
         .expect("mutate source before active replay completion");
     assert!(matches!(
-        runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None),
+        runtime.publish_verified_snapshot_with_admission(
+            Arc::new(AtomicBool::new(false)),
+            None,
+            None
+        ),
         Err(GraphDbError::Corrupt { .. })
     ));
     assert_unverified_publication_state(&runtime, true);
@@ -1267,7 +1286,10 @@ async fn sealed_graph_writer_reports_native_work_through_journal_commit_boundary
     let observer: GraphNativeWorkObserverV1 = {
         let observed = Arc::clone(&observed);
         Arc::new(move |work| {
-            observed.lock().expect("native graph observation lock").push(work);
+            observed
+                .lock()
+                .expect("native graph observation lock")
+                .push(work);
         })
     };
     let first_snapshot = fixture
@@ -2119,7 +2141,9 @@ async fn concurrent_sealed_publishers_share_one_gate_and_converge_on_one_head()
         .lock()
         .expect("hold the publication gate");
     let outcome = std::thread::scope(|scope| {
-        let worker = scope.spawn(|| reconcile.publish_verified_snapshot_with_admission(Arc::clone(&cancelled), None, None));
+        let worker = scope.spawn(|| {
+            reconcile.publish_verified_snapshot_with_admission(Arc::clone(&cancelled), None, None)
+        });
         cancelled.store(true, Ordering::Release);
         drop(held);
         worker.join().expect("join the cancelled publisher")
@@ -2131,10 +2155,20 @@ async fn concurrent_sealed_publishers_share_one_gate_and_converge_on_one_head()
     // generation concurrently: the loser waits out the winner, then resumes
     // the winner's exact publication instead of conflicting.
     let (seat_outcome, reconcile_outcome) = std::thread::scope(|scope| {
-        let seat_worker =
-            scope.spawn(|| seat.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None));
-        let reconcile_worker =
-            scope.spawn(|| reconcile.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None));
+        let seat_worker = scope.spawn(|| {
+            seat.publish_verified_snapshot_with_admission(
+                Arc::new(AtomicBool::new(false)),
+                None,
+                None,
+            )
+        });
+        let reconcile_worker = scope.spawn(|| {
+            reconcile.publish_verified_snapshot_with_admission(
+                Arc::new(AtomicBool::new(false)),
+                None,
+                None,
+            )
+        });
         (
             seat_worker.join().expect("join the seat publisher"),
             reconcile_worker
@@ -2324,7 +2358,8 @@ async fn sealed_publication_refuses_over_the_resident_memory_watermark() {
 
     set_sample(&sample, pressure.low_watermark_bytes());
     let not_cancelled = Arc::new(AtomicBool::new(false));
-    let refused = runtime.publish_verified_snapshot_with_admission(Arc::clone(&not_cancelled), None, None);
+    let refused =
+        runtime.publish_verified_snapshot_with_admission(Arc::clone(&not_cancelled), None, None);
     // The projection peak is process-global and other cases reset it; this
     // cell's own sampler is what saw the crossing.
     assert!(
@@ -3061,7 +3096,11 @@ async fn concurrent_worktree_scopes_publish_with_one_corpus_build_and_bounded_rs
             workers.push(thread_scope.spawn(move || {
                 worker_barrier.wait();
                 let started = Instant::now();
-                let result = runtime.publish_verified_snapshot_with_admission(Arc::new(AtomicBool::new(false)), None, None);
+                let result = runtime.publish_verified_snapshot_with_admission(
+                    Arc::new(AtomicBool::new(false)),
+                    None,
+                    None,
+                );
                 let elapsed_ms =
                     u64::try_from(started.elapsed().as_millis()).expect("publish milliseconds");
                 (scope_index, result, elapsed_ms)
diff --git a/crates/tracedecay-store/src/lib.rs b/crates/tracedecay-store/src/lib.rs
index e062bc5327c..d7da1868a8a 100644
--- a/crates/tracedecay-store/src/lib.rs
+++ b/crates/tracedecay-store/src/lib.rs
@@ -181,10 +181,10 @@ pub use runtime::{
     FOREGROUND_BATCH_MAX_BYTES, FOREGROUND_BATCH_MAX_OPERATIONS, FactReadOperationV1,
     FactReadResultV1, FrozenWatermarkCoverageV1, FrozenWatermarkVectorV1, GlobalQueueProfileV1,
     GraphCanonicalReplaySourceDigestV1, GraphDependencyGenerationClosureDigestV1,
-    GraphDependencyGenerationIdentityV1, GraphGenerationIdV1, GraphNamespaceV1, GraphNodeV1,
+    GraphDependencyGenerationIdentityV1, GraphGenerationIdV1, GraphNamespaceV1,
+    GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1, GraphNodeV1,
     GraphPendingReplayDiscardOutcomeV1, GraphPendingReplayDiscardV1, GraphProjectionIdV1,
     GraphProjectionIdentityV1, GraphPublicationIdempotencyKeyV1, GraphPublicationInputDigestV1,
-    GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
     GraphPublicationKeyV1, GraphPublicationOperationContextV1,
     GraphPublicationProjectionPageRequestV1, GraphPublicationProjectionPageV1,
     GraphPublicationReplayCursorV1, GraphPublicationReplayLookupV1,
diff --git a/crates/tracedecay-store/src/runtime/graph_publication.rs b/crates/tracedecay-store/src/runtime/graph_publication.rs
index 14b00297557..b3c27d007bc 100644
--- a/crates/tracedecay-store/src/runtime/graph_publication.rs
+++ b/crates/tracedecay-store/src/runtime/graph_publication.rs
@@ -24,7 +24,8 @@ pub use cleanup::{
 mod operation;
 pub use operation::{
     GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
-    GraphPublicationOperationContextV1, GraphPublicationStoreErrorV1, GraphPublicationStoreResultV1,
+    GraphPublicationOperationContextV1, GraphPublicationStoreErrorV1,
+    GraphPublicationStoreResultV1,
 };
 #[path = "graph_publication/store.rs"]
 mod store;
diff --git a/crates/tracedecay-store/src/runtime/mod.rs b/crates/tracedecay-store/src/runtime/mod.rs
index 41fbd7e5c9a..c33ace4a09e 100644
--- a/crates/tracedecay-store/src/runtime/mod.rs
+++ b/crates/tracedecay-store/src/runtime/mod.rs
@@ -32,9 +32,9 @@ pub use error::{
 pub use graph_publication::{
     GraphCanonicalReplaySourceDigestV1, GraphDependencyGenerationClosureDigestV1,
     GraphDependencyGenerationIdentityV1, GraphGenerationIdV1, GraphNamespaceV1,
+    GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
     GraphPendingReplayDiscardOutcomeV1, GraphPendingReplayDiscardV1, GraphProjectionIdV1,
     GraphProjectionIdentityV1, GraphPublicationIdempotencyKeyV1, GraphPublicationInputDigestV1,
-    GraphNativeWorkKindV1, GraphNativeWorkObserverV1, GraphNativeWorkV1,
     GraphPublicationKeyV1, GraphPublicationOperationContextV1,
     GraphPublicationProjectionPageRequestV1, GraphPublicationProjectionPageV1,
     GraphPublicationReplayCursorV1, GraphPublicationReplayLookupV1,
diff --git a/crates/tracedecay/tests/daemon_suite/git_watch_test.rs b/crates/tracedecay/tests/daemon_suite/git_watch_test.rs
index 5b2d42face2..b5f986bb9ec 100644
--- a/crates/tracedecay/tests/daemon_suite/git_watch_test.rs
+++ b/crates/tracedecay/tests/daemon_suite/git_watch_test.rs
@@ -428,19 +428,28 @@ async fn cold_and_restarted_daemon_status_retains_actual_native_graph_writes() {
     let first = wait_for_symbol(&harness, &project, "refs/heads/main", None, "on_main").await;
     let cold = status(&harness, &project).await;
     let native = &cold["code_index_freshness"]["worktree"]["native_graph_progress"];
-    assert_eq!(native["generation_id"], first, "cold publication owner: {cold}");
+    assert_eq!(
+        native["generation_id"], first,
+        "cold publication owner: {cold}"
+    );
     assert_eq!(native["committed_compact_segments"], 1, "{cold}");
     assert_eq!(native["active"], false, "{cold}");
     assert!(
-        native["encoded_entities"].as_u64().is_some_and(|count| count > 0),
+        native["encoded_entities"]
+            .as_u64()
+            .is_some_and(|count| count > 0),
         "the actual direct writer must report nonzero accepted entity rows: {cold}"
     );
     assert!(
-        native["committed_compact_bytes"].as_u64().is_some_and(|bytes| bytes > 0),
+        native["committed_compact_bytes"]
+            .as_u64()
+            .is_some_and(|bytes| bytes > 0),
         "only a real installed, digest-verified container is a commit: {cold}"
     );
     assert!(
-        native["last_progress_micros"].as_i64().is_some_and(|when| when > 0),
+        native["last_progress_micros"]
+            .as_i64()
+            .is_some_and(|when| when > 0),
         "read-side readiness must not replace the native writer clock: {cold}"
     );
     let original_digest = native["sealed_graph_digest"].clone();
@@ -452,10 +461,16 @@ async fn cold_and_restarted_daemon_status_retains_actual_native_graph_writes() {
         .await
         .expect("restart the real project composition");
     let retained = wait_for_symbol(&harness, &project, "refs/heads/main", None, "on_main").await;
-    assert_eq!(retained, first, "a read-only restart must retain the first seal");
+    assert_eq!(
+        retained, first,
+        "a read-only restart must retain the first seal"
+    );
 
-    fs::write(project.join("src/successor.rs"), "pub fn successor_after_restart() {}\n")
-        .expect("write changed source");
+    fs::write(
+        project.join("src/successor.rs"),
+        "pub fn successor_after_restart() {}\n",
+    )
+    .expect("write changed source");
     commit_all(&project, "successor after restart");
     request_refresh(&harness, &project).await;
     let successor = wait_for_symbol(
@@ -472,7 +487,9 @@ async fn cold_and_restarted_daemon_status_retains_actual_native_graph_writes() {
     assert_ne!(native["sealed_graph_digest"], original_digest, "{latest}");
     assert_eq!(native["committed_compact_segments"], 1, "{latest}");
     assert!(
-        native["committed_compact_bytes"].as_u64().is_some_and(|bytes| bytes > 0),
+        native["committed_compact_bytes"]
+            .as_u64()
+            .is_some_and(|bytes| bytes > 0),
         "successor must emit its own verified native commit: {latest}"
     );
     harness.shutdown().await;
diff --git a/crates/tracedecay/tests/daemon_suite/indexing_lifecycle_test.rs b/crates/tracedecay/tests/daemon_suite/indexing_lifecycle_test.rs
index 5344cae052a..e001fa5798e 100644
--- a/crates/tracedecay/tests/daemon_suite/indexing_lifecycle_test.rs
+++ b/crates/tracedecay/tests/daemon_suite/indexing_lifecycle_test.rs
@@ -344,7 +344,9 @@ async fn hard_killed_cold_preseal_attempt_recovers_a_verified_native_graph() {
             let attempt = &receipt["code_index_freshness"]["worktree"]["preseal_attempt"];
             if attempt["active"] == true
                 && attempt["phase"] == "parse_evidence"
-                && attempt["completed_items"].as_u64().is_some_and(|count| count > 0)
+                && attempt["completed_items"]
+                    .as_u64()
+                    .is_some_and(|count| count > 0)
             {
                 return receipt;
             }
@@ -380,13 +382,15 @@ async fn hard_killed_cold_preseal_attempt_recovers_a_verified_native_graph() {
     );
     let repeat = status(&socket, &handshake).await;
     assert_eq!(
-        repeat["code_index_freshness"]["worktree"]["preseal_attempt"],
-        *attempt,
+        repeat["code_index_freshness"]["worktree"]["preseal_attempt"], *attempt,
         "status polling under a paused producer must not invent new work"
     );
 
     let killed = daemon.kill_and_wait().expect("hard-kill the cold daemon");
-    assert!(!killed.success(), "cold interruption must be a real process kill");
+    assert!(
+        !killed.success(),
+        "cold interruption must be a real process kill"
+    );
 
     // The hold is deliberately not propagated to the new daemon. It has to
     // capture, parse, seal, and publish from the surviving real Git tree.

From 0651f1dbed2dd6d96e64bd7822b03b82c6cd7358 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 12:45:18 -0800
Subject: [PATCH 33/80] fix(code-index): accept borrowed resolution index
 segments

---
 crates/tracedecay-code-index/src/production/sparse_successor.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/tracedecay-code-index/src/production/sparse_successor.rs b/crates/tracedecay-code-index/src/production/sparse_successor.rs
index 2168b53e220..02e07d4ed9c 100644
--- a/crates/tracedecay-code-index/src/production/sparse_successor.rs
+++ b/crates/tracedecay-code-index/src/production/sparse_successor.rs
@@ -988,7 +988,7 @@ pub(super) fn resolve_staged_generation(
     let resolution_index = super::resolution_index::seal_resolution_index_charged(
         &facts,
         &mut |workspace| retain_facts(count(phase_base)?.saturating_add(workspace)),
-        &mut |segment| {
+        |segment: SealedGenerationSegmentPublicationV1<'_>| {
             publish(segment)?;
             // An accepted resolution-index segment is genuine staged work,
             // not a committed native graph page or a status-read heartbeat.

From 0bd6df1506d0f75d6d960e48382cbfd4d9f71391 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 12:52:45 -0800
Subject: [PATCH 34/80] fix(dashboard): surface live code-index attempt
 progress

---
 .../schemas/dashboard-contracts.schema.json   | 225 ++++++++++++++++++
 dashboard/src/contracts/decoders.ts           |  79 ++++++
 dashboard/src/contracts/types.ts              |  39 +++
 .../code/IndexFreshness.dom.test.tsx          |  21 ++
 .../src/workspaces/code/IndexFreshness.tsx    |  15 +-
 .../CodeIndexPipeline.dom.test.tsx            |  14 ++
 .../observatory/CodeIndexPipeline.tsx         |  44 +++-
 sdks/typescript/src/operations.ts             |  14 +-
 8 files changed, 443 insertions(+), 8 deletions(-)

diff --git a/dashboard/codegen/schemas/dashboard-contracts.schema.json b/dashboard/codegen/schemas/dashboard-contracts.schema.json
index 1d35e5924b2..c4a0789464d 100644
--- a/dashboard/codegen/schemas/dashboard-contracts.schema.json
+++ b/dashboard/codegen/schemas/dashboard-contracts.schema.json
@@ -4459,6 +4459,138 @@
       ],
       "type": "object"
     },
+    "CodeIndexNativeGraphPhaseV1": {
+      "description": "Native graph writer progress is independent of text-artifact commit counts.\nEncoded rows are physical work, never a durable page. Stage-page commits\nand installed + digest-verified compact segments are durable work.",
+      "enum": [
+        "compact_encoding",
+        "stage_page_commit",
+        "compact_segment_verified"
+      ],
+      "type": "string"
+    },
+    "CodeIndexNativeGraphProgressV1": {
+      "properties": {
+        "active": {
+          "type": "boolean"
+        },
+        "attempt_sequence": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "committed_compact_bytes": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "committed_compact_segments": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "committed_stage_bytes": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "committed_stage_mutations": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "committed_stage_pages": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "daemon_incarnation": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "encoded_entities": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "encoded_relations": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "generation_id": {
+          "type": "string"
+        },
+        "last_progress_micros": {
+          "description": "The time of the last actual native writer callback, not a status read.",
+          "format": "int64",
+          "type": [
+            "integer",
+            "null"
+          ]
+        },
+        "phase": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/CodeIndexNativeGraphPhaseV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "producer_incarnation": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "progress_epoch": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "sealed_graph_digest": {
+          "type": "string"
+        },
+        "total_entities": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": [
+            "integer",
+            "null"
+          ]
+        },
+        "total_relations": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": [
+            "integer",
+            "null"
+          ]
+        }
+      },
+      "required": [
+        "generation_id",
+        "sealed_graph_digest",
+        "daemon_incarnation",
+        "producer_incarnation",
+        "attempt_sequence",
+        "progress_epoch",
+        "phase",
+        "encoded_entities",
+        "total_entities",
+        "encoded_relations",
+        "total_relations",
+        "committed_stage_pages",
+        "committed_stage_mutations",
+        "committed_stage_bytes",
+        "committed_compact_segments",
+        "committed_compact_bytes",
+        "last_progress_micros",
+        "active"
+      ],
+      "type": "object"
+    },
     "CodeIndexOmittedSourceV1": {
       "properties": {
         "display_path": {
@@ -4509,6 +4641,79 @@
       ],
       "type": "object"
     },
+    "CodeIndexPresealAttemptProgressV1": {
+      "description": "Independently owned attempt work, not committed text or graph pages.",
+      "properties": {
+        "active": {
+          "type": "boolean"
+        },
+        "attempt_sequence": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "completed_items": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "daemon_incarnation": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "last_progress_micros": {
+          "description": "No timestamp is invented before actual work or by status polling.",
+          "format": "int64",
+          "type": [
+            "integer",
+            "null"
+          ]
+        },
+        "phase": {
+          "$ref": "#/$defs/CodeIndexPresealWorkPhaseV1"
+        },
+        "producer_incarnation": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "progress_epoch": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": "integer"
+        },
+        "total_items": {
+          "format": "uint64",
+          "minimum": 0,
+          "type": [
+            "integer",
+            "null"
+          ]
+        }
+      },
+      "required": [
+        "daemon_incarnation",
+        "producer_incarnation",
+        "attempt_sequence",
+        "progress_epoch",
+        "phase",
+        "completed_items",
+        "total_items",
+        "last_progress_micros",
+        "active"
+      ],
+      "type": "object"
+    },
+    "CodeIndexPresealWorkPhaseV1": {
+      "description": "Observed capture, parse, and source-reference resolution before sealing.",
+      "enum": [
+        "capture",
+        "parse_evidence",
+        "resolution"
+      ],
+      "type": "string"
+    },
     "CodeIndexRestoreProgressV1": {
       "description": "Bounded authentication work required to restore one immutable lexical\nartifact as a serving reader.\n\nThe unit is a fixed restore check, not bytes or build work. Completed\nchecks are published only after they pass. `authenticated_remaining` is\nalways `authenticated_total - authenticated_completed`, so a caller can\ndistinguish bounded cold restore from an unbounded rebuild.",
       "properties": {
@@ -4791,6 +4996,16 @@
             "null"
           ]
         },
+        "native_graph_progress": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/CodeIndexNativeGraphProgressV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "omitted_sources": {
           "anyOf": [
             {
@@ -4813,6 +5028,16 @@
           ],
           "description": "Deterministic contract violation currently parking background\nconvergence, when one is observed. `staleness_state` reads `parked`\nwhile this is set and no generation serves."
         },
+        "preseal_attempt": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/CodeIndexPresealAttemptProgressV1"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
         "progress": {
           "anyOf": [
             {
diff --git a/dashboard/src/contracts/decoders.ts b/dashboard/src/contracts/decoders.ts
index 09eca2a5d7c..23cd6d8274b 100644
--- a/dashboard/src/contracts/decoders.ts
+++ b/dashboard/src/contracts/decoders.ts
@@ -133,8 +133,12 @@ import type {
   CodeIndexGenerationRecoveryServingV1,
   CodeIndexGenerationRecoveryV1,
   CodeIndexMountFailureV1,
+  CodeIndexNativeGraphPhaseV1,
+  CodeIndexNativeGraphProgressV1,
   CodeIndexOmittedSourcesV1,
   CodeIndexOmittedSourceV1,
+  CodeIndexPresealAttemptProgressV1,
+  CodeIndexPresealWorkPhaseV1,
   CodeIndexRestoreProgressV1,
   CodeIndexRouteRefusalV1,
   CodeIndexSourceOmissionReasonV1,
@@ -2603,6 +2607,51 @@ export const CodeIndexMountFailureV1Schema: z.ZodObject<{
   remediation: z.string(),
 });
 
+/** Native graph writer progress is independent of text-artifact commit counts.
+Encoded rows are physical work, never a durable page. Stage-page commits
+and installed + digest-verified compact segments are durable work. */
+export const CodeIndexNativeGraphPhaseV1Schema: z.ZodEnum<{ "compact_encoding": "compact_encoding"; "compact_segment_verified": "compact_segment_verified"; "stage_page_commit": "stage_page_commit" }> = z.enum(["compact_encoding", "compact_segment_verified", "stage_page_commit"]);
+
+export const CodeIndexNativeGraphProgressV1Schema: z.ZodObject<{
+  active: z.ZodType<boolean, unknown>;
+  attempt_sequence: z.ZodType<number, unknown>;
+  committed_compact_bytes: z.ZodType<number, unknown>;
+  committed_compact_segments: z.ZodType<number, unknown>;
+  committed_stage_bytes: z.ZodType<number, unknown>;
+  committed_stage_mutations: z.ZodType<number, unknown>;
+  committed_stage_pages: z.ZodType<number, unknown>;
+  daemon_incarnation: z.ZodType<number, unknown>;
+  encoded_entities: z.ZodType<number, unknown>;
+  encoded_relations: z.ZodType<number, unknown>;
+  generation_id: z.ZodType<string, unknown>;
+  last_progress_micros: z.ZodType<number | null, unknown>;
+  phase: z.ZodType<CodeIndexNativeGraphPhaseV1 | null, unknown>;
+  producer_incarnation: z.ZodType<number, unknown>;
+  progress_epoch: z.ZodType<number, unknown>;
+  sealed_graph_digest: z.ZodType<string, unknown>;
+  total_entities: z.ZodType<number | null, unknown>;
+  total_relations: z.ZodType<number | null, unknown>;
+}> = z.object({
+  active: z.boolean(),
+  attempt_sequence: z.number().int().min(0),
+  committed_compact_bytes: z.number().int().min(0),
+  committed_compact_segments: z.number().int().min(0),
+  committed_stage_bytes: z.number().int().min(0),
+  committed_stage_mutations: z.number().int().min(0),
+  committed_stage_pages: z.number().int().min(0),
+  daemon_incarnation: z.number().int().min(0),
+  encoded_entities: z.number().int().min(0),
+  encoded_relations: z.number().int().min(0),
+  generation_id: z.string(),
+  last_progress_micros: z.number().int().nullable(),
+  phase: z.union([z.lazy(() => CodeIndexNativeGraphPhaseV1Schema), z.null()]),
+  producer_incarnation: z.number().int().min(0),
+  progress_epoch: z.number().int().min(0),
+  sealed_graph_digest: z.string(),
+  total_entities: z.number().int().min(0).nullable(),
+  total_relations: z.number().int().min(0).nullable(),
+});
+
 /** Sources a sealed snapshot captured but does not index. */
 export const CodeIndexOmittedSourcesV1Schema: z.ZodObject<{
   count: z.ZodType<number, unknown>;
@@ -2622,6 +2671,32 @@ export const CodeIndexOmittedSourceV1Schema: z.ZodObject<{
   reason: z.lazy(() => CodeIndexSourceOmissionReasonV1Schema),
 });
 
+/** Independently owned attempt work, not committed text or graph pages. */
+export const CodeIndexPresealAttemptProgressV1Schema: z.ZodObject<{
+  active: z.ZodType<boolean, unknown>;
+  attempt_sequence: z.ZodType<number, unknown>;
+  completed_items: z.ZodType<number, unknown>;
+  daemon_incarnation: z.ZodType<number, unknown>;
+  last_progress_micros: z.ZodType<number | null, unknown>;
+  phase: z.ZodType<CodeIndexPresealWorkPhaseV1, unknown>;
+  producer_incarnation: z.ZodType<number, unknown>;
+  progress_epoch: z.ZodType<number, unknown>;
+  total_items: z.ZodType<number | null, unknown>;
+}> = z.object({
+  active: z.boolean(),
+  attempt_sequence: z.number().int().min(0),
+  completed_items: z.number().int().min(0),
+  daemon_incarnation: z.number().int().min(0),
+  last_progress_micros: z.number().int().nullable(),
+  phase: z.lazy(() => CodeIndexPresealWorkPhaseV1Schema),
+  producer_incarnation: z.number().int().min(0),
+  progress_epoch: z.number().int().min(0),
+  total_items: z.number().int().min(0).nullable(),
+});
+
+/** Observed capture, parse, and source-reference resolution before sealing. */
+export const CodeIndexPresealWorkPhaseV1Schema: z.ZodEnum<{ "capture": "capture"; "parse_evidence": "parse_evidence"; "resolution": "resolution" }> = z.enum(["capture", "parse_evidence", "resolution"]);
+
 /** Bounded authentication work required to restore one immutable lexical
 artifact as a serving reader.
 
@@ -2720,8 +2795,10 @@ export const CodeIndexWorktreeFreshnessV1Schema: z.ZodObject<{
   hook_hint_count: z.ZodType<number | null, unknown>;
   last_reconcile_micros: z.ZodType<number | null, unknown>;
   latest_generation_id: z.ZodType<string | null, unknown>;
+  native_graph_progress: z.ZodOptional<z.ZodType<CodeIndexNativeGraphProgressV1 | null, unknown>>;
   omitted_sources: z.ZodOptional<z.ZodType<CodeIndexOmittedSourcesV1 | null, unknown>>;
   parked: z.ZodType<CodeIndexConvergenceParkedV1 | null, unknown>;
+  preseal_attempt: z.ZodOptional<z.ZodType<CodeIndexPresealAttemptProgressV1 | null, unknown>>;
   progress: z.ZodType<CodeIndexBuildProgressV1 | null, unknown>;
   rebuild_in_flight: z.ZodType<boolean, unknown>;
   repository_id: z.ZodType<string | null, unknown>;
@@ -2741,8 +2818,10 @@ export const CodeIndexWorktreeFreshnessV1Schema: z.ZodObject<{
   hook_hint_count: z.number().int().min(0).nullable(),
   last_reconcile_micros: z.number().int().nullable(),
   latest_generation_id: z.string().nullable(),
+  native_graph_progress: z.union([z.lazy(() => CodeIndexNativeGraphProgressV1Schema), z.null()]).optional(),
   omitted_sources: z.union([z.lazy(() => CodeIndexOmittedSourcesV1Schema), z.null()]).optional(),
   parked: z.union([z.lazy(() => CodeIndexConvergenceParkedV1Schema), z.null()]),
+  preseal_attempt: z.union([z.lazy(() => CodeIndexPresealAttemptProgressV1Schema), z.null()]).optional(),
   progress: z.union([z.lazy(() => CodeIndexBuildProgressV1Schema), z.null()]),
   rebuild_in_flight: z.boolean(),
   repository_id: z.string().nullable(),
diff --git a/dashboard/src/contracts/types.ts b/dashboard/src/contracts/types.ts
index 649013d24d8..45c3b6f4b3c 100644
--- a/dashboard/src/contracts/types.ts
+++ b/dashboard/src/contracts/types.ts
@@ -978,6 +978,29 @@ export type CodeIndexMountFailureV1 = {
   remediation: string;
 };
 
+export type CodeIndexNativeGraphPhaseV1 = "compact_encoding" | "compact_segment_verified" | "stage_page_commit";
+
+export type CodeIndexNativeGraphProgressV1 = {
+  active: boolean;
+  attempt_sequence: number;
+  committed_compact_bytes: number;
+  committed_compact_segments: number;
+  committed_stage_bytes: number;
+  committed_stage_mutations: number;
+  committed_stage_pages: number;
+  daemon_incarnation: number;
+  encoded_entities: number;
+  encoded_relations: number;
+  generation_id: string;
+  last_progress_micros: number | null;
+  phase: CodeIndexNativeGraphPhaseV1 | null;
+  producer_incarnation: number;
+  progress_epoch: number;
+  sealed_graph_digest: string;
+  total_entities: number | null;
+  total_relations: number | null;
+};
+
 export type CodeIndexOmittedSourcesV1 = {
   count: number;
   sources: Array<CodeIndexOmittedSourceV1>;
@@ -989,6 +1012,20 @@ export type CodeIndexOmittedSourceV1 = {
   reason: CodeIndexSourceOmissionReasonV1;
 };
 
+export type CodeIndexPresealAttemptProgressV1 = {
+  active: boolean;
+  attempt_sequence: number;
+  completed_items: number;
+  daemon_incarnation: number;
+  last_progress_micros: number | null;
+  phase: CodeIndexPresealWorkPhaseV1;
+  producer_incarnation: number;
+  progress_epoch: number;
+  total_items: number | null;
+};
+
+export type CodeIndexPresealWorkPhaseV1 = "capture" | "parse_evidence" | "resolution";
+
 export type CodeIndexRestoreProgressV1 = {
   artifact_digest: string;
   authenticated_completed: number;
@@ -1047,8 +1084,10 @@ export type CodeIndexWorktreeFreshnessV1 = {
   hook_hint_count: number | null;
   last_reconcile_micros: number | null;
   latest_generation_id: string | null;
+  native_graph_progress?: CodeIndexNativeGraphProgressV1 | null | undefined;
   omitted_sources?: CodeIndexOmittedSourcesV1 | null | undefined;
   parked: CodeIndexConvergenceParkedV1 | null;
+  preseal_attempt?: CodeIndexPresealAttemptProgressV1 | null | undefined;
   progress: CodeIndexBuildProgressV1 | null;
   rebuild_in_flight: boolean;
   repository_id: string | null;
diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index fcfe173f56f..69872062ad9 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -130,6 +130,27 @@ describe('Code index freshness', () => {
     expect(text).toContain('240ms');
   });
 
+  it('distinguishes native rows encoded from pages and segments committed', async () => {
+    renderFreshness('loading', {
+      worktrees: [{
+        ...worktree(),
+        native_graph_progress: {
+          generation_id: 'generation.4f21c9',
+          sealed_graph_digest: 'sha256:graph',
+          daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 3, progress_epoch: 4,
+          phase: 'stage_page_commit', active: true, last_progress_micros: NOW_MICROS,
+          encoded_entities: 90, total_entities: 100, encoded_relations: 40, total_relations: 50,
+          committed_stage_pages: 2, committed_stage_mutations: 70, committed_stage_bytes: 4096,
+          committed_compact_segments: 0, committed_compact_bytes: 0,
+        },
+      }],
+      note: 'daemon scheduler state',
+    });
+    expect(await screen.findByText(
+      'stage page commit · 90 entities encoded · 40 relations encoded · 2 pages committed · 0 segments committed',
+    )).toBeTruthy();
+  });
+
   it('renders bounded artifact restore progress separately from a rebuild', async () => {
     renderFreshness('loading', {
       worktrees: [
diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index 221f6d456a0..73f4fab87e1 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -37,11 +37,13 @@ import { authorizationState } from '../../ui/EnvelopeTruth.tsx';
 import { StateChip } from '../../ui/StateChip.tsx';
 import { elideStart, formatCount, formatMicrosUtc } from '../../ui/format.ts';
 import {
+  CodeIndexAttemptReading,
   CodeIndexMountFailureNotice,
   codeIndexBlockedReasonLabel,
   codeIndexPhaseLabel,
   codeIndexProgressPercentage,
   formatDurationMicros,
+  hasLiveWorktreeProgress,
   isCurrentOrNewerCodeIndexProgress,
 } from '../observatory/CodeIndexPipeline.tsx';
 import { formatBytes } from '../observatory/storageModel.ts';
@@ -162,6 +164,7 @@ function WorktreeReading({
       {progress ? (
         <BuildProgressReading progress={progress} observedAtMicros={observedAtMicros} />
       ) : null}
+      <CodeIndexAttemptReading worktree={worktree} />
       {worktree.restore_progress ? (
         <div className="border-b border-edge-subtle pb-1.5 text-3xs leading-snug">
           <div className="flex items-baseline justify-between gap-2">
@@ -321,6 +324,7 @@ function worktreeHasActiveBuild(worktree: CodeIndexWorktreeFreshnessV1): boolean
     worktree.latest_generation_id == null && worktree.staleness_state === 'indexing';
   if (
     !worktree.rebuild_in_flight &&
+    !hasLiveWorktreeProgress(worktree) &&
     worktree.staleness_state !== 'verifying' &&
     worktree.staleness_state !== 'restoring' &&
     !initialIndexing
@@ -339,9 +343,14 @@ function allActiveBuildsQuiet(
   const observedAt = result.envelope.time.observation_time_micros;
   return result.envelope.payload.worktrees.every((worktree) => {
     if (!worktreeHasActiveBuild(worktree)) return true;
-    const progress = worktree.progress;
-    if (progress == null) return false;
-    return observedAt - progress.last_progress_micros >= QUIET_AFTER_SECONDS * 1_000_000;
+    const lastUpdates = [
+      ...(worktree.preseal_attempt?.active ? [worktree.preseal_attempt.last_progress_micros] : []),
+      ...(worktree.native_graph_progress?.active ? [worktree.native_graph_progress.last_progress_micros] : []),
+      ...(worktree.progress ? [worktree.progress.last_progress_micros] : []),
+    ];
+    return lastUpdates.length > 0 && lastUpdates.every(
+      (stamp) => stamp != null && observedAt - stamp >= QUIET_AFTER_SECONDS * 1_000_000,
+    );
   });
 }
 
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index bc61e12ca98..eb57f1ca9e7 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -1,5 +1,6 @@
 import { cleanup, render, screen } from '@testing-library/react';
 import { afterEach, describe, expect, it } from 'vitest';
+import { CodeIndexFreshnessPayloadV1Schema } from '../../contracts/generated.ts';
 import type {
   CodeIndexBuildProgressV1,
   CodeIndexFreshnessPayloadV1,
@@ -118,6 +119,19 @@ const restoreProgress = {
 afterEach(cleanup);
 
 describe('code-index activity polling', () => {
+  it('shows pre-seal work before the first text page commits', () => {
+    const result = freshness({ preseal_attempt: {
+      daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 3,
+      progress_epoch: 4, phase: 'resolution', completed_items: 7,
+      total_items: null, last_progress_micros: OBSERVED_AT, active: true,
+    } });
+    result.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(result.envelope.payload);
+    expect(hasActiveCodeIndexBuild(result)).toBe(true);
+    render(<CodeIndexPipeline result={result} pending={false} scopeKey="project" />);
+    expect(screen.getByText('resolution · 7 items')).toBeTruthy();
+    expect(screen.queryByText('no active code-index build')).toBeNull();
+  });
+
   it('keeps polling an in-flight rebuild before its first committed report', () => {
     expect(hasActiveCodeIndexBuild(freshness({ rebuild_in_flight: true }))).toBe(true);
   });
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index 571d7eb4d38..58dc453672a 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -73,7 +73,7 @@ export function CodeIndexPipeline({
         </div>
       ) : null}
       {progress.length === 0 ? (
-        worktrees.some((worktree) => worktree.restore_progress != null) ? null : (
+        worktrees.some(hasLiveWorktreeProgress) ? null : (
           <p className="mt-2 text-body text-text-muted">
             {worktrees.some((worktree) => worktree.rebuild_in_flight)
               ? 'code-index build in progress; progress not yet reported'
@@ -132,12 +132,52 @@ function CodeIndexReadinessList({
               {graphServingLabel(worktree.code_graph_serving)}
             </dd>
           </dl>
+          <CodeIndexAttemptReading worktree={worktree} />
         </li>
       ))}
     </ul>
   );
 }
 
+export function CodeIndexAttemptReading({ worktree }: { worktree: CodeIndexWorktreeFreshnessV1 }) {
+  const attempt = worktree.preseal_attempt;
+  const graph = worktree.native_graph_progress;
+  if (!attempt?.active && !graph?.active) return null;
+  return (
+    <dl className="grid grid-cols-2 gap-x-4 gap-y-1 text-sm">
+      {attempt?.active && (
+        <>
+          <dt className="text-text-muted">Before sealing</dt>
+          <dd className="text-right text-text-secondary">
+            {attempt.phase.replaceAll('_', ' ')} · {formatCount(attempt.completed_items)}
+            {attempt.total_items != null && ` / ${formatCount(attempt.total_items)}`} items
+          </dd>
+        </>
+      )}
+      {graph?.active && (
+        <>
+          <dt className="text-text-muted">Graph writer</dt>
+          <dd className="text-right text-text-secondary">
+            {graph.phase?.replaceAll('_', ' ') ?? 'awaiting first update'} ·{' '}
+            {formatCount(graph.encoded_entities)} entities encoded ·{' '}
+            {formatCount(graph.encoded_relations)} relations encoded ·{' '}
+            {formatCount(graph.committed_stage_pages)} pages committed ·{' '}
+            {formatCount(graph.committed_compact_segments)} segments committed
+          </dd>
+        </>
+      )}
+    </dl>
+  );
+}
+
+export function hasLiveWorktreeProgress(worktree: CodeIndexWorktreeFreshnessV1): boolean {
+  return (
+    worktree.restore_progress != null ||
+    worktree.preseal_attempt?.active === true ||
+    worktree.native_graph_progress?.active === true
+  );
+}
+
 function lexicalReadinessLabel(worktree: CodeIndexWorktreeFreshnessV1): string {
   if (!worktree.latest_generation_id) return 'unavailable';
   return worktree.staleness_state ?? 'unknown';
@@ -233,7 +273,7 @@ export function hasActiveCodeIndexBuild(
       result.envelope.payload.worktrees.some(
         (worktree) =>
           worktree.rebuild_in_flight ||
-          worktree.restore_progress != null ||
+          hasLiveWorktreeProgress(worktree) ||
           (worktree.progress != null && worktree.progress.phase !== 'ready'),
       ))
   );
diff --git a/sdks/typescript/src/operations.ts b/sdks/typescript/src/operations.ts
index c2607556f05..ce5dc82ce35 100644
--- a/sdks/typescript/src/operations.ts
+++ b/sdks/typescript/src/operations.ts
@@ -205,8 +205,12 @@ export type CodeIndexConvergenceParkedV1 = { readonly blocked_reason?: CodeIndex
 export type CodeIndexFreshnessCoverageV1 = "unobserved" | "complete" | "partial_refresh_in_progress" | "partial_artifact_restore" | "partial_source_verification" | "partial_unverified_restore" | "partial_hook_hint_overflow" | "partial_omitted_sources";
 export type CodeIndexGenerationRecoveryServingV1 = "preserved" | "refused";
 export type CodeIndexGenerationRecoveryV1 = { readonly incompatibilities: readonly string[]; readonly incompatible_generation_id: string; readonly serving: CodeIndexGenerationRecoveryServingV1; readonly [key: string]: unknown };
+export type CodeIndexNativeGraphPhaseV1 = "compact_encoding" | "stage_page_commit" | "compact_segment_verified";
+export type CodeIndexNativeGraphProgressV1 = { readonly active: boolean; readonly attempt_sequence: number; readonly committed_compact_bytes: number; readonly committed_compact_segments: number; readonly committed_stage_bytes: number; readonly committed_stage_mutations: number; readonly committed_stage_pages: number; readonly daemon_incarnation: number; readonly encoded_entities: number; readonly encoded_relations: number; readonly generation_id: string; readonly last_progress_micros?: number | null; readonly phase?: CodeIndexNativeGraphPhaseV1 | null; readonly producer_incarnation: number; readonly progress_epoch: number; readonly sealed_graph_digest: string; readonly total_entities?: number | null; readonly total_relations?: number | null; readonly [key: string]: unknown };
 export type CodeIndexOmittedSourceV1 = { readonly display_path: string; readonly git_path_bytes: readonly number[]; readonly reason: CodeIndexSourceOmissionReasonV1; readonly [key: string]: unknown };
 export type CodeIndexOmittedSourcesV1 = { readonly count: number; readonly sources: readonly CodeIndexOmittedSourceV1[]; readonly [key: string]: unknown };
+export type CodeIndexPresealAttemptProgressV1 = { readonly active: boolean; readonly attempt_sequence: number; readonly completed_items: number; readonly daemon_incarnation: number; readonly last_progress_micros?: number | null; readonly phase: CodeIndexPresealWorkPhaseV1; readonly producer_incarnation: number; readonly progress_epoch: number; readonly total_items?: number | null; readonly [key: string]: unknown };
+export type CodeIndexPresealWorkPhaseV1 = "capture" | "parse_evidence" | "resolution";
 export type CodeIndexReadinessTargetV1 = "fresh" | "ready" | "graph_ready";
 export type CodeIndexReadinessWaitOutcomeV1 = { readonly outcome: "reached"; readonly [key: string]: unknown } | { readonly last_state: string; readonly outcome: "timed_out"; readonly [key: string]: unknown } | { readonly outcome: "unavailable"; readonly reason: string; readonly [key: string]: unknown };
 export type CodeIndexReadinessWaitV1 = { readonly state: CodeIndexReadinessTargetV1; readonly timeout_ms: number };
@@ -214,7 +218,7 @@ export type CodeIndexRestoreProgressV1 = { readonly artifact_digest: string; rea
 export type CodeIndexSourceOmissionReasonV1 = { readonly kind: "unrepresentable_path"; readonly [key: string]: unknown } | { readonly detail: string; readonly kind: "privacy_withheld"; readonly [key: string]: unknown };
 export type CodeIndexStalenessStateV1 = "fresh" | "stale" | "indexing" | "refreshing" | "restoring" | "verifying" | "parked";
 export type CodeIndexWorkerSelectionV1 = { readonly mode: "automatic" } | { readonly mode: "exact"; readonly workers: number };
-export type CodeIndexWorktreeFreshnessV1 = { readonly clone_index?: CodeCloneIndexStatusV1 | null; readonly code_graph_serving?: CodeGraphServingReadinessV1 | null; readonly coverage: CodeIndexFreshnessCoverageV1; readonly generation_recovery?: CodeIndexGenerationRecoveryV1 | null; readonly hook_hint_count?: number | null; readonly last_reconcile_micros?: number | null; readonly latest_generation_id?: string | null; readonly omitted_sources?: CodeIndexOmittedSourcesV1 | null; readonly parked?: CodeIndexConvergenceParkedV1 | null; readonly progress?: CodeIndexBuildProgressV1 | null; readonly rebuild_in_flight: boolean; readonly repository_id?: string | null; readonly restore_progress?: CodeIndexRestoreProgressV1 | null; readonly sealed_at_micros?: number | null; readonly snapshot_content_identity?: string | null; readonly source_reference?: string | null; readonly source_revision?: string | null; readonly staleness_state?: CodeIndexStalenessStateV1 | null; readonly worktree_id?: string | null; readonly worktree_root: string; readonly [key: string]: unknown };
+export type CodeIndexWorktreeFreshnessV1 = { readonly clone_index?: CodeCloneIndexStatusV1 | null; readonly code_graph_serving?: CodeGraphServingReadinessV1 | null; readonly coverage: CodeIndexFreshnessCoverageV1; readonly generation_recovery?: CodeIndexGenerationRecoveryV1 | null; readonly hook_hint_count?: number | null; readonly last_reconcile_micros?: number | null; readonly latest_generation_id?: string | null; readonly native_graph_progress?: CodeIndexNativeGraphProgressV1 | null; readonly omitted_sources?: CodeIndexOmittedSourcesV1 | null; readonly parked?: CodeIndexConvergenceParkedV1 | null; readonly preseal_attempt?: CodeIndexPresealAttemptProgressV1 | null; readonly progress?: CodeIndexBuildProgressV1 | null; readonly rebuild_in_flight: boolean; readonly repository_id?: string | null; readonly restore_progress?: CodeIndexRestoreProgressV1 | null; readonly sealed_at_micros?: number | null; readonly snapshot_content_identity?: string | null; readonly source_reference?: string | null; readonly source_revision?: string | null; readonly staleness_state?: CodeIndexStalenessStateV1 | null; readonly worktree_id?: string | null; readonly worktree_root: string; readonly [key: string]: unknown };
 export type CodeLexicalField = "symbol_name" | "qualified_name" | "path" | "signature" | "documentation" | "body_text" | "preamble_text" | "exact_term" | "subtoken";
 export type CodeLexicalFieldFilter = { readonly field: CodeLexicalField; readonly include: boolean };
 export type CodeOccurrenceRecord = { readonly chunk?: CodeSearchChunkId | null; readonly file: FileOccurrenceId; readonly path: string; readonly span: SourceSpan; readonly symbol?: SymbolOccurrenceId | null };
@@ -2008,8 +2012,12 @@ const DEFINITIONS = {
   CodeIndexFreshnessCoverageV1: {"description":"Coverage of one freshness read. Distinct from [`CodeIndexStalenessStateV1`]:\na generation can be fresh and still omit hook-hint counts, or unverified\nwhile the ladder would otherwise say ready.\n\n`Unobserved` is only the constructed default. A projected read never emits\nit, so an absent observation cannot be mistaken for `complete`.","oneOf":[{"enum":["unobserved","complete","partial_refresh_in_progress","partial_artifact_restore","partial_source_verification","partial_unverified_restore","partial_hook_hint_overflow"],"type":"string"},{"const":"partial_omitted_sources","description":"The sealed generation is fresh for every source it can index, and\n[`CodeIndexWorktreeFreshnessV1::omitted_sources`] names the sources it\ncannot. Waiting cannot change it.","type":"string"}]},
   CodeIndexGenerationRecoveryServingV1: {"description":"Serving disposition of an incompatible generation during recovery.","enum":["preserved","refused"],"type":"string"},
   CodeIndexGenerationRecoveryV1: {"description":"Recovery state for a durable generation sealed under a different production\nowner configuration.","properties":{"incompatibilities":{"description":"Stable owner-input reason codes reported by the code-index authority.","items":{"type":"string"},"type":"array"},"incompatible_generation_id":{"description":"Generation retired from incremental reuse.","type":"string"},"serving":{"$ref":"#/$defs/CodeIndexGenerationRecoveryServingV1","description":"Whether the prior generation may continue serving while its replacement\nbuilds under the current configuration."}},"required":["incompatible_generation_id","incompatibilities","serving"],"type":"object"},
+  CodeIndexNativeGraphPhaseV1: {"description":"Native graph writer progress is independent of text-artifact commit counts.\nEncoded rows are physical work, never a durable page. Stage-page commits\nand installed + digest-verified compact segments are durable work.","enum":["compact_encoding","stage_page_commit","compact_segment_verified"],"type":"string"},
+  CodeIndexNativeGraphProgressV1: {"properties":{"active":{"type":"boolean"},"attempt_sequence":{"format":"uint64","minimum":0,"type":"integer"},"committed_compact_bytes":{"format":"uint64","minimum":0,"type":"integer"},"committed_compact_segments":{"format":"uint64","minimum":0,"type":"integer"},"committed_stage_bytes":{"format":"uint64","minimum":0,"type":"integer"},"committed_stage_mutations":{"format":"uint64","minimum":0,"type":"integer"},"committed_stage_pages":{"format":"uint64","minimum":0,"type":"integer"},"daemon_incarnation":{"format":"uint64","minimum":0,"type":"integer"},"encoded_entities":{"format":"uint64","minimum":0,"type":"integer"},"encoded_relations":{"format":"uint64","minimum":0,"type":"integer"},"generation_id":{"type":"string"},"last_progress_micros":{"description":"The time of the last actual native writer callback, not a status read.","format":"int64","type":["integer","null"]},"phase":{"anyOf":[{"$ref":"#/$defs/CodeIndexNativeGraphPhaseV1"},{"type":"null"}]},"producer_incarnation":{"format":"uint64","minimum":0,"type":"integer"},"progress_epoch":{"format":"uint64","minimum":0,"type":"integer"},"sealed_graph_digest":{"type":"string"},"total_entities":{"format":"uint64","minimum":0,"type":["integer","null"]},"total_relations":{"format":"uint64","minimum":0,"type":["integer","null"]}},"required":["generation_id","sealed_graph_digest","daemon_incarnation","producer_incarnation","attempt_sequence","progress_epoch","encoded_entities","encoded_relations","committed_stage_pages","committed_stage_mutations","committed_stage_bytes","committed_compact_segments","committed_compact_bytes","active"],"type":"object"},
   CodeIndexOmittedSourceV1: {"properties":{"display_path":{"description":"`git_path_bytes` decoded for display, invalid UTF-8 replaced.","type":"string"},"git_path_bytes":{"description":"The exact Git path bytes, which need not be UTF-8.","items":{"format":"uint8","maximum":255,"minimum":0,"type":"integer"},"type":"array"},"reason":{"$ref":"#/$defs/CodeIndexSourceOmissionReasonV1"}},"required":["git_path_bytes","display_path","reason"],"type":"object"},
   CodeIndexOmittedSourcesV1: {"description":"Sources a sealed snapshot captured but does not index.","properties":{"count":{"description":"Every omitted source in the snapshot.","format":"uint64","minimum":0,"type":"integer"},"sources":{"description":"The first omitted sources in Git path order, at most\n[`CODE_INDEX_OMITTED_SOURCE_LIST_LIMIT`].","items":{"$ref":"#/$defs/CodeIndexOmittedSourceV1"},"type":"array"}},"required":["count","sources"],"type":"object"},
+  CodeIndexPresealAttemptProgressV1: {"description":"Independently owned attempt work, not committed text or graph pages.","properties":{"active":{"type":"boolean"},"attempt_sequence":{"format":"uint64","minimum":0,"type":"integer"},"completed_items":{"format":"uint64","minimum":0,"type":"integer"},"daemon_incarnation":{"format":"uint64","minimum":0,"type":"integer"},"last_progress_micros":{"description":"No timestamp is invented before actual work or by status polling.","format":"int64","type":["integer","null"]},"phase":{"$ref":"#/$defs/CodeIndexPresealWorkPhaseV1"},"producer_incarnation":{"format":"uint64","minimum":0,"type":"integer"},"progress_epoch":{"format":"uint64","minimum":0,"type":"integer"},"total_items":{"format":"uint64","minimum":0,"type":["integer","null"]}},"required":["daemon_incarnation","producer_incarnation","attempt_sequence","progress_epoch","phase","completed_items","active"],"type":"object"},
+  CodeIndexPresealWorkPhaseV1: {"description":"Observed capture, parse, and source-reference resolution before sealing.","enum":["capture","parse_evidence","resolution"],"type":"string"},
   CodeIndexReadinessTargetV1: {"description":"The readiness a status caller can wait for.","oneOf":[{"const":"fresh","description":"A sealed complete generation serves exact and lexical reads for the\ncurrent source: `code_index_freshness.status` is `current`.","type":"string"},{"const":"ready","description":"`fresh`, and the generation's native code graph also serves.","type":"string"},{"const":"graph_ready","description":"A published generation's native code graph serves and no convergence\npark is set, whatever the source freshness. Waiting for it never\nsweeps the source, so it cannot arm the reconcile it would observe.","type":"string"}]},
   CodeIndexReadinessWaitOutcomeV1: {"description":"How a `wait_for` status read ended. The status payload beside it is read\nafter the wait ends.","oneOf":[{"properties":{"outcome":{"const":"reached","type":"string"}},"required":["outcome"],"type":"object"},{"description":"The caller's budget elapsed; `last_state` is the last observed\n`code_index_freshness.status`.","properties":{"last_state":{"type":"string"},"outcome":{"const":"timed_out","type":"string"}},"required":["outcome","last_state"],"type":"object"},{"description":"Waiting cannot reach the target: no scheduler is mounted, graph\nserving was refused, convergence is parked, or the request ended.","properties":{"outcome":{"const":"unavailable","type":"string"},"reason":{"type":"string"}},"required":["outcome","reason"],"type":"object"}]},
   CodeIndexReadinessWaitV1: {"additionalProperties":false,"description":"`tracedecay_status` `wait_for`: hold the status read until the worktree\nreaches `state`, for at most the caller's `timeout_ms`.","properties":{"state":{"$ref":"#/$defs/CodeIndexReadinessTargetV1"},"timeout_ms":{"format":"uint64","minimum":0,"type":"integer"}},"required":["state","timeout_ms"],"type":"object"},
@@ -2017,7 +2025,7 @@ const DEFINITIONS = {
   CodeIndexSourceOmissionReasonV1: {"oneOf":[{"description":"No logical path can carry the Git path: not UTF-8, a backslash, a\ncontrol character, or leading or trailing whitespace.","properties":{"kind":{"const":"unrepresentable_path","type":"string"}},"required":["kind"],"type":"object"},{"description":"The privacy boundary withheld the file's bytes.","properties":{"detail":{"type":"string"},"kind":{"const":"privacy_withheld","type":"string"}},"required":["kind","detail"],"type":"object"}]},
   CodeIndexStalenessStateV1: {"description":"Closed staleness ladder for one mounted worktree.\n\nThe scheduler publishes one of these tokens. MCP, the dashboard, and the\nCLI must match the variant, not a hand-copied string, so a new ladder\nstate cannot appear at one caller and be missed at the others.","enum":["fresh","stale","indexing","refreshing","restoring","verifying","parked"],"type":"string"},
   CodeIndexWorkerSelectionV1: {"description":"Profile-level worker-count intent for the process-wide code-index pool.\n`Automatic` delegates the concrete count to runtime resource admission;\n`Exact` persists an operator-requested positive worker count.","oneOf":[{"additionalProperties":false,"properties":{"mode":{"const":"automatic","type":"string"}},"required":["mode"],"type":"object"},{"additionalProperties":false,"properties":{"mode":{"const":"exact","type":"string"},"workers":{"format":"uint16","maximum":65535,"minimum":0,"type":"integer"}},"required":["mode","workers"],"type":"object"}]},
-  CodeIndexWorktreeFreshnessV1: {"description":"Freshness/generation state for one mounted worktree.\n\n`Deserialize` is part of the wire contract: the CLI status command decodes\nexactly this type back out of the daemon's `tracedecay_status` response,\nkeeping one authority for the freshness shape.","properties":{"clone_index":{"anyOf":[{"$ref":"#/$defs/CodeCloneIndexStatusV1"},{"type":"null"}],"description":"Clone readiness from the same sealed lexical artifact."},"code_graph_serving":{"anyOf":[{"$ref":"#/$defs/CodeGraphServingReadinessV1"},{"type":"null"}],"description":"Whether that generation's verified graph projection can serve reads."},"coverage":{"$ref":"#/$defs/CodeIndexFreshnessCoverageV1","description":"Whether this read covers the complete mounted scheduler state."},"generation_recovery":{"anyOf":[{"$ref":"#/$defs/CodeIndexGenerationRecoveryV1"},{"type":"null"}],"description":"One-shot owner-configuration recovery currently replacing an\nincompatible durable generation."},"hook_hint_count":{"description":"Pending hook-hint count, when cheaply available.","format":"uint64","minimum":0,"type":["integer","null"]},"last_reconcile_micros":{"description":"Last reconcile observation time (microseconds since the Unix epoch).","format":"int64","type":["integer","null"]},"latest_generation_id":{"description":"Latest sealed generation identity, when a complete generation exists.","type":["string","null"]},"omitted_sources":{"anyOf":[{"$ref":"#/$defs/CodeIndexOmittedSourcesV1"},{"type":"null"}],"description":"Sources the serving snapshot captured but does not index, when any."},"parked":{"anyOf":[{"$ref":"#/$defs/CodeIndexConvergenceParkedV1"},{"type":"null"}],"description":"Deterministic contract violation currently parking background\nconvergence, when one is observed. `staleness_state` reads `parked`\nwhile this is set and no generation serves."},"progress":{"anyOf":[{"$ref":"#/$defs/CodeIndexBuildProgressV1"},{"type":"null"}],"description":"Latest committed progress for the active generation, if one is mounted."},"rebuild_in_flight":{"description":"Whether the exact scheduler route owns a reconcile pass or has a\npending wake. A stale seated generation with this false is stalled,\nnot in a routine rebuild window.","type":"boolean"},"repository_id":{"description":"Stable repository identity resolved by the scheduler.","type":["string","null"]},"restore_progress":{"anyOf":[{"$ref":"#/$defs/CodeIndexRestoreProgressV1"},{"type":"null"}],"description":"Bounded immutable-artifact restore work currently in flight. This is\nseparate from build progress because restore commits no index data."},"sealed_at_micros":{"description":"Time the complete generation was durably sealed.","format":"int64","type":["integer","null"]},"snapshot_content_identity":{"description":"Content identity of the complete source snapshot.","type":["string","null"]},"source_reference":{"description":"Exact source reference captured by the sealed generation.","type":["string","null"]},"source_revision":{"description":"Exact source revision captured by the sealed generation.","type":["string","null"]},"staleness_state":{"anyOf":[{"$ref":"#/$defs/CodeIndexStalenessStateV1"},{"type":"null"}],"description":"Staleness-ladder state from the last scheduler execution. `fresh` means\nthe scheduler most recently observed a fresh source; the status read\ndoes not probe the worktree to revalidate that observation."},"worktree_id":{"description":"Stable worktree identity resolved by the scheduler.","type":["string","null"]},"worktree_root":{"description":"Display path of the mounted worktree root.","type":"string"}},"required":["worktree_root","rebuild_in_flight","coverage"],"type":"object"},
+  CodeIndexWorktreeFreshnessV1: {"description":"Freshness/generation state for one mounted worktree.\n\n`Deserialize` is part of the wire contract: the CLI status command decodes\nexactly this type back out of the daemon's `tracedecay_status` response,\nkeeping one authority for the freshness shape.","properties":{"clone_index":{"anyOf":[{"$ref":"#/$defs/CodeCloneIndexStatusV1"},{"type":"null"}],"description":"Clone readiness from the same sealed lexical artifact."},"code_graph_serving":{"anyOf":[{"$ref":"#/$defs/CodeGraphServingReadinessV1"},{"type":"null"}],"description":"Whether that generation's verified graph projection can serve reads."},"coverage":{"$ref":"#/$defs/CodeIndexFreshnessCoverageV1","description":"Whether this read covers the complete mounted scheduler state."},"generation_recovery":{"anyOf":[{"$ref":"#/$defs/CodeIndexGenerationRecoveryV1"},{"type":"null"}],"description":"One-shot owner-configuration recovery currently replacing an\nincompatible durable generation."},"hook_hint_count":{"description":"Pending hook-hint count, when cheaply available.","format":"uint64","minimum":0,"type":["integer","null"]},"last_reconcile_micros":{"description":"Last reconcile observation time (microseconds since the Unix epoch).","format":"int64","type":["integer","null"]},"latest_generation_id":{"description":"Latest sealed generation identity, when a complete generation exists.","type":["string","null"]},"native_graph_progress":{"anyOf":[{"$ref":"#/$defs/CodeIndexNativeGraphProgressV1"},{"type":"null"}]},"omitted_sources":{"anyOf":[{"$ref":"#/$defs/CodeIndexOmittedSourcesV1"},{"type":"null"}],"description":"Sources the serving snapshot captured but does not index, when any."},"parked":{"anyOf":[{"$ref":"#/$defs/CodeIndexConvergenceParkedV1"},{"type":"null"}],"description":"Deterministic contract violation currently parking background\nconvergence, when one is observed. `staleness_state` reads `parked`\nwhile this is set and no generation serves."},"preseal_attempt":{"anyOf":[{"$ref":"#/$defs/CodeIndexPresealAttemptProgressV1"},{"type":"null"}]},"progress":{"anyOf":[{"$ref":"#/$defs/CodeIndexBuildProgressV1"},{"type":"null"}],"description":"Latest committed progress for the active generation, if one is mounted."},"rebuild_in_flight":{"description":"Whether the exact scheduler route owns a reconcile pass or has a\npending wake. A stale seated generation with this false is stalled,\nnot in a routine rebuild window.","type":"boolean"},"repository_id":{"description":"Stable repository identity resolved by the scheduler.","type":["string","null"]},"restore_progress":{"anyOf":[{"$ref":"#/$defs/CodeIndexRestoreProgressV1"},{"type":"null"}],"description":"Bounded immutable-artifact restore work currently in flight. This is\nseparate from build progress because restore commits no index data."},"sealed_at_micros":{"description":"Time the complete generation was durably sealed.","format":"int64","type":["integer","null"]},"snapshot_content_identity":{"description":"Content identity of the complete source snapshot.","type":["string","null"]},"source_reference":{"description":"Exact source reference captured by the sealed generation.","type":["string","null"]},"source_revision":{"description":"Exact source revision captured by the sealed generation.","type":["string","null"]},"staleness_state":{"anyOf":[{"$ref":"#/$defs/CodeIndexStalenessStateV1"},{"type":"null"}],"description":"Staleness-ladder state from the last scheduler execution. `fresh` means\nthe scheduler most recently observed a fresh source; the status read\ndoes not probe the worktree to revalidate that observation."},"worktree_id":{"description":"Stable worktree identity resolved by the scheduler.","type":["string","null"]},"worktree_root":{"description":"Display path of the mounted worktree root.","type":"string"}},"required":["worktree_root","rebuild_in_flight","coverage"],"type":"object"},
   CodeLexicalField: {"description":"Typed code fields accepted by the generation-owned lexical authority.","enum":["symbol_name","qualified_name","path","signature","documentation","body_text","preamble_text","exact_term","subtoken"],"type":"string"},
   CodeLexicalFieldFilter: {"additionalProperties":false,"properties":{"field":{"$ref":"#/$defs/CodeLexicalField"},"include":{"type":"boolean"}},"required":["field","include"],"type":"object"},
   CodeOccurrenceRecord: {"additionalProperties":false,"properties":{"chunk":{"anyOf":[{"$ref":"#/$defs/CodeSearchChunkId"},{"type":"null"}]},"file":{"$ref":"#/$defs/FileOccurrenceId"},"path":{"type":"string"},"span":{"$ref":"#/$defs/SourceSpan"},"symbol":{"anyOf":[{"$ref":"#/$defs/SymbolOccurrenceId"},{"type":"null"}]}},"required":["file","path","span"],"type":"object"},
@@ -3447,7 +3455,7 @@ const SCHEMAS: readonly CanonicalJsonSchema[] = [
   {"$defs":{"SymbolPrimitiveRecord":DEFINITIONS.SymbolPrimitiveRecord},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"file":{"type":"string"},"symbols":{"items":{"$ref":"#/$defs/SymbolPrimitiveRecord"},"type":"array"}},"required":["file","symbols"],"title":"SourceOutlinePrimitiveResult","type":"object"},
   {"$defs":{"BranchStackEdgeV1":DEFINITIONS.BranchStackEdgeV1,"BranchStackId":DEFINITIONS.BranchStackId,"BranchStackNodeV1":DEFINITIONS.BranchStackNodeV1,"BranchStackRevisionId":DEFINITIONS.BranchStackRevisionId,"CommitId":DEFINITIONS.CommitId,"ManifestDigest":DEFINITIONS.ManifestDigest,"NativeIntegrationDirectionV1":DEFINITIONS.NativeIntegrationDirectionV1,"NativeIntegrationSelectionDeclarationV1":DEFINITIONS.NativeIntegrationSelectionDeclarationV1,"ProjectId":DEFINITIONS.ProjectId,"RefId":DEFINITIONS.RefId,"RepositoryId":DEFINITIONS.RepositoryId,"ResolvedScope":DEFINITIONS.ResolvedScope,"ScopeSetId":DEFINITIONS.ScopeSetId,"ScopeSetRevision":DEFINITIONS.ScopeSetRevision,"StackNodeId":DEFINITIONS.StackNodeId,"WorktreeId":DEFINITIONS.WorktreeId,"WorktreeInventoryEpoch":DEFINITIONS.WorktreeInventoryEpoch,"WorktreeInventorySnapshotId":DEFINITIONS.WorktreeInventorySnapshotId},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"description":"Exact caller-supplied identity frozen by `stack_snapshot`.\n\nThis proof binds the exact authorized `ProjectId`, `RepositoryId`, source\nand destination worktree/ref identity, frozen inventory, scope/grant/policy\nrevisions, and one declared-edge or independent-branch selection. Paths,\nfree-form SHA values, branch display names, and provider topology remain\nunrepresentable.","properties":{"authorized_scope_set_digest":{"$ref":"#/$defs/ManifestDigest"},"authorized_scope_set_id":{"$ref":"#/$defs/ScopeSetId"},"authorized_scope_set_revision":{"$ref":"#/$defs/ScopeSetRevision"},"destination":{"$ref":"#/$defs/ResolvedScope"},"grant_digest":{"$ref":"#/$defs/ManifestDigest"},"inventory_epoch":{"$ref":"#/$defs/WorktreeInventoryEpoch"},"inventory_snapshot_id":{"$ref":"#/$defs/WorktreeInventorySnapshotId"},"policy_digest":{"$ref":"#/$defs/ManifestDigest"},"selection":{"$ref":"#/$defs/NativeIntegrationSelectionDeclarationV1"},"source":{"$ref":"#/$defs/ResolvedScope"}},"required":["source","destination","authorized_scope_set_id","authorized_scope_set_revision","authorized_scope_set_digest","inventory_snapshot_id","inventory_epoch","selection","grant_digest","policy_digest"],"title":"NativeIntegrationStackSnapshotSurfaceRequest","type":"object"},
   {"$defs":{"CodeIndexReadinessTargetV1":DEFINITIONS.CodeIndexReadinessTargetV1,"CodeIndexReadinessWaitV1":DEFINITIONS.CodeIndexReadinessWaitV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"admission_only":{"default":false,"description":"Report only that the project route is admitted, reading no graph,\nindex, or session state. Default false.","type":"boolean"},"include_branch_diagnostics":{"default":false,"description":"Full tracked-branch diagnostic list. Default false.","type":"boolean"},"include_session_ingest":{"default":false,"description":"Session-ingest health. Default false.","type":"boolean"},"include_staleness":{"default":false,"description":"Git staleness object. Default false.","type":"boolean"},"include_storage_health":{"default":false,"description":"Storage-health snapshot. Default false.","type":"boolean"},"wait_for":{"anyOf":[{"$ref":"#/$defs/CodeIndexReadinessWaitV1"},{"type":"null"}],"description":"Hold the status read until the code index reaches `state` (`fresh`:\nstatus `current`; `ready`: also native graph serving; `graph_ready`: a\npublished generation's native graph serves, whatever the freshness),\nfor at most `timeout_ms`. The payload's `wait` reports `reached`,\n`timed_out` with `last_state`, or `unavailable` with `reason`."}},"title":"StatusSurfaceRequestV1","type":"object"},
-  {"$defs":{"CodeCloneIndexBudgetsV1":DEFINITIONS.CodeCloneIndexBudgetsV1,"CodeCloneIndexCoverageV1":DEFINITIONS.CodeCloneIndexCoverageV1,"CodeCloneIndexObservationV1":DEFINITIONS.CodeCloneIndexObservationV1,"CodeCloneIndexResourcesV1":DEFINITIONS.CodeCloneIndexResourcesV1,"CodeCloneIndexStatusV1":DEFINITIONS.CodeCloneIndexStatusV1,"CodeGraphServingReadinessV1":DEFINITIONS.CodeGraphServingReadinessV1,"CodeIndexBuildBlockedReasonV1":DEFINITIONS.CodeIndexBuildBlockedReasonV1,"CodeIndexBuildPhaseV1":DEFINITIONS.CodeIndexBuildPhaseV1,"CodeIndexBuildProgressV1":DEFINITIONS.CodeIndexBuildProgressV1,"CodeIndexConvergenceParkedV1":DEFINITIONS.CodeIndexConvergenceParkedV1,"CodeIndexFreshnessCoverageV1":DEFINITIONS.CodeIndexFreshnessCoverageV1,"CodeIndexGenerationRecoveryServingV1":DEFINITIONS.CodeIndexGenerationRecoveryServingV1,"CodeIndexGenerationRecoveryV1":DEFINITIONS.CodeIndexGenerationRecoveryV1,"CodeIndexOmittedSourceV1":DEFINITIONS.CodeIndexOmittedSourceV1,"CodeIndexOmittedSourcesV1":DEFINITIONS.CodeIndexOmittedSourcesV1,"CodeIndexReadinessWaitOutcomeV1":DEFINITIONS.CodeIndexReadinessWaitOutcomeV1,"CodeIndexRestoreProgressV1":DEFINITIONS.CodeIndexRestoreProgressV1,"CodeIndexSourceOmissionReasonV1":DEFINITIONS.CodeIndexSourceOmissionReasonV1,"CodeIndexStalenessStateV1":DEFINITIONS.CodeIndexStalenessStateV1,"CodeIndexWorktreeFreshnessV1":DEFINITIONS.CodeIndexWorktreeFreshnessV1,"LcmConvergenceStateV1":DEFINITIONS.LcmConvergenceStateV1,"LcmConvergenceV1":DEFINITIONS.LcmConvergenceV1,"LcmDoctorProjectionStateV1":DEFINITIONS.LcmDoctorProjectionStateV1,"LcmDoctorProjectionV1":DEFINITIONS.LcmDoctorProjectionV1,"NativeHostIdentityV1":DEFINITIONS.NativeHostIdentityV1,"ProjectStatusV1":DEFINITIONS.ProjectStatusV1,"ResidentMemoryHolderReadV1":DEFINITIONS.ResidentMemoryHolderReadV1,"RetrievalWorkerStatusV1":DEFINITIONS.RetrievalWorkerStatusV1,"SchemaConvergenceFindingV1":DEFINITIONS.SchemaConvergenceFindingV1,"SchemaConvergenceStageV1":DEFINITIONS.SchemaConvergenceStageV1,"SchemaConvergenceStateV1":DEFINITIONS.SchemaConvergenceStateV1,"StatusAdmissionV1":DEFINITIONS.StatusAdmissionV1,"StatusBranchMismatchV1":DEFINITIONS.StatusBranchMismatchV1,"StatusCodeIndexFreshnessV1":DEFINITIONS.StatusCodeIndexFreshnessV1,"StatusGitStalenessUnavailableV1":DEFINITIONS.StatusGitStalenessUnavailableV1,"StatusGitStalenessV1":DEFINITIONS.StatusGitStalenessV1,"StatusHookReplayFailureV1":DEFINITIONS.StatusHookReplayFailureV1,"StatusHookReplaySpoolV1":DEFINITIONS.StatusHookReplaySpoolV1,"StatusHookReplayV1":DEFINITIONS.StatusHookReplayV1,"StatusMemoryOwnerV1":DEFINITIONS.StatusMemoryOwnerV1,"StatusMemoryPressureV1":DEFINITIONS.StatusMemoryPressureV1,"StatusMemoryReservationV1":DEFINITIONS.StatusMemoryReservationV1,"StatusMemoryV1":DEFINITIONS.StatusMemoryV1,"StatusRetrievalServingV1":DEFINITIONS.StatusRetrievalServingV1,"StatusSchemaConvergenceStateV1":DEFINITIONS.StatusSchemaConvergenceStateV1,"StatusSchemaConvergenceV1":DEFINITIONS.StatusSchemaConvergenceV1,"StatusServingConditionV1":DEFINITIONS.StatusServingConditionV1,"StatusServingFreshnessV1":DEFINITIONS.StatusServingFreshnessV1,"StatusSessionGitEvidenceUnavailableV1":DEFINITIONS.StatusSessionGitEvidenceUnavailableV1,"StatusSessionGitEvidenceV1":DEFINITIONS.StatusSessionGitEvidenceV1,"StoreResetRequiredV1":DEFINITIONS.StoreResetRequiredV1},"$schema":"https://json-schema.org/draft/2020-12/schema","anyOf":[{"$ref":"#/$defs/StatusAdmissionV1"},{"$ref":"#/$defs/ProjectStatusV1"}],"description":"`tracedecay_status` for an `admission_only` read, or the project's status.","title":"StatusResultV1"},
+  {"$defs":{"CodeCloneIndexBudgetsV1":DEFINITIONS.CodeCloneIndexBudgetsV1,"CodeCloneIndexCoverageV1":DEFINITIONS.CodeCloneIndexCoverageV1,"CodeCloneIndexObservationV1":DEFINITIONS.CodeCloneIndexObservationV1,"CodeCloneIndexResourcesV1":DEFINITIONS.CodeCloneIndexResourcesV1,"CodeCloneIndexStatusV1":DEFINITIONS.CodeCloneIndexStatusV1,"CodeGraphServingReadinessV1":DEFINITIONS.CodeGraphServingReadinessV1,"CodeIndexBuildBlockedReasonV1":DEFINITIONS.CodeIndexBuildBlockedReasonV1,"CodeIndexBuildPhaseV1":DEFINITIONS.CodeIndexBuildPhaseV1,"CodeIndexBuildProgressV1":DEFINITIONS.CodeIndexBuildProgressV1,"CodeIndexConvergenceParkedV1":DEFINITIONS.CodeIndexConvergenceParkedV1,"CodeIndexFreshnessCoverageV1":DEFINITIONS.CodeIndexFreshnessCoverageV1,"CodeIndexGenerationRecoveryServingV1":DEFINITIONS.CodeIndexGenerationRecoveryServingV1,"CodeIndexGenerationRecoveryV1":DEFINITIONS.CodeIndexGenerationRecoveryV1,"CodeIndexNativeGraphPhaseV1":DEFINITIONS.CodeIndexNativeGraphPhaseV1,"CodeIndexNativeGraphProgressV1":DEFINITIONS.CodeIndexNativeGraphProgressV1,"CodeIndexOmittedSourceV1":DEFINITIONS.CodeIndexOmittedSourceV1,"CodeIndexOmittedSourcesV1":DEFINITIONS.CodeIndexOmittedSourcesV1,"CodeIndexPresealAttemptProgressV1":DEFINITIONS.CodeIndexPresealAttemptProgressV1,"CodeIndexPresealWorkPhaseV1":DEFINITIONS.CodeIndexPresealWorkPhaseV1,"CodeIndexReadinessWaitOutcomeV1":DEFINITIONS.CodeIndexReadinessWaitOutcomeV1,"CodeIndexRestoreProgressV1":DEFINITIONS.CodeIndexRestoreProgressV1,"CodeIndexSourceOmissionReasonV1":DEFINITIONS.CodeIndexSourceOmissionReasonV1,"CodeIndexStalenessStateV1":DEFINITIONS.CodeIndexStalenessStateV1,"CodeIndexWorktreeFreshnessV1":DEFINITIONS.CodeIndexWorktreeFreshnessV1,"LcmConvergenceStateV1":DEFINITIONS.LcmConvergenceStateV1,"LcmConvergenceV1":DEFINITIONS.LcmConvergenceV1,"LcmDoctorProjectionStateV1":DEFINITIONS.LcmDoctorProjectionStateV1,"LcmDoctorProjectionV1":DEFINITIONS.LcmDoctorProjectionV1,"NativeHostIdentityV1":DEFINITIONS.NativeHostIdentityV1,"ProjectStatusV1":DEFINITIONS.ProjectStatusV1,"ResidentMemoryHolderReadV1":DEFINITIONS.ResidentMemoryHolderReadV1,"RetrievalWorkerStatusV1":DEFINITIONS.RetrievalWorkerStatusV1,"SchemaConvergenceFindingV1":DEFINITIONS.SchemaConvergenceFindingV1,"SchemaConvergenceStageV1":DEFINITIONS.SchemaConvergenceStageV1,"SchemaConvergenceStateV1":DEFINITIONS.SchemaConvergenceStateV1,"StatusAdmissionV1":DEFINITIONS.StatusAdmissionV1,"StatusBranchMismatchV1":DEFINITIONS.StatusBranchMismatchV1,"StatusCodeIndexFreshnessV1":DEFINITIONS.StatusCodeIndexFreshnessV1,"StatusGitStalenessUnavailableV1":DEFINITIONS.StatusGitStalenessUnavailableV1,"StatusGitStalenessV1":DEFINITIONS.StatusGitStalenessV1,"StatusHookReplayFailureV1":DEFINITIONS.StatusHookReplayFailureV1,"StatusHookReplaySpoolV1":DEFINITIONS.StatusHookReplaySpoolV1,"StatusHookReplayV1":DEFINITIONS.StatusHookReplayV1,"StatusMemoryOwnerV1":DEFINITIONS.StatusMemoryOwnerV1,"StatusMemoryPressureV1":DEFINITIONS.StatusMemoryPressureV1,"StatusMemoryReservationV1":DEFINITIONS.StatusMemoryReservationV1,"StatusMemoryV1":DEFINITIONS.StatusMemoryV1,"StatusRetrievalServingV1":DEFINITIONS.StatusRetrievalServingV1,"StatusSchemaConvergenceStateV1":DEFINITIONS.StatusSchemaConvergenceStateV1,"StatusSchemaConvergenceV1":DEFINITIONS.StatusSchemaConvergenceV1,"StatusServingConditionV1":DEFINITIONS.StatusServingConditionV1,"StatusServingFreshnessV1":DEFINITIONS.StatusServingFreshnessV1,"StatusSessionGitEvidenceUnavailableV1":DEFINITIONS.StatusSessionGitEvidenceUnavailableV1,"StatusSessionGitEvidenceV1":DEFINITIONS.StatusSessionGitEvidenceV1,"StoreResetRequiredV1":DEFINITIONS.StoreResetRequiredV1},"$schema":"https://json-schema.org/draft/2020-12/schema","anyOf":[{"$ref":"#/$defs/StatusAdmissionV1"},{"$ref":"#/$defs/ProjectStatusV1"}],"description":"`tracedecay_status` for an `admission_only` read, or the project's status.","title":"StatusResultV1"},
   {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"include_details":{"default":false,"type":"boolean"}},"title":"StorageStatusPrimitiveRequest","type":"object"},
   {"$defs":{"StorageStatusHistoryPointV1":DEFINITIONS.StorageStatusHistoryPointV1},"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"properties":{"database_bytes":{"format":"uint64","minimum":0,"type":["integer","null"]},"details":{"items":{"type":"string"},"type":"array"},"freelist_pages":{"default":null,"format":"uint64","minimum":0,"type":["integer","null"]},"history":{"default":[],"items":{"$ref":"#/$defs/StorageStatusHistoryPointV1"},"type":"array"},"history_coverage":{"default":null,"type":["string","null"]},"page_count":{"default":null,"format":"uint64","minimum":0,"type":["integer","null"]},"page_size_bytes":{"default":null,"format":"uint32","minimum":0,"type":["integer","null"]},"project_id":{"default":null,"type":["string","null"]},"read_only":{"type":"boolean"},"status":{"type":"string"},"store_path":{"default":null,"type":["string","null"]}},"required":["status","read_only","details"],"title":"StorageStatusPrimitiveResult","type":"object"},
   {"$schema":"https://json-schema.org/draft/2020-12/schema","additionalProperties":false,"description":"Exact public input accepted by `tracedecay_str_replace`.","properties":{"dry_run":{"default":false,"type":"boolean"},"expected_state":{"description":"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.","type":["string","null"]},"idempotency_key":{"type":["string","null"]},"new_str":{"type":"string"},"old_str":{"type":"string"},"path":{"type":"string"},"verify":{"default":false,"type":"boolean"}},"required":["path","old_str","new_str"],"title":"StrReplaceSurfaceRequestV1","type":"object"},

From 4ca0527751c2880f51c75fc3553644c9442965b0 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 01:52:34 -0800
Subject: [PATCH 35/80] test(automation): bind scheduler fixtures to backend
 identities

Repair three hosted automation_runner_test failures by supplying the
configured executable identity required by the production prefilter.
Use the same identity for the prefilter and retained runner, preserving
manual-schedule, exact-ledger, live-lock and lock-race assertions.

Add a production-prefilter regression for unconfigured refusal,
deduplication and same-occurrence recovery after binding, with zero
backend calls and no effectful terminal. Do not relax backend admission,
change timeouts, or alter the graph publication changes.

Refs #4532
---
 .../tests/automation_runner_test/jobs.rs      | 124 ++++++++++++++++--
 1 file changed, 110 insertions(+), 14 deletions(-)

diff --git a/crates/tracedecay/tests/automation_runner_test/jobs.rs b/crates/tracedecay/tests/automation_runner_test/jobs.rs
index 740283d56e8..7342786381b 100644
--- a/crates/tracedecay/tests/automation_runner_test/jobs.rs
+++ b/crates/tracedecay/tests/automation_runner_test/jobs.rs
@@ -86,6 +86,7 @@ fn enabled_job_config() -> AutomationSettingsV1 {
 struct ContentBackend {
     calls: AtomicUsize,
     content: &'static str,
+    executable: Option<std::path::PathBuf>,
 }
 
 impl ContentBackend {
@@ -93,9 +94,15 @@ impl ContentBackend {
         Self {
             calls: AtomicUsize::new(0),
             content,
+            executable: None,
         }
     }
 
+    fn with_executable(mut self, executable: &Path) -> Self {
+        self.executable = Some(executable.to_path_buf());
+        self
+    }
+
     fn calls(&self) -> usize {
         self.calls.load(Ordering::SeqCst)
     }
@@ -126,7 +133,7 @@ impl AgentTaskBackend for ContentBackend {
     }
 
     fn executable(&self) -> Option<&std::path::Path> {
-        None
+        self.executable.as_deref()
     }
 }
 
@@ -988,6 +995,10 @@ async fn scheduler_trigger_skips_repeat_and_respects_lock_discipline() {
     let mut job = sample_job("sched-job");
     job.schedule = Some("manual".to_string());
     let config = enabled_job_config();
+    // Reach the schedule gate with a bound identity, not the earlier
+    // backend-unconfigured refusal. This gate never invokes the backend.
+    let executable = tempfile::NamedTempFile::new().unwrap();
+    let backend = ContentBackend::new("unused").with_executable(executable.path());
 
     // Manual schedule: every scheduler tick of the same occurrence reaches
     // the prefilter, which records the skip once.
@@ -996,7 +1007,7 @@ async fn scheduler_trigger_skips_repeat_and_respects_lock_discipline() {
         let run = evaluate_and_record_scheduler_skip(
             &dashboard_root,
             &config,
-            None,
+            backend.executable(),
             &job,
             "sched-occurrence",
             None,
@@ -1019,7 +1030,7 @@ async fn scheduler_trigger_skips_repeat_and_respects_lock_discipline() {
     let repeated = evaluate_and_record_scheduler_skip(
         &dashboard_root,
         &config,
-        None,
+        backend.executable(),
         &job,
         "sched-occurrence",
         None,
@@ -1031,6 +1042,76 @@ async fn scheduler_trigger_skips_repeat_and_respects_lock_discipline() {
         repeated.ledger_record, records[0],
         "an immediate repeat skip must return the exact durable prior row"
     );
+    assert_eq!(backend.calls(), 0);
+}
+
+#[tokio::test]
+async fn scheduler_prefilter_rejects_unconfigured_backend_and_recovers_without_effect() {
+    let temp = tempdir().unwrap();
+    let dashboard_root = temp.path().join("dashboard");
+    let job = sample_job("backend-recovery");
+    let config = enabled_job_config();
+    let occurrence = "backend-recovery-occurrence";
+    let backend = ContentBackend::new("unused");
+
+    let first = evaluate_and_record_scheduler_skip(
+        &dashboard_root,
+        &config,
+        backend.executable(),
+        &job,
+        occurrence,
+        None,
+    )
+    .await
+    .unwrap()
+    .expect("a due job still requires a configured backend");
+    assert_eq!(first.report["reason"], json!("backend_unconfigured"));
+    assert_eq!(first.ledger_record.status, AutomationRunStatus::Skipped);
+    assert_ne!(first.run_id, occurrence);
+    let repeated = evaluate_and_record_scheduler_skip(
+        &dashboard_root,
+        &config,
+        backend.executable(),
+        &job,
+        occurrence,
+        None,
+    )
+    .await
+    .unwrap()
+    .unwrap();
+    assert_eq!(repeated.ledger_record, first.ledger_record);
+
+    let executable = tempfile::NamedTempFile::new().unwrap();
+    let backend = backend.with_executable(executable.path());
+    assert!(
+        evaluate_and_record_scheduler_skip(
+            &dashboard_root,
+            &config,
+            backend.executable(),
+            &job,
+            occurrence,
+            None,
+        )
+        .await
+        .unwrap()
+        .is_none(),
+        "binding the backend must admit the same due occurrence without cooldown"
+    );
+    assert_eq!(backend.calls(), 0);
+    assert_eq!(
+        load_run_records(&dashboard_root, 10).await.unwrap(),
+        vec![first.ledger_record],
+        "advisory admission must not append an effectful terminal"
+    );
+    assert!(
+        tracedecay_automation_runtime::automation::run_ledger::find_run_record_exact_bounded(
+            &dashboard_root,
+            occurrence,
+        )
+        .await
+        .unwrap()
+        .is_none()
+    );
 }
 
 #[tokio::test]
@@ -1206,15 +1287,22 @@ async fn scheduler_prefilter_live_lock_wins_over_not_due_summary() {
 
     let config = enabled_job_config();
     let occurrence = "locked-prefilter-occurrence";
-    let prefilter =
-        evaluate_and_record_scheduler_skip(&dashboard_root, &config, None, &job, occurrence, None)
-            .await
-            .unwrap()
-            .expect("the live job lock must produce a diagnostic");
+    let executable = tempfile::NamedTempFile::new().unwrap();
+    let backend = ContentBackend::new("unused").with_executable(executable.path());
+    let prefilter = evaluate_and_record_scheduler_skip(
+        &dashboard_root,
+        &config,
+        backend.executable(),
+        &job,
+        occurrence,
+        None,
+    )
+    .await
+    .unwrap()
+    .expect("the live job lock must produce a diagnostic");
     assert_eq!(prefilter.report["reason"], json!("scheduler_lock_active"));
     assert_ne!(prefilter.run_id, occurrence);
 
-    let backend = ContentBackend::new("unused");
     let admitted_job = tracedecay_automation_runtime::automation::jobs::admit_job(&job).unwrap();
     let retained = run_user_job_with_backend_for_retained_settlement(
         &dashboard_root,
@@ -1262,12 +1350,21 @@ async fn retained_scheduler_runner_reacquires_after_due_prefilter() {
     job.schedule = Some("every 1h".to_owned());
     let config = enabled_job_config();
     let occurrence = "prefilter-gap-occurrence";
+    let executable = tempfile::NamedTempFile::new().unwrap();
+    let backend = ContentBackend::new("unused").with_executable(executable.path());
 
     assert!(
-        evaluate_and_record_scheduler_skip(&dashboard_root, &config, None, &job, occurrence, None)
-            .await
-            .unwrap()
-            .is_none(),
+        evaluate_and_record_scheduler_skip(
+            &dashboard_root,
+            &config,
+            backend.executable(),
+            &job,
+            occurrence,
+            None,
+        )
+        .await
+        .unwrap()
+        .is_none(),
         "a new interval job is advisory-due before effect admission"
     );
     let _raced_in =
@@ -1276,7 +1373,6 @@ async fn retained_scheduler_runner_reacquires_after_due_prefilter() {
             .unwrap()
             .expect("the advisory prefilter must release its reservation lock");
 
-    let backend = ContentBackend::new("unused");
     let admitted_job = tracedecay_automation_runtime::automation::jobs::admit_job(&job).unwrap();
     let retained = run_user_job_with_backend_for_retained_settlement(
         &dashboard_root,

From 8798ed637df0886c551f2a7fe41f17ccf6fa3988 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 14:42:22 -0800
Subject: [PATCH 36/80] build(extension): refresh the embedded server from the
 SDK

---
 plugin/chatgpt-extension/embedded/server.mjs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/plugin/chatgpt-extension/embedded/server.mjs b/plugin/chatgpt-extension/embedded/server.mjs
index 46939ae1dbc..c870efaefb1 100644
--- a/plugin/chatgpt-extension/embedded/server.mjs
+++ b/plugin/chatgpt-extension/embedded/server.mjs
@@ -74,7 +74,7 @@ data:
 `;return i&&(o+=`id: ${i}
 `),o+=`data: ${JSON.stringify(r)}
 
-`,e.enqueue(t.encode(o)),!0}catch(e){return this.onerror?.(e),!1}}handleUnsupportedRequest(){return this.onerror?.(Error("Method not allowed.")),Response.json({jsonrpc:"2.0",error:{code:-32e3,message:"Method not allowed."},id:null},{status:405,headers:{Allow:"GET, POST, DELETE","Content-Type":"application/json"}})}async handlePostRequest(e,t){try{var r,i;let o,n,a,s,d,c=e.headers.get("accept");if(!c?.includes("application/json")||!c.includes("text/event-stream"))return this.onerror?.(Error("Not Acceptable: Client must accept both application/json and text/event-stream")),this.createJsonErrorResponse(406,-32e3,"Not Acceptable: Client must accept both application/json and text/event-stream");if(r=e.headers.get("content-type"),"application/json"!==r&&"application/json"!==function(e){if(e)try{return lU.parse(e).type}catch{let t=(e.split(";",1)[0]??"").trim().toLowerCase();if(""===t||e.slice(t.length).includes(","))return;return t}}(r))return this.onerror?.(Error("Unsupported Media Type: Content-Type must be application/json")),this.createJsonErrorResponse(415,-32e3,"Unsupported Media Type: Content-Type must be application/json");if(t?.parsedBody===void 0)try{let t=await async function(e,t=4194304){if(Number(e.headers.get("content-length"))>t)return{tooLarge:!0};if(null===e.body)return{tooLarge:!1,text:""};let r=e.body.getReader(),i=new TextDecoder,o=0,n="";try{for(;;){let{done:e,value:a}=await r.read();if(e)break;if((o+=a.byteLength)>t)return{tooLarge:!0};n+=i.decode(a,{stream:!0})}}finally{r.releaseLock()}return{tooLarge:!1,text:n+i.decode()}}(e,this._maxRequestBodySize);if(t.tooLarge){let e=(i=this._maxRequestBodySize,`Payload Too Large: Request body must not exceed ${i} bytes`);return this.onerror?.(Error(e)),this.createJsonErrorResponse(413,-32e3,e)}o=JSON.parse(t.text)}catch(e){return this.onerror?.(e),this.createJsonErrorResponse(400,-32700,"Parse error: Invalid JSON")}else o=t.parsedBody;if(Array.isArray(o)&&o.length>100)return this.onerror?.(Error("Invalid Request: Batch must not exceed 100 messages")),this.createJsonErrorResponse(400,-32600,"Invalid Request: Batch must not exceed 100 messages");try{n=Array.isArray(o)?o.map(e=>aA.parse(e)):[aA.parse(o)]}catch(e){return this.onerror?.(e),this.createJsonErrorResponse(400,-32700,"Parse error: Invalid JSON-RPC message")}if(this._closed)return this.createJsonErrorResponse(404,-32001,"Session not found");let l=n.some(e=>aQ.safeParse(e).success);if(l){if(this._initialized&&void 0!==this.sessionId)return this.onerror?.(Error("Invalid Request: Server already initialized")),this.createJsonErrorResponse(400,-32600,"Invalid Request: Server already initialized");if(n.length>1)return this.onerror?.(Error("Invalid Request: Only one initialization request is allowed")),this.createJsonErrorResponse(400,-32600,"Invalid Request: Only one initialization request is allowed");this.sessionId=this.sessionIdGenerator?.(),this._initialized=!0,this.sessionId&&this._onsessioninitialized&&await Promise.resolve(this._onsessioninitialized(this.sessionId))}if(!l){let t=this.validateSession(e);if(t)return t;let r=this.validateProtocolVersion(e);if(r)return r}if(this._closed)return this.createJsonErrorResponse(404,-32001,"Session not found");try{a=await this._checkScopeChallenge(n,t?.authInfo)}catch(e){return this.onerror?.(e),this.createJsonErrorResponse(500,-32603,"Internal server error")}if(a)return a;if(!n.some(e=>lc(e))){for(let r of n)this.onmessage?.(r,{authInfo:t?.authInfo,request:e});return new Response(null,{status:202})}let p=crypto.randomUUID(),u=n.find(e=>aQ.safeParse(e).success),m=u?u.params.protocolVersion:e.headers.get("mcp-protocol-version")??"2025-03-26";if(this._enableJsonResponse)return new Promise(r=>{for(let e of(this._streamMapping.set(p,{resolveJson:r,cleanup:()=>{this._streamMapping.delete(p)}}),n))lc(e)&&this._requestToStreamMapping.set(e.id,p);for(let r of n)this.onmessage?.(r,{authInfo:t?.authInfo,request:e})});let f=new TextEncoder,h=new ReadableStream({start:e=>{s=e},cancel:()=>{void 0!==d&&clearInterval(d),this._streamMapping.get(p)?.controller===s&&this._streamMapping.delete(p)}}),y={"Content-Type":"text/event-stream","Cache-Control":"no-cache, no-transform",Connection:"keep-alive","X-Accel-Buffering":"no"};for(let e of(void 0!==this.sessionId&&(y["mcp-session-id"]=this.sessionId),n))lc(e)&&(this._streamMapping.set(p,{controller:s,encoder:f,cleanup:()=>{void 0!==d&&clearInterval(d),this._streamMapping.delete(p);try{s.close()}catch{}}}),this._requestToStreamMapping.set(e.id,p));for(let r of(await this.writePrimingEvent(s,f,p,m),n)){let i,o;lc(r)&&this._eventStore&&this.supportsEmptySSEData(m)&&(i=()=>{this.closeSSEStream(r.id)},o=()=>{this.closeStandaloneSSEStream()}),this.onmessage?.(r,{authInfo:t?.authInfo,request:e,closeSSEStream:i,closeStandaloneSSEStream:o})}return this._streamMapping.get(p)?.controller===s&&(d=this.startKeepAlive(s,f)),new Response(h,{status:200,headers:y})}catch(e){return this.onerror?.(e),this.createJsonErrorResponse(400,-32700,"Parse error",{data:String(e)})}}async handleDeleteRequest(e){let t=this.validateSession(e);if(t)return t;let r=this.validateProtocolVersion(e);if(r)return r;try{return await Promise.resolve(this._onsessionclosed?.(this.sessionId)),new Response(null,{status:200})}finally{await this.close()}}validateSession(e){if(void 0===this.sessionIdGenerator)return;if(!this._initialized)return this.onerror?.(Error("Bad Request: Server not initialized")),this.createJsonErrorResponse(400,-32e3,"Bad Request: Server not initialized");let t=e.headers.get("mcp-session-id");return t?t!==this.sessionId?(this.onerror?.(Error("Session not found")),this.createJsonErrorResponse(404,-32001,"Session not found")):void 0:(this.onerror?.(Error("Bad Request: Mcp-Session-Id header is required")),this.createJsonErrorResponse(400,-32e3,"Bad Request: Mcp-Session-Id header is required"))}validateProtocolVersion(e){let t=e.headers.get("mcp-protocol-version");if(null!==t&&!this._supportedProtocolVersions.includes(t)){let e=`Bad Request: Unsupported protocol version: ${t} (supported versions: ${this._supportedProtocolVersions.join(", ")})`;return this.onerror?.(Error(e)),this.createJsonErrorResponse(400,-32e3,e)}}async close(){if(!this._closed){for(let{cleanup:e}of(this._closed=!0,this._streamMapping.values()))e();this._streamMapping.clear(),this._requestResponseMap.clear(),this.onclose?.()}}closeSSEStream(e){let t=this._requestToStreamMapping.get(e);if(!t)return;let r=this._streamMapping.get(t);r&&r.cleanup()}closeStandaloneSSEStream(){let e=this._streamMapping.get(this._standaloneSseStreamId);e&&e.cleanup()}async send(e,t){let r=t?.relatedRequestId;if((aO.safeParse(e).success||aE.safeParse(e).success)&&(r=e.id),void 0===r){let t;if(aO.safeParse(e).success||aE.safeParse(e).success)throw Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");this._eventStore&&(t=await this._eventStore.storeEvent(this._standaloneSseStreamId,e));let r=this._streamMapping.get(this._standaloneSseStreamId);if(void 0===r)return;r.controller&&r.encoder&&(void 0===t||!r.replayedEventIds?.has(t))&&this.writeSSEEvent(r.controller,r.encoder,e,t);return}let i=this._requestToStreamMapping.get(r);if(!i)throw Error(`No connection established for request ID: ${String(r)}`);let o=this._streamMapping.get(i);if(!this._enableJsonResponse){let t;this._eventStore&&(t=await this._eventStore.storeEvent(i,e),o=this._streamMapping.get(i)),o?.controller&&o?.encoder&&(void 0===t||!o.replayedEventIds?.has(t))&&this.writeSSEEvent(o.controller,o.encoder,e,t)}if(aO.safeParse(e).success||aE.safeParse(e).success){this._requestResponseMap.set(r,e);let t=[...this._requestToStreamMapping.entries()].filter(([e,t])=>t===i).map(([e])=>e);if(t.every(e=>this._requestResponseMap.has(e))){if(!o){if(this._enableJsonResponse)throw Error(`No connection established for request ID: ${String(r)}`);if(!this._eventStore){for(let e of(this.onerror?.(Error(`Response for request ID ${String(r)} is undeliverable: per-request stream is disconnected and no eventStore is configured`)),t))this._requestResponseMap.delete(e),this._requestToStreamMapping.delete(e);return}for(let e of t)this._requestResponseMap.delete(e),this._requestToStreamMapping.delete(e);return}if(this._enableJsonResponse&&o.resolveJson){let e={"Content-Type":"application/json"};void 0!==this.sessionId&&(e["mcp-session-id"]=this.sessionId);let r=t.map(e=>this._requestResponseMap.get(e));1===r.length?o.resolveJson(Response.json(r[0],{status:200,headers:e})):o.resolveJson(Response.json(r,{status:200,headers:e})),o.cleanup()}else o.cleanup();for(let e of t)this._requestResponseMap.delete(e),this._requestToStreamMapping.delete(e)}}}};let uY=Symbol("swallowsErrorsAfterClose");var u1=class{_readBuffer;_started=!1;_closed=!1;constructor(e=N.stdin,t=N.stdout,r){this._stdin=e,this._stdout=t,this._readBuffer=new lH({maxBufferSize:r?.maxBufferSize})}onclose;onerror;onmessage;_ondata=e=>{try{this._readBuffer.append(e),this.processReadBuffer()}catch(e){this.onerror?.(e),this.close().catch(()=>{})}};_onerror=e=>{this.onerror?.(e)};_onstdouterror=e=>{this._closed||(this.onerror?.(e),this.close().catch(()=>{}))};_onstdinclose=()=>{this.close().catch(()=>{})};async start(){if(this._started)throw Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");for(let e of(this._started=!0,this._stdout.listeners("error")))e[uY]&&this._stdout.off("error",e);(this._stdin.readableEnded||this._stdin.destroyed)&&setImmediate(this._onstdinclose),this._stdin.on("data",this._ondata),this._stdin.on("error",this._onerror),this._stdin.on("end",this._onstdinclose),this._stdin.on("close",this._onstdinclose),this._stdout.on("error",this._onstdouterror)}processReadBuffer(){for(;;)try{let e=this._readBuffer.readMessage();if(null===e)break;this.onmessage?.(e)}catch(e){this.onerror?.(e)}}async close(){this._closed||(this._closed=!0,this._stdin.off("data",this._ondata),this._stdin.off("error",this._onerror),this._stdin.off("end",this._onstdinclose),this._stdin.off("close",this._onstdinclose),this._onstdouterror[uY]=!0,0===this._stdin.listenerCount("data")&&this._stdin.pause(),this._readBuffer.clear(),this.onclose?.())}send(e){return this._closed?Promise.reject(Error("StdioServerTransport is closed")):new Promise((t,r)=>{let i=JSON.stringify(e)+"\n",o=!1,n=e=>{o||(o=!0,this._stdout.off("error",n),this._stdout.off("drain",a),r(e))},a=()=>{o||(o=!0,this._stdout.off("error",n),this._stdout.off("drain",a),t())};if(this._stdout.once("error",n),this._stdout.write(i)){if(o)return;o=!0,this._stdout.off("error",n),t()}else o||this._stdout.once("drain",a)})}},u0=class extends Error{constructor(e,t){super(e,t),this.name="RequestError"}};let u2=new Set(["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","server","user-agent"]),u4=/^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/,u6=e=>9===e||10===e||13===e||32===e,u3=e=>{if(!u6(e.charCodeAt(0))&&!u6(e.charCodeAt(e.length-1)))return e;let t=0,r=e.length;for(;t<r&&u6(e.charCodeAt(t));)t++;for(;r>t&&u6(e.charCodeAt(r-1));)r--;return e.slice(t,r)},u9=/[\0\r\n]/,u5=globalThis.Headers,u8=(e,t=u5)=>{let r=new t;for(let t=0;t<e.length;t+=2){let i=e[t];i.startsWith(":")||r.append(i,e[t+1])}return r};var u7=class{#e;#t;#r;#i;constructor(e){this.#e=e,e instanceof z&&(this.#t=e.rawHeaders.slice())}get #o(){return this.#t??=this.#e.rawHeaders.slice()}get #n(){return this.#r||(this.#r=u8(this.#o),this.#t=void 0),this.#r}#a(e){if("string"==typeof e){if(!u4.test(e))throw TypeError(`Invalid header name: ${e}`);return e.toLowerCase()}}#s(e){let t=this.#e instanceof z?void 0:this.#e.headers;if(!t||u2.has(e)||"set-cookie"===e||"__proto__"===e)return;if(!Object.hasOwn(t,e))return null;let r=t[e];if("string"==typeof r){let e=u3(r);return u9.test(e)?void 0:e}}#d(e,t){let r="cookie"===t?"; ":", ",i=null;for(let o=0;o<e.length;o+=2){let n=e[o];if(n.length===t.length&&n.toLowerCase()===t){let t=u3(e[o+1]);if(u9.test(t)){this.#i=!0;return}i=null===i?t:i+r+t}}return i}append(e,t){this.#n.append(e,t)}delete(e){this.#n.delete(e)}get(e){let t=this.#a(e);if(t&&!this.#r&&!this.#i){let e=this.#s(t);if(void 0!==e)return e;let r=this.#d(this.#o,t);if(void 0!==r)return r}return this.#n.get(e)}has(e){let t=this.#a(e);if(t&&!this.#r&&!this.#i){let e=this.#s(t);if(void 0!==e)return null!==e;let r=this.#d(this.#o,t);if(void 0!==r)return null!==r}return this.#n.has(e)}set(e,t){this.#n.set(e,t)}getSetCookie(){return this.#n.getSetCookie()}keys(){return this.#n.keys()}values(){return this.#n.values()}entries(){return this.#n.entries()}forEach(e,t){this.#n.forEach((r,i)=>{e.call(t,r,i,this)})}[Symbol.iterator](){return this.entries()}};Object.defineProperty(u7.prototype,Symbol.for("nodejs.util.inspect.custom"),{value:function(e,t,r){return`Headers (lightweight) ${r(Object.fromEntries(this),{...t,depth:null==e?null:e-1})}`}}),Object.setPrototypeOf(u7.prototype,u5.prototype);let me=e=>globalThis.Headers===u5?new u7(e):u8(e.rawHeaders,globalThis.Headers),mt=/^\/[!#$&-;=?-\[\]_a-z~]*$/,mr=/\/\.\.?(?:[/?#]|$)/,mi=/^[a-z0-9._-]+(?::(?:[1-5]\d{3,4}|[6-9]\d{3}))?$/,mo=global.Request;var mn=class extends mo{constructor(e,t){if("object"==typeof e&&mh in e){let r=void 0!==t&&"body"in t&&null!=t.body;if(e[mV]&&!r)throw TypeError("Cannot construct a Request with a Request object that has already been used.");e=e[mh]()}void 0!==t?.body?.getReader&&(t.duplex??="half"),super(e,t)}};let ma=Symbol("wrapBodyStream"),ms=new Set(["latin1","binary","hex","base64","base64url"]),md=Symbol("bodyBufferedBeforeDisconnect"),mc=Symbol("bodyBufferedLengthBeforeDisconnect"),ml=(e,t)=>Buffer.isBuffer(e)?e:Buffer.from(e,t??"utf8"),mp=e=>{let t;return!(e instanceof z)&&!!e.complete&&!!e.readableAborted&&"function"==typeof e.read&&(null===(t=e.readableEncoding)||ms.has(t))},mu=e=>{e.readableDidRead||!mp(e)||(e[mc]??=e.readableLength)},mm=(e,t)=>{let r;if(e.readableDidRead&&!t||!mp(e))return;if(void 0!==e[md])return e[md];let i=e.errored;if(i&&"ECONNRESET"!==i.code)r=i;else if(void 0!==e[mc]&&e.readableLength!==e[mc])r=mI();else{let i=t??[],o=e.read();null!==o&&i.push(ml(o,e.readableEncoding));let n=1===i.length?i[0]:Buffer.concat(i);r=n;let a=e.headers["content-length"];if("string"==typeof a&&/^\d+$/.test(a)){let e=Number(a);Number.isSafeInteger(e)&&n.length!==e&&(r=mI())}}return e[md]=r,r},mf=(e,t)=>{t instanceof Error?e.error(t):(t.length>0&&e.enqueue(t),e.close())},mh=Symbol("getRequestCache"),my=Symbol("requestCache"),mg=Symbol("incomingKey"),m_=Symbol("urlKey"),mv=Symbol("methodKey"),mb=Symbol("headersKey"),m$=Symbol("abortControllerKey"),mS=Symbol("getAbortController"),mk=Symbol("abortRequest"),mw=Symbol("bodyBuffer"),mP=Symbol("bodyReadPromise"),mV=Symbol("bodyConsumedDirectly"),mR=Symbol("bodyLockReader"),mq=Symbol("abortReason"),mI=()=>TypeError("Body is unusable"),mx=new TextDecoder,mj=/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/,mC=(e,t,r)=>{if(e[mV])return Promise.reject(mI());let i=e.method;if("GET"===i||"HEAD"===i)return e[mh]()[t]();let o=(e=>{if(!mj.test(e))return TypeError(`'${e}' is not a valid HTTP method.`);let t=e.toUpperCase();if("CONNECT"===t||"TRACK"===t||"TRACE"===t&&"TRACE"!==e)return TypeError(`'${e}' HTTP method is unsupported.`)})(i);if(o)return Promise.reject(o);if(e[my]&&"TRACE"!==i)return e[my][t]();let n=(e=>{if(e[mV])return Promise.reject(mI());e[mV]=!0})(e);if(n)return n;let a=mT(e);if(a){let t=Promise.resolve(r(a,e));return e[mw]=void 0,t}return mE(e).then(t=>{let i=r(t,e);return e[mw]=void 0,i})},mT=e=>{let t=e[mg];if("rawBody"in t&&t.rawBody instanceof Buffer)return t.rawBody},mO=(e,t)=>{if(t.errored)return t.errored;let r=e[mq];return void 0!==r?r instanceof Error?r:Error(String(r)):Error("Client connection prematurely closed.")},mE=e=>{if(e[mw])return Promise.resolve(e[mw]);if(e[mP])return e[mP];let t=e[mg];if(t.readableDidRead)return Promise.reject(mI());let r=mm(t);if(void 0!==r)return r instanceof Error?Promise.reject(r):(e[mw]=r,Promise.resolve(r));let i=new Promise((r,i)=>{let o=[],n=!1,a=e=>{n||(n=!0,u(),e())},s=n=>{let s=t.errored??n;return!!mp(t)&&(!s||"ECONNRESET"===s.code)&&(a(()=>{let a=mm(t,o);a instanceof Error?i(a):void 0===a?i(n??mO(e,t)):(e[mw]=a,r(a))}),!0)},d=e=>{o.push(ml(e,t.readableEncoding))},c=()=>{a(()=>{let t=1===o.length?o[0]:Buffer.concat(o);e[mw]=t,r(t)})},l=e=>{s(e)||a(()=>{i(e)})},p=()=>{t.readableEnded?c():s()||a(()=>{i(mO(e,t))})},u=()=>{t.off("data",d),t.off("end",c),t.off("error",l),t.off("close",p),e[mP]=void 0};t.on("data",d),t.on("end",c),t.on("error",l),t.on("close",p),queueMicrotask(()=>{!n&&(t.readableEnded?c():t.errored?l(t.errored):t.destroyed&&p())})});return e[mP]=i,i},mA={get method(){return this[mv]},get url(){return this[m_]},get headers(){return this[mb]||=me(this[mg])},[mk](e){void 0===this[mq]&&(this[mq]=e);let t=this[m$];t&&!t.signal.aborted&&t.abort(e)},[mS](){return this[m$]||=new AbortController,void 0===this[mq]||this[m$].signal.aborted||this[m$].abort(this[mq]),this[m$]},[mh](){let e=this[mS]();if(this[my])return this[my];let t=this.method;if(this[mV]&&"GET"!==t&&"HEAD"!==t){this[mw]=void 0;let r={method:"TRACE"===t?"GET":t,headers:this.headers,signal:e.signal};"TRACE"!==t&&(r.body=new ReadableStream({start(e){e.close()}}),r.duplex="half");let i=new mn(this[m_],r);return"TRACE"===t&&Object.defineProperty(i,"method",{get:()=>"TRACE"}),this[my]=i}return this[my]=((e,t,r,i,o)=>{let n={method:e,headers:r,signal:o.signal};if("TRACE"===e){n.method="GET";let e=new mn(t,n);return Object.defineProperty(e,"method",{get:()=>"TRACE"}),e}if("GET"!==e&&"HEAD"!==e)if("rawBody"in i&&i.rawBody instanceof Buffer)n.body=new ReadableStream({start(e){e.enqueue(i.rawBody),e.close()}});else if(i[ma]){let e;n.body=new ReadableStream({async pull(t){try{if(!e){let e=mm(i);if(void 0!==e)return void mf(t,e)}e||=L.toWeb(i).getReader();let{done:r,value:o}=await e.read();r?t.close():t.enqueue(o)}catch(e){t.error(e)}}})}else{let e=mm(i);void 0!==e?n.body=new ReadableStream({start(t){mf(t,e)}}):n.body=L.toWeb(i)}return new mn(t,n)})(this.method,this[m_],this.headers,this[mg],e)},get body(){if(!this[mV])return this[mh]().body;let e=this[mh]();return!this[mR]&&e.body&&(this[mR]=e.body.getReader()),e.body},get bodyUsed(){return!!this[mV]||!!this[my]&&this[my].bodyUsed}};Object.defineProperty(mA,"signal",{get(){return this[mS]().signal}}),["cache","credentials","destination","integrity","mode","redirect","referrer","referrerPolicy","keepalive"].forEach(e=>{Object.defineProperty(mA,e,{get(){return this[mh]()[e]}})}),["clone","formData"].forEach(e=>{Object.defineProperty(mA,e,{value:function(){if(this[mV]){if("clone"===e)throw mI();return Promise.reject(mI())}return this[mh]()[e]()}})}),Object.defineProperty(mA,"text",{value:function(){return mC(this,"text",e=>mx.decode(e))}}),Object.defineProperty(mA,"arrayBuffer",{value:function(){return mC(this,"arrayBuffer",e=>e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength))}}),Object.defineProperty(mA,"blob",{value:function(){return mC(this,"blob",(e,t)=>{let r=(t[mb]||=me(t[mg])).get("content-type")||"";return new Response(e,r?{headers:{"content-type":r}}:void 0).blob()})}}),Object.defineProperty(mA,"json",{value:function(){return this[mV]?Promise.reject(mI()):this.text().then(JSON.parse)}}),Object.defineProperty(mA,Symbol.for("nodejs.util.inspect.custom"),{value:function(e,t,r){return`Request (lightweight) ${r({method:this.method,url:this.url,headers:this.headers,nativeRequest:this[my]},{...t,depth:null==e?null:e-1})}`}}),Object.setPrototypeOf(mA,mn.prototype);let mW="text/plain; charset=UTF-8",mM=Symbol("responseCache"),mN=Symbol("getResponseCache"),mz=Symbol("cache"),mD=global.Response;var mF=class e{#c;#l;[mN](){let e=this[mz],t=e&&e[2]instanceof Headers?e[2]:void 0;return delete this[mz],this[mM]||=new mD(this.#c,t?{status:this.#l?.status,statusText:this.#l?.statusText,headers:t}:this.#l)}constructor(t,r){let i;if(this.#c=t,r instanceof mD){let t=r[mM];if(t){this.#l=t,this[mN]();return}this.#l=r instanceof e?r.#l:r,i=new Headers(r.headers)}else this.#l=r;(null==t||"string"==typeof t||void 0!==t?.getReader||t instanceof Blob||t instanceof Uint8Array)&&(this[mz]=[r?.status||200,t??null,i||r?.headers])}get headers(){let e=this[mz];return e?(e[2]instanceof Headers||(e[2]=new Headers(e[2]||(null===e[1]?void 0:{"content-type":mW}))),e[2]):this[mN]().headers}get status(){return this[mz]?.[0]??this[mN]().status}get ok(){let e=this.status;return e>=200&&e<300}};["body","bodyUsed","redirected","statusText","trailers","type","url"].forEach(e=>{Object.defineProperty(mF.prototype,e,{get(){return this[mN]()[e]}})}),["arrayBuffer","blob","clone","formData","json","text"].forEach(e=>{Object.defineProperty(mF.prototype,e,{value:function(){return this[mN]()[e]()}})}),Object.defineProperty(mF.prototype,Symbol.for("nodejs.util.inspect.custom"),{value:function(e,t,r){return`Response (lightweight) ${r({status:this.status,headers:this.headers,ok:this.ok,nativeResponse:this[mM]},{...t,depth:null==e?null:e-1})}`}}),Object.setPrototypeOf(mF,mD),Object.setPrototypeOf(mF.prototype,mD.prototype);let mL=/^https?:\/\/[!#-;=?-[\]_a-z~A-Z]+$/,mU=new Set([301,302,303,307,308]);function mH(e,t,r){let i=t=>{e.cancel(t).catch(()=>{})};return t.on("close",i),t.on("error",i),(r??e.read()).then(a,o),e.closed.finally(()=>{t.off("close",i),t.off("error",i)});function o(e){e&&t.destroy(e)}function n(){e.read().then(a,o)}function a({done:r,value:i}){try{if(r)t.end();else{if(t.write(i))return e.read().then(a,o);t.once("drain",n)}}catch(e){o(e)}}}function mG(e,t){if(e.locked)throw TypeError("ReadableStream is locked.");if(!t.destroyed)return mH(e.getReader(),t)}Object.defineProperty(mF,"redirect",{value:function(e,t=302){if(!mU.has(t))throw RangeError("Invalid status code");return new mF(null,{status:t,headers:{location:e instanceof URL?e.href:mL.test(e)?e:new URL(e).href}})},writable:!0,configurable:!0}),Object.defineProperty(mF,"json",{value:function(e,t){let r,i=JSON.stringify(e);if(void 0===i)throw TypeError("The data is not JSON serializable");let o=t?.headers;return o?(r=new Headers(o)).has("content-type")||r.set("content-type","application/json"):r={"content-type":"application/json"},new mF(i,{status:t?.status??200,statusText:t?.statusText,headers:r})},writable:!0,configurable:!0});let mB=(e,t)=>{let r={};if(e instanceof Headers||(e=new Headers(e??void 0)),e.has("set-cookie")){let t=[];for(let[i,o]of e)"set-cookie"===i?t.push(o):r[i]=o;t.length>0&&(r["set-cookie"]=t)}else for(let[t,i]of e)r[t]=i;return t&&(r["content-type"]??=t),r},mK=Symbol("outgoingEnded"),mJ=Symbol("incomingDraining"),mZ=e=>{if(e.destroyed||e[mJ])return;if(e[mJ]=!0,e instanceof z){try{e.stream?.close?.(D.NGHTTP2_NO_ERROR)}catch{}return}let t=0,r=()=>{clearTimeout(o),e.off("data",n),e.off("end",r),e.off("error",r)},i=()=>{r();let t=e.socket;t&&!t.destroyed&&("function"==typeof t.destroySoon?t.destroySoon():"function"==typeof t.destroy&&t.destroy())},o=setTimeout(i,500);o.unref?.();let n=e=>{(t+=e.length)>0x4000000&&i()};e.on("data",n),e.on("end",r),e.on("error",r),e.resume()},mQ=e=>new Response(null,{status:e instanceof Error&&("TimeoutError"===e.name||"TimeoutError"===e.constructor.name)?504:500}),mX=(e,t)=>{let r=e instanceof Error?e:Error("unknown error",{cause:e});"ERR_STREAM_PREMATURE_CLOSE"===r.code?console.info("The user aborted a request."):(console.error(e),t.headersSent||(t instanceof T&&(t._contentLength=null),t.writeHead(500,{"Content-Type":"text/plain"})),t.end(`Error: ${r.message}`),t.destroy(r))},mY=e=>{"flushHeaders"in e&&e.writable&&e.flushHeaders()},m1=(e,t,r)=>!(null!==e._contentLength||!e._hasBody||!e.useChunkedEncodingByDefault||e._removedContLen||!(t>=200)||204===t||304===t||e.hasHeader("content-length")||e.hasHeader("transfer-encoding")||e.hasHeader("trailer"))&&(e._contentLength=r,!0),m0=(e,t,r)=>{m1(e,t,r)?e.writeHead(t,{"Content-Type":mW}):e.writeHead(t,{"Content-Type":mW,"Content-Length":r})},m2=async(e,t)=>{let[r,i,o]=e[mz];if(!o){null===i?(t.writeHead(r),t.end()):"string"==typeof i?(m0(t,r,Buffer.byteLength(i)),t.end(i)):i instanceof Uint8Array?(m0(t,r,i.byteLength),t.end(i)):i instanceof Blob?(m0(t,r,i.size),t.end(new Uint8Array(await i.arrayBuffer()))):(t.writeHead(r,{"Content-Type":mW}),mY(t),await mG(i,t)?.catch(e=>mX(e,t))),t[mK]?.();return}let n=!1,a=!1,s=!0;if(o instanceof Headers)n=o.has("content-length"),o=mB(o,null===i?void 0:mW);else if(Array.isArray(o)){let e=new Headers(o);n=e.has("content-length"),o=mB(e,null===i?void 0:mW)}else for(let e in a=!0,o){if(14===e.length&&"content-length"===e.toLowerCase()){n=!0;break}(17===e.length&&"transfer-encoding"===e.toLowerCase()||7===e.length&&"trailer"===e.toLowerCase())&&(s=!1)}if(!n){let e;"string"==typeof i?e=Buffer.byteLength(i):i instanceof Uint8Array?e=i.byteLength:i instanceof Blob&&(e=i.size),void 0===e||a&&s&&m1(t,r,e)||(a&&(o={...o}),o["Content-Length"]=e)}t.writeHead(r,o),null==i?t.end():"string"==typeof i||i instanceof Uint8Array?t.end(i):i instanceof Blob?t.end(new Uint8Array(await i.arrayBuffer())):(mY(t),await mG(i,t)?.catch(e=>mX(e,t))),t[mK]?.()},m4=(e,t={})=>{let r=t.autoCleanupIncoming??!0;return!1!==t.overrideGlobalObjects&&global.Request!==mn&&(Object.defineProperty(global,"Request",{value:mn}),Object.defineProperty(global,"Response",{value:mF})),async(i,o)=>{let n,a,s=!1,d=!1,c=()=>{if(a&&!d){let e,t;d=!0,o.on("close",(e=a,t=s,()=>{i.errored?(mu(i),e[mk](i.errored.toString())):(!o.writableFinished||i instanceof z&&i.aborted)&&(mu(i),e[mk]("Client connection prematurely closed.")),t&&!i.readableEnded&&setTimeout(()=>{i.readableEnded||setTimeout(()=>{mZ(i)})})}))}};try{let d;if(a=((e,t)=>{let r,i=Object.create(mA);i[mg]=e,i[mv]=(e=>{if("string"!=typeof e||0===e.length)return"GET";switch(e){case"DELETE":case"GET":case"HEAD":case"OPTIONS":case"PATCH":case"POST":case"PUT":case"QUERY":return e}let t=e.toUpperCase();switch(t){case"DELETE":case"GET":case"HEAD":case"OPTIONS":case"POST":case"PUT":return t;default:return e}})(e.method);let o=e.url||"";if("/"!==o[0]&&(o.startsWith("http://")||o.startsWith("https://"))){if(e instanceof z)throw new u0("Absolute URL for :path is not allowed in HTTP/2");try{i[m_]=new URL(o).href}catch(e){throw new u0("Invalid absolute URL",{cause:e})}return i}let n=(e instanceof z?e.authority:e.headers.host)||t;if(!n)throw new u0("Missing host header");if(e instanceof z){if("http"!==(r=e.scheme)&&"https"!==r)throw new u0("Unsupported scheme")}else r=e.socket&&e.socket.encrypted?"https":"http";try{i[m_]=((e,t,r)=>{let i=`${e}://${t}${r}`;if(mi.test(t)){if(0===r.length)return i+"/";if(47!==r.charCodeAt(0))throw new u0("Invalid URL");return!mt.test(r)||mr.test(r)?new URL(i).href:i}{let e=new URL(i);if(e.hostname.length!==t.length&&e.hostname!==(t.includes(":")?t.replace(/:\d+$/,""):t).toLowerCase())throw new u0("Invalid host header");return e.href}})(r,n,o)}catch(e){if(e instanceof u0)throw e;throw new u0("Invalid URL",{cause:e})}return i})(i,t.hostname),(s=r&&"GET"!==i.method&&"HEAD"!==i.method)&&(i[ma]=!0,i instanceof z&&(o[mK]=()=>{i.readableEnded||setTimeout(()=>{i.readableEnded||setTimeout(()=>{i.destroy(),o.destroy()})})})),d=n=e(a,{incoming:i,outgoing:o}),"function"!=typeof d.then&&(e=>{if(!(mz in e))return!1;let t=e[mz][1];return null===t||"string"==typeof t||t instanceof Uint8Array})(n))return s&&!i.readableEnded&&o.once("finish",()=>{i.readableEnded||mZ(i)}),m2(n,o);c()}catch(e){if(n)return mX(e,o);if(t.errorHandler){if(c(),!(n=await t.errorHandler(a||e instanceof u0?e:new u0(e.message,{cause:e}))))return}else n=a?mQ(e):new Response(null,{status:400})}try{return await (async(e,t,r={})=>{if("function"==typeof e.then)if(r.errorHandler)try{e=await e}catch(i){let t=await r.errorHandler(i);if(!t)return;e=t}else e=await e.catch(mQ);if(mz in e)return m2(e,t);let i=mB(e.headers,null===e.body?void 0:mW);if(e.body){let r,o=e.body.getReader(),n=[],a=!1;if("chunked"!==i["transfer-encoding"]){let e=2;for(let t=0;t<e;t++){r||=o.read();let i=await (async function(e){return Promise.race([e,Promise.resolve().then(()=>Promise.resolve(void 0))])})(r).catch(e=>{console.error(e),a=!0});if(!i){if(1===t){await new Promise(e=>setTimeout(e)),e=3;continue}break}if(r=void 0,i.value&&n.push(i.value),i.done){a=!0;break}}!a||"content-length"in i||(i["content-length"]=n.reduce((e,t)=>e+t.length,0))}t.writeHead(e.status,i),n.forEach(e=>{t.write(e)}),a?t.end():(0===n.length&&mY(t),await mH(o,t,r))}else i["x-hono-already-sent"]||(t.writeHead(e.status,i),t.end());t[mK]?.()})(n,o,t)}catch(e){return mX(e,o)}}};globalThis.CloseEvent??Event,globalThis.ErrorEvent??Event,Symbol("CONNECTION_SYMBOL_KEY"),Symbol("WAIT_FOR_WEBSOCKET_SYMBOL");var m6=class{_webStandardTransport;_requestListener;_requestContext=new WeakMap;constructor(e={}){this._webStandardTransport=new uX(e),this._requestListener=m4(async e=>{let t=this._requestContext.get(e);return this._webStandardTransport.handleRequest(e,{authInfo:t?.authInfo,parsedBody:t?.parsedBody})},{overrideGlobalObjects:!1})}get sessionId(){return this._webStandardTransport.sessionId}set onclose(e){this._webStandardTransport.onclose=e}get onclose(){return this._webStandardTransport.onclose}set onerror(e){this._webStandardTransport.onerror=e}get onerror(){return this._webStandardTransport.onerror}set onmessage(e){this._webStandardTransport.onmessage=e}get onmessage(){return this._webStandardTransport.onmessage}async start(){return this._webStandardTransport.start()}async close(){return this._webStandardTransport.close()}async send(e,t){return this._webStandardTransport.send(e,t)}setSupportedProtocolVersions(e){this._webStandardTransport.setSupportedProtocolVersions(e)}setScopeChallengeResolver(e){this._webStandardTransport.setScopeChallengeResolver(e)}async handleRequest(e,t,r){let i=e.auth;await m4(async e=>this._webStandardTransport.handleRequest(e,{authInfo:i,parsedBody:r}),{overrideGlobalObjects:!1})(e,t)}closeSSEStream(e){this._webStandardTransport.closeSSEStream(e)}closeStandaloneSSEStream(){this._webStandardTransport.closeStandaloneSSEStream()}};function m3(e=process.env){let t=e.TRACEDECAY_DATA_DIR;if(void 0!==t&&t.length>0)return E.resolve(t);let r="win32"===process.platform?e.USERPROFILE:e.HOME,i=void 0!==r&&r.length>0?r:U.homedir();return E.join(i,".tracedecay")}let m9=o5().min(1),m5=nM({pid:nk().int().nonnegative(),process_run_id:o5(),started_at_unix_secs:nk().int(),epoch:nk().int().nonnegative(),version:o5(),endpoint:nT(),http_application_endpoint:m9.nullable().optional(),auth_token:o5().min(1),profile_root:o5().min(1)});function m8(e){if(e<=0)return!1;try{return process.kill(e,0),!0}catch(e){return"object"==typeof e&&null!==e&&"code"in e&&"EPERM"===e.code}}function m7(e){let t=e.http_application_endpoint;return null==t?null:`http://${t}`}function fe(e){let t=JSON.stringify(function e(t){return Array.isArray(t)?t.map(e):"object"==typeof t&&null!==t?Object.fromEntries(Object.entries(t).sort(([e],[t])=>e<t?-1:+(e>t)).map(([t,r])=>[t,e(r)])):t}(e));if(void 0===t)throw TypeError("value is not canonical JSON");return t}function ft(e,t){if("object"!=typeof e||null===e||Array.isArray(e))throw TypeError(`malformed canonical schema: ${t} must be an object`);return e}function fr(e,t){switch(t){case"null":return null===e;case"boolean":return"boolean"==typeof e;case"integer":return"number"==typeof e&&Number.isSafeInteger(e);case"number":return"number"==typeof e&&Number.isFinite(e);case"string":return"string"==typeof e;case"array":return Array.isArray(e);case"object":return"object"==typeof e&&null!==e&&!Array.isArray(e);default:throw TypeError(`unsupported canonical schema type: ${t}`)}}function fi(e,t){if("object"!=typeof e||null===e||Array.isArray(e))throw TypeError(`malformed canonical envelope: ${t} must be an object`);return e}function fo(e,t){if("string"!=typeof e)throw TypeError(`malformed canonical envelope: ${t} must be a string`);return e}function fn(e,t){if("number"!=typeof e||!Number.isFinite(e))throw TypeError(`malformed canonical envelope: ${t} must be a finite number`);return e}function fa(e,t){if(!Array.isArray(e))throw TypeError(`malformed canonical envelope: ${t} must be an array`);return e}function fs(e,t){let r=fn(e,t);if(!Number.isSafeInteger(r))throw TypeError(`malformed canonical envelope: ${t} must be a safe integer`);return r}function fd(e,t){let r=fs(e,t);if(r<0)throw TypeError(`malformed canonical envelope: ${t} must be non-negative`);return r}let fc=new TextEncoder;function fl(e,t,r){let i=fo(e,t);if(0===i.length||i.trim()!==i||fc.encode(i).byteLength>r||/\p{Cc}/u.test(i))throw TypeError(`malformed canonical envelope: ${t} is not a bounded identifier`);return i}function fp(e,t,r,i,o,n,a,s,d){let c=fi(e,"success envelope");if(fo(c.binding_id,"binding_id")!==t)throw TypeError("malformed canonical envelope: binding mismatch");let l=fi(c.contract,"contract");if(fo(l.schema_id,"contract.schema_id")!==r||fn(l.schema_revision,"contract.schema_revision")!==i)throw TypeError("malformed canonical envelope: result contract mismatch");fo(c.request_id,"request_id"),fi(c.scope,"scope");let p=fi(c.outcome,"outcome"),u=fo(p.outcome,"outcome.outcome");return{...c,outcome:{...p,outcome:u,value:function(e,t,r,i,o,n,a){let s=fi(t,"outcome.value");if(!("payload"in s))throw TypeError("malformed canonical envelope: outcome.value.payload is required");if(("durable_effect"!==o||"required"!==n||"effect"!==e)&&("operation"!==o||"not_required"!==n||"evidence"!==e&&"preview"!==e))throw TypeError(`malformed canonical envelope: outcome ${e} is outside the operation receipt contract`);if(!function(e,t,r){let i=fi(e,"outcome.value.execution");if(fn(i.started_at,"execution.started_at"),fn(i.ended_at,"execution.ended_at"),!("effective_deadline"in i)||!("cancellation"in i))throw TypeError("malformed canonical envelope: receipt fields are required");let o=fi(i.budget,"execution.budget");fn(o.units_consumed,"budget.units_consumed"),fn(o.bytes_consumed,"budget.bytes_consumed"),fn(o.elapsed_micros,"budget.elapsed_micros");let n=fo(i.termination,"execution.termination");if(!t.includes(n))throw TypeError(`malformed canonical envelope: termination ${n} is not legal for this operation`);if(("cancelled"===n||"timed_out"===n)&&null===i.cancellation)throw TypeError("malformed canonical envelope: terminal cancellation observation is required");if(null!==i.cancellation){let e=fi(r,"operation.cancellation"),t=fo(e.mode,"operation.cancellation.mode"),o=fi(i.cancellation,"execution.cancellation"),a=fo(o.stage,"execution.cancellation.stage");if(fs(o.observed_at,"execution.cancellation.observed_at"),!["before_admission","before_read","during_read","before_effect","effect_in_flight","reconciling","after_commit"].includes(a))throw TypeError(`malformed canonical envelope: unknown cancellation stage ${a}`);if("not_cancellable"===t){if("timed_out"!==n)throw TypeError("malformed canonical envelope: non-cancellable operation returned cancellation evidence")}else if(!fa(e.points,"operation.cancellation.points").includes(a))throw TypeError(`malformed canonical envelope: cancellation stage ${a} is not legal for this operation`)}}(s.execution,r,i),"evidence"===e)fi(s.temporal,"temporal"),fi(s.authority,"authority"),fa(s.evidence_authorities,"evidence_authorities"),fi(s.coverage,"coverage"),fa(s.omissions,"omissions"),fa(s.scores,"scores"),fa(s.contributions,"contributions"),function(e){let t=fi(e,"outcome.value.page");if(fl(t.sort_contract_id,"page.sort_contract_id",192),1>fd(t.sort_revision,"page.sort_revision"))throw TypeError("malformed canonical envelope: page sort_revision must be positive");let r=null===t.total?null:fd(t.total,"page.total"),i=fd(t.returned,"page.returned");if(null!==r&&i>r)throw TypeError("malformed canonical envelope: page returned exceeds total");null!==t.cursor&&function(e){let t=fi(e,"page.cursor"),r=fo(t.kind,"page.cursor.kind");if("opaque"===r)fl(t.cursor,"page.cursor.cursor",4096);else throw TypeError(`malformed canonical envelope: unsupported page cursor kind ${r}`)}(t.cursor),null!==t.expires_at&&fs(t.expires_at,"page.expires_at")}(s.page);else if("preview"===e)fo(s.preview_id,"preview_id"),fo(s.preview_digest,"preview_digest"),fo(s.effect_class,"effect_class"),fi(s.authority,"authority"),fo(s.expected_state,"expected_state");else if("effect"===e)fo(s.effect_id,"effect_id"),fo(s.effect_class,"effect_class"),fo(s.idempotency_key,"idempotency_key"),fi(s.authority,"authority"),fo(s.expected_state,"expected_state"),fo(s.reconciliation,"reconciliation"),fi(s.receipt,"receipt");else throw TypeError(`malformed canonical envelope: unsupported outcome ${e}`);return{...s,payload:null===s.payload?null:a(s.payload)}}(u,p.value,o,n,a,s,d)}}}function fu(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function fm(e){return"number"==typeof e&&Number.isSafeInteger(e)&&e>=0}function ff(e){return"number"==typeof e&&Number.isSafeInteger(e)}function fh(e,t){return"string"==typeof e&&e.length>0&&e.trim()===e&&fc.encode(e).byteLength<=t&&!/\p{Cc}/u.test(e)}async function fy(e){let t=await crypto.subtle.digest("SHA-256",fc.encode(fe(e)));return`sha256:${Array.from(new Uint8Array(t),e=>e.toString(16).padStart(2,"0")).join("")}`}function fg(e){return fu(e)&&"string"==typeof e.code&&"string"==typeof e.message}let f_={description:"Strongly typed algorithm-tagged integrity digest: `AccessPolicyDigest`.",type:"string"},fv={description:"Strongly typed canonical identity: `AccessRuleId`.",type:"string"},fb={description:"Strongly typed canonical identity: `ActorId`.",type:"string"},f$={description:"Strongly typed canonical identity: `AgentInstanceId`.",type:"string"},fS={enum:["memory_curator","session_reflector","skill_writer","combined_review","user_job"],type:"string"},fk={properties:{coverage:{$ref:"#/$defs/MetricCoverageV1"},current:{anyOf:[{$ref:"#/$defs/AnalyticsModeV1"},{type:"null"}]},transition_watermark:{type:["string","null"]},unavailable_reason:{type:["string","null"]}},required:["coverage"],type:"object"},fw={enum:["off","local_only","aggregate_share"],type:"string"},fP={oneOf:[{const:"project",description:"Analytics events of the resolved project.",type:"string"},{const:"all",description:"Analytics events of every registered project.",type:"string"}]},fV={description:"Strongly typed canonical identity: `AnalyzerEnvironmentVariable`.",type:"string"},fR={description:"Strongly typed canonical identity: `AnalyzerExecutableId`.",type:"string"},fq={oneOf:[{properties:{executable_id:{$ref:"#/$defs/AnalyzerExecutableId"},kind:{const:"built_in",type:"string"}},required:["kind","executable_id"],type:"object"},{properties:{executable_digest:{$ref:"#/$defs/ManifestDigest"},kind:{const:"approved_external",type:"string"}},required:["kind","executable_digest"],type:"object"}]},fI={description:"Strongly typed canonical identity: `AnalyzerLanguageId`.",type:"string"},fx={additionalProperties:!1,description:"One language's analyzer selection. Host registration may project only the\nnon-sensitive `language_id`/`enabled` pair; all other fields remain in the\nconfiguration authority.",properties:{arguments:{items:{type:"string"},type:"array"},enabled:{type:"boolean"},environment_allowlist:{items:{$ref:"#/$defs/AnalyzerEnvironmentVariable"},type:"array",uniqueItems:!0},executable:{$ref:"#/$defs/AnalyzerExecutableReferenceV1"},initialization_options:{additionalProperties:{$ref:"#/$defs/AnalyzerStructuredValueV1"},type:"object"},language_id:{$ref:"#/$defs/AnalyzerLanguageId"},privacy_class:{$ref:"#/$defs/AnalyzerPrivacyClassV1"},resource_limits:{$ref:"#/$defs/AnalyzerResourceLimitsV1"},restart_policy:{$ref:"#/$defs/AnalyzerRestartPolicyV1"},settings:{additionalProperties:{$ref:"#/$defs/AnalyzerStructuredValueV1"},type:"object"}},required:["language_id","enabled","executable","arguments","initialization_options","settings","environment_allowlist","privacy_class","resource_limits","restart_policy"],type:"object"},fj={enum:["non_sensitive","sensitive","restricted"],type:"string"},fC={additionalProperties:!1,properties:{maximum_memory_mib:{format:"uint32",minimum:0,type:"integer"},request_timeout_millis:{format:"uint64",minimum:0,type:"integer"},startup_timeout_millis:{format:"uint64",minimum:0,type:"integer"}},required:["maximum_memory_mib","startup_timeout_millis","request_timeout_millis"],type:"object"},fT={enum:["restart_on_configuration_change","manual_restart_only"],type:"string"},fO={additionalProperties:!1,description:"Canonical analyzer settings. A changed selection produces a new\nconfiguration revision/digest; cache invalidation remains owned elsewhere.",properties:{schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"},selections:{items:{$ref:"#/$defs/AnalyzerLanguageSelectionV1"},type:"array"}},required:["schema_version","selections"],type:"object"},fE={description:"A structured analyzer option value. This deliberately excludes raw\nenvironment values, commands, credential material, and transport blobs.",oneOf:[{properties:{kind:{const:"boolean",type:"string"},value:{type:"boolean"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"integer",type:"string"},value:{format:"int64",type:"integer"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"text",type:"string"},value:{type:"string"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"text_list",type:"string"},value:{items:{type:"string"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"object",type:"string"},value:{additionalProperties:{$ref:"#/$defs/AnalyzerStructuredValueV1"},type:"object"}},required:["kind","value"],type:"object"}]},fA={description:"The structured facts behind a problem. Adapters read these fields; the\nproblem's `message` is only their one human rendering.",oneOf:[{additionalProperties:!1,description:"The worktree's code index is parked until the operator applies\n`remedy`; repeating the request cannot change the answer.",properties:{cause:{type:"string"},kind:{const:"parked",type:"string"},remedy:{type:"string"},retries_on_wake:{type:"boolean"}},required:["kind","cause","remedy","retries_on_wake"],type:"object"},{additionalProperties:!1,description:"A session refresh asked to begin from a source frontier the\ncommitted projection has already passed.",properties:{active:{format:"uint64",minimum:0,type:"integer"},committed:{format:"uint64",minimum:0,type:"integer"},kind:{const:"stale_refresh_frontier",type:"string"},requested:{format:"uint64",minimum:0,type:"integer"}},required:["kind","requested","committed","active"],type:"object"},{additionalProperties:!1,description:"A compare-and-swap request named `requested` in `field`, but the\nauthority holds `current`. Resending with `current` is a new request.",properties:{current:{format:"uint64",minimum:0,type:"integer"},field:{type:"string"},kind:{const:"stale_precondition",type:"string"},requested:{format:"uint64",minimum:0,type:"integer"}},required:["kind","field","requested","current"],type:"object"},{additionalProperties:!1,description:"A workflow step effect named placement digest `found`, but the step's\ncurrent placement is `expected`: the effect was settled against a\nplacement the run has since replaced.",properties:{expected:{type:"string"},found:{type:"string"},kind:{const:"workflow_placement_digest_stale",type:"string"}},required:["kind","expected","found"],type:"object"},{additionalProperties:!1,description:"A writer lock stayed held by other writers past its admission\ndeadline.",properties:{deadline_ms:{format:"uint64",minimum:0,type:"integer"},kind:{const:"lock_deadline",type:"string"},resource:{type:"string"}},required:["kind","resource","deadline_ms"],type:"object"},{additionalProperties:!1,description:"A persisted store whose shape this binary does not open. It is served\nin this typed state until the operator runs `remedy`, which deletes\nthe old data; nothing is migrated or backed up.",properties:{authority:{type:"string"},found_version:{format:"int64",type:["integer","null"]},kind:{const:"reset_required",type:"string"},reason:{type:"string"},remedy:{type:"string"},required_version:{format:"int64",type:["integer","null"]}},required:["kind","authority","reason","remedy"],type:"object"},{additionalProperties:!1,description:"No compiler runs automatically for the diagnostics scope: no tsconfig\nowns `file`, or, for a workspace read (`file` null), none exists under\nthe project root. `searched` lists the owner search's candidates,\nnearest first; it is empty for a workspace read or a file outside the\nproject root.",properties:{file:{type:["string","null"]},kind:{const:"diagnostics_unsupported",type:"string"},searched:{items:{$ref:"#/$defs/DiagnosticsSearchedTsconfigV1"},type:"array"}},required:["kind","searched"],type:"object"},{additionalProperties:!1,description:"The TypeScript `producer` has not published diagnostics for the\ncurrent code generation yet. `generation` is the last generation it\npublished, null when it has published none.",properties:{generation:{type:["string","null"]},kind:{const:"diagnostics_pending",type:"string"},producer:{type:"string"}},required:["kind","producer"],type:"object"},{additionalProperties:!1,description:"The code graph's engine or catalog was released for memory and was\nstill warming again when the read's budget ran out;\n`retry_after_millis` is the measured warm-up it still needs.",properties:{kind:{const:"code_graph_rewarming",type:"string"},retry_after_millis:{format:"uint64",minimum:0,type:"integer"}},required:["kind","retry_after_millis"],type:"object"},{additionalProperties:!1,description:"No TraceDecay daemon accepts connections on `socket`. `named_by` is\nthe environment variable that chose the socket, when one did;\n`service_unit` is what this client observed of the managed service.",properties:{kind:{const:"daemon_unreachable",type:"string"},named_by:{type:["string","null"]},service_unit:{$ref:"#/$defs/DaemonServiceUnitObservationV1"},socket:{type:"string"}},required:["kind","socket","service_unit"],type:"object"}]},fW={description:"Strongly typed canonical identity: `AttemptId`.",type:"string"},fM={description:"Authoritative scope of a source binding. A mutable path, label, or host\nprofile cannot be represented as authority.",oneOf:[{properties:{id:{$ref:"#/$defs/ProjectId"},kind:{const:"project",type:"string"}},required:["kind","id"],type:"object"},{properties:{id:{$ref:"#/$defs/UserProfileId"},kind:{const:"projectless_hermes",type:"string"}},required:["kind","id"],type:"object"}]},fN={additionalProperties:!1,description:"One exact application scope paired with its registered physical locator.\n\nThe scope remains the identity authority. The locator is retained only so\na later read or restart can reopen the exact registered root without an\nactive-graph or CWD fallback.",properties:{locator:{anyOf:[{$ref:"#/$defs/RegisteredRootLocatorV1"},{type:"null"}]},scope:{$ref:"#/$defs/ResolvedScope"}},required:["scope"],type:"object"},fz={additionalProperties:!1,description:"Immutable canonical set of exact roots admitted by their existing request\ncontexts. A registered locator participates only as frozen reopening\nevidence; its paired [`ResolvedScope`](crate::context::ResolvedScope) remains\nthe root identity authority.",properties:{actor_id:{$ref:"#/$defs/ActorId"},digest:{$ref:"#/$defs/ManifestDigest"},revision:{$ref:"#/$defs/ScopeSetRevision"},roots:{items:{$ref:"#/$defs/AuthorizedRoot"},type:"array"},scope_set_id:{$ref:"#/$defs/ScopeSetId"}},required:["scope_set_id","revision","actor_id","roots","digest"],type:"object"},fD={description:"A terminal automatic-fact receipt state.",enum:["applied","quarantined"],type:"string"},fF={oneOf:[{properties:{kind:{const:"disabled",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"eligible_only",type:"string"},maximum_per_run:{format:"uint16",maximum:65535,minimum:1,type:"integer"},minimum_idle_seconds:{format:"uint64",minimum:1,type:"integer"}},required:["kind","minimum_idle_seconds","maximum_per_run"],type:"object"}]},fL={enum:["disabled","codex_app_server"],type:"string"},fU={enum:["standalone","delegated_host"],type:"string"},fH={description:"The settled status every successful read in this family reports.",enum:["ok"],type:"string"},fG={description:"Which owner's automation schedulers a reconcile covers.",oneOf:[{const:"project",description:"The served project's scheduler, answered by the project's owner.",type:"string"},{const:"profile",description:"Every cached project scheduler of the profile, answered by the\ndaemon's profile owner.",type:"string"}]},fB={properties:{created_at:{type:"string"},kind:{type:"string"},path:{type:"string"},schema_version:{format:"uint32",minimum:0,type:"integer"},sha256:{type:"string"},summary:{type:["string","null"]}},required:["schema_version","kind","path","sha256","created_at"],type:"object"},fK={description:"Automation run reads answer from the active project's ledger only.",enum:["active_project"],type:"string"},fJ={enum:["queued","running","succeeded","failed","skipped"],type:"string"},fZ={additionalProperties:!1,properties:{allow_job_commands:{type:"boolean"},backend:{$ref:"#/$defs/AutomationBackendV1"},combine_due_tasks:{type:"boolean"},enabled:{type:"boolean"},host_mode:{$ref:"#/$defs/AutomationHostModeV1"},model_id:{type:["string","null"]},scheduler_tick_secs:{format:"uint64",minimum:0,type:"integer"},schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"},tasks:{$ref:"#/$defs/AutomationTaskSetV1"},timeout_secs:{format:"uint64",minimum:0,type:"integer"}},required:["schema_version","enabled","backend","host_mode","timeout_secs","scheduler_tick_secs","combine_due_tasks","allow_job_commands","tasks"],type:"object"},fQ={additionalProperties:!1,properties:{memory_curator:{$ref:"#/$defs/AutomationTaskSettingsV1"},session_reflector:{$ref:"#/$defs/AutomationTaskSettingsV1"},skill_writer:{$ref:"#/$defs/AutomationTaskSettingsV1"}},required:["memory_curator","session_reflector","skill_writer"],type:"object"},fX={additionalProperties:!1,properties:{cooldown_secs:{format:"uint64",minimum:0,type:["integer","null"]},enabled:{type:"boolean"},interval_secs:{format:"uint64",minimum:0,type:["integer","null"]},min_idle_secs:{format:"uint64",minimum:0,type:["integer","null"]},schedule:{type:["string","null"]},session_evidence_budget_backoff_secs:{description:"Suppression window between session-evidence retrieval attempts while\nthe evidence budget stays exhausted. Unset uses the automation crate's\none-hour default. Distinct from `cooldown_secs`, which paces retries\nafter failed runs; budget exhaustion is a skip, not a failure.",format:"uint64",minimum:0,type:["integer","null"]}},required:["enabled"],type:"object"},fY={enum:["manual_cli","manual_mcp","dashboard","application","scheduler","host_receipt"],type:"string"},f1={description:"Strongly typed canonical identity: `BrainId`.",type:"string"},f0={oneOf:[{properties:{kind:{const:"reject",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"append_monotonic_ordinal",type:"string"},maximum_attempts:{format:"uint16",maximum:65535,minimum:1,type:"integer"}},required:["kind","maximum_attempts"],type:"object"}]},f2={oneOf:[{properties:{bytes:{format:"uint8",maximum:255,minimum:1,type:"integer"},kind:{const:"task_id_digest_prefix",type:"string"}},required:["kind","bytes"],type:"object"},{properties:{kind:{const:"repository_slug",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"work_class",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"monotonic_collision_ordinal",type:"string"}},required:["kind"],type:"object"}]},f4={enum:["hyphen","underscore","slash"],type:"string"},f6={additionalProperties:!1,properties:{collision:{$ref:"#/$defs/BranchCollisionPolicyV1"},components:{items:{$ref:"#/$defs/BranchNameComponentV1"},type:"array"},maximum_bytes:{format:"uint16",maximum:65535,minimum:1,type:"integer"},prefix:{$ref:"#/$defs/CanonicalGitRefPrefix"},separator:{$ref:"#/$defs/BranchNameSeparatorV1"}},required:["prefix","components","separator","maximum_bytes","collision"],type:"object"},f3={additionalProperties:!1,description:"A declared dependency edge; propagation direction remains an application\ndecision and is never inferred from this edge.",properties:{dependency:{$ref:"#/$defs/StackNodeId"},dependent:{$ref:"#/$defs/StackNodeId"}},required:["dependency","dependent"],type:"object"},f9={description:"Strongly typed canonical identity: `BranchStackId`.",type:"string"},f5={additionalProperties:!1,description:"One visible branch/ref at one immutable tip.",properties:{node_id:{$ref:"#/$defs/StackNodeId"},project_id:{$ref:"#/$defs/ProjectId"},reference:{$ref:"#/$defs/RefId"},repository_id:{$ref:"#/$defs/RepositoryId"},tip:{$ref:"#/$defs/CommitId"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["node_id","project_id","repository_id","reference","tip"],type:"object"},f8={description:"Strongly typed canonical identity: `BranchStackRevisionId`.",type:"string"},f7={additionalProperties:!1,description:"Immutable branch-stack projection at one exact inventory revision.",properties:{canonical_order:{items:{$ref:"#/$defs/StackNodeId"},type:"array"},digest:{$ref:"#/$defs/ManifestDigest"},edges:{items:{$ref:"#/$defs/BranchStackEdgeV1"},type:"array"},inventory_epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},inventory_snapshot_id:{$ref:"#/$defs/WorktreeInventorySnapshotId"},nodes:{items:{$ref:"#/$defs/BranchStackNodeV1"},type:"array"},revision_id:{$ref:"#/$defs/BranchStackRevisionId"},source:{$ref:"#/$defs/BranchStackSourceV1"},stack_id:{$ref:"#/$defs/BranchStackId"}},required:["stack_id","revision_id","inventory_snapshot_id","inventory_epoch","source","nodes","edges","canonical_order","digest"],type:"object"},he={description:"Authoritative source that declared the exact stack topology.",enum:["explicit_declaration","accepted_task_branch_topology"],type:"string"},ht={enum:["no_branches","unbranched","independent_branches","local_stack"],type:"string"},hr={additionalProperties:!1,properties:{allowed:{items:{$ref:"#/$defs/BranchTopologyKindV1"},type:"array",uniqueItems:!0}},required:["allowed"],type:"object"},hi={description:"Strongly typed canonical identity: `CalibrationProfileId`.",type:"string"},ho={additionalProperties:!1,description:"Surface-owned query semantics. Page size remains an invocation control, but\ncontinuation is a request field so CLI, MCP, and HTTP callers all have the\nsame channel for spending a `next_cursor`.",properties:{cursor:{default:null,type:["string","null"]},order:{$ref:"#/$defs/RetrievalOrder"},projection:{$ref:"#/$defs/ResultProjection"}},required:["projection","order"],type:"object"},hn={additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"},stage:{$ref:"#/$defs/CancellationStage"}},required:["stage","observed_at"],type:"object"},ha={description:"Exact stage at which cancellation or deadline state was observed.",enum:["before_admission","before_read","during_read","before_effect","effect_in_flight","reconciling","after_commit"],type:"string"},hs={additionalProperties:!1,description:"One retriever's scored contribution to a fused candidate. Every ranked\ncandidate retains every retriever's raw score domain, ordinal rank,\ncalibrated feature, weight, and weighted contribution.",properties:{calibrated_feature_micros:{format:"uint32",minimum:0,type:"integer"},calibration_profile_id:{$ref:"#/$defs/CalibrationProfileId"},ordinal_rank:{format:"uint32",minimum:0,type:"integer"},raw_score:{$ref:"#/$defs/FixedPointScore"},retriever:{$ref:"#/$defs/RetrieverKind"},retriever_revision:{$ref:"#/$defs/ComponentRevision"},score_domain:{$ref:"#/$defs/ScoreDomainId"},source_occurrence_id:{$ref:"#/$defs/SourceOccurrenceId"},weight_micros:{format:"uint32",minimum:0,type:"integer"},weighted_contribution_micros:{format:"uint64",minimum:0,type:"integer"}},required:["retriever","retriever_revision","source_occurrence_id","ordinal_rank","raw_score","score_domain","calibration_profile_id","calibrated_feature_micros","weight_micros","weighted_contribution_micros"],type:"object"},hd={description:"A validated full native Git ref name, such as `refs/heads/main`.",type:"string"},hc={description:"A validated ref/branch prefix. Branch naming accepts a short branch prefix\n(for example `tracedecay/`) while protected-ref selectors use full\n`refs/.../` prefixes.",type:"string"},hl={description:"Strongly typed canonical identity: `CapabilityId`.",type:"string"},hp={description:"Strongly typed canonical identity: `CatalogGenerationId`.",type:"string"},hu={description:"Strongly typed canonical identity: `ChangePlanId`.",type:"string"},hm={additionalProperties:!1,properties:{from_inclusive:{format:"int64",type:["integer","null"]},through_inclusive:{format:"int64",type:["integer","null"]}},type:"object"},hf={additionalProperties:!1,description:'Why co-change mining produced no answer, so an empty\n`missing_co_change_partners` does not read as "no partner is missing".',properties:{reason:{type:"string"},retryable:{type:"boolean"}},required:["reason","retryable"],type:"object"},hh={enum:["kind","language","path"],type:"string"},hy={description:"Strongly typed canonical identity: `CodeGenerationId`.",type:"string"},hg={description:"Freshness of the generation a verified graph read serves.",oneOf:[{properties:{state:{const:"current",type:"string"}},required:["state"],type:"object"},{properties:{rebuild_in_flight:{type:"boolean"},sealed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"last_complete_stale",type:"string"}},required:["state","sealed_at","rebuild_in_flight"],type:"object"}]},h_={description:"A typed reason an otherwise active generation cannot make durable progress.",enum:["resident_memory","source_unavailable","artifact_store_unavailable","retry_backoff","publication_authority_corrupt"],type:"string"},hv={description:'A deterministic contract violation that parked background convergence.\n\nParked is not dead: the worker keeps re-observing the violation on its\nordinary wake cadence, so an operator fix (for example restoring an\nowner-private mode) is picked up on the next wake without a restart. The\nstate exists so `status`, doctor, and the dashboard report the violation\ntyped instead of an indefinite "warming".',properties:{blocked_reason:{anyOf:[{$ref:"#/$defs/CodeIndexBuildBlockedReasonV1"},{type:"null"}],description:"Stable class for callers that must decide whether new work is admissible."},observed_passes:{description:"Background passes that re-observed the violation since parking.",format:"uint64",minimum:0,type:"integer"},parked_at_micros:{description:"When the violation was first observed (microseconds since the Unix epoch).",format:"int64",type:"integer"},reason:{description:"Exact typed failure that parked convergence.",type:"string"},remediation:{description:"Operator action that clears the violation.",type:"string"},retries_on_wake:{description:"Whether the worker re-checks this violation on every ordinary wake.\nTrue for filesystem/contract violations an operator fix clears in\nplace; false for an abnormal task failure that only changed input (a\nnew sealed generation) retries.",type:"boolean"}},required:["reason","remediation","parked_at_micros","observed_passes","retries_on_wake"],type:"object"},hb={properties:{display_path:{description:"`git_path_bytes` decoded for display, invalid UTF-8 replaced.",type:"string"},git_path_bytes:{description:"The exact Git path bytes, which need not be UTF-8.",items:{format:"uint8",maximum:255,minimum:0,type:"integer"},type:"array"},reason:{$ref:"#/$defs/CodeIndexSourceOmissionReasonV1"}},required:["git_path_bytes","display_path","reason"],type:"object"},h$={description:"Sources a sealed snapshot captured but does not index.",properties:{count:{description:"Every omitted source in the snapshot.",format:"uint64",minimum:0,type:"integer"},sources:{description:"The first omitted sources in Git path order, at most\n[`CODE_INDEX_OMITTED_SOURCE_LIST_LIMIT`].",items:{$ref:"#/$defs/CodeIndexOmittedSourceV1"},type:"array"}},required:["count","sources"],type:"object"},hS={oneOf:[{description:"No logical path can carry the Git path: not UTF-8, a backslash, a\ncontrol character, or leading or trailing whitespace.",properties:{kind:{const:"unrepresentable_path",type:"string"}},required:["kind"],type:"object"},{description:"The privacy boundary withheld the file's bytes.",properties:{detail:{type:"string"},kind:{const:"privacy_withheld",type:"string"}},required:["kind","detail"],type:"object"}]},hk={description:"Closed staleness ladder for one mounted worktree.\n\nThe scheduler publishes one of these tokens. MCP, the dashboard, and the\nCLI must match the variant, not a hand-copied string, so a new ladder\nstate cannot appear at one caller and be missed at the others.",enum:["fresh","stale","indexing","refreshing","restoring","verifying","parked"],type:"string"},hw={description:"Profile-level worker-count intent for the process-wide code-index pool.\n`Automatic` delegates the concrete count to runtime resource admission;\n`Exact` persists an operator-requested positive worker count.",oneOf:[{additionalProperties:!1,properties:{mode:{const:"automatic",type:"string"}},required:["mode"],type:"object"},{additionalProperties:!1,properties:{mode:{const:"exact",type:"string"},workers:{format:"uint16",maximum:65535,minimum:0,type:"integer"}},required:["mode","workers"],type:"object"}]},hP={additionalProperties:!1,properties:{chunk:{anyOf:[{$ref:"#/$defs/CodeSearchChunkId"},{type:"null"}]},file:{$ref:"#/$defs/FileOccurrenceId"},path:{type:"string"},span:{$ref:"#/$defs/SourceSpan"},symbol:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}]}},required:["file","path","span"],type:"object"},hV={additionalProperties:!1,description:"One immutable code-index generation inside the authorized single root.\nThe path prefix narrows a query but never establishes project identity.",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},path_prefix:{type:["string","null"]}},required:["generation"],type:"object"},hR={description:"Strongly typed canonical identity: `CodeSearchChunkId`.",type:"string"},hq={description:"Strongly typed canonical identity: `CommitId`.",type:"string"},hI={enum:["promote","reject","insufficient_evidence"],type:"string"},hx={description:"Whether the bounded complexity walk over a symbol's body ran to the end.\n\nThe extractor stops walking a body once its traversal budget is spent. The\ncounters accumulated by then are lower bounds over the visited prefix, not\nfacts about the whole body, so every surface that prints, ranks, or\naggregates complexity must render this state instead of treating those\ncounters as exact.",oneOf:[{enum:["complete"],type:"string"},{const:"traversal_budget_exhausted",description:"The walk stopped when the traversal budget ran out.",type:"string"}]},hj={description:"Strongly typed canonical identity: `ComponentRevision`.",type:"string"},hC={description:"Strongly typed canonical identity: `ComponentVersion`.",type:"string"},hT={enum:["config_summary"],type:"string"},hO={additionalProperties:!1,description:"One entry per changed config file instead of one per config key.",properties:{config_keys:{format:"uint",minimum:0,type:"integer"},file:{type:"string"},kind:{$ref:"#/$defs/ConfigSummaryKindV1"}},required:["file","kind","config_keys"],type:"object"},hE={description:"Strongly typed canonical identity: `ConfigurationIdempotencyKey`.",type:"string"},hA={description:"A typed configuration layer identity. The default layer intentionally has\nno caller-controlled identifier.",oneOf:[{properties:{kind:{const:"default",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"user_profile",type:"string"},profile_id:{$ref:"#/$defs/UserProfileId"}},required:["kind","profile_id"],type:"object"},{properties:{kind:{const:"project",type:"string"},project_id:{$ref:"#/$defs/ProjectId"}},required:["kind","project_id"],type:"object"},{properties:{collection_id:{$ref:"#/$defs/QueryCollectionId"},kind:{const:"collection",type:"string"}},required:["kind","collection_id"],type:"object"}]},hW={description:"Strongly typed canonical identity: `ConfigurationReceiptId`.",type:"string"},hM={description:"Strongly typed canonical identity: `ConfigurationRevisionId`.",type:"string"},hN={description:"Strongly typed canonical identity: `ConfigurationSnapshotId`.",type:"string"},hz={description:"Values that the typed registry can accept.",oneOf:[{properties:{kind:{const:"boolean",type:"string"},value:{type:"boolean"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"unsigned",type:"string"},value:{format:"uint64",minimum:0,type:"integer"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"code_index_worker_selection",type:"string"},value:{$ref:"#/$defs/CodeIndexWorkerSelectionV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"text",type:"string"},value:{type:"string"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"string_list",type:"string"},value:{items:{type:"string"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"source_bindings",type:"string"},value:{items:{$ref:"#/$defs/ScopeSourceBinding"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"access_rules",type:"string"},value:{items:{$ref:"#/$defs/ScopeAccessRule"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"analyzer_settings",type:"string"},value:{$ref:"#/$defs/AnalyzerSettingsV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"work_topology_policy",type:"string"},value:{$ref:"#/$defs/WorkTopologyPolicyV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"work_executable_bindings",type:"string"},value:{items:{$ref:"#/$defs/WorkExecutableBindingV1"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"work_expertise_consent",type:"string"},value:{$ref:"#/$defs/WorkExpertiseConsentV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"context_scout_settings",type:"string"},value:{$ref:"#/$defs/ContextScoutSettingsV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"automation_settings",type:"string"},value:{$ref:"#/$defs/AutomationSettingsV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"lcm_summarizer_executables",type:"string"},value:{$ref:"#/$defs/LcmSummarizerExecutablesV1"}},required:["kind","value"],type:"object"}]},hD={description:"Strongly typed algorithm-tagged integrity digest: `ContentDigest`.",type:"string"},hF={description:"What one caller `lexical_anchors` entry contributed to the response, in\ncaller order.",oneOf:[{additionalProperties:!1,description:"`matched` indexed rows carried the anchor; `admitted` result sites\ncarrying it are in this response, and `dropped` counts the sites the\nlexical lane admitted that a later stage removed, by reason.",properties:{admitted:{format:"uint64",minimum:0,type:"integer"},anchor:{type:"string"},dropped:{items:{$ref:"#/$defs/LexicalAnchorDropV1"},type:"array"},matched:{format:"uint64",minimum:0,type:"integer"},outcome:{const:"matched",type:"string"}},required:["outcome","anchor","matched","admitted"],type:"object"},{additionalProperties:!1,description:"No indexed row carries the anchor.",properties:{anchor:{type:"string"},outcome:{const:"unmatched",type:"string"}},required:["outcome","anchor"],type:"object"},{additionalProperties:!1,description:"The anchor's route did not serve; `coverage` names the lane state.",properties:{anchor:{type:"string"},outcome:{const:"not_served",type:"string"}},required:["outcome","anchor"],type:"object"}]},hL={enum:["explore","plan"],type:"string"},hU={additionalProperties:!1,description:"Exact opaque destination for one public Context Scout operation.\n\nThe daemon converts this transport-neutral address into its runtime value\nonly after catalog admission. Keeping the public wire here makes CLI, MCP,\nHTTP, and both SDKs share one generated schema authority.",properties:{agent_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},logical_message_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},profile_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},project_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},protected_session_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},provider_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},thread_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},turn_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"}},required:["profile_id","provider_id","protected_session_id","thread_id","turn_id","agent_id","logical_message_id","project_id"],type:"object"},hH={enum:["retrieval","diagnostic","coordination","verification"],type:"string"},hG={additionalProperties:!1,description:"Public lease proof. It carries only opaque identities; the daemon resolves\nit back to the durable queue row before recording delivery.",properties:{envelope_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},lease_expires_at:{$ref:"#/$defs/UtcMicros"},lease_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},work:{$ref:"#/$defs/ContextScoutWorkV1"}},required:["work","envelope_id","lease_id","lease_expires_at"],type:"object"},hB={additionalProperties:!1,properties:{max_candidates:{format:"uint32",minimum:0,type:"integer"},max_evidence:{format:"uint32",minimum:0,type:"integer"},max_model_input_tokens:{format:"uint32",minimum:0,type:"integer"},max_model_output_tokens:{format:"uint32",minimum:0,type:"integer"},max_text_bytes:{format:"uint32",minimum:0,type:"integer"}},required:["max_candidates","max_evidence","max_text_bytes","max_model_input_tokens","max_model_output_tokens"],type:"object"},hK={enum:["deterministic","configured_model"],type:"string"},hJ={enum:["active","paused","disabled"],type:"string"},hZ={enum:["codex_app_server"],type:"string"},hQ={enum:["attempted","delayed","displayed","expanded","explicitly_accepted","explicitly_rejected","dismissed","expired_unseen","corrected","unknown"],type:"string"},hX={additionalProperties:!1,properties:{delivered_at:{$ref:"#/$defs/UtcMicros"},envelope_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},outcome:{$ref:"#/$defs/ContextScoutDeliveryOutcomeV1"},receipt_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"}},required:["receipt_id","envelope_id","delivered_at","outcome"],type:"object"},hY={enum:["immediate","next_boundary","idle_window","on_request","suppressed"],type:"string"},h1={enum:["complete","partial","stale","cancelled","unavailable"],type:"string"},h0={additionalProperties:!1,properties:{anchor_ids:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},availability:{$ref:"#/$defs/ContextScoutEvidenceAvailabilityV1"},claim_digest:{$ref:"#/$defs/ManifestDigest"},content_generation:{$ref:"#/$defs/CodeGenerationId"},session_window:{anyOf:[{$ref:"#/$defs/ContextScoutSessionWindowV1"},{type:"null"}],description:"Session turns a session-evidence suggestion was judged from. Absent for\ncode evidence."}},required:["content_generation","availability","anchor_ids","claim_digest"],type:"object"},h2={enum:["explicitly_accepted","explicitly_rejected","dismissed","corrected"],type:"string"},h4={additionalProperties:!1,properties:{kind:{$ref:"#/$defs/ContextScoutFeedbackKindV1"},receipt_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"}},required:["receipt_id","kind"],type:"object"},h6={description:"One user intent the Scout can recognize. The serialized keys are the\nhistorical hook hint category keys, so persisted hint analytics, hint\nsettlement, and evals keep one vocabulary.",enum:["search","semantic_search","file_read","tool_descriptor_read","broad_read","call_graph","impact","symbol_lookup","file_lookup","project_context","session_recall","atomic_edit","type_orientation","explore_subagent","subagent_start_context","build_diagnostics","review_changes","memory_store","edit_redundancy","unexpected_changes"],type:"string"},h3={additionalProperties:!1,description:"Operator configuration for the Context Scout intent pass.",properties:{action_fact_score_permille:{description:"Score a deterministic action fact contributes for its intent.",format:"uint16",maximum:65535,minimum:0,type:"integer"},enabled:{type:"boolean"},engine:{$ref:"#/$defs/DecisionEngineSettingsV1"},min_delivery_gap_secs:{format:"uint32",minimum:0,type:"integer"},prompt_lookup_deadline_ms:{format:"uint32",minimum:0,type:"integer"},questions:{items:{$ref:"#/$defs/IntentQuestionSettingsV1"},type:"array"},ttl_secs:{format:"uint32",minimum:0,type:"integer"},window:{$ref:"#/$defs/IntentWindowSettingsV1"}},required:["enabled","engine","window","questions","action_fact_score_permille","ttl_secs","min_delivery_gap_secs","prompt_lookup_deadline_ms"],type:"object"},h9={additionalProperties:!1,properties:{max_candidates:{format:"uint",minimum:0,type:"integer"},max_evidence:{format:"uint",minimum:0,type:"integer"},max_model_input_tokens:{format:"uint",minimum:0,type:"integer"},max_model_output_tokens:{format:"uint",minimum:0,type:"integer"},max_text_bytes:{format:"uint",minimum:0,type:"integer"}},required:["max_candidates","max_evidence","max_text_bytes","max_model_input_tokens","max_model_output_tokens"],type:"object"},h5={enum:["disabled","codex_app_server","unsupported","decision_engine"],type:"string"},h8={oneOf:[{enum:["not_requested","succeeded","disabled","unavailable","denied","disconnected","cancelled","deadline_exceeded","token_budget_exceeded","invalid_output"],type:"string"},{const:"backpressured",description:"The engine's concurrency bound was full; the request was not sent.",type:"string"}]},h7={additionalProperties:!1,properties:{actual_model:{type:["string","null"]},actual_provider:{type:["string","null"]},estimated_cost_microusd:{format:"uint64",minimum:0,type:["integer","null"]},input_tokens:{format:"uint64",minimum:0,type:["integer","null"]},output_tokens:{format:"uint64",minimum:0,type:["integer","null"]},requested_backend:{$ref:"#/$defs/ContextScoutModelBackendV1"}},required:["requested_backend"],type:"object"},ye={additionalProperties:!1,properties:{feedback:{anyOf:[{$ref:"#/$defs/ContextScoutFeedbackV1"},{type:"null"}]},receipt:{$ref:"#/$defs/ContextScoutDeliveryReceiptV1"},suggestion:{$ref:"#/$defs/ContextScoutSuggestionProjectionV1"}},required:["suggestion","receipt"],type:"object"},yt={oneOf:[{enum:["deterministic","model_assisted","deterministic_fallback"],type:"string"},{const:"decision_engine",description:"Produced by the session intent pass: decision-engine answers combined\nwith deterministic action facts.",type:"string"}]},yr={enum:["deterministic","configured_model"],type:"string"},yi={enum:["active","paused","disabled"],type:"string"},yo={additionalProperties:!1,description:"Exact bounded span of one session's transcript an intent pass read. The\nwindow body is never retained; only its digest and store-id bounds are.",properties:{first_store_id:{format:"int64",type:"integer"},last_store_id:{format:"int64",type:"integer"},message_count:{format:"uint16",maximum:65535,minimum:0,type:"integer"},newest_timestamp:{format:"int64",type:["integer","null"]},window_digest:{$ref:"#/$defs/ManifestDigest"}},required:["first_store_id","last_store_id","message_count","window_digest"],type:"object"},yn={additionalProperties:!1,description:"Canonical Context Scout control-plane value. Disabled is the only stock\nstate; deterministic or configured-model execution requires an explicit\nconfiguration revision.",properties:{intent:{anyOf:[{$ref:"#/$defs/ContextScoutIntentSettingsV1"},{type:"null"}],description:"Session intent pass. Absent means the Scout runs no intent pass; the\nfield is omitted from the canonical encoding so settings written before\nit existed keep their behavior digest."},limits:{$ref:"#/$defs/ContextScoutConfigurationLimitsV1"},mode:{$ref:"#/$defs/ContextScoutConfigurationModeV1"},model_id:{type:["string","null"]},model_path:{anyOf:[{$ref:"#/$defs/ContextScoutConfiguredModelPathV1"},{type:"null"}]},model_timeout_secs:{format:"uint64",minimum:0,type:["integer","null"]},schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"},state:{$ref:"#/$defs/ContextScoutConfigurationStateV1"}},required:["schema_version","state","mode","limits"],type:"object"},ya={enum:["stored","duplicate","superseded"],type:"string"},ys={additionalProperties:!1,properties:{category:{$ref:"#/$defs/ContextScoutCategoryV1"},configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},dedupe_key:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},delivery_window:{$ref:"#/$defs/ContextScoutDeliveryWindowV1"},envelope_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},evidence:{$ref:"#/$defs/ContextScoutEvidenceProjectionV1"},expires_at:{$ref:"#/$defs/UtcMicros"},model_outcome:{$ref:"#/$defs/ContextScoutModelOutcomeV1"},model_receipt:{anyOf:[{$ref:"#/$defs/ContextScoutModelReceiptV1"},{type:"null"}]},relevance_score:{format:"uint16",maximum:65535,minimum:0,type:"integer"},route:{$ref:"#/$defs/ContextScoutRouteV1"},suggestion_text:{type:"string"},work:{$ref:"#/$defs/ContextScoutWorkV1"}},required:["work","envelope_id","configuration_revision","delivery_window","route","model_outcome","dedupe_key","category","relevance_score","suggestion_text","evidence","expires_at"],type:"object"},yd={oneOf:[{enum:["disabled","paused","dirty_overlay","quiet_or_unreceptive","no_eligible_candidate","expired","duplicate","cancelled","model_output_invalid","evidence_partial","evidence_stale","evidence_unavailable"],type:"string"},{const:"pending_sibling",description:"A suggestion for the same session is already pending delivery.",type:"string"}]},yc={additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},generation:{format:"uint64",minimum:0,type:"integer"},input_watermark:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"}},required:["address","generation","input_watermark"],type:"object"},yl={properties:{authorized_scope_ref:{type:"string"},current:{type:"boolean"},estimated_cost:{items:{$ref:"#/$defs/MetricValueV1"},type:"array"},horizon:{$ref:"#/$defs/ObservabilityHorizonV1"},latency:{description:"Provider-backed operation latency, projected from the same retained\nPlan 26 operation-resource events as Observatory. Each entry keeps\nprovider/model identity explicit; `None` is a real uncorrelated state,\nnever a client-side guess.",items:{$ref:"#/$defs/ProviderLatencyReadModelV1"},type:"array"},observed_at_micros:{format:"int64",type:"integer"},pricing_revision:{type:["string","null"]},usage:{items:{$ref:"#/$defs/MetricValueV1"},type:"array"},watermark:{type:"string"}},required:["authorized_scope_ref","horizon","watermark","observed_at_micros","current","usage","estimated_cost","latency"],type:"object"},yp={description:"Which side of a file dependency the coupling report counts.",enum:["fan_in","fan_out"],type:"string"},yu={description:"Completeness is explicit; unknown never renders as clean.",enum:["complete","partial","unknown"],type:"string"},ym={additionalProperties:!1,properties:{completeness:{$ref:"#/$defs/CoverageCompleteness"},domain:{$ref:"#/$defs/EvidenceDomain"}},required:["domain","completeness"],type:"object"},yf={enum:["known","partial","stale","unknown","sampled","capped"],type:"string"},yh={description:"Strongly typed canonical identity: `CredentialReferenceId`.",type:"string"},yy={enum:["disabled","manual_receipt_only","fast_forward_only","merge_commit","cherry_pick_exact_commits"],type:"string"},yg={additionalProperties:!1,properties:{allow_cross_repository:{type:"boolean"},allowed_modes:{items:{$ref:"#/$defs/CrossMergeModeV1"},type:"array",uniqueItems:!0},default_mode:{$ref:"#/$defs/CrossMergeModeV1"}},required:["allowed_modes","default_mode","allow_cross_repository"],type:"object"},y_={description:"The managed daemon service unit as a client observed it, from the unit\nfile alone.",oneOf:[{additionalProperties:!1,properties:{state:{const:"not_installed",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The unit file could not be read.",properties:{error:{type:"string"},state:{const:"unobservable",type:"string"}},required:["state","error"],type:"object"},{additionalProperties:!1,description:"The unit file at `path` serves the socket `serves`.",properties:{path:{type:"string"},serves:{type:"string"},state:{const:"installed",type:"string"}},required:["state","path","serves"],type:"object"}]},yv={additionalProperties:!1,description:"One immutable deadline supplied by the caller or upstream admission layer.",properties:{expires_at:{$ref:"#/$defs/UtcMicros"}},required:["expires_at"],type:"object"},yb={additionalProperties:!1,description:"The decision engine the intent pass asks. There is no default endpoint or\nmodel; both come only from explicit operator configuration.",properties:{base_url:{type:"string"},max_concurrent:{format:"uint8",maximum:255,minimum:0,type:"integer"},max_state_bytes:{format:"uint32",minimum:0,type:"integer"},model:{type:["string","null"]},timeout_ms:{format:"uint32",minimum:0,type:"integer"}},required:["base_url","timeout_ms","max_concurrent","max_state_bytes"],type:"object"},y$={description:"Diagnostic severity. Source severity is preserved exactly; TraceDecay\nnever raises severity because several producers agree.",enum:["error","warning","information","hint"],type:"string"},yS={additionalProperties:!1,description:"One tsconfig location the diagnostics owner search checked.",properties:{path:{description:"Relative to the project root, forward-slash separated.",type:"string"},present:{description:"The config exists, but neither it nor its references include the\nfile.",type:"boolean"}},required:["path","present"],type:"object"},yk={description:"Whether Doctor observed all of a family's evidence sources.",oneOf:[{const:"complete",description:"Every relevant evidence source for the family was observed.",type:"string"},{const:"partial",description:"Some evidence sources were observed; others were omitted.",type:"string"},{const:"unknown",description:"Whether coverage is complete could not be determined.",type:"string"}]},yw={description:"Shape of the design-structure-matrix report.",enum:["stats","clusters","matrix"],type:"string"},yP={enum:["prevented","committed","unknown","not_applicable"],type:"string"},yV={enum:["exact_duplicate","superseded_overlap","repeated_investigation","duplicate_effect","not_duplicate","censored","unknown"],type:"string"},yR={description:"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.",oneOf:[{enum:["read","preview","source_edit","git_index_stage","git_index_unstage","configuration_write","administrative"],type:"string"},{const:"spawns_process",description:"Runs a child process in the project (e.g. the project's test runner).",type:"string"},{const:"binds_server",description:"Binds a listening server in the daemon process.",type:"string"},{const:"schedules_work",description:"Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.",type:"string"},{const:"maintains_owner_state",description:"Maintains bookkeeping the daemon keeps for the project or profile it\nserves: resets a usage counter, records registry token accounting, or\nreconciles automation schedulers with the saved configuration. Each\nwrite settles within the call and answers its new state.",type:"string"},{const:"maintains_profile_state",description:"Reads and rewrites the daemon profile's own state: its project\nregistry, accounting ledgers, and session stores. Unlike bookkeeping,\nit includes long work, a registry collection or a transcript import,\nthat a cancelled call stops.",type:"string"},{const:"records_host_evidence",description:"Records a host's session evidence (transcripts, hook admissions,\nreceipts) in daemon-owned session stores.",type:"string"}]},yq={additionalProperties:!1,description:"Durable effect proof. It records identities and receipts, never credentials\nor arbitrary command text.",properties:{actor:{$ref:"#/$defs/ActorId"},catalog_digest:{$ref:"#/$defs/ManifestDigest"},committed_state:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},configuration_digest:{$ref:"#/$defs/ManifestDigest"},effect_class:{$ref:"#/$defs/EffectClass"},expected_state:{$ref:"#/$defs/ManifestDigest"},external_proof:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},idempotency_key:{type:"string"},input_digest:{$ref:"#/$defs/ManifestDigest"},operation:{$ref:"#/$defs/UseCaseId"},outcome:{$ref:"#/$defs/EffectTermination"},policy_digest:{$ref:"#/$defs/ManifestDigest"},privacy_digest:{$ref:"#/$defs/ManifestDigest"},request_id:{type:"string"},scope:{$ref:"#/$defs/ResolvedScope"}},required:["operation","request_id","actor","scope","effect_class","idempotency_key","input_digest","expected_state","policy_digest","configuration_digest","catalog_digest","privacy_digest","outcome"],type:"object"},yI={description:"Durable effect receipt terminal state.",enum:["completed","cancelled","timed_out","failed","partial","effect_unknown"],type:"string"},yx={additionalProperties:!1,description:"Deterministic coverage fold input for an evidence packet.",properties:{completeness:{$ref:"#/$defs/CoverageCompleteness"},domains:{items:{$ref:"#/$defs/CoverageDomainState"},type:"array"},eligible:{format:"uint64",minimum:0,type:["integer","null"]},requested_domains:{items:{$ref:"#/$defs/EvidenceDomain"},type:"array"},returned:{format:"uint64",minimum:0,type:"integer"},visited:{format:"uint64",minimum:0,type:["integer","null"]}},required:["requested_domains","returned","completeness","domains"],type:"object"},yj={description:"Requested evidence domain for bounded coverage and omissions.",enum:["symbol","source","graph","test","temporal","anchor","operational","diagnostic"],type:"string"},yC={description:"Evidence role used by dedupe/diversity caps. Independent corroboration\nand contradictions are preserved.",enum:["primary","corroboration","contradiction","context"],type:"string"},yT={description:"The exact tiers, lexicographically ordered above all approximate\ncandidates. Fusion derives this only from a validated [`ExactAdmissionProof`].",enum:["exact_message","exact_literal_phrase","approximate"],type:"string"},yO={description:"The classification of one whole exact technical term. Whole exact terms\nand language-profiled subtokens are distinct fields.",enum:["whole_symbol","qualified_name","path","compiler_error_code","compiler_error_text","runtime_error_code","runtime_error_text","cli_flag","tool_name","configuration_key","commit_identifier"],type:"string"},yE={description:"Strongly typed canonical identity: `FactAssertionId`.",type:"string"},yA={enum:["general","user_pref","project","tool","decision","code_area"],type:"string"},yW={enum:["committed","idempotent_replay"],type:"string"},yM={oneOf:[{additionalProperties:!1,properties:{kind:{const:"profile",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"project",type:"string"},project_id:{$ref:"#/$defs/ProjectId"}},required:["kind","project_id"],type:"object"}]},yN={additionalProperties:!1,properties:{active_assertion_id:{anyOf:[{$ref:"#/$defs/FactAssertionId"},{type:"null"}]},committed_event_ids:{items:{$ref:"#/$defs/FactEventId"},type:"array"},disposition:{$ref:"#/$defs/FactCommitDispositionV1"},fact_id:{$ref:"#/$defs/FactId"},last_event_id:{$ref:"#/$defs/FactEventId"},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["disposition","fact_id","owner","committed_event_ids","last_event_id"],type:"object"},yz={description:"Strongly typed canonical identity: `FactEventId`.",type:"string"},yD={enum:["helpful","unhelpful"],type:"string"},yF={description:"Strongly typed canonical identity: `FactId`.",type:"string"},yL={oneOf:[{additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},kind:{const:"evidence",type:"string"},stable_key:{$ref:"#/$defs/LocatorDigest"}},required:["kind","anchor_id","stable_key"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"application",type:"string"},operation_id:{$ref:"#/$defs/ProvenanceId"}},required:["kind","operation_id"],type:"object"}]},yU={description:"Payload states that structurally cannot expose an available fact payload.",enum:["redacted","quarantined","retention_expired","deleted","unavailable","ambiguous"],type:"string"},yH={oneOf:[{additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactV1"},kind:{const:"available",type:"string"}},required:["kind","fact"],type:"object"},{additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactV1"},kind:{const:"superseded",type:"string"},superseded_by:{$ref:"#/$defs/FactId"}},required:["kind","fact","superseded_by"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"unavailable",type:"string"},status:{$ref:"#/$defs/FactStatusV1"}},required:["kind","status"],type:"object"}]},yG={oneOf:[{additionalProperties:!1,properties:{kind:{const:"not_applicable",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"not_mounted",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{expanded_fact_count:{format:"uint",minimum:0,type:"integer"},kind:{const:"complete",type:"string"},relation_count:{format:"uint",minimum:0,type:"integer"},root_count:{format:"uint",minimum:0,type:"integer"}},required:["kind","root_count","relation_count","expanded_fact_count"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"degraded",type:"string"},reason:{$ref:"#/$defs/FactSearchGraphDegradationV1"}},required:["kind","reason"],type:"object"}]},yB={enum:["conflict","unavailable","budget_exhausted","deadline_exceeded"],type:"string"},yK={additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactV1"},scores:{$ref:"#/$defs/FactSearchScoresV1"},why:{type:["string","null"]}},required:["fact","scores"],type:"object"},yJ={additionalProperties:!1,properties:{fts_score_millionths:{format:"uint32",minimum:0,type:"integer"},holographic_score_millionths:{format:"uint32",minimum:0,type:"integer"},jaccard_score_millionths:{format:"uint32",minimum:0,type:"integer"},score_millionths:{format:"uint32",minimum:0,type:"integer"},trust_score_millionths:{format:"uint32",minimum:0,type:"integer"}},required:["score_millionths","fts_score_millionths","jaccard_score_millionths","holographic_score_millionths","trust_score_millionths"],type:"object"},yZ={additionalProperties:!1,properties:{fact_id:{$ref:"#/$defs/FactId"},owner:{$ref:"#/$defs/FactCommitOwnerV1"},payload_access:{$ref:"#/$defs/FactPayloadAccessV1"},projected_as_of:{$ref:"#/$defs/UtcMicros"}},required:["owner","fact_id","payload_access","projected_as_of"],type:"object"},yQ={additionalProperties:!1,properties:{access_count:{format:"uint64",minimum:0,type:"integer"},created_at:{$ref:"#/$defs/UtcMicros"},helpful_count:{format:"uint64",minimum:0,type:"integer"},last_feedback_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},last_recalled_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},last_retrieved_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},retrieval_count:{format:"uint64",minimum:0,type:"integer"},unhelpful_count:{format:"uint64",minimum:0,type:"integer"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["retrieval_count","access_count","helpful_count","unhelpful_count","created_at","updated_at"],type:"object"},yX={additionalProperties:!1,description:"Available fact projection. Unavailable payload states use\n[`FactProjectionV1::Unavailable`] and cannot fabricate payload fields.",properties:{active_assertion_id:{$ref:"#/$defs/FactAssertionId"},category:{$ref:"#/$defs/FactCategoryV1"},content:{type:"string"},entities:{items:{type:"string"},type:"array"},fact_id:{$ref:"#/$defs/FactId"},last_event_id:{$ref:"#/$defs/FactEventId"},metadata:{additionalProperties:!0,type:"object"},owner:{$ref:"#/$defs/FactCommitOwnerV1"},projected_as_of:{$ref:"#/$defs/UtcMicros"},source:{$ref:"#/$defs/FactIdentitySourceResultV1"},source_label:{type:["string","null"]},tags:{items:{type:"string"},type:"array"},telemetry:{$ref:"#/$defs/FactTelemetryV1"},trust_score_millionths:{format:"uint32",minimum:0,type:"integer"}},required:["owner","fact_id","content","category","tags","entities","trust_score_millionths","source","active_assertion_id","last_event_id","projected_as_of","telemetry","metadata"],type:"object"},yY={additionalProperties:!1,description:"Exact source-owned state for one advisory producer in a composed feedback\ncycle. The producer tag is part of the durable cycle result so consumers\nnever infer provenance from the position of an aggregate provider state.",properties:{producer:{$ref:"#/$defs/FeedbackDiagnosticProducerV1"},state:{$ref:"#/$defs/ProviderEvaluationStateV1"}},required:["producer","state"],type:"object"},y1={description:"Availability of the canonical baseline used to classify a current\ndiagnostic. An unavailable or partial baseline never upgrades a finding\nto `New`; only an authoritative `NoPriorBaseline` state may do so without\na baseline record.",oneOf:[{enum:["complete","partial","stale","unavailable"],type:"string"},{const:"no_prior_baseline",description:"The authoritative runtime confirmed that there is no prior saved\ngeneration to compare. This is authoritative empty history, not an\ninvented horizon and not unavailable/partial coverage.",type:"string"}]},y0={description:"Content identity distinguishes durable saved content from an authorized\nephemeral document overlay. Overlay identity is deliberately local to its\nowning session and cannot be made durable by converting it to a digest.",oneOf:[{properties:{file_digest:{$ref:"#/$defs/ManifestDigest"},generation_digest:{$ref:"#/$defs/ManifestDigest"},kind:{const:"saved_content",type:"string"}},required:["kind","generation_digest","file_digest"],type:"object"},{properties:{agent_id:{anyOf:[{$ref:"#/$defs/AgentInstanceId"},{type:"null"}]},document_version:{format:"uint64",minimum:0,type:"integer"},kind:{const:"ephemeral_overlay",type:"string"},overlay_digest:{$ref:"#/$defs/ManifestDigest"},owner_client_id:{$ref:"#/$defs/HostInstanceId"},session_id:{$ref:"#/$defs/SessionId"}},required:["kind","session_id","owner_client_id","document_version","overlay_digest"],type:"object"}]},y2={description:"Strongly typed canonical identity: `FeedbackCycleId`.",type:"string"},y4={enum:["clean","duplicate_noop","blocked","incomplete_coverage","stale_replan_required","budget_exceeded","cancelled","user_stop","daemon_unavailable"],type:"string"},y6={enum:["new","pre_existing","unknown"],type:"string"},y3={description:"Closed producer vocabulary for standard diagnostic projection.",enum:["code_diagnostic","git_hub_review","ci_localization","proximity"],type:"string"},y9={additionalProperties:!1,description:"Bounded code location used only to project an anchored advisory finding\ninto an editor. The finding's `retrieval_anchor_id` remains the evidence\nexpansion authority; this value carries no source body or provider payload.",properties:{code:{type:"string"},code_description_uri:{type:["string","null"]},file:{$ref:"#/$defs/FileOccurrenceId"},producer:{$ref:"#/$defs/FeedbackDiagnosticProducerV1"},safe_bounded_message:{type:"string"},severity:{$ref:"#/$defs/DiagnosticSeverityV1"},span:{$ref:"#/$defs/SourceSpan"},symbol:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}]}},required:["file","span","code","severity","safe_bounded_message","producer"],type:"object"},y5={enum:["durable","session_only"],type:"string"},y8={description:"Strongly typed canonical identity: `FeedbackFindingId`.",type:"string"},y7={enum:["active","superseded","resolved","cleared"],type:"string"},ge={additionalProperties:!1,properties:{cycle_id:{$ref:"#/$defs/FeedbackCycleId"},expand_handle:{description:"Server-minted request handle for `feedback_expand`, present only when\nthe canonical finding has a retained retrieval anchor.",type:["string","null"]},finding:{$ref:"#/$defs/FeedbackFindingV1"},get_handle:{description:"Server-minted request handle for `feedback_get`; durable identity remains\n`finding.finding_id`.\n\nCursor identity types are deliberately absent from the generated schema\nsurface; the public wire form is the bounded opaque string.",type:"string"},result_id:{$ref:"#/$defs/FeedbackResultId"},scope:{$ref:"#/$defs/FeedbackScopeV1"}},required:["result_id","cycle_id","scope","finding","get_handle"],type:"object"},gt={additionalProperties:!1,description:"Reference-only post-edit feedback finding. The safe preview is bounded display framing,\nnever a source-text copy or a second diagnostic store.",properties:{classification:{$ref:"#/$defs/FeedbackDiagnosticClassificationV1"},diagnostic_projection:{anyOf:[{$ref:"#/$defs/FeedbackDiagnosticProjectionV1"},{type:"null"}]},finding_id:{$ref:"#/$defs/FeedbackFindingId"},lifecycle:{$ref:"#/$defs/FeedbackFindingLifecycleV1"},provider_state:{$ref:"#/$defs/ProviderEvaluationStateV1"},retrieval_anchor_id:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},safe_bounded_preview:{type:["string","null"]}},required:["finding_id","classification","lifecycle","provider_state"],type:"object"},gr={description:"Coverage state for graph impact and affected-test evidence. An empty impact\nset is clean only when its state is complete.",enum:["complete","partial","stale","unavailable"],type:"string"},gi={additionalProperties:!1,description:"Reference-only graph and test impact for one feedback target. The owning\ngraph/query layer supplies these identities; this contract does not create\nanother graph, test map, or evidence store.",properties:{affected_callers:{items:{$ref:"#/$defs/SymbolOccurrenceId"},type:"array"},affected_files:{items:{$ref:"#/$defs/FileOccurrenceId"},type:"array"},affected_tests:{items:{$ref:"#/$defs/SymbolOccurrenceId"},type:"array"},affected_tests_state:{$ref:"#/$defs/FeedbackImpactStateV1"},evidence_anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},state:{$ref:"#/$defs/FeedbackImpactStateV1"},target:{$ref:"#/$defs/FeedbackTargetV1"}},required:["target","affected_files","affected_callers","affected_tests","evidence_anchors","state","affected_tests_state"],type:"object"},go={description:"Strongly typed canonical identity: `FeedbackResultId`.",type:"string"},gn={additionalProperties:!1,description:"Exact repository scope used for a feedback evaluation. A path, current\nworking directory, repository display name, or mutable branch label is not\na substitute for this identity.",properties:{branch_ref:{type:"string"},head_commit_id:{$ref:"#/$defs/CommitId"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["project_id","repository_id","worktree_id","branch_ref","head_commit_id"],type:"object"},ga={additionalProperties:!1,description:"Exact changed-code address for one single-root feedback evaluation. The\naddress carries canonical file/range/symbol identities, never a path or\nmutable line number.",properties:{file:{$ref:"#/$defs/FileOccurrenceId"},generation_id:{anyOf:[{$ref:"#/$defs/CodeGenerationId"},{type:"null"}]},span:{anyOf:[{$ref:"#/$defs/SourceSpan"},{type:"null"}]},symbol:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}]}},required:["file"],type:"object"},gs={description:"Strongly typed canonical identity: `FileOccurrenceId`.",type:"string"},gd={description:"How `tracedecay_files` lays out its listing.",oneOf:[{const:"flat",description:"One file per line.",type:"string"},{const:"grouped",description:"Grouped by directory.",type:"string"}]},gc={description:"Deterministic fixed-point score in millionths. No floating point crosses\nthis boundary.",format:"uint64",minimum:0,type:"integer"},gl={description:"Compatibility state of one source/projection pair.",enum:["current","stale","incompatible","missing","unknown"],type:"string"},gp={additionalProperties:!1,description:"A candidate after contribution grouping and fixed-point fusion.",properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},contributions:{items:{$ref:"#/$defs/CandidateContribution"},type:"array"},decisions:{items:{$ref:"#/$defs/RankingDecision"},type:"array"},exact_class:{$ref:"#/$defs/ExactClass"},freshness:{items:{$ref:"#/$defs/SourceFreshness"},type:"array"},logical_evidence_id:{$ref:"#/$defs/LogicalEvidenceId"},occurrences:{items:{$ref:"#/$defs/OccurrenceProvenance"},type:"array"},source_role:{$ref:"#/$defs/RetrievalSourceRoleV1",description:"Strongest source role across the fused occurrences."},utility_micros:{format:"uint64",minimum:0,type:"integer"}},required:["anchor_id","logical_evidence_id","occurrences","exact_class","source_role","utility_micros","contributions","freshness","decisions"],type:"object"},gu={description:"Metric whose distribution the Gini report measures.",enum:["complexity","lines","fan_in","fan_out","members"],type:"string"},gm={description:"Unit the Gini report aggregates its metric over.",enum:["file","symbol"],type:"string"},gf={description:"Expected blob identity, or explicit absent-file state.",oneOf:[{enum:["absent_file"],type:"string"},{additionalProperties:!1,properties:{present:{$ref:"#/$defs/GitOidV1"}},required:["present"],type:"object"}]},gh={description:"Native change kind for one side (index or worktree) of a status entry,\nor for a whole-file diff record.",enum:["unmodified","modified","added","deleted","renamed","copied","type_changed","unmerged"],type:"string"},gy={additionalProperties:!1,description:"A symbol the exact base/head branch-generation comparison reports.",properties:{content_digest:{type:"string"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},name:{type:"string"},qualified_name:{type:"string"}},required:["id","name","qualified_name","kind","file","content_digest"],type:"object"},gg={oneOf:[{additionalProperties:!1,description:"Caller-selected files: symbols may be unchanged or not yet edited.",properties:{kind:{const:"proposed_files",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{base:{$ref:"#/$defs/GitOidV1"},head:{$ref:"#/$defs/GitOidV1"},kind:{const:"commit_range",type:"string"}},required:["kind","base","head"],type:"object"},{additionalProperties:!1,description:"Pinned HEAD (or empty tree) to the selected immutable index blobs.",properties:{head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},kind:{const:"staged",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,description:"Selected index blobs to captured working-tree bytes.",properties:{kind:{const:"working_tree",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,description:"Net change from pinned HEAD (or empty tree), including untracked files.",properties:{head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},kind:{const:"head_to_worktree",type:"string"}},required:["kind"],type:"object"}]},g_={additionalProperties:!1,description:"A verified-graph symbol a git-context read reports.",properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line"],type:"object"},gv={additionalProperties:!1,description:"Typed coverage of a read-only Git result: the sorted, de-duplicated set\nof degradations observed while capturing it.",properties:{degradations:{items:{$ref:"#/$defs/GitDegradationV1"},type:"array"}},required:["degradations"],type:"object"},gb={description:"Typed coverage/degradation reasons for a read-only Git result. A result\ncarrying any degradation is truthful but not complete; callers must not\ntreat it as a clean full view.",oneOf:[{enum:["detached_head","unborn_branch","sparse_checkout","split_index","unreadable_state","unsupported_object_format","in_progress_operation","shallow_boundary","truncated_output"],type:"string"},{const:"ignored_collision",description:"Ignored content shares a directory with live tracked/untracked\nentries, so the untracked/ignored view may be collapsed by Git.",type:"string"},{const:"conflicted_state",description:"Unmerged index stages are present.",type:"string"},{const:"submodule_state",description:"Submodule entries exist; the adapter does not recurse into them.",type:"string"}]},g$={description:"A native Git file mode as stored in tree/index records (six octal digits,\ne.g. `100644`, `100755`, `120000` symlink, `160000` gitlink/submodule).",type:"string"},gS={description:"A changed file's semantic role.",enum:["config","docs","source","test"],type:"string"},gk={description:"Native HEAD state. Missing, unborn, and detached states are explicit,\nnever guessed.",oneOf:[{properties:{branch:{type:"string"},commit:{$ref:"#/$defs/GitOidV1"},state:{const:"attached",type:"string"}},required:["state","branch","commit"],type:"object"},{properties:{commit:{$ref:"#/$defs/GitOidV1"},state:{const:"detached",type:"string"}},required:["state","commit"],type:"object"},{properties:{branch:{type:"string"},state:{const:"unborn",type:"string"}},required:["state","branch"],type:"object"}]},gw={enum:["disabled","probe_private_preview"],type:"string"},gP={additionalProperties:!1,description:"Expected index entry state for compare-and-swap: blob identity (or\nabsent), mode, and unmerged-stage state. `unmerged_stage` is `None` for a\nmerged (stage-0) entry.",properties:{blob:{$ref:"#/$defs/GitBlobExpectationV1"},mode:{anyOf:[{$ref:"#/$defs/GitFileModeV1"},{type:"null"}]},unmerged_stage:{format:"uint8",maximum:255,minimum:0,type:["integer","null"]}},required:["blob"],type:"object"},gV={description:"Strongly typed canonical identity: `GitIndexPreviewId`.",type:"string"},gR={description:"The only native Git mutations represented by the index-transaction runtime. Generic Git execution,\nref rewrites, commits, merge/rebase/cherry-pick, push, and worktree writes are\ndeliberately absent.",enum:["stage_hunks","unstage_hunks"],type:"string"},gq={description:"A native Git object id (commit, tree, or blob), lowercase hex, SHA-1 or\nSHA-256 length. This is identity evidence only; it never authorizes\nobject reconstruction or traversal outside native Git.",type:"string"},gI={description:"In-progress native Git operation state, read from repository metadata.",enum:["none","merge","rebase","cherry_pick","revert","bisect","sequencer","unknown"],type:"string"},gx={description:"Whether a bounded page holds every answer or stopped at its limit.",enum:["complete","partial"],type:"string"},gj={enum:["complete"],type:"string"},gC={enum:["partial"],type:"string"},gT={enum:["unavailable"],type:"string"},gO={enum:["result_limit"],type:"string"},gE={additionalProperties:!1,properties:{branch:{type:["string","null"]},commit:{type:["string","null"]},worktree:{type:["string","null"]}},type:"object"},gA={description:"Flat public selector for an admitted Git diff scope.\n\nThis intentionally differs from [`tracedecay_domain::GitDiffScopeV1`]: MCP\nand CLI accept `scope`, `base`, and `head` as sibling fields, then\ntransport parsing builds the canonical domain scope after checking their\nlegal combinations.",enum:["working_tree","staged","commit_range"],type:"string"},gW={enum:["git"],type:"string"},gM={additionalProperties:!1,properties:{kind:{$ref:"#/$defs/GitToolErrorKindV1"},message:{type:"string"},operation:{$ref:"#/$defs/GitToolOperationV1"}},required:["kind","operation","message"],type:"object"},gN={additionalProperties:!1,description:"Git itself refused the refs, worktree status, or history the tool reads.",properties:{error:{$ref:"#/$defs/GitToolErrorV1"}},required:["error"],type:"object"},gz={description:"The git step that refused the read.",enum:["diff","status","log"],type:"string"},gD={additionalProperties:!1,properties:{binding_digest:{$ref:"#/$defs/ManifestDigest"},consumed_at:{$ref:"#/$defs/UtcMicros"},input_digest:{$ref:"#/$defs/ManifestDigest"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},request_id:{type:"string"},token_digest:{$ref:"#/$defs/ManifestDigest"}},required:["binding_digest","token_digest","request_id","input_digest","consumed_at","receipt_digest"],type:"object"},gF={enum:["forbid_force_and_rebase"],type:"string"},gL={description:"Strongly typed canonical identity: `HostInstanceId`.",type:"string"},gU={description:"`HunkRef` operation direction: working tree to index, or index to\nHEAD/base. No other direction is encodable.",enum:["working_tree_to_index","index_to_head"],type:"string"},gH={additionalProperties:!1,description:"Immutable hunk identity for compare-and-swap. A hunk is identified by exact repository,\ndirection, path, expected base/index/worktree identity, normalized hunk\nheader, context and patch digests, and the preview that issued the\nreference, never by display ordinal or line number alone.\n\nquery mints these as read-only identity evidence only. Applying them is a\ndaemon Git mutation path and is not representable here.",properties:{attributes_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Attributes/filter identity relevant to clean/smudge and EOL handling."},context_digest:{$ref:"#/$defs/ManifestDigest"},direction:{$ref:"#/$defs/HunkDirectionV1"},expected_base_blob:{$ref:"#/$defs/GitBlobExpectationV1"},expected_index_entry:{$ref:"#/$defs/GitIndexEntryExpectationV1"},expected_worktree_blob:{anyOf:[{$ref:"#/$defs/GitBlobExpectationV1"},{type:"null"}],description:"Expected working-tree identity when the operation reads the worktree:\na native content digest or explicit absent-file state. `None` means\nthe operation direction does not read the worktree."},expected_worktree_mode:{anyOf:[{$ref:"#/$defs/GitFileModeV1"},{type:"null"}]},hunk_header:{description:"Normalized `@@ -o,l +n,m @@` header text.",type:"string"},original_path:{description:"Old path for a rename or copy.",type:["string","null"]},patch_digest:{$ref:"#/$defs/ManifestDigest"},path:{type:"string"},preview_id:{type:"string"},repository:{$ref:"#/$defs/RepositoryId"},schema_version:{type:"string"},selected_line_bitmap:{description:"Selected hunk-line bitmap (little-endian word order, line 1 = bit 0\nof word 0). Full-hunk identity covers the larger old/new side so\ndeletion-only hunks remain representable.",items:{format:"uint64",minimum:0,type:"integer"},type:"array"},snapshot_digest:{$ref:"#/$defs/ManifestDigest"},worktree:{$ref:"#/$defs/WorktreeId"}},required:["repository","worktree","direction","path","expected_base_blob","expected_index_entry","hunk_header","context_digest","patch_digest","selected_line_bitmap","preview_id","schema_version","snapshot_digest"],type:"object"},gG={enum:["available","retained_but_unavailable","redacted","deleted","retention_expired","unauthorized","locked","unverifiable"],type:"string"},gB={additionalProperties:!1,description:"One yes/no question asked of the decision engine for one intent. The\nintent is a candidate when the engine's probability reaches\n`threshold_permille` and, when set, exceeds the runner-up by\n`margin_permille`.",properties:{instructions:{type:"string"},intent:{$ref:"#/$defs/ContextScoutIntentKindV1"},margin_permille:{format:"uint16",maximum:65535,minimum:0,type:["integer","null"]},threshold_permille:{format:"uint16",maximum:65535,minimum:0,type:"integer"}},required:["intent","instructions","threshold_permille"],type:"object"},gK={additionalProperties:!1,description:"Bounds on the recent-session window one intent pass reads.",properties:{freshen_budget_ms:{description:"Time the pass may wait for the transcript store to ingest the newest\nturn before it reads the window as it stands.",format:"uint32",minimum:0,type:"integer"},max_age_secs:{format:"uint32",minimum:0,type:"integer"},max_bytes:{format:"uint32",minimum:0,type:"integer"},max_messages:{format:"uint8",maximum:255,minimum:0,type:"integer"},max_user_turns:{format:"uint8",maximum:255,minimum:0,type:"integer"}},required:["max_user_turns","max_messages","max_bytes","max_age_secs","freshen_budget_ms"],type:"object"},gJ={description:"p50/p95/p99 for one provider operation latency stage.",properties:{p50:{$ref:"#/$defs/MetricValueV1"},p95:{$ref:"#/$defs/MetricValueV1"},p99:{$ref:"#/$defs/MetricValueV1"}},required:["p50","p95","p99"],type:"object"},gZ={oneOf:[{properties:{state:{const:"ready",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"cancelled",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"timed_out",type:"string"}},required:["state"],type:"object"},{properties:{reason:{type:"string"},state:{const:"unavailable",type:"string"}},required:["state","reason"],type:"object"},{properties:{diagnostic:{type:"string"},state:{const:"failed",type:"string"}},required:["state","diagnostic"],type:"object"}]},gQ={additionalProperties:!1,properties:{limit:{format:"uint64",minimum:0,type:"integer"},offset:{format:"uint64",minimum:0,type:"integer"},returned_chars:{format:"uint64",minimum:0,type:"integer"},total_chars:{format:"uint64",minimum:0,type:"integer"},truncated:{type:"boolean"}},required:["offset","limit","returned_chars","total_chars","truncated"],type:"object"},gX={description:"Whether historical discovery, projection publication, and summary\nconvergence have all settled for everything the store's sources hold.",oneOf:[{const:"converging",description:"A stage still owes committed work.",type:"string"},{const:"converged",description:"The worker committed the last owed item and has nothing pending.",type:"string"},{const:"blocked",description:"Every runnable stage settled, but historical discovery is blocked.",type:"string"},{const:"unavailable",description:"No worker is serving the store.",type:"string"}]},gY={additionalProperties:!1,properties:{converged_at_unix_micros:{description:"When the latest convergence event was published.",format:"int64",type:["integer","null"]},epoch:{description:"Convergence events this worker has published; a larger value is a\nnewer event.",format:"uint64",minimum:0,type:"integer"},reason:{description:"The historical discovery blocker when `state` is `blocked`.",type:["string","null"]},state:{$ref:"#/$defs/LcmConvergenceStateV1"}},required:["state","epoch"],type:"object"},g1={description:"Whether the refresh worker that serves this store's temporal projection\nis current, still converging history, or not serving at all.",enum:["current","stale","unavailable"],type:"string"},g0={additionalProperties:!1,description:"The temporal projection's serving state at diagnosis time. A store whose\nschema is healthy can still have nothing to serve while history is being\nre-derived (for example on a fresh profile); this is where\nthat state is named instead of being read as absent data.",properties:{convergence:{$ref:"#/$defs/LcmConvergenceV1"},reason:{description:"Machine reason for a non-current state: `historical_convergence`,\n`historical_retry:<code>`, `historical_blocked:<code>`, or the worker\nunavailability (`worker_missing`, `worker_recovering`, `worker_stalled`,\n`worker_stopped`).",type:["string","null"]},state:{$ref:"#/$defs/LcmDoctorProjectionStateV1"},worker:{$ref:"#/$defs/RetrievalWorkerStatusV1"}},required:["state","worker","convergence"],type:"object"},g2={additionalProperties:!1,properties:{content:{type:"string"},content_hash:{type:"string"},message_id:{type:"string"},metadata_json:{type:["string","null"]},ordinal:{format:"int64",type:"integer"},payload_ref:{type:["string","null"]},provider:{type:"string"},role:{type:"string"},session_id:{type:"string"},storage_kind:{$ref:"#/$defs/LcmStorageKindV1"},store_id:{format:"int64",type:"integer"},timestamp:{format:"int64",type:["integer","null"]}},required:["provider","message_id","session_id","store_id","role","ordinal","content","content_hash","storage_kind"],type:"object"},g4={oneOf:[{properties:{freshness:{$ref:"#/$defs/TemporalFreshnessV1"},outcome:{const:"complete",type:"string"}},required:["outcome","freshness"],type:"object"},{properties:{freshness:{$ref:"#/$defs/TemporalFreshnessV1"},omitted:{format:"uint64",minimum:0,type:"integer"},outcome:{const:"partial",type:"string"}},required:["outcome","freshness","omitted"],type:"object"},{properties:{freshness:{$ref:"#/$defs/TemporalFreshnessV1"},outcome:{const:"stale",type:"string"}},required:["outcome","freshness"],type:"object"}]},g6={oneOf:[{properties:{kind:{const:"raw_message",type:"string"},store_id:{format:"int64",type:"integer"}},required:["kind","store_id"],type:"object"},{properties:{kind:{const:"summary_node",type:"string"},node_id:{type:"string"}},required:["kind","node_id"],type:"object"}]},g3={enum:["inline","external","canonical_occurrence"],type:"string"},g9={description:"One provider's summarizer executable: absent by default, or the exact\nabsolute path the operator configured with its optional tuning.",oneOf:[{properties:{state:{const:"unconfigured",type:"string"}},required:["state"],type:"object"},{properties:{canonical_path:{type:"string"},model:{description:"Model requested for summary turns; the provider default when absent.",type:["string","null"]},state:{const:"configured",type:"string"},timeout_secs:{description:"Wall-clock budget for one summary run, within\n[`LCM_SUMMARIZER_TIMEOUT_SECS_RANGE`]; the caller's default when absent.",format:"uint64",minimum:0,type:["integer","null"]}},required:["state","canonical_path"],type:"object"}]},g5={additionalProperties:!1,description:"The per-provider summarizer executables one configuration snapshot admits.",properties:{codex:{$ref:"#/$defs/LcmSummarizerExecutableV1",default:{state:"unconfigured"},description:"`codex`, driven over app-server JSON-RPC for Codex sessions."},cursor_agent:{$ref:"#/$defs/LcmSummarizerExecutableV1",default:{state:"unconfigured"},description:"`cursor-agent`, asked for a summary of Cursor sessions."}},type:"object"},g8={additionalProperties:!1,properties:{conversation_id:{type:"string"},created_at:{format:"int64",type:"integer"},depth:{format:"int64",type:"integer"},expand_hint:{type:["string","null"]},metadata_json:{type:["string","null"]},node_id:{type:"string"},provider:{type:"string"},session_id:{type:"string"},source_refs:{items:{$ref:"#/$defs/LcmSourceRefV1"},type:"array"},source_time_end:{format:"int64",type:["integer","null"]},source_time_start:{format:"int64",type:["integer","null"]},source_token_count:{format:"int64",type:"integer"},summary_hash:{type:"string"},summary_text:{type:"string"},summary_token_count:{format:"int64",type:"integer"}},required:["node_id","provider","conversation_id","session_id","depth","summary_text","summary_hash","source_refs","summary_token_count","source_token_count","created_at"],type:"object"},g7={additionalProperties:!1,properties:{anchors:{items:{type:"string"},type:"array"},authorized_root:{type:["string","null"]},coverage:{$ref:"#/$defs/TemporalCoverageV1"},explanations:{items:{$ref:"#/$defs/TemporalExplanationV1"},type:"array"},next_cursor:{type:["string","null"]},omissions:{items:{$ref:"#/$defs/TemporalOmissionV1"},type:"array"},source_coverage:{items:{$ref:"#/$defs/SessionSourceCoverageV1"},type:"array"},watermarks:{$ref:"#/$defs/TemporalWatermarksV1"}},required:["anchors","watermarks","coverage","explanations"],type:"object"},_e={description:"Why a site the lexical lane admitted for a caller anchor is absent from\nthe response.",oneOf:[{const:"diversity_cap",description:"Collapsed as a duplicate or held back by the per-file diversity cap.",type:"string"},{const:"outside_page",description:"Ranked, but outside the returned page: an earlier page, or behind\n`next_cursor`.",type:"string"},{const:"not_hydrated",description:"On the page, but late hydration returned no source for it.",type:"string"},{const:"out_of_scope",description:"Outside the caller's scope prefix.",type:"string"}]},_t={additionalProperties:!1,description:"Anchor sites one serving stage removed from the response.",properties:{reason:{$ref:"#/$defs/LexicalAnchorDropReasonV1"},sites:{format:"uint64",minimum:0,type:"integer"}},required:["reason","sites"],type:"object"},_r={description:"Strongly typed algorithm-tagged integrity digest: `LocatorDigest`.",type:"string"},_i={description:"Strongly typed canonical identity: `LogicalCopyClusterId`.",type:"string"},_o={description:"Strongly typed canonical identity: `LogicalEvidenceId`.",type:"string"},_n={enum:["global","project"],type:"string"},_a={properties:{absorbed_into:{type:["string","null"]},activated_at:{format:"int64",type:["integer","null"]},archived_reason:{type:["string","null"]},category:{type:"string"},checksum:{type:"string"},created_at:{format:"int64",type:"integer"},id:{type:"string"},materialization_scope:{$ref:"#/$defs/ManagedSkillMaterializationScope"},pinned:{type:"boolean"},provenance:{$ref:"#/$defs/ManagedSkillProvenance"},routing_description:{type:"string"},state:{$ref:"#/$defs/ManagedSkillState"},summary:{type:"string"},targets:{default:["cursor","codex","claude","agents","opencode","kimi","kiro","hermes"],items:{$ref:"#/$defs/SkillInstallTarget"},type:"array"},title:{type:"string"},updated_at:{format:"int64",type:"integer"}},required:["id","title","summary","routing_description","category","state","pinned","checksum","created_at","updated_at","provenance"],type:"object"},_s={properties:{actor:{type:"string"},run_id:{type:["string","null"]},source:{$ref:"#/$defs/ManagedSkillSource"}},required:["source","actor"],type:"object"},_d={enum:["automation_run","user","import"],type:"string"},_c={enum:["active","disabled","archived"],type:"string"},_l={description:"Strongly typed algorithm-tagged integrity digest: `ManifestDigest`.",type:"string"},_p={description:"The only Git histories this product operation can create.",enum:["fast_forward","two_parent_merge","cherry_pick_exact_commits"],type:"string"},_u={enum:["project","user"],type:"string"},_m={enum:["all","parents_only","subagents_only"],type:"string"},_f={enum:["all","direct_user","tool_result"],type:"string"},_h={properties:{calibration_revision:{type:"string"},cohort_revision:{type:"string"},drift_valid:{type:"boolean"},estimator_revision:{type:"string"},support:{format:"uint64",minimum:0,type:"integer"}},required:["estimator_revision","calibration_revision","cohort_revision","support","drift_valid"],type:"object"},_y={properties:{descriptor_revision:{type:"string"},eligible_population:{type:"string"}},required:["descriptor_revision","eligible_population"],type:"object"},_g={properties:{censored:{format:"uint64",minimum:0,type:"integer"},completed:{format:"uint64",minimum:0,type:"integer"},eligible:{description:"Exact denominator cardinality. `None` means the denominator is unknown.",format:"uint64",minimum:0,type:["integer","null"]},excluded:{format:"uint64",minimum:0,type:"integer"},observed:{format:"uint64",minimum:0,type:"integer"},state:{$ref:"#/$defs/CoverageStateV1"},unknown:{format:"uint64",minimum:0,type:"integer"}},required:["observed","completed","censored","unknown","excluded","state"],type:"object"},__={enum:["measurement","association","calibrated_prediction"],type:"string"},_v={properties:{projector_revision:{type:"string"},source:{$ref:"#/$defs/MetricSourceV1"},source_revision:{type:"string"},watermark:{type:"string"}},required:["source","source_revision","projector_revision","watermark"],type:"object"},_b={enum:["observability_envelope","feedback_observations","provider_usage_observation","savings_ledger"],type:"string"},_$={properties:{baseline_watermark:{type:["string","null"]},delta:{format:"double",type:["number","null"]},horizon:{$ref:"#/$defs/ObservabilityHorizonV1"}},required:["horizon"],type:"object"},_S={properties:{lower:{format:"double",type:["number","null"]},reason:{type:["string","null"]},upper:{format:"double",type:["number","null"]}},type:"object"},_k={properties:{calibration:{anyOf:[{$ref:"#/$defs/MetricCalibrationV1"},{type:"null"}]},cohort:{$ref:"#/$defs/MetricCohortV1"},coverage:{$ref:"#/$defs/MetricCoverageV1"},denominator:{type:"string"},denominator_value:{format:"uint64",minimum:0,type:["integer","null"]},descriptor_revision:{type:"string"},evidence_class:{$ref:"#/$defs/MetricEvidenceClassV1"},metric:{type:"string"},provenance:{$ref:"#/$defs/MetricProvenanceV1"},temporal:{$ref:"#/$defs/MetricTemporalV1"},unavailable_reason:{type:["string","null"]},uncertainty:{$ref:"#/$defs/MetricUncertaintyV1"},unit:{type:"string"},value:{description:"Aggregate value. It is absent whenever its denominator or coverage is\ninsufficient; observed lower bounds remain available in `coverage`.",format:"double",type:["number","null"]}},required:["descriptor_revision","metric","unit","denominator","coverage","evidence_class","provenance","cohort","temporal","uncertainty"],type:"object"},_w={additionalProperties:!1,description:"A file that historically changes with `partner_of` but is missing from the\nchange set under review, e.g. a migration beside its schema.",properties:{co_changes:{description:"Commits that changed both `partner_of` and `file`.",format:"uint64",minimum:0,type:"integer"},file:{type:"string"},partner_of:{type:"string"},partner_of_changes:{description:"Commits that changed `partner_of`.",format:"uint64",minimum:0,type:"integer"}},required:["file","partner_of","co_changes","partner_of_changes"],type:"object"},_P={additionalProperties:!1,description:"Frozen continuation identity shared by all participating roots.",properties:{digest:{$ref:"#/$defs/ManifestDigest"},next_page:{format:"uint64",minimum:1,type:"integer"},order_digest:{$ref:"#/$defs/ManifestDigest"},query_digest:{$ref:"#/$defs/ManifestDigest"},root_cursors:{items:{$ref:"#/$defs/RootScopeOutcomeV1_for_Nullable_string"},type:"array"},root_generations:{items:{$ref:"#/$defs/RootScopeOutcomeV1_for_Nullable_RootGenerationV1"},type:"array"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_set_digest","root_generations","root_cursors","query_digest","order_digest","next_page","digest"],type:"object"},_V={description:"Strongly typed canonical identity: `NativeIntegrationApprovalId`.",type:"string"},_R={description:"Explicit direction of one integration. Stack meaning is never inferred.",enum:["propagate_dependency_to_dependent","land_dependent_into_dependency","integrate_independent_branch"],type:"string"},_q={description:"Truthful preview classification. Only `MechanicalIntegrationEligible`\ncarries apply-eligible evidence.",oneOf:[{properties:{detail:{$ref:"#/$defs/MechanicalIntegrationModeV1"},state:{const:"mechanical_integration_eligible",type:"string"}},required:["state","detail"],type:"object"},{properties:{state:{const:"already_integrated",type:"string"}},required:["state"],type:"object"},{properties:{detail:{properties:{conflict_digest:{$ref:"#/$defs/ManifestDigest"}},required:["conflict_digest"],type:"object"},state:{const:"native_conflict",type:"string"}},required:["state","detail"],type:"object"},{properties:{detail:{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"}},required:["evidence_digest"],type:"object"},state:{const:"semantic_review_required",type:"string"}},required:["state","detail"],type:"object"},{properties:{detail:{properties:{reason:{$ref:"#/$defs/NativeIntegrationUnavailabilityV1"}},required:["reason"],type:"object"},state:{const:"partial",type:"string"}},required:["state","detail"],type:"object"},{properties:{detail:{properties:{reason:{$ref:"#/$defs/NativeIntegrationUnavailabilityV1"}},required:["reason"],type:"object"},state:{const:"unavailable",type:"string"}},required:["state","detail"],type:"object"}]},_I={description:"Strongly typed canonical identity: `NativeIntegrationPreviewId`.",type:"string"},_x={additionalProperties:!1,description:"Canonical stack-snapshot proof returned by `stack_snapshot` and consumed\nverbatim by preflight.",properties:{authorized_scope_set_digest:{$ref:"#/$defs/ManifestDigest"},authorized_scope_set_id:{$ref:"#/$defs/ScopeSetId"},authorized_scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},destination:{$ref:"#/$defs/ResolvedScope"},grant_digest:{$ref:"#/$defs/ManifestDigest"},inventory_epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},inventory_snapshot_id:{$ref:"#/$defs/WorktreeInventorySnapshotId"},policy_digest:{$ref:"#/$defs/ManifestDigest"},selection:{$ref:"#/$defs/NativeIntegrationSelectionBindingV1"},source:{$ref:"#/$defs/ResolvedScope"}},required:["source","destination","authorized_scope_set_id","authorized_scope_set_revision","authorized_scope_set_digest","inventory_snapshot_id","inventory_epoch","selection","grant_digest","policy_digest"],type:"object"},_j={description:"Canonically sealed selection passed to the topology authority.\n\n`stack_snapshot` requests carry declaration content; its boundary seals\nthat declaration into this proof, and preflight accepts the proof verbatim.\nThe topology authority never discovers roots or edges.",oneOf:[{properties:{binding:{properties:{declared_revision:{$ref:"#/$defs/BranchStackRevisionV1"},destination_node_id:{$ref:"#/$defs/StackNodeId"},direction:{$ref:"#/$defs/NativeIntegrationDirectionV1"},revision_digest:{$ref:"#/$defs/ManifestDigest"},revision_id:{$ref:"#/$defs/BranchStackRevisionId"},source_node_id:{$ref:"#/$defs/StackNodeId"},stack_id:{$ref:"#/$defs/BranchStackId"}},required:["stack_id","revision_id","revision_digest","declared_revision","source_node_id","destination_node_id","direction"],type:"object"},kind:{const:"declared_stack_edge",type:"string"}},required:["kind","binding"],type:"object"},{properties:{binding:{properties:{destination_ref:{$ref:"#/$defs/RefId"},proposal_digest:{$ref:"#/$defs/ManifestDigest"},source_ref:{$ref:"#/$defs/RefId"}},required:["proposal_digest","source_ref","destination_ref"],type:"object"},kind:{const:"independent_branch",type:"string"}},required:["kind","binding"],type:"object"}]},_C={description:"The only truthful terminal outcomes after recovery.",enum:["committed","aborted_no_change","rolled_back","needs_inspection"],type:"string"},_T={description:"Strongly typed canonical identity: `NativeIntegrationTransactionId`.",type:"string"},_O={description:"Why a preflight cannot authorize apply.",enum:["partial_evidence","stale_scope","denied","native_state_unavailable","reset_required","durability_uncertain","unsupported_hooks","signing_required","destination_occupied"],type:"string"},_E={description:"A target selected by exact registered identity. Repository inventory names\none repository; cleanup names one worktree within that repository.",oneOf:[{properties:{kind:{const:"repository",type:"string"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"}},required:["kind","project_id","repository_id"],type:"object"},{properties:{kind:{const:"worktree",type:"string"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["kind","project_id","repository_id","worktree_id"],type:"object"}]},_A={additionalProperties:!1,properties:{body:{format:"uint64",minimum:0,type:"integer"},full_file:{format:"uint64",minimum:0,type:"integer"}},required:["body","full_file"],type:"object"},_W={properties:{since_micros:{format:"int64",type:"integer"},until_micros:{format:"int64",type:"integer"}},required:["since_micros","until_micros"],type:"object"},_M={additionalProperties:!1,description:"Stable logical identity of one provider observation source.\n\nThe session identity is provider-native evidence. The physical file identity\nis represented separately by [`ObservationSourceGenerationV1`].",properties:{provider:{$ref:"#/$defs/ProviderId"},session_id:{$ref:"#/$defs/SessionId"},source_key:{anyOf:[{$ref:"#/$defs/SessionId"},{type:"null"}]}},required:["provider","session_id"],type:"object"},_N={properties:{analytics_mode:{$ref:"#/$defs/AnalyticsModeReadModelV1"},authorized_scope_ref:{type:"string"},comparison:{$ref:"#/$defs/PerformanceComparisonReadModelV1"},current:{type:"boolean"},horizon:{$ref:"#/$defs/ObservabilityHorizonV1"},metrics:{items:{$ref:"#/$defs/MetricValueV1"},type:"array"},observed_at_micros:{format:"int64",type:"integer"},rejected_arguments:{$ref:"#/$defs/RejectedArgumentAnalyticsV1"},watermark:{type:"string"}},required:["authorized_scope_ref","horizon","watermark","observed_at_micros","current","metrics","analytics_mode","comparison","rejected_arguments"],type:"object"},_z={additionalProperties:!1,description:"Structured occurrence provenance retained through fusion. Fusion\npreserves each exact `(source_occurrence_id, retriever_evidence_anchor)`\npair; parallel unassociated provenance vectors are forbidden.",properties:{evidence_role:{$ref:"#/$defs/EvidenceRole"},file_occurrence_id:{anyOf:[{$ref:"#/$defs/FileOccurrenceId"},{type:"null"}]},freshness:{$ref:"#/$defs/SourceFreshness"},logical_copy_cluster_id:{anyOf:[{$ref:"#/$defs/LogicalCopyClusterId"},{type:"null"}]},logical_copy_evidence_anchor:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},repository_id:{anyOf:[{$ref:"#/$defs/RepositoryId"},{type:"null"}]},retriever_evidence_anchor:{$ref:"#/$defs/RetrievalAnchorId"},session_or_thread_id:{anyOf:[{$ref:"#/$defs/SessionOrThreadId"},{type:"null"}]},source_namespace:{$ref:"#/$defs/SourceNamespace"},source_occurrence_id:{$ref:"#/$defs/SourceOccurrenceId"}},required:["source_occurrence_id","retriever_evidence_anchor","source_namespace","evidence_role","freshness"],type:"object"},_D={additionalProperties:!1,description:"Bounded work accounting supplied by an owning port or transaction.",properties:{bytes_consumed:{format:"uint64",minimum:0,type:"integer"},elapsed_micros:{format:"uint64",minimum:0,type:"integer"},units_consumed:{format:"uint64",minimum:0,type:"integer"}},required:["units_consumed","bytes_consumed","elapsed_micros"],type:"object"},_F={additionalProperties:!1,description:"Canonical operation evidence. An admitted failure remains represented here\nrather than being replaced by a transport exception.",properties:{budget:{$ref:"#/$defs/OperationBudgetUsage"},cancellation:{anyOf:[{$ref:"#/$defs/CancellationObservation"},{type:"null"}]},effective_deadline:{$ref:"#/$defs/Deadline"},ended_at:{$ref:"#/$defs/UtcMicros"},started_at:{$ref:"#/$defs/UtcMicros"},termination:{$ref:"#/$defs/OperationTermination"}},required:["started_at","ended_at","effective_deadline","budget","termination"],type:"object"},_L={description:"Terminal state after an operation has been admitted.",enum:["completed","cancelled","timed_out","failed","unavailable","partial","effect_unknown"],type:"string"},_U={additionalProperties:!1,description:"Bounded opaque page request. Resume authorization occurs before an adapter\ndecodes or hydrates the cursor.",properties:{cursor:{description:"Opaque resume token. The identifier type is deliberately absent from the\ngenerated schema surface, so the public wire form is its bounded string.",type:["string","null"]},page_size:{format:"uint32",minimum:0,type:"integer"}},required:["page_size"],type:"object"},_H={properties:{baseline_build:{type:["string","null"]},candidate_build:{type:["string","null"]},configuration:{type:["string","null"]},corpus:{type:["string","null"]},coverage:{$ref:"#/$defs/MetricCoverageV1"},disposition:{$ref:"#/$defs/ComparisonDispositionV1"},eligible_outcomes:{format:"uint64",minimum:0,type:["integer","null"]},environment:{type:["string","null"]},oracle:{type:["string","null"]},paired_outcomes:{format:"uint64",minimum:0,type:["integer","null"]},platform:{type:["string","null"]},regression_observed:{type:["boolean","null"]},rollback_profile:{type:["string","null"]},unavailable_reason:{type:["string","null"]},workload:{type:["string","null"]}},required:["disposition","coverage"],type:"object"},_G={oneOf:[{enum:["brief"],type:"string"},{const:"symbols",description:"Exact changed-symbol enumeration, with its existing continuation cursor.",type:"string"}]},_B={description:"Whether the served code generation is known current at serve time.",enum:["fresh","possibly_stale"],type:"string"},_K={additionalProperties:!1,description:"The indexing state behind a `possibly_stale` verdict: the served\ngeneration, the scheduler's latest sealed generation, its staleness-ladder\nstate, and the lanes that answered from an older generation. `summary` is\nthe one-line rendering agents read.",properties:{latest_generation:{type:["string","null"]},parked:{anyOf:[{$ref:"#/$defs/CodeIndexConvergenceParkedV1"},{type:"null"}],description:"The park holding convergence until the operator applies its remedy.\nNo wake retries it, so repeating the request cannot change the answer."},reason:{type:["string","null"]},rebuild_in_flight:{type:["boolean","null"]},served_generation:{type:["string","null"]},stale_lanes:{items:{type:"string"},type:"array"},staleness_state:{anyOf:[{$ref:"#/$defs/CodeIndexStalenessStateV1"},{type:"null"}]},summary:{type:"string"}},required:["summary"],type:"object"},_J={enum:["complete"],type:"string"},_Z={additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},message:{type:"string"},node_id:{type:"string"},reason_code:{type:"string"},status:{type:"string"},suggestions:{description:"Nearest served symbols by edit distance to the requested id, by id,\nsimple name, or qualified name.",items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},type:"array"}},required:["status","reason_code","node_id","message"],type:"object"},_Q={enum:["full","partial"],type:"string"},_X={additionalProperties:!1,description:"Freshness verdict carried by every search and context response. `indexing`\nis present exactly when the state is `possibly_stale`.",properties:{indexing:{anyOf:[{$ref:"#/$defs/PrimitiveIndexingStateV1"},{type:"null"}]},state:{$ref:"#/$defs/PrimitiveFreshnessStateV1"}},required:["state"],type:"object"},_Y={additionalProperties:!1,properties:{language:{type:["string","null"]},provider:{type:["string","null"]},reason:{type:"string"}},required:["reason"],type:"object"},_1={additionalProperties:!1,properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},kind:{type:"string"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"},unavailable_fields:{items:{type:"string"},type:"array"}},required:["node_id","name","qualified_name","kind","file","start_line","end_line","unavailable_fields"],type:"object"},_0={additionalProperties:!1,properties:{detail:{type:"string"},reason_code:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/PrimitiveUnavailableStatusV1"}},required:["status","reason_code","retryable","detail"],type:"object"},_2={enum:["unavailable"],type:"string"},_4={description:"Strongly typed canonical identity: `ProjectId`.",type:"string"},_6={properties:{alias_count:{format:"uint",minimum:0,type:"integer"},artifact_count:{format:"uint",minimum:0,type:"integer"},branches:{items:{type:"string"},type:"array"},canonical_root:{type:"string"},default_branch:{description:"Repository default branch recorded at registration.",type:["string","null"]},head_branch:{description:"Branch the checkout's HEAD names now; `None` when HEAD is detached or\nno checkout of this project could be read.",type:["string","null"]},is_active:{type:["boolean","null"]},kind:{type:"string"},label:{type:"string"},last_seen_at:{format:"int64",type:"integer"},project_id:{type:"string"},project_root:{type:"string"},store_count:{format:"uint",minimum:0,type:"integer"}},required:["project_id","label","project_root","canonical_root","kind","branches","store_count","artifact_count","alias_count","last_seen_at"],type:"object"},_3={properties:{project_count:{format:"uint",minimum:0,type:"integer"},repo_count:{format:"uint",minimum:0,type:"integer"},truncated:{type:"boolean"}},required:["project_count","repo_count","truncated"],type:"object"},_9={properties:{branches:{items:{type:"string"},type:"array"},git_common_dir:{type:["string","null"]},label:{type:"string"},project_count:{format:"uint",minimum:0,type:"integer"},projects:{items:{$ref:"#/$defs/ProjectRegistryEntry"},type:"array"}},required:["label","project_count","branches","projects"],type:"object"},_5={description:"Strongly typed canonical identity: `ProjectionGenerationId`.",type:"string"},_8={description:"Strongly typed canonical identity: `ProposalId`.",type:"string"},_7={enum:["reject","require_human_approval_and_independent_review"],type:"string"},ve={additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/ProtectedRefDispositionV1"},selector:{$ref:"#/$defs/ProtectedRefSelectorV1"}},required:["selector","disposition"],type:"object"},vt={oneOf:[{properties:{kind:{const:"native_default_branch",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"exact",type:"string"},value:{$ref:"#/$defs/CanonicalGitRefNameV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"prefix",type:"string"},value:{$ref:"#/$defs/CanonicalGitRefPrefix"}},required:["kind","value"],type:"object"}]},vr={description:"Strongly typed canonical identity: `ProvenanceId`.",type:"string"},vi={description:"Complete provider states remain distinct. Empty findings are clean only\nwhen every requested provider completed with complete supported coverage.",enum:["supported_completed_complete","unsupported","absent","indexing","stale","cancelled","timed_out","failed","partial","unavailable"],type:"string"},vo={description:"Strongly typed canonical identity: `ProviderId`.",type:"string"},vn={description:"One provider/model cohort in the Costs latency read model.\n\nThe percentile cells are ordinary canonical metrics so every value carries\nits exact unit, horizon, denominator, coverage/censoring, and projector\nprovenance. Identity provenance is kept separately because latency is\nmeasured by `OperationResourceObservedV1`, while provider/model identity\nmay be joined from an exact `ProviderUsageObservationV1` request/session.",properties:{first_progress:{$ref:"#/$defs/LatencyDistributionReadModelV1"},identity_provenance:{$ref:"#/$defs/MetricProvenanceV1"},identity_unavailable_reason:{type:["string","null"]},model:{type:["string","null"]},provider:{type:["string","null"]},queue:{$ref:"#/$defs/LatencyDistributionReadModelV1"},service:{$ref:"#/$defs/LatencyDistributionReadModelV1"},start:{$ref:"#/$defs/LatencyDistributionReadModelV1"},terminal:{$ref:"#/$defs/LatencyDistributionReadModelV1"}},required:["identity_provenance","queue","start","first_progress","service","terminal"],type:"object"},va={properties:{canonical_root:{type:"string"},created_at:{format:"int64",type:"integer"},default_branch:{description:"Repository default branch recorded at registration.",type:["string","null"]},display_root:{type:"string"},git_common_dir:{type:["string","null"]},head_branch:{description:"Branch the checkout's HEAD names now; `None` when HEAD is detached or\nno checkout of this project could be read.",type:["string","null"]},is_active:{type:["boolean","null"]},label:{type:"string"},last_seen_at:{format:"int64",type:"integer"},project_id:{type:"string"},project_root:{type:"string"}},required:["project_id","label","project_root","display_root","canonical_root","created_at","last_seen_at"],type:"object"},vs={enum:["owner_receipt","locally_measured","estimated","unknown"],type:"string"},vd={description:"Strongly typed canonical identity: `QueryCollectionId`.",type:"string"},vc={description:"Which endpoint of each counted edge the rank report ranks.",enum:["incoming","outgoing"],type:"string"},vl={description:"Relationship the rank report counts.",enum:["implements","extends","calls","uses","contains","annotates","type_of","returns","receives"],type:"string"},vp={additionalProperties:!1,description:"One recorded ranking decision. Explanations are rendered from this\nprovenance, never reconstructed from a final scalar score.",properties:{detail:{type:"string"},evidence_anchor:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},kind:{$ref:"#/$defs/RankingDecisionKind"},policy_anchor:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},retriever:{anyOf:[{$ref:"#/$defs/RetrieverKind"},{type:"null"}]}},required:["kind","detail"],type:"object"},vu={description:"The decision kinds the pipeline must record.",enum:["exact_tier_admission","same_source_duplicate_collapse","logical_copy_representative_selection","contradiction_preservation","diversity_cap","comparator_provenance","fallback"],type:"string"},vm={description:"Strongly typed canonical identity: `RefId`.",type:"string"},vf={additionalProperties:!1,description:"Exact registered root locator retained with an authorized scope.\n\n`canonical_root` is routing evidence for the already-resolved\n[`ResolvedScope`]. It cannot replace or manufacture that scope identity.",properties:{canonical_root:{type:"string"},profile:{$ref:"#/$defs/SharedProfileStoreLocatorV1"},project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id","profile","canonical_root"],type:"object"},vh={description:"Frequency and rate projection for dispatcher rejected-argument observations.\n\nCounts may be known while `rejection_rate` stays absent: Plan 26 forbids\nfabricating a rate when the eligible-attempt denominator is unknown.",properties:{coverage:{$ref:"#/$defs/MetricCoverageV1"},eligible_attempts:{format:"uint64",minimum:0,type:["integer","null"]},groups:{items:{$ref:"#/$defs/RejectedArgumentGroupV1"},type:"array"},projector_revision:{type:"string"},redacted_name_count:{format:"uint64",minimum:0,type:"integer"},rejected_total:{format:"uint64",minimum:0,type:["integer","null"]},rejection_rate:{format:"double",type:["number","null"]},unavailable_reason:{type:["string","null"]},watermark:{type:"string"}},required:["coverage","projector_revision","watermark","redacted_name_count","groups"],type:"object"},vy={description:"Closed error class for a rejected surface argument.",enum:["missing","invalid_shape","out_of_bounds","unsupported","unauthorized","stale","unknown"],type:"string"},vg={description:"One surface \xd7 operation \xd7 argument \xd7 error-class cell in the rejected-argument view.",properties:{argument:{$ref:"#/$defs/RejectedArgumentNameV1"},count:{format:"uint64",minimum:0,type:"integer"},error_class:{$ref:"#/$defs/RejectedArgumentErrorClassV1"},operation:{type:"string"},rate:{description:"Eligible-attempt rate for this cell. Absent when the attempt\ndenominator or coverage is insufficient.",format:"double",type:["number","null"]},surface:{$ref:"#/$defs/RejectedArgumentSurfaceV1"}},required:["surface","operation","argument","error_class","count"],type:"object"},v_={description:"Normalized rejected-argument name. Raw flags, values, and tokens never\nenter this vocabulary.",enum:["request_body","pagination","request_handle","operation","lifecycle","unknown"],type:"string"},vv={description:"Transport that rejected a surface argument. Unknown preserves missing\nattribution instead of inventing cli/mcp/http.",enum:["cli","mcp","http","unknown"],type:"string"},vb={description:"Strongly typed canonical identity: `RepositoryId`.",type:"string"},v$={oneOf:[{properties:{kind:{const:"all_authorized",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"allowlist",type:"string"},repositories:{items:{$ref:"#/$defs/RepositoryId"},type:"array",uniqueItems:!0}},required:["kind","repositories"],type:"object"}]},vS={enum:["successful_terminal"],type:"string"},vk={additionalProperties:!1,properties:{capability_id:{$ref:"#/$defs/CapabilityId"},expectation:{$ref:"#/$defs/RequiredCheckExpectationV1"},maximum_age_seconds:{format:"uint32",minimum:1,type:"integer"}},required:["capability_id","expectation","maximum_age_seconds"],type:"object"},vw={additionalProperties:!1,description:"The resolved configuration scope is one exact project/repository/worktree root.\n\nPaths, CWDs, labels, and mutable branch spellings are deliberately absent.",properties:{project_id:{$ref:"#/$defs/ProjectId"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},repository_id:{$ref:"#/$defs/RepositoryId"},scope_digest:{$ref:"#/$defs/ManifestDigest"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["project_id","repository_id","worktree_id","scope_digest"],type:"object"},vP={description:"Bounded output projection chosen by a concrete use case.",enum:["summary","evidence","references_only"],type:"string"},vV={additionalProperties:!1,properties:{code:{type:"string"},kind:{type:["string","null"]},maximum:{format:"uint",minimum:0,type:["integer","null"]},message:{type:"string"},observed:{format:"uint",minimum:0,type:["integer","null"]},reason:{type:["string","null"]},retryable:{type:["boolean","null"]}},required:["code","message"],type:"object"},vR={enum:["aborted","budget_exhausted","busy","cancelled","complete","complete_zero","cursor_manifest_limit_exceeded","deadline_exceeded","deleted","denied","error","failed","joined","locked","not_found","ok","partial","recorded","redacted","running","stale","started","unavailable","unsupported_filter","wrong_scope"],type:"string"},vq={anyOf:[{format:"uint64",minimum:0,type:"integer"},{type:"string"}],description:"The temporal filter intentionally retains the established integer-or-text\nwire form (Unix timestamps, RFC3339, and relative expressions)."},vI={description:"Strongly typed canonical identity: `RetrievalAnchorId`.",type:"string"},vx={description:"Stable semantic ordering; adapters may not replace it with transport order.",enum:["relevance","source_position","temporal_descending","stable_identity"],type:"string"},vj={additionalProperties:!1,properties:{order:{$ref:"#/$defs/RetrievalOrder"},page:{$ref:"#/$defs/PageRequest"},projection:{$ref:"#/$defs/ResultProjection"},temporal:{$ref:"#/$defs/TemporalModeV1"}},required:["temporal","page","projection","order"],type:"object"},vC={description:"Source-role evidence used at lane admission and fusion.\n\nA production definition outranks a test-file hit for the same symbol even\nwhen the test has a higher measured score. Non-definition production hits\ncompete with test hits on measured scores so comments and references do\nnot crowd out relevant tests.",oneOf:[{const:"production_definition",description:"Non-test path whose name or signature matched the query.",type:"string"},{const:"production_other",description:"Non-test path that is not a name or signature definition match.",type:"string"},{const:"test_reference",description:"Hit under a test path.",type:"string"}]},vT={additionalProperties:!1,properties:{backlog:{format:"uint",minimum:0,type:"integer"},blocker:{type:["string","null"]},last_progress_at_unix_micros:{format:"int64",type:["integer","null"]},retry_class:{type:["string","null"]}},required:["backlog"],type:"object"},vO={description:"Runtime-backed retrieval lanes. Each lane is independently testable,\ndisableable, budgeted, and attributable; one lane is never an alias over\nanother.",enum:["exact_literal","lexical","graph","temporal","task_session","diagnostic"],type:"string"},vE={oneOf:[{properties:{kind:{const:"none",type:"string"}},required:["kind"],type:"object"},{properties:{count:{format:"uint16",maximum:65535,minimum:1,type:"integer"},kind:{const:"independent_review_count",type:"string"}},required:["kind","count"],type:"object"},{properties:{kind:{const:"code_owner_and_independent_review",type:"string"}},required:["kind"],type:"object"}]},vA={enum:["no_review","independent_review","standard_pull_requests","git_hub_stacked_pull_requests"],type:"string"},vW={additionalProperties:!1,properties:{allowed:{items:{$ref:"#/$defs/ReviewTopologyKindV1"},type:"array",uniqueItems:!0},github_stacked_prs:{$ref:"#/$defs/GitHubStackedPullRequestPolicyV1"}},required:["allowed","github_stacked_prs"],type:"object"},vM={additionalProperties:!1,description:"Immutable collection and stack revisions for one exact resolved root.",properties:{collection_revision:{$ref:"#/$defs/ManifestDigest"},generation_digest:{$ref:"#/$defs/ManifestDigest"},scope_digest:{$ref:"#/$defs/ManifestDigest"},stack_revision:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest","collection_revision","stack_revision","generation_digest"],type:"object"},vN={additionalProperties:!1,description:"One typed outcome pinned to the digest of an exact resolved root.",properties:{outcome:{$ref:"#/$defs/ScopeOutcome_for_Nullable_RootGenerationV1"},scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest","outcome"],type:"object"},vz={additionalProperties:!1,description:"One typed outcome pinned to the digest of an exact resolved root.",properties:{outcome:{$ref:"#/$defs/ScopeOutcome_for_Nullable_string"},scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest","outcome"],type:"object"},vD={enum:["allow","deny"],type:"string"},vF={description:"Strongly typed canonical identity: `RunId`.",type:"string"},vL={additionalProperties:!1,properties:{degraded_row:{type:["string","null"]},stage:{$ref:"#/$defs/SchemaConvergenceStageV1"},started_at_micros:{format:"int64",type:"integer"},state:{$ref:"#/$defs/SchemaConvergenceStateV1"},store:{type:"string"}},required:["store","stage","state","started_at_micros"],type:"object"},vU={enum:["registered_schema"],type:"string"},vH={oneOf:[{enum:["pending","running","completed"],type:"string"},{const:"retrying",description:"The last attempt failed and the store's convergence task tries again by\nitself. `degraded_row` carries that attempt's failure.",type:"string"},{const:"degraded",description:"Convergence stopped on a failure and nothing retries it on this mount.",type:"string"}]},vG={additionalProperties:!1,description:"Restrictive policy input. An allow never grants capabilities absent from\nthe independently authorized capability set passed to the resolver.",properties:{authority:{$ref:"#/$defs/AuthorityRef"},capabilities:{items:{$ref:"#/$defs/CapabilityId"},type:"array",uniqueItems:!0},effect:{$ref:"#/$defs/RuleEffect"},expires_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},rule_id:{$ref:"#/$defs/AccessRuleId"},subject:{$ref:"#/$defs/ScopeAccessSubjectV1"}},required:["rule_id","subject","authority","capabilities","effect"],type:"object"},vB={additionalProperties:!1,description:"Typed rule selectors. Unset dimensions match all values at that dimension,\nbut at least one dimension must be constrained. Free-form paths, labels,\ncollection names, and branch names are deliberately absent.",properties:{actor:{anyOf:[{$ref:"#/$defs/ActorId"},{type:"null"}]},operation:{anyOf:[{$ref:"#/$defs/ScopeControlOperationV1"},{type:"null"}]},source_kind:{anyOf:[{$ref:"#/$defs/SourceKindV1"},{type:"null"}]}},type:"object"},vK={enum:["read","source_bind","source_rebind","source_unbind","access_rule_upsert","access_rule_remove","replace_topology_policy","rollback"],type:"string"},vJ={description:"Truthful outcome for one authorized root or an aggregate over roots.\n\n`Denied` and `Unavailable` carry no value and therefore cannot be confused\nwith a successful empty result.",oneOf:[{properties:{outcome:{const:"exact",type:"string"},value:{anyOf:[{$ref:"#/$defs/RootGenerationV1"},{type:"null"}]}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"partial",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopePartialReasonV1"},value:{anyOf:[{$ref:"#/$defs/RootGenerationV1"},{type:"null"}]}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"denied",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopeUnavailableReasonV1"}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"}]},vZ={description:"Truthful outcome for one authorized root or an aggregate over roots.\n\n`Denied` and `Unavailable` carry no value and therefore cannot be confused\nwith a successful empty result.",oneOf:[{properties:{outcome:{const:"exact",type:"string"},value:{type:["string","null"]}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"partial",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopePartialReasonV1"},value:{type:["string","null"]}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"denied",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopeUnavailableReasonV1"}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"}]},vQ={description:"Typed explanation for a root that returned usable but incomplete data.",enum:["incomplete","stale","budget_exceeded","root_denied","root_unavailable"],type:"string"},vX={description:"Stable identity of one authorized scope-set record.",type:"string"},vY={description:"Monotonic optimistic-concurrency revision of one scope set.",format:"uint64",minimum:1,type:"integer"},v1={additionalProperties:!1,description:"A source-to-authority binding. It stores only the source kind, a redacted\nlocator digest, and the pre-resolved authority reference.",properties:{authority:{$ref:"#/$defs/AuthorityRef"},binding_id:{$ref:"#/$defs/SourceBindingId"},source_kind:{$ref:"#/$defs/SourceKindV1"},source_locator_digest:{$ref:"#/$defs/LocatorDigest"}},required:["binding_id","source_kind","source_locator_digest","authority"],type:"object"},v0={description:"Typed explanation for a root that could not return usable data.",enum:["authority_unavailable","root_missing","store_unavailable"],type:"string"},v2={description:"Strongly typed canonical identity: `ScoreDomainId`.",type:"string"},v4={additionalProperties:!1,description:"Reference-only filesystem locator. The raw path is sealed outside this\ncontract; only the privacy-bound locator digest and sealed-value digest are\nrepresentable here.",properties:{locator_digest:{$ref:"#/$defs/LocatorDigest"},sealed_value_digest:{$ref:"#/$defs/ManifestDigest"}},required:["locator_digest","sealed_value_digest"],type:"object"},v6={additionalProperties:!1,properties:{knowledge:{$ref:"#/$defs/ClosedUtcIntervalV1"},valid:{$ref:"#/$defs/ValidCoverageIntervalV1"}},required:["knowledge","valid"],type:"object"},v3={oneOf:[{properties:{kind:{const:"caught_up",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"projection_behind_source",type:"string"},lag:{format:"uint64",minimum:0,type:"integer"}},required:["kind","lag"],type:"object"},{properties:{kind:{const:"source_behind_target",type:"string"},lag:{format:"uint64",minimum:0,type:"integer"}},required:["kind","lag"],type:"object"},{properties:{kind:{const:"projection_and_source_behind",type:"string"},projection_lag:{format:"uint64",minimum:0,type:"integer"},source_lag:{format:"uint64",minimum:0,type:"integer"}},required:["kind","projection_lag","source_lag"],type:"object"},{properties:{kind:{const:"locked",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"redacted",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"retention_withheld",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"unavailable",type:"string"}},required:["kind"],type:"object"}]},v9={additionalProperties:!1,properties:{mode:{$ref:"#/$defs/TemporalModeV1"}},required:["mode"],type:"object"},v5={enum:["fresh","stale","partial","locked","redacted","retention_withheld","unavailable"],type:"string"},v8={description:"Strongly typed canonical identity: `SessionId`.",type:"string"},v7={description:"Strongly typed canonical identity: `SessionOrThreadId`.",type:"string"},be={additionalProperties:!1,properties:{committed_through:{format:"uint64",minimum:0,type:"integer"},observed_through:{format:"uint64",minimum:0,type:"integer"}},required:["observed_through","committed_through"],type:"object"},bt={additionalProperties:!1,properties:{committed_batches:{format:"uint64",minimum:0,type:"integer"},committed_records:{format:"uint64",minimum:0,type:"integer"},coverage:{$ref:"#/$defs/TemporalCoverageV1"},frontier:{$ref:"#/$defs/SessionRefreshFrontierResultV1"},operation_id:{type:"string"},session_id:{type:"string"},source_coverage:{items:{$ref:"#/$defs/SessionSourceCoverageV1"},type:"array"},updated_at:{format:"int64",type:"integer"}},required:["operation_id","session_id","frontier","coverage","committed_batches","committed_records","updated_at"],type:"object"},br={additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/TemporalCoverageV1"},failure_code:{type:["string","null"]},frontier:{$ref:"#/$defs/SessionRefreshFrontierResultV1"},operation_id:{type:"string"},session_id:{type:"string"},source_coverage:{items:{$ref:"#/$defs/SessionSourceCoverageV1"},type:"array"},state:{$ref:"#/$defs/SessionRefreshTerminalStateResultV1"},terminal_at:{format:"int64",type:"integer"}},required:["operation_id","session_id","frontier","coverage","state","terminal_at"],type:"object"},bi={enum:["complete","failed","cancelled"],type:"string"},bo={description:"Structural budget boundary that rejected a session retrieval request.\nThese causes are non-retryable request corrections; concurrent permit or\nqueue pressure remains a separate capacity-saturation failure.",enum:["request_result_limit","request_hydration_limit","request_context_bytes","request_candidate_bytes","request_record_bytes","request_hydration_bytes","estimator_version_mismatch","execution_work_exhausted","candidate_read_exhausted","record_read_exhausted","kernel_result_limit","participant_manifest_participants","participant_manifest_canonical_bytes","cursor_manifest_limit","hydration_bytes","context_bytes","context_tokens"],type:"string"},bn={additionalProperties:!1,properties:{committed_frontier:{format:"uint64",minimum:0,type:"integer"},covered_intervals:{items:{$ref:"#/$defs/SessionCoverageIntervalV1"},type:"array"},missing_intervals:{items:{$ref:"#/$defs/SessionCoverageIntervalV1"},type:"array"},observed_frontier:{format:"uint64",minimum:0,type:"integer"},reason:{$ref:"#/$defs/SessionCoverageReasonV1"},request:{$ref:"#/$defs/SessionCoverageRequestV1"},source_id:{type:"string"},state:{$ref:"#/$defs/SessionCoverageStateV1"},target_watermark:{format:"uint64",minimum:0,type:"integer"}},required:["source_id","observed_frontier","committed_frontier","target_watermark","request","covered_intervals","missing_intervals","state","reason"],type:"object"},ba={description:"Typed configuration key. Keys are lowercase, dotted product identifiers;\nuntyped host/adapter keys are not representable.",type:"string"},bs={additionalProperties:!1,description:"Logical and verified physical identity of the shared Profile shard.\n\nBrain and profile IDs select the shard; the verified store locator binds its\nphysical store. Lease incarnations and authority epochs remain runtime fences.",properties:{brain_id:{$ref:"#/$defs/BrainId"},profile_id:{$ref:"#/$defs/UserProfileId"},store_id:{type:"string"}},required:["brain_id","profile_id","store_id"],type:"object"},bd={additionalProperties:!1,properties:{complete:{type:"boolean"},family_digest:{$ref:"#/$defs/ManifestDigest"},match_class:{$ref:"#/$defs/SimilarMatchClassV1"},member_count:{format:"uint",minimum:0,type:"integer"},members:{items:{$ref:"#/$defs/SimilarOccurrenceV1"},type:"array"},next_cursor:{type:["string","null"]},normalization_revision:{format:"uint16",maximum:65535,minimum:0,type:"integer"},representative_payload_digest:{$ref:"#/$defs/ManifestDigest"}},required:["match_class","normalization_revision","family_digest","representative_payload_digest","member_count","members","complete"],type:"object"},bc={enum:["conservative_exact","rename_normalized_exact"],type:"string"},bl={additionalProperties:!1,properties:{body_span:{$ref:"#/$defs/SourceSpan"},path:{type:"string"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},snapshot_digest:{$ref:"#/$defs/ManifestDigest"},source_generation:{$ref:"#/$defs/CodeGenerationId"},symbol_occurrence_id:{$ref:"#/$defs/SymbolOccurrenceId"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["project_id","repository_id","source_generation","snapshot_digest","symbol_occurrence_id","path","body_span"],type:"object"},bp={properties:{evidence:{default:[],items:{type:"string"},type:"array"},improvement:{type:"boolean"},priority:{type:"string"},reason:{type:"string"},recommendation:{type:"string"},skill_id:{type:"string"}},required:["skill_id","improvement","recommendation","reason","priority"],type:"object"},bu={enum:["cursor","codex","claude","agents","opencode","kimi","kiro","hermes"],type:"string"},bm={properties:{evidence:{default:[],items:{type:"string"},type:"array"},reason:{type:"string"},recommendation:{type:"string"},skill_id:{type:"string"},stale:{type:"boolean"}},required:["skill_id","stale","recommendation","reason"],type:"object"},bf={description:"One skill's durable usage counters. The ledger stores one per skill; a\nsummary is the same record merged with the skill's current metadata.",properties:{activated_at:{description:"When the skill last transitioned into the active state; mirrors the\nmanaged skill metadata so outcome scoring works from summaries alone.",format:"int64",type:["integer","null"]},category:{type:["string","null"]},created_by:{type:["string","null"]},first_seen_at:{format:"int64",type:"integer"},imported_analytics_events:{description:"Import keys that already counted toward this skill. They are not a\nstore-wide set: each key names this skill, so another skill must not\nshare the write.",items:{type:"string"},type:"array",uniqueItems:!0},last_activity_at:{format:"int64",type:"integer"},last_patched_at:{format:"int64",type:["integer","null"]},last_used_at:{format:"int64",type:["integer","null"]},last_viewed_at:{format:"int64",type:["integer","null"]},patch_count:{format:"uint64",minimum:0,type:"integer"},pinned:{type:"boolean"},provenance_source:{anyOf:[{$ref:"#/$defs/ManagedSkillSource"},{type:"null"}]},schema_version:{format:"uint32",minimum:0,type:"integer"},skill_id:{type:"string"},state:{anyOf:[{$ref:"#/$defs/ManagedSkillState"},{type:"null"}]},targets:{default:[],items:{type:"string"},type:"array"},title:{type:["string","null"]},use_count:{format:"uint64",minimum:0,type:"integer"},use_count_at_activation:{format:"uint64",minimum:0,type:["integer","null"]},view_count:{format:"uint64",minimum:0,type:"integer"},view_count_at_activation:{description:"View/use totals captured at activation time so activity since activation\nis an exact delta rather than a heuristic.",format:"uint64",minimum:0,type:["integer","null"]}},required:["schema_version","skill_id","pinned","view_count","use_count","patch_count","first_seen_at","last_activity_at"],type:"object"},bh={description:"Strongly typed canonical identity: `SourceBindingId`.",type:"string"},by={additionalProperties:!1,description:"Source freshness is source- and retriever-specific: there is no global\nage-decay multiplier. Missing, stale, incompatible, and current are\ndistinct states.",properties:{compatibility:{$ref:"#/$defs/FreshnessCompatibilityV1"},generation_lag:{format:"uint64",minimum:0,type:["integer","null"]},observed_at:{$ref:"#/$defs/UtcMicros"},policy_revision:{$ref:"#/$defs/ComponentRevision"},projection_watermark:{format:"uint64",minimum:0,type:["integer","null"]},source_generation:{format:"uint64",minimum:0,type:["integer","null"]},source_instance:{$ref:"#/$defs/SourceInstanceKey"},source_namespace:{$ref:"#/$defs/SourceNamespace"},source_watermark:{format:"uint64",minimum:0,type:["integer","null"]}},required:["source_namespace","source_instance","observed_at","compatibility","policy_revision"],type:"object"},bg={description:"Strongly typed canonical identity: `SourceInstanceKey`.",type:"string"},b_={enum:["claude","codex","cursor","git_hub","hermes","kiro"],type:"string"},bv={description:"Strongly typed canonical identity: `SourceNamespace`.",type:"string"},bb={description:"Strongly typed canonical identity: `SourceOccurrenceId`.",type:"string"},b$={additionalProperties:!1,description:"Byte range inside one sanitized source file. Mutable line numbers are\nnever part of identity.",properties:{end_byte:{format:"uint64",minimum:0,type:"integer"},start_byte:{format:"uint64",minimum:0,type:"integer"}},required:["start_byte","end_byte"],type:"object"},bS={description:"Strongly typed canonical identity: `SourceStoreId`.",type:"string"},bk={description:"Strongly typed canonical identity: `StackDeliveryWatermarkId`.",type:"string"},bw={description:"Strongly typed canonical identity: `StackNodeId`.",type:"string"},bP={description:"Strongly typed canonical identity: `StackSignalId`.",type:"string"},bV={additionalProperties:!1,description:"Exact base/head symbol comparison was unavailable; the git evidence beside\nit is still the answer.",properties:{reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","reason","retryable"],type:"object"},bR={additionalProperties:!1,description:"Optional narrowing inside the immutable project/repository/worktree scope\ncarried by [`RequestContext`]. A path prefix never establishes identity or\nauthorization.",properties:{path_prefix:{type:["string","null"]}},type:"object"},bq={description:"Strongly typed canonical identity: `SymbolOccurrenceId`.",type:"string"},bI={additionalProperties:!1,properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},is_async:{type:"boolean"},kind:{type:"string"},line:{description:"One-based user-facing line.",format:"uint32",minimum:0,type:"integer"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"},score:{format:"double",type:["number","null"]},signature:{type:["string","null"]}},required:["node_id","name","qualified_name","kind","file","line","end_line","is_async"],type:"object"},bx={additionalProperties:!1,properties:{depth:{format:"uint32",minimum:0,type:["integer","null"]},dispatch_from:{type:["string","null"]},dispatch_via_trait:{type:"boolean"},edge_kind:{type:"string"},symbol:{$ref:"#/$defs/SymbolPrimitiveRecord"}},required:["symbol","edge_kind","dispatch_via_trait"],type:"object"},bj={additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},link_id:{type:"string"},observed_at:{$ref:"#/$defs/UtcMicros"},revision:{format:"uint64",minimum:0,type:"integer"},task_id:{$ref:"#/$defs/TaskId"}},required:["link_id","revision","task_id","anchor_id","evidence_digest","observed_at"],type:"object"},bC={additionalProperties:!1,properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},from_actor_id:{$ref:"#/$defs/ActorId"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},run_id:{$ref:"#/$defs/RunId"},step_id:{$ref:"#/$defs/WorkflowStepId"},task_id:{$ref:"#/$defs/TaskId"},thread_id:{$ref:"#/$defs/ThreadId"},to_actor_id:{$ref:"#/$defs/ActorId"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["project_id","repository_id","worktree_id","definition_id","definition_version","step_id","task_id","thread_id","run_id","from_actor_id","to_actor_id"],type:"object"},bT={description:"Strongly typed canonical identity: `TaskId`.",type:"string"},bO={additionalProperties:!1,properties:{hidden:{format:"uint64",minimum:0,type:"integer"},redacted:{format:"uint64",minimum:0,type:"integer"},unknown:{format:"uint64",minimum:0,type:"integer"},visible:{format:"uint64",minimum:0,type:"integer"}},required:["visible","hidden","unknown","redacted"],type:"object"},bE={additionalProperties:!1,properties:{anchor:{type:"string"},summary:{type:"string"}},required:["anchor","summary"],type:"object"},bA={oneOf:[{properties:{state:{const:"fresh",type:"string"}},required:["state"],type:"object"},{properties:{generation_lag:{format:"uint64",minimum:0,type:"integer"},state:{const:"stored",type:"string"}},required:["state","generation_lag"],type:"object"},{properties:{generation_lag:{format:"uint64",minimum:0,type:"integer"},state:{const:"partial",type:"string"}},required:["state","generation_lag"],type:"object"}]},bW={description:"Requested temporal interpretation.",oneOf:[{additionalProperties:!1,properties:{kind:{const:"current",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{cutoff:{$ref:"#/$defs/UtcMicros"},kind:{const:"as_of",type:"string"}},required:["kind","cutoff"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"evolution",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"forensic",type:"string"}},required:["kind"],type:"object"}]},bM={additionalProperties:!1,properties:{anchor:{type:"string"},rank:{format:"uint32",minimum:0,type:"integer"},reason:{$ref:"#/$defs/HydrationStateResultV1"}},required:["rank","anchor","reason"],type:"object"},bN={additionalProperties:!1,properties:{generation:{format:"uint64",minimum:0,type:"integer"},index:{format:"uint64",minimum:0,type:"integer"},projection:{format:"uint64",minimum:0,type:"integer"},source:{format:"uint64",minimum:0,type:"integer"},summary:{format:"uint64",minimum:0,type:"integer"}},required:["generation","source","projection","index","summary"],type:"object"},bz={description:"Strongly typed canonical identity: `ThreadId`.",type:"string"},bD={additionalProperties:!1,description:"What a token budget did to an answer. `est_tokens` is the kept rows.\n`over_ceiling` means a single row was larger than its section quota and\nwas kept anyway.",properties:{budget_tokens:{format:"uint32",minimum:0,type:"integer"},est_tokens:{format:"uint32",minimum:0,type:"integer"},over_ceiling:{type:"boolean"},sections:{items:{$ref:"#/$defs/TokenBudgetSectionV1"},type:"array"}},required:["budget_tokens","est_tokens","over_ceiling","sections"],type:"object"},bF={additionalProperties:!1,description:"One section a token budget kept or cut.",properties:{section:{type:"string"},shown:{format:"uint32",minimum:0,type:"integer"},total:{format:"uint32",minimum:0,type:"integer"}},required:["section","total","shown"],type:"object"},bL={additionalProperties:!1,properties:{maximum_active_per_repository:{format:"uint16",maximum:65535,minimum:1,type:"integer"},maximum_global_active:{format:"uint16",maximum:65535,minimum:1,type:"integer"},maximum_parallel_per_task:{format:"uint16",maximum:65535,minimum:1,type:"integer"},maximum_stack_depth:{format:"uint16",maximum:65535,minimum:1,type:"integer"}},required:["maximum_active_per_repository","maximum_parallel_per_task","maximum_global_active","maximum_stack_depth"],type:"object"},bU={enum:["reject","require_explicit_human_approval","require_human_approval_and_independent_review"],type:"string"},bH={additionalProperties:!1,properties:{cleanliness:{$ref:"#/$defs/WorktreeCleanlinessRequirementV1"},maximum_preflight_age_seconds:{format:"uint32",minimum:1,type:"integer"},require_fresh_preflight:{type:"boolean"},review:{$ref:"#/$defs/ReviewRequirementV1"},tests:{items:{$ref:"#/$defs/RequiredCheckV1"},type:"array"}},required:["cleanliness","tests","review","require_fresh_preflight","maximum_preflight_age_seconds"],type:"object"},bG={enum:["critical_only","lifecycle","verbose"],type:"string"},bB={description:"Risky construct the pattern scan looks for.",enum:["unwrap","expect","panic","todo","unimplemented","unsafe_block"],type:"string"},bK={description:"Stable, canonical catalog identity for `UseCaseId`.",type:"string"},bJ={description:"Strongly typed canonical identity: `UserProfileId`.",type:"string"},bZ={description:"UTC timestamp represented as microseconds from the Unix epoch.",format:"int64",type:"integer"},bQ={oneOf:[{properties:{interval:{$ref:"#/$defs/ClosedUtcIntervalV1"},kind:{const:"known",type:"string"}},required:["kind","interval"],type:"object"},{properties:{kind:{const:"unknown",type:"string"}},required:["kind"],type:"object"}]},bX={additionalProperties:!1,description:"One exact verified graph snapshot identity.",properties:{event_sequence:{format:"uint64",minimum:0,type:"integer"},graph_version:{format:"uint64",minimum:0,type:"integer"},recovered_graph_digest:{$ref:"#/$defs/ManifestDigest"},source_watermark:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},type:"object"}},required:["graph_version","event_sequence","source_watermark","recovered_graph_digest"],type:"object"},bY={additionalProperties:!1,properties:{criterion_id:{type:"string"},description:{type:"string"},evidence_required:{type:"boolean"}},required:["criterion_id","description","evidence_required"],type:"object"},b1={enum:["never","on_request"],type:"string"},b0={description:"Strongly typed canonical identity: `WorkArtifactId`.",type:"string"},b2={additionalProperties:!1,properties:{artifact_id:{$ref:"#/$defs/WorkArtifactId"},byte_length:{format:"uint64",minimum:0,type:"integer"},digest:{$ref:"#/$defs/ManifestDigest"}},required:["artifact_id","digest","byte_length"],type:"object"},b4={additionalProperties:!1,description:"Sealed terminal evidence for one provider attempt. The digest of this\nrecord is the evidence digest carried by [`WorkTerminalEvidenceV1`] and by\nthe `RuntimeEvidenceRef` attached to the Work projection, so the receipt\nin Work always names an inspectable record.",properties:{actual_route:{anyOf:[{$ref:"#/$defs/WorkProviderRouteV1"},{type:"null"}]},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{$ref:"#/$defs/WorkAttemptProviderOutcomeV1"},provider_fallback:{anyOf:[{$ref:"#/$defs/WorkProviderFallbackRecordV1"},{type:"null"}],description:"Present only when the pinned preferred backend was disqualified before\nstartup. `None` means the attempt ran on its first-choice backend."},provider_session:{anyOf:[{$ref:"#/$defs/ObservationSourceIdentityV1"},{type:"null"}],description:"Native provider-qualified session/thread identity, when the provider\nreported one. Admission cannot supply this value and no fallback is\nfabricated."},requested_route:{$ref:"#/$defs/WorkProviderRouteV1"},stderr:{anyOf:[{$ref:"#/$defs/WorkAttemptStreamSummaryV1"},{type:"null"}]},stdout:{anyOf:[{$ref:"#/$defs/WorkAttemptStreamSummaryV1"},{type:"null"}]}},required:["identity","requested_route","outcome","observed_at"],type:"object"},b6={additionalProperties:!1,properties:{attempt_id:{$ref:"#/$defs/AttemptId"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","attempt_id"],type:"object"},b3={description:"How much of the authorized attempt set one page covers.",oneOf:[{additionalProperties:!1,description:"Every attempt after the page start was returned; zero returned is the\nexplicit empty authorized result, not a concealment.",properties:{coverage:{const:"complete",type:"string"},returned:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned"],type:"object"},{additionalProperties:!1,description:"The page cap was reached; `resume` continues under the same verified\ntopology generation.",properties:{coverage:{const:"capped",type:"string"},remaining:{format:"uint32",minimum:0,type:"integer"},resume:{$ref:"#/$defs/WorkAttemptListCursorV1"},returned:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned","remaining","resume"],type:"object"}]},b9={description:"Opaque resume point for the next page of one attempt-list-family read,\nbound to the operation and `page_size` that minted it and pinned to the\nverified topology generation the page was read under.",type:"string"},b5={additionalProperties:!1,properties:{completed:{format:"uint64",minimum:0,type:"integer"},total:{format:"uint64",minimum:0,type:"integer"}},required:["completed","total"],type:"object"},b8={additionalProperties:!1,properties:{accepted_proposal:{$ref:"#/$defs/ProposalId",description:"Exact accepted proposal the attempt was admitted against. A superseded\nor cleared proposal is a different binding, not a compatible refresh."},event_sequence:{description:"Exact immutable product event that verified this graph version.",format:"uint64",minimum:0,type:"integer"},graph_version:{format:"uint64",minimum:0,type:"integer"},recovered_graph_digest:{$ref:"#/$defs/ManifestDigest",description:"Digest of the graph recovered and verified at admission."},source_watermark:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},description:"Source-frontier identity preserved from the verified product graph.",type:"object"}},required:["graph_version","event_sequence","source_watermark","recovered_graph_digest","accepted_proposal"],type:"object"},b7={description:"How one provider attempt ended, as observed by the daemon runtime.",oneOf:[{properties:{code:{format:"int32",type:"integer"},outcome:{const:"exited",type:"string"}},required:["outcome","code"],type:"object"},{properties:{outcome:{const:"signalled",type:"string"},signal:{format:"int32",type:"integer"}},required:["outcome","signal"],type:"object"},{properties:{outcome:{const:"timed_out",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"cancelled",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"provider_unavailable",type:"string"},state:{$ref:"#/$defs/WorkProviderAvailabilityV1"}},required:["outcome","state"],type:"object"},{properties:{channel:{$ref:"#/$defs/WorkAttemptStreamChannelV1"},outcome:{const:"stream_overflow",type:"string"}},required:["outcome","channel"],type:"object"},{properties:{outcome:{const:"launch_failed",type:"string"}},required:["outcome"],type:"object"},{description:"The provider started but its typed protocol session did not reach a\nterminal answer: a malformed, out-of-order, oversized, or lost frame.\nPlan 32 requires such a stream to seal failed evidence rather than a\ntext-scraped success.",properties:{outcome:{const:"protocol_failed",type:"string"}},required:["outcome"],type:"object"}]},$e={additionalProperties:!1,properties:{artifacts:{items:{$ref:"#/$defs/WorkArtifactRefV1"},type:"array"},evidence:{anyOf:[{$ref:"#/$defs/WorkAttemptEvidenceRecordV1"},{type:"null"}]},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["identity","artifacts"],type:"object"},$t={enum:["leased","running","cancellation_requested","cancellation_acknowledged","cancellation_escalated","recovery_required","succeeded","failed","timed_out","cancelled"],type:"string"},$r={enum:["stdout","stderr"],type:"string"},$i={additionalProperties:!1,description:"Bounded summary of one captured provider stream.",properties:{byte_length:{format:"uint64",minimum:0,type:"integer"},digest:{$ref:"#/$defs/ManifestDigest"},truncated:{type:"boolean"}},required:["byte_length","truncated","digest"],type:"object"},$o={additionalProperties:!1,description:"The verified Work topology snapshot one attempt-list page was read under.",properties:{generation:{description:"The verified graph generation the topology snapshot is published under.",type:"string"},task_count:{description:"The number of tasks in the verified topology.",format:"uint32",minimum:0,type:"integer"}},required:["generation","task_count"],type:"object"},$n={properties:{actual_route:{anyOf:[{$ref:"#/$defs/WorkProviderRouteV1"},{type:"null"}]},artifacts:{items:{$ref:"#/$defs/WorkArtifactRefV1"},type:"array"},cancellation:{$ref:"#/$defs/WorkCancellationStateV1"},execution:{$ref:"#/$defs/WorkExecutionEnvelopeV1"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},lease:{$ref:"#/$defs/WorkLeaseFenceV1"},progress:{anyOf:[{$ref:"#/$defs/WorkAttemptProgressV1"},{type:"null"}]},projection_binding:{$ref:"#/$defs/WorkAttemptProjectionBindingV1"},recovery:{$ref:"#/$defs/WorkRecoveryStateV1"},requested_route:{$ref:"#/$defs/WorkProviderRouteV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"},terminal:{anyOf:[{$ref:"#/$defs/WorkTerminalEvidenceV1"},{type:"null"}]}},required:["identity","projection_binding","execution","lease","state","artifacts","cancellation","recovery","requested_route"],type:"object"},$a={additionalProperties:!1,properties:{acknowledged_at:{$ref:"#/$defs/UtcMicros"},request:{$ref:"#/$defs/WorkCancellationRequestV1"}},required:["request","acknowledged_at"],type:"object"},$s={additionalProperties:!1,properties:{acknowledgement:{$ref:"#/$defs/WorkCancellationAcknowledgementV1"},escalated_at:{$ref:"#/$defs/UtcMicros"}},required:["acknowledgement","escalated_at"],type:"object"},$d={description:"Strongly typed canonical identity: `WorkCancellationRequestId`.",type:"string"},$c={additionalProperties:!1,properties:{request_id:{$ref:"#/$defs/WorkCancellationRequestId"},requested_at:{$ref:"#/$defs/UtcMicros"}},required:["request_id","requested_at"],type:"object"},$l={oneOf:[{properties:{state:{const:"none",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"requested",type:"string"},value:{$ref:"#/$defs/WorkCancellationRequestV1"}},required:["state","value"],type:"object"},{properties:{state:{const:"acknowledged",type:"string"},value:{$ref:"#/$defs/WorkCancellationAcknowledgementV1"}},required:["state","value"],type:"object"},{properties:{state:{const:"escalated",type:"string"},value:{$ref:"#/$defs/WorkCancellationEscalationV1"}},required:["state","value"],type:"object"}]},$p={description:"Strongly typed canonical identity: `WorkCommandId`.",type:"string"},$u={description:"Where a configured route places task content.",enum:["local","tenant","external"],type:"string"},$m={additionalProperties:!1,properties:{topology_generation:{$ref:"#/$defs/WorkTopologyGenerationRefV1"},work_generation:{$ref:"#/$defs/ProjectionGenerationId"}},required:["work_generation","topology_generation"],type:"object"},$f={additionalProperties:!1,properties:{cost_micros:{format:"uint64",minimum:0,type:["integer","null"]},coverage:{$ref:"#/$defs/CoverageStateV1"},effect_count:{format:"uint64",minimum:0,type:["integer","null"]},effect_outcome:{$ref:"#/$defs/DuplicateEffectOutcomeV1"},evidence:{$ref:"#/$defs/QuantityEvidenceClassV1"},test_count:{format:"uint64",minimum:0,type:["integer","null"]},token_count:{format:"uint64",minimum:0,type:["integer","null"]},wall_micros:{format:"uint64",minimum:0,type:["integer","null"]}},required:["evidence","effect_outcome","coverage"],type:"object"},$h={description:"Effect semantics admitted for one provider attempt.",enum:["observational","intercepted","compound_non_repeatable"],type:"string"},$y={description:"Declared effort class of a configured route.",enum:["minimal","standard","extended"],type:"string"},$g={enum:["deny","allowlisted"],type:"string"},$_={oneOf:[{additionalProperties:!1,properties:{cursor:{type:"string"},kind:{const:"anchor",type:"string"},link_id:{type:"string"}},required:["kind","link_id","cursor"],type:"object"},{additionalProperties:!1,properties:{continuation:{$ref:"#/$defs/WorkTaskSessionContinuationV1"},kind:{const:"task_session",type:"string"}},required:["kind","continuation"],type:"object"}]},$v={additionalProperties:!1,description:"One immutable evidence frontier. Local code/session evidence and live Git\nevidence each carry their own frontier; the evaluator never merges,\nsubstitutes, or advances one from the other.",properties:{digest:{$ref:"#/$defs/ManifestDigest"},watermark:{$ref:"#/$defs/UtcMicros"}},required:["watermark","digest"],type:"object"},$b={additionalProperties:!1,description:"Exact on-disk executable selected for one opaque executable identity.\n\nThe path is configuration data, never a lookup hint. Runtime admission\ncanonicalizes it again and verifies the file bytes against\n`executable.artifact_digest` before returning an executable binding.",properties:{canonical_path:{type:"string"},capabilities:{items:{$ref:"#/$defs/WorkExecutableCapabilityV1"},type:"array"},executable:{$ref:"#/$defs/WorkExecutableReference"},routes:{items:{$ref:"#/$defs/WorkRouteCandidateV1"},type:"array"}},required:["executable","canonical_path","capabilities","routes"],type:"object"},$$={description:"One executable capability admitted by a configured artifact binding.\n\nThe closed variants bind a provider backend to its exact wire protocol.\nCallers cannot claim an arbitrary backend/protocol combination.",enum:["claude_code_stream_json","codex_app_server_json_rpc","codex_cli_exec_json"],type:"string"},$S={additionalProperties:!1,properties:{artifact_digest:{$ref:"#/$defs/ManifestDigest"},executable_id:{type:"string"}},required:["executable_id","artifact_digest"],type:"object"},$k={additionalProperties:!1,description:"Exact immutable provider admission attached to the durable Work attempt.\n\nCallers name typed route and scope facts, never argv, environment entries,\nor executable paths. The daemon resolves the registered executable only\nafter this envelope has been persisted and admitted to the canonical queue.",properties:{attempt_identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},cancellation_generation:{format:"uint64",minimum:0,type:"integer"},commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},instructions:{description:"Exact provider instructions admitted with this attempt. The adapter\ndelivers these bytes verbatim on the provider's typed input channel;\nthey are never interpolated into argv or an ambient prompt source.",type:"string"},operation:{$ref:"#/$defs/WorkflowOperationRef"},project_id:{$ref:"#/$defs/ProjectId"},projection_binding:{$ref:"#/$defs/WorkAttemptProjectionBindingV1"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},repository_id:{$ref:"#/$defs/RepositoryId"},worktree_id:{$ref:"#/$defs/WorktreeId"},worktree_root:{type:"string"}},required:["attempt_identity","projection_binding","operation","execution_snapshot","project_id","repository_id","worktree_id","worktree_root","commit","instructions","cancellation_generation","effect_state"],type:"object"},$w={additionalProperties:!1,properties:{max_concurrency:{format:"uint32",minimum:0,type:"integer"},max_input_tokens:{format:"uint64",minimum:0,type:"integer"},max_output_tokens:{format:"uint64",minimum:0,type:"integer"},max_protocol_bytes:{format:"uint64",minimum:0,type:"integer"},max_stderr_bytes:{format:"uint64",minimum:0,type:"integer"},max_stdout_bytes:{format:"uint64",minimum:0,type:"integer"}},required:["max_input_tokens","max_output_tokens","max_stdout_bytes","max_stderr_bytes","max_protocol_bytes","max_concurrency"],type:"object"},$P={additionalProperties:!1,description:"Immutable provider and topology authority pinned for exactly one Work\nexecution. Every constraint the execution is governed by is named here;\nnothing in this value is an opaque stand-in that a reader must resolve\nagainst a mutable store.",properties:{approval:{$ref:"#/$defs/WorkApprovalPolicy"},backend:{$ref:"#/$defs/WorkProviderBackendV1"},configuration_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},configuration_snapshot_id:{$ref:"#/$defs/ConfigurationSnapshotId"},credential_references:{items:{$ref:"#/$defs/CredentialReferenceId"},type:"array",uniqueItems:!0},deadline:{$ref:"#/$defs/UtcMicros"},effective_behavior_digest:{$ref:"#/$defs/ManifestDigest"},egress:{$ref:"#/$defs/WorkEgressPolicy"},environment_allowlist:{items:{type:"string"},type:"array",uniqueItems:!0},executable:{$ref:"#/$defs/WorkExecutableReference"},fallback:{$ref:"#/$defs/WorkFallbackTopology"},filesystem:{$ref:"#/$defs/WorkFilesystemPolicy"},limits:{$ref:"#/$defs/WorkExecutionLimits"},model:{type:"string"},protocol:{$ref:"#/$defs/WorkProviderProtocol"},resolution_provenance_digest:{$ref:"#/$defs/ManifestDigest"},route:{$ref:"#/$defs/WorkProviderRouteV1"},sandbox:{$ref:"#/$defs/WorkSandboxPolicy"},topology:{$ref:"#/$defs/WorkTopologyPolicyV1",description:"See [`WorkExecutionSnapshotInput::topology`]. Validated on construction,\nso an admitted snapshot can never pin a topology that weakens the\nprotected-ref floor or permits a native integration without its gates."}},required:["configuration_revision_id","configuration_snapshot_id","effective_behavior_digest","resolution_provenance_digest","route","backend","protocol","model","executable","sandbox","approval","filesystem","egress","environment_allowlist","credential_references","limits","deadline","fallback","topology"],type:"object"},$V={enum:["language","framework","architecture","testing","operations","security","domain"],type:"string"},$R={additionalProperties:!1,description:"Explicit, expiring consent for ephemeral expertise context.\n\nUser-profile and project authorization are separate registered settings;\nWork requires both and uses only their category intersection.",properties:{allowed_categories:{items:{$ref:"#/$defs/WorkExpertiseCategoryV1"},type:"array",uniqueItems:!0},enabled:{type:"boolean"},expires_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},granted_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"}},required:["schema_version","enabled","allowed_categories"],type:"object"},$q={oneOf:[{additionalProperties:!1,properties:{kind:{const:"disabled",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{executable:{$ref:"#/$defs/WorkExecutableReference"},kind:{const:"codex_cli",type:"string"},route:{$ref:"#/$defs/WorkProviderRouteV1"}},required:["kind","route","executable"],type:"object"}]},$I={format:"uint64",minimum:0,title:"WorkFenceEpochV1",type:"integer"},$x={enum:["read_only","workspace_write"],type:"string"},$j={oneOf:[{additionalProperties:!1,properties:{item:{$ref:"#/$defs/WorkItemV1"},kind:{const:"task_added",type:"string"}},required:["kind","item"],type:"object"},{additionalProperties:!1,properties:{initiative:{$ref:"#/$defs/WorkInitiativeV1"},item:{$ref:"#/$defs/WorkItemV1"},kind:{const:"task_created",type:"string"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},plan:{$ref:"#/$defs/WorkPlanV1"}},required:["kind","initiative","plan","milestone","item"],type:"object"},{additionalProperties:!1,properties:{decided_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},kind:{const:"relation_replan_decided",type:"string"},proposal:{$ref:"#/$defs/WorkRelationReplanProposalV1"}},required:["kind","proposal","disposition","decided_at"],type:"object"},{additionalProperties:!1,properties:{applied_at:{$ref:"#/$defs/UtcMicros"},kind:{const:"task_relations_replanned",type:"string"},proposal_id:{$ref:"#/$defs/ProposalId"}},required:["kind","proposal_id","applied_at"],type:"object"},{additionalProperties:!1,properties:{evidence:{$ref:"#/$defs/TaskEvidenceLinkV1"},kind:{const:"evidence_linked",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","evidence"],type:"object"},{additionalProperties:!1,properties:{decided_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},kind:{const:"proposal_decided",type:"string"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["kind","proposal","disposition","decided_at"],type:"object"},{additionalProperties:!1,properties:{accepted_at:{$ref:"#/$defs/UtcMicros"},kind:{const:"proposal_accepted",type:"string"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["kind","proposal","accepted_at"],type:"object"},{additionalProperties:!1,properties:{admitted_at:{$ref:"#/$defs/UtcMicros"},based_on_version:{format:"uint64",minimum:0,type:"integer"},kind:{const:"execution_admitted",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","based_on_version","admitted_at"],type:"object"},{additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},kind:{const:"accepted_attempt_linked",type:"string"},linked_at:{$ref:"#/$defs/UtcMicros"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","based_on_version","identity","linked_at"],type:"object"},{additionalProperties:!1,properties:{accepted_at:{$ref:"#/$defs/UtcMicros"},evidence_by_criterion:{additionalProperties:{type:"string"},type:"object"},kind:{const:"task_accepted",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","evidence_by_criterion","accepted_at"],type:"object"},{additionalProperties:!1,properties:{handoff:{$ref:"#/$defs/WorkHandoffV1"},kind:{const:"handoff_recorded",type:"string"}},required:["kind","handoff"],type:"object"}]},$C={additionalProperties:!1,description:"One attempt on the evidence frontier: exactly which attempt, in which\nstate, backed by which sealed evidence digest (when the attempt has\nreported one). No lease or fence is part of the frontier. Those are\nruntime authority, not checkpoint evidence.",properties:{evidence_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"The digest of the sealed terminal evidence record, when the attempt\nhas one. `None` is the typed not-yet-reported state."},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"}},required:["identity","state"],type:"object"},$T={additionalProperties:!1,description:"The exact work/evidence frontier one handoff records.",properties:{attempts:{description:"The evidence frontier: every attempt the issuer knows about, in\nstable identity order.",items:{$ref:"#/$defs/WorkHandoffAttemptFrontierV1"},type:"array"},blockers:{description:"What is blocking progress. Bounded, non-empty entries.",items:{type:"string"},type:"array"},legal_actions:{description:"The actions the issuer believes are legal next steps.",items:{type:"string"},type:"array"},lineage:{$ref:"#/$defs/WorkHandoffLineageV1"},task_id:{$ref:"#/$defs/TaskId"},unknowns:{description:"What the issuer does not know yet. Bounded, non-empty entries.",items:{type:"string"},type:"array"},work_version:{description:"The exact Work version the frontier was cut at.",format:"uint64",minimum:0,type:"integer"}},required:["task_id","work_version","attempts","unknowns","blockers","legal_actions","lineage"],type:"object"},$O={additionalProperties:!1,description:"Who issued this frontier and what it supersedes.",properties:{issued_at:{$ref:"#/$defs/UtcMicros"},issued_by:{$ref:"#/$defs/ActorId"},prior_frontier_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"The canonical digest of the frontier this one supersedes, when the\ntask has been handed off before. `None` states a first handoff."}},required:["issued_by","issued_at"],type:"object"},$E={additionalProperties:!1,properties:{evidence_frontier:{items:{type:"string"},type:"array",uniqueItems:!0},from_actor:{$ref:"#/$defs/ActorId"},handed_off_at:{$ref:"#/$defs/UtcMicros"},handoff_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"},to_actor:{$ref:"#/$defs/ActorId"},unknowns:{items:{type:"string"},type:"array",uniqueItems:!0}},required:["handoff_id","task_id","from_actor","to_actor","evidence_frontier","unknowns","handed_off_at"],type:"object"},$A={additionalProperties:!1,properties:{initiative_id:{type:"string"},milestone_id:{type:"string"},plan_id:{type:"string"}},required:["initiative_id","plan_id","milestone_id"],type:"object"},$W={additionalProperties:!1,properties:{created_at:{$ref:"#/$defs/UtcMicros"},id:{type:"string"},title:{type:"string"}},required:["id","title","created_at"],type:"object"},$M={additionalProperties:!1,properties:{acceptance_criteria:{items:{$ref:"#/$defs/WorkAcceptanceCriterionV1"},type:"array"},causal_candidates:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},created_at:{$ref:"#/$defs/UtcMicros"},deadline:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},dependencies:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},effort:{format:"uint32",minimum:0,type:"integer"},hierarchy:{$ref:"#/$defs/WorkHierarchyV1"},informational_relations:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},scheduled_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},task_id:{$ref:"#/$defs/TaskId"},title:{type:"string"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["task_id","hierarchy","title","dependencies","informational_relations","causal_candidates","acceptance_criteria","effort","created_at","updated_at"],type:"object"},$N={additionalProperties:!1,properties:{accepted_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},accepted_attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},accepted_criteria:{additionalProperties:{type:"string"},type:"object"},accepted_proposal:{anyOf:[{$ref:"#/$defs/ProposalId"},{type:"null"}]},accepted_route:{anyOf:[{$ref:"#/$defs/WorkRouteDecisionV1"},{type:"null"}]},archived_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},evidence_links:{items:{type:"string"},type:"array",uniqueItems:!0},execution_admitted_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},handoffs:{items:{$ref:"#/$defs/WorkHandoffV1"},type:"array"},input:{$ref:"#/$defs/WorkItemInputV1"}},required:["input","evidence_links","accepted_criteria","accepted_attempts","handoffs"],type:"object"},$z={description:"A job task key: `[a-z0-9-]`, 1 to 48 bytes. Identities derive from it.",type:"string"},$D={additionalProperties:!1,properties:{epoch:{$ref:"#/$defs/WorkFenceEpochV1"},lease_id:{$ref:"#/$defs/WorkLeaseId"}},required:["lease_id","epoch"],type:"object"},$F={description:"Strongly typed canonical identity: `WorkLeaseId`.",type:"string"},$L={additionalProperties:!1,properties:{created_at:{$ref:"#/$defs/UtcMicros"},id:{type:"string"},plan_id:{type:"string"},title:{type:"string"}},required:["id","plan_id","title","created_at"],type:"object"},$U={description:"Ordinal band. Never a probability, never a scalar score.\n\nBands are ordered `Lowest` .. `Highest`. Comparison is the only operation\nconsumers perform over them, so no weighted sum can be reconstructed from\na recorded decision.",enum:["lowest","low","moderate","high","highest"],type:"string"},$H={description:"Closed set of conditions that block admission or removal.",oneOf:[{const:"dirty_tracked_files",description:"Tracked files differ from the index or HEAD.",type:"string"},{const:"untracked_data",description:"Untracked data is present in the target.",type:"string"},{const:"unique_commits",description:"The target holds commits reachable from nowhere else.",type:"string"},{const:"active_holder",description:"Another admitted placement holds this target.",type:"string"},{const:"unresolved_effect",description:"An effect against this placement is unresolved.",type:"string"},{const:"unacknowledged_receipt",description:"A receipt produced against this placement is unacknowledged.",type:"string"},{const:"uncertain_pull_request",description:"A pull request produced from this placement is in an uncertain state.",type:"string"},{const:"shared_ref",description:"A ref in this target is shared with another holder.",type:"string"},{const:"missing_anchor",description:"A retrieval or evidence anchor this placement referenced is missing.",type:"string"},{const:"stale_scope",description:"The authorized scope no longer matches the placement.",type:"string"},{const:"authorization_lost",description:"Authorization for this placement was lost.",type:"string"},{const:"target_unreadable",description:"The target could not be read, so its state is unknown.",type:"string"},{const:"network_required",description:"The placement declared itself network-free but the action needs network.",type:"string"}],title:"WorkPlacementBlockerV1"},$G={additionalProperties:!1,description:"Which run a placement belongs to. Placement never redefines TaskId.",properties:{run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id"],title:"WorkPlacementIdentityV1",type:"object"},$B={description:"The supported placement choices, and only those.",oneOf:[{const:"no_managed_placement",description:"TraceDecay manages no checkout for this run. No-Git work is first class.",type:"string"},{const:"clean_in_place",description:"The caller's own strictly clean checkout, explicitly acknowledged.",type:"string"},{const:"linked_worktree",description:"A linked worktree of the same repository.",type:"string"},{const:"isolated_clone",description:"An isolated local clone.",type:"string"}],title:"WorkPlacementKindV1"},$K={description:"The durable state of one admitted placement.",oneOf:[{const:"admitted",description:"The placement holds its target.",type:"string"},{const:"released",description:"The placement gave its target up cleanly. Nothing was deleted by this\ntransition; removal is a separate cleanup preflight.",type:"string"},{const:"quarantined",description:"The placement was retained because removal is blocked.",type:"string"}],title:"WorkPlacementStateV1"},$J={additionalProperties:!1,description:"The exact placement a caller asked for.",properties:{in_place_acknowledged:{description:"Set only for `CleanInPlace`: the caller states it accepts running in\nits own checkout. Acknowledgement is explicit, never inferred.",type:"boolean"},kind:{$ref:"#/$defs/WorkPlacementKindV1"},network_free:{description:"The placement declares it needs no network. Declared, not detected.",type:"boolean"},root:{description:"Absolute root, present exactly when the kind manages one.",type:["string","null"]}},required:["kind","in_place_acknowledged","network_free"],title:"WorkPlacementTargetV1",type:"object"},$Z={additionalProperties:!1,description:"One run's durable placement relation.",properties:{authority_version:{format:"uint64",minimum:0,type:"integer"},blockers:{items:{$ref:"#/$defs/WorkPlacementBlockerV1"},type:"array",uniqueItems:!0},identity:{$ref:"#/$defs/WorkPlacementIdentityV1"},retention_eligible_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}],description:"When retention makes this placement *eligible* for a fresh cleanup\npreflight. Eligibility is not delete authority."},state:{$ref:"#/$defs/WorkPlacementStateV1"},target:{$ref:"#/$defs/WorkPlacementTargetV1"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["identity","target","state","authority_version","transitioned_at","blockers"],title:"WorkPlacementV1",type:"object"},$Q={additionalProperties:!1,properties:{created_at:{$ref:"#/$defs/UtcMicros"},id:{type:"string"},initiative_id:{type:"string"},title:{type:"string"}},required:["id","initiative_id","title","created_at"],type:"object"},$X={oneOf:[{additionalProperties:!1,properties:{kind:{const:"project",type:"string"},project_id:{$ref:"#/$defs/ProjectId"}},required:["kind","project_id"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"repository",type:"string"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"}},required:["kind","project_id","repository_id"],type:"object"}]},$Y={additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},source_store_id:{$ref:"#/$defs/SourceStoreId"}},required:["source_store_id","anchor_id","evidence_digest"],type:"object"},$1={oneOf:[{additionalProperties:!1,properties:{graph:{$ref:"#/$defs/WorkProductGraphV1"},kind:{const:"created",type:"string"}},required:["kind","graph"],type:"object"},{additionalProperties:!1,properties:{change:{$ref:"#/$defs/WorkGraphChangeV1"},kind:{const:"changed",type:"string"}},required:["kind","change"],type:"object"}]},$0={additionalProperties:!1,properties:{actor_id:{$ref:"#/$defs/ActorId"},authorized_relation_scopes:{items:{$ref:"#/$defs/WorkProductAuthorizedRelationScopeV1"},type:"array"},canonical_input_digest:{$ref:"#/$defs/ManifestDigest"},catalog_generation_id:{$ref:"#/$defs/CatalogGenerationId"},causation_event_id:{type:["string","null"]},command_id:{$ref:"#/$defs/WorkCommandId"},configuration_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},event_id:{type:"string"},evidence:{items:{$ref:"#/$defs/WorkProductEventEvidenceV1"},type:"array"},expected_graph_version:{format:"uint64",minimum:0,type:["integer","null"]},occurred_at:{$ref:"#/$defs/UtcMicros"},owner_scope:{$ref:"#/$defs/WorkProductProfileScopeV1"},payload:{$ref:"#/$defs/WorkProductEventPayloadV1"},policy_revision_id:{type:"string"},result_graph_version:{format:"uint64",minimum:0,type:"integer"},sequence:{format:"uint64",minimum:0,type:"integer"},source_watermark:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},type:"object"}},required:["event_id","sequence","actor_id","owner_scope","authorized_relation_scopes","result_graph_version","command_id","canonical_input_digest","evidence","source_watermark","occurred_at","policy_revision_id","configuration_revision_id","catalog_generation_id","payload"],type:"object"},$2={oneOf:[{additionalProperties:!1,properties:{authority:{const:"no_prior_graph",type:"string"}},required:["authority"],type:"object"},{additionalProperties:!1,properties:{authority:{const:"verified",type:"string"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["authority","verified_version"],type:"object"}]},$4={additionalProperties:!1,properties:{evidence:{items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},initiatives:{items:{$ref:"#/$defs/WorkInitiativeV1"},type:"array"},items:{items:{$ref:"#/$defs/WorkItemV1"},type:"array"},milestones:{items:{$ref:"#/$defs/WorkMilestoneV1"},type:"array"},plans:{items:{$ref:"#/$defs/WorkPlanV1"},type:"array"},proposal_decisions:{items:{$ref:"#/$defs/WorkProposalDecisionV1"},type:"array"},relation_replan_decisions:{items:{$ref:"#/$defs/WorkRelationReplanDecisionV1"},type:"array"},version:{format:"uint64",minimum:0,type:"integer"}},required:["version","initiatives","plans","milestones","items","proposal_decisions","relation_replan_decisions","evidence"],type:"object"},$6={additionalProperties:!1,properties:{causation_event_id:{type:["string","null"]},command_id:{$ref:"#/$defs/WorkCommandId"},evidence:{items:{$ref:"#/$defs/WorkProductEventEvidenceV1"},type:"array"},expected_authority:{$ref:"#/$defs/WorkProductExpectedAuthorityV1"},occurred_at:{$ref:"#/$defs/UtcMicros"},revisions:{$ref:"#/$defs/WorkProductRevisionPinsV1"}},required:["expected_authority","command_id","evidence","occurred_at","revisions"],type:"object"},$3={additionalProperties:!1,properties:{event:{$ref:"#/$defs/WorkProductEventV1"},replayed:{type:"boolean"},verified_graph_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["event","verified_graph_version","replayed"],type:"object"},$9={additionalProperties:!1,properties:{brain_id:{$ref:"#/$defs/BrainId"},profile_id:{$ref:"#/$defs/UserProfileId"}},required:["brain_id","profile_id"],type:"object"},$5={oneOf:[{properties:{initiative_id:{type:"string"},kind:{const:"initiative_contains_plan",type:"string"},plan_id:{type:"string"}},required:["kind","initiative_id","plan_id"],type:"object"},{properties:{kind:{const:"plan_contains_milestone",type:"string"},milestone_id:{type:"string"},plan_id:{type:"string"}},required:["kind","plan_id","milestone_id"],type:"object"},{properties:{kind:{const:"milestone_contains_task",type:"string"},milestone_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","milestone_id","task_id"],type:"object"},{properties:{dependency:{$ref:"#/$defs/TaskId"},dependent:{$ref:"#/$defs/TaskId"},kind:{const:"gates",type:"string"}},required:["kind","dependency","dependent"],type:"object"},{properties:{kind:{const:"informational",type:"string"},source:{$ref:"#/$defs/TaskId"},target:{$ref:"#/$defs/TaskId"}},required:["kind","source","target"],type:"object"},{properties:{cause:{$ref:"#/$defs/TaskId"},effect:{$ref:"#/$defs/TaskId"},kind:{const:"causal_candidate",type:"string"}},required:["kind","cause","effect"],type:"object"},{properties:{kind:{const:"evidence",type:"string"},link_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","link_id"],type:"object"},{properties:{identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},kind:{const:"accepted_attempt",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","identity"],type:"object"},{properties:{handoff_id:{type:"string"},kind:{const:"handoff",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","handoff_id"],type:"object"},{properties:{kind:{const:"proposal_decision",type:"string"},proposal_id:{$ref:"#/$defs/ProposalId"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","proposal_id"],type:"object"}]},$8={additionalProperties:!1,properties:{catalog_generation_id:{$ref:"#/$defs/CatalogGenerationId"},configuration_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},policy_revision_id:{type:"string"}},required:["policy_revision_id","configuration_revision_id","catalog_generation_id"],type:"object"},$7={description:"The exact owner-relative relation set selected for a canonical Work graph.\n\nThis identity lives in the domain because attempt admission must retain\nit byte-for-byte through provider settlement. Reconstructing it from a\nproject context would conflate explicit no-Git work with a scoped\nrepository relation.",oneOf:[{properties:{selection:{const:"profile_owned_no_git",type:"string"}},required:["selection"],type:"object"},{properties:{relation_scopes:{items:{$ref:"#/$defs/WorkProductAuthorizedRelationScopeV1"},type:"array",uniqueItems:!0},selection:{const:"relations",type:"string"}},required:["selection","relation_scopes"],type:"object"}]},Se={additionalProperties:!1,properties:{decided_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["proposal","disposition","decided_at"],type:"object"},St={enum:["accepted","rejected","superseded"],type:"string"},Sr={additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},children:{items:{$ref:"#/$defs/WorkProposedChildV1"},type:"array"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},explanation:{type:"string"},proposal_id:{$ref:"#/$defs/ProposalId"},route:{$ref:"#/$defs/WorkRouteDecisionV1"},shape:{$ref:"#/$defs/WorkShapeAssessmentV1"},sizing:{$ref:"#/$defs/WorkSizingV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["proposal_id","task_id","based_on_version","shape","sizing","children","route","explanation","evidence_digest","configuration_digest"],type:"object"},Si={additionalProperties:!1,properties:{dependencies:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},effort:{format:"uint32",minimum:0,type:"integer"},task_id:{$ref:"#/$defs/TaskId"},title:{type:"string"}},required:["task_id","title","effort","dependencies"],type:"object"},So={description:"Typed provider availability observed at negotiation. These are product\nstates, not transport errors: each one names why the configured native\nprovider could not run, without inventing a fallback.",oneOf:[{const:"absent",description:"No executable binding is configured for the pinned executable identity.",type:"string"},{const:"stale",description:"The configured binding no longer matches the pinned reference.",type:"string"},{const:"unsupported",description:"The configured binding does not admit the pinned backend/protocol.",type:"string"},{const:"digest_mismatch",description:"The on-disk executable bytes do not match the pinned digest.",type:"string"},{const:"unavailable",description:"The configured executable could not be read or is not executable.",type:"string"}]},Sn={description:"Provider protocol selected by the pinned Work configuration snapshot.",enum:["claude_code_cli","codex_app_server","codex_cli"],type:"string"},Sa={additionalProperties:!1,description:'Why an admitted attempt did not run on the backend its pinned execution\nsnapshot preferred.\n\nPlan 32 (`docs/plans/tracedecay-v2/32-dynamic-workflow-runtime-and-sdk.md`,\n"Native provider execution") admits the Codex CLI "only when app-server is\nunsupported or absent before session start and the pinned Plan 20 snapshot\nexplicitly allows that fallback", and the plan index requires that fallback\nto be "reported rather than hidden". This record is that report: it names\nthe preferred backend, the typed state that disqualified it, and the\nconfiguration-bounded fallback that was selected, so a fallback run can\nnever be read as a first choice.\n\nIt is also written when the fallback itself was refused, so a denial keeps\nboth failures instead of collapsing them into one state.',properties:{fallback_backend:{$ref:"#/$defs/WorkProviderBackendV1",description:"The backend named by the snapshot's configured fallback topology."},fallback_route:{$ref:"#/$defs/WorkProviderRouteV1",description:"The route that fallback runs on."},fallback_state:{anyOf:[{$ref:"#/$defs/WorkProviderAvailabilityV1"},{type:"null"}],description:"`None` when the fallback actually started; `Some(state)` when the\nfallback was itself refused."},preferred_backend:{$ref:"#/$defs/WorkProviderBackendV1",description:"The backend the pinned snapshot named first."},preferred_route:{$ref:"#/$defs/WorkProviderRouteV1",description:"The route that backend would have run on."},preferred_state:{$ref:"#/$defs/WorkProviderAvailabilityV1",description:"Why the preferred backend could not be used."}},required:["preferred_backend","preferred_route","preferred_state","fallback_backend","fallback_route"],type:"object"},Ss={enum:["claude_stream_json","codex_app_server_json_rpc","codex_exec_json"],type:"string"},Sd={description:"Strongly typed canonical identity: `WorkProviderRouteId`.",type:"string"},Sc={additionalProperties:!1,properties:{provider_id:{$ref:"#/$defs/ProviderId"},route_id:{$ref:"#/$defs/WorkProviderRouteId"}},required:["provider_id","route_id"],type:"object"},Sl={oneOf:[{properties:{state:{const:"fresh",type:"string"}},required:["state"],type:"object"},{properties:{checkpoint:{anyOf:[{$ref:"#/$defs/WorkArtifactRefV1"},{type:"null"}]},source_attempt_id:{$ref:"#/$defs/AttemptId"},state:{const:"resumed",type:"string"}},required:["state","source_attempt_id"],type:"object"},{properties:{reason:{$ref:"#/$defs/WorkRestartReasonV1"},source_attempt_id:{$ref:"#/$defs/AttemptId"},state:{const:"restarted",type:"string"}},required:["state","source_attempt_id","reason"],type:"object"},{description:"The attempt cannot continue and must be recovered. A first attempt\nlost before it ever resumed anything has no predecessor, so the source\nis absent rather than pointing at the attempt itself.",properties:{observed_at:{$ref:"#/$defs/UtcMicros"},reason:{$ref:"#/$defs/WorkRestartReasonV1"},source_attempt_id:{anyOf:[{$ref:"#/$defs/AttemptId"},{type:"null"}],default:null},state:{const:"recovery_required",type:"string"}},required:["state","reason","observed_at"],type:"object"}]},Sp={additionalProperties:!1,properties:{decided_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},proposal:{$ref:"#/$defs/WorkRelationReplanProposalV1"}},required:["proposal","disposition","decided_at"],type:"object"},Su={additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},causal_candidates:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},dependencies:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},informational_relations:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},payload_digest:{$ref:"#/$defs/ManifestDigest"},proposal_id:{$ref:"#/$defs/ProposalId"},task_id:{$ref:"#/$defs/TaskId"}},required:["proposal_id","task_id","based_on_version","dependencies","informational_relations","causal_candidates","payload_digest"],type:"object"},Sm={enum:["lease_lost","provider_unavailable","process_lost","failure_observed"],type:"string"},Sf={enum:["runtime_failure","restart_recovery_required"],type:"string"},Sh={additionalProperties:!1,description:"A selector into the owning runtime-terminal evidence authority.\n\n`evidence_ref` is an opaque local reference. The Work retry owner resolves\nit through [`WorkRetryEvidencePortV1`]; callers never submit the evidence\ndigest, outcome, or observation time that decides eligibility.",properties:{cause:{$ref:"#/$defs/WorkRetryCauseV1"},evidence_ref:{type:"string"},source:{$ref:"#/$defs/WorkRetrySourceV1"}},required:["source","cause","evidence_ref"],type:"object"},Sy={enum:["runtime"],type:"string"},Sg={additionalProperties:!1,description:"One eligible route supplied by the authorized configuration snapshot.\n\nThe application filters these candidates by the current request grant and\nverifies the exact pinned executable before policy evaluates them.",properties:{autonomy:{$ref:"#/$defs/WorkOrdinalBandV1"},content_location:{$ref:"#/$defs/WorkContentLocationClassV1"},correctness:{$ref:"#/$defs/WorkOrdinalBandV1"},cost:{$ref:"#/$defs/WorkOrdinalBandV1"},declared_budget_ceiling:{format:"uint64",minimum:0,type:"integer"},effort:{$ref:"#/$defs/WorkEffortClassV1"},evidence_quality:{$ref:"#/$defs/WorkOrdinalBandV1"},execution:{$ref:"#/$defs/WorkRouteExecutionProfileV1"},latency:{$ref:"#/$defs/WorkOrdinalBandV1"},model_id:{type:"string"},provider_capability_id:{type:"string"},route_id:{type:"string"},sensitive_data_fitness:{$ref:"#/$defs/WorkOrdinalBandV1"}},required:["route_id","provider_capability_id","model_id","effort","declared_budget_ceiling","content_location","correctness","sensitive_data_fitness","latency","cost","autonomy","evidence_quality","execution"],type:"object"},S_={oneOf:[{properties:{alternatives:{items:{$ref:"#/$defs/WorkProviderRouteV1"},type:"array"},decision:{const:"selected",type:"string"},exclusions:{items:{type:"string"},type:"array",uniqueItems:!0},fallback:{type:"string"},recommended:{$ref:"#/$defs/WorkProviderRouteV1"}},required:["decision","recommended","alternatives","exclusions","fallback"],type:"object"},{properties:{decision:{const:"abstained",type:"string"},reason:{type:"string"}},required:["decision","reason"],type:"object"}]},Sv={additionalProperties:!1,description:"Complete execution constraints configured for one provider route.\n\nThe route candidate is the configuration authority for these values. Work\nadmission copies them into the immutable execution snapshot; provider\nadapters never supply defaults.",properties:{approval:{$ref:"#/$defs/WorkApprovalPolicy"},credential_references:{items:{$ref:"#/$defs/CredentialReferenceId"},type:"array",uniqueItems:!0},egress:{$ref:"#/$defs/WorkEgressPolicy"},environment_allowlist:{items:{type:"string"},type:"array",uniqueItems:!0},fallback:{$ref:"#/$defs/WorkFallbackTopology"},filesystem:{$ref:"#/$defs/WorkFilesystemPolicy"},limits:{$ref:"#/$defs/WorkExecutionLimits"},maximum_duration_micros:{description:"Maximum elapsed time from execution admission to provider completion.",format:"uint64",minimum:0,type:"integer"},sandbox:{$ref:"#/$defs/WorkSandboxPolicy"}},required:["sandbox","approval","filesystem","egress","environment_allowlist","credential_references","limits","maximum_duration_micros","fallback"],type:"object"},Sb={description:"A monotonically versioned control authority.",format:"uint64",minimum:0,title:"WorkRunControlAuthorityV1",type:"integer"},S$={description:"Why a run was paused or resumed. A closed vocabulary keeps the reason out\nof free text so it can be read by a projection without being a prompt.",oneOf:[{const:"operator_request",description:"An authorized operator asked for the transition.",type:"string"},{const:"human_wait",description:"The run is waiting on a human approval or answer.",type:"string"},{const:"budget_exhausted",description:"The shared budget ledger is exhausted for now.",type:"string"},{const:"recovery",description:"Recovery or failover is reconciling the run.",type:"string"}],title:"WorkRunControlReasonV1"},SS={description:'The published control state of one run.\n\nThere is no `Cancelled` here: cancellation is an attempt-level authority\nowned through the lease fence, and duplicating it as a run state would\ncreate a second place a run could be "over".',oneOf:[{const:"running",description:"New reservations are admitted.",type:"string"},{const:"paused",description:"New reservations are fenced; committed evidence is preserved.",type:"string"}],title:"WorkRunControlStateV1"},Sk={additionalProperties:!1,description:"The run's deadline as of the last control transition.\n\n`remaining_micros` is the authority; `deadline` is the absolute instant that\nremaining resolves to while the run is running. Both are recorded so a\nreader never has to recompute one from a clock it does not trust.",properties:{checkpoint_at:{$ref:"#/$defs/UtcMicros",description:"The instant the checkpoint was taken."},deadline:{$ref:"#/$defs/UtcMicros",description:"The absolute deadline the run is measured against right now."},remaining_micros:{description:"Micros left against that deadline at `checkpoint_at`. Never negative,\nand never larger than the value the previous checkpoint carried.",format:"int64",type:"integer"}},required:["deadline","remaining_micros","checkpoint_at"],title:"WorkRunDeadlineCheckpointV1",type:"object"},Sw={enum:["required"],type:"string"},SP={enum:["ordinal","heuristic","calibrated_range"],type:"string"},SV={additionalProperties:!1,properties:{ambiguity:{format:"uint8",maximum:255,minimum:0,type:"integer"},blast_radius:{format:"uint8",maximum:255,minimum:0,type:"integer"},complexity:{format:"uint8",maximum:255,minimum:0,type:"integer"},integration_overhead:{format:"uint8",maximum:255,minimum:0,type:"integer"},score_kind:{$ref:"#/$defs/WorkScoreKindV1"}},required:["score_kind","complexity","ambiguity","blast_radius","integration_overhead"],type:"object"},SR={additionalProperties:!1,properties:{coverage:{type:"string"},high:{format:"uint32",minimum:0,type:"integer"},likely:{format:"uint32",minimum:0,type:"integer"},low:{format:"uint32",minimum:0,type:"integer"},score_kind:{$ref:"#/$defs/WorkScoreKindV1"}},required:["score_kind","low","likely","high","coverage"],type:"object"},Sq={additionalProperties:!1,description:"Succeeded sources grouped by the exact artifact digest list they produced.\nGroups are ordered largest first; smaller groups are the minority\nevidence, and more than one group is the disagreement, preserved as\nstructure instead of being resolved by fiat.",properties:{artifacts:{description:"The artifact digest list every source in this group produced.",items:{$ref:"#/$defs/ManifestDigest"},type:"array"},sources:{description:"The concurring sources, in the caller's requested order.",items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"}},required:["artifacts","sources"],type:"object"},SI={description:"Why a synthesis request was answered with the unsynthesized set instead\nof an admitted attempt.",oneOf:[{const:"no_citable_sources",description:"No source contributed a citable artifact: every source failed, was\ncancelled, timed out, is still unknown, or succeeded without\ndeclaring artifacts. There is nothing a synthesis could truthfully\ncite.",type:"string"}]},Sx={additionalProperties:!1,description:"One immutable source envelope: which attempt, and what it truthfully\ncontributed at admission time.",properties:{outcome:{$ref:"#/$defs/WorkSynthesisSourceOutcomeV1"},source:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["source","outcome"],type:"object"},Sj={description:"One sibling attempt's terminal contribution, captured verbatim from the\nWork authority at admission time.",oneOf:[{description:"The source succeeded; its declared artifact digests, in declaration\norder, are the evidence a synthesis may cite.",properties:{artifacts:{items:{$ref:"#/$defs/ManifestDigest"},type:"array"},outcome:{const:"succeeded",type:"string"}},required:["outcome","artifacts"],type:"object"},{description:"The source failed; its sealed terminal evidence digest is preserved\nso the failure stays visible in the synthesis record.",properties:{evidence:{$ref:"#/$defs/ManifestDigest"},outcome:{const:"failed",type:"string"}},required:["outcome","evidence"],type:"object"},{description:"The source timed out; preserved like a failure.",properties:{evidence:{$ref:"#/$defs/ManifestDigest"},outcome:{const:"timed_out",type:"string"}},required:["outcome","evidence"],type:"object"},{description:"The source was cancelled; preserved like a failure.",properties:{evidence:{$ref:"#/$defs/ManifestDigest"},outcome:{const:"cancelled",type:"string"}},required:["outcome","evidence"],type:"object"},{description:"The source has not reached a terminal state. The unknown is preserved\nas an unknown; it contributes no citable evidence and is never\nguessed at.",properties:{outcome:{const:"unknown",type:"string"},state:{$ref:"#/$defs/WorkAttemptStateV1"}},required:["outcome","state"],type:"object"}]},SC={additionalProperties:!1,description:"The ordered, digest-sealed source envelope set a synthesis admission\nconsumed. Reordering or mutating any envelope changes the digest, so a\nreplayed or tampered set is distinguishable from the admitted one.",properties:{set_digest:{$ref:"#/$defs/ManifestDigest",description:"Canonical digest over the ordered envelopes."},sources:{description:"The envelopes, exactly in the caller's requested order.",items:{$ref:"#/$defs/WorkSynthesisSourceEnvelopeV1"},type:"array"}},required:["sources","set_digest"],type:"object"},ST={additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},binding:{description:"Binds the continuation to the retrieve-evidence operation and the\nresult-shaping request fields the envelope does not echo.",type:"string"},participant_epoch:{$ref:"#/$defs/ManifestDigest"},ranking_cursor:{type:["string","null"]},source:{$ref:"#/$defs/ObservationSourceIdentityV1"},temporal_cursor:{type:["string","null"]},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["verified_version","attempt","source","participant_epoch","binding"],type:"object"},SO={oneOf:[{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"succeeded",type:"string"}},required:["outcome","evidence_digest","observed_at"],type:"object"},{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"failed",type:"string"}},required:["outcome","evidence_digest","observed_at"],type:"object"},{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"timed_out",type:"string"}},required:["outcome","evidence_digest","observed_at"],type:"object"},{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"cancelled",type:"string"}},required:["outcome","evidence_digest","observed_at"],type:"object"}]},SE={description:"Strongly typed algorithm-tagged integrity digest: `WorkTopologyGenerationRefV1`.",type:"string"},SA={additionalProperties:!1,description:"Complete V1 policy. Partial values are intentionally impossible: callers\nmust provide the entire policy and validation rejects adapter-local defaults.",properties:{branch_naming:{$ref:"#/$defs/BranchNamingPolicyV1"},branch_topology:{$ref:"#/$defs/BranchTopologyPolicyV1"},concurrency:{$ref:"#/$defs/TopologyConcurrencyPolicyV1"},cross_merge:{$ref:"#/$defs/CrossMergePolicyV1"},escalation:{$ref:"#/$defs/TopologyEscalationPolicyV1"},gates:{$ref:"#/$defs/TopologyGatePolicyV1"},history_rewrite:{$ref:"#/$defs/HistoryRewritePolicyV1"},notifications:{$ref:"#/$defs/TopologyNotificationLevelV1"},placement:{$ref:"#/$defs/WorktreePlacementModeV1"},protected_refs:{items:{$ref:"#/$defs/ProtectedRefRuleV1"},type:"array"},retention:{$ref:"#/$defs/WorktreeRetentionPolicyV1"},review_topology:{$ref:"#/$defs/ReviewTopologyPolicyV1"},roots:{items:{$ref:"#/$defs/WorktreeRootPolicyV1"},type:"array"},schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"}},required:["schema_version","placement","roots","branch_topology","review_topology","branch_naming","concurrency","cross_merge","gates","protected_refs","history_rewrite","escalation","retention","notifications"],type:"object"},SW={additionalProperties:!1,properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:0,type:"integer"},pinned_catalog_digest:{$ref:"#/$defs/ManifestDigest",description:"Must equal the live Work executable catalog digest. Validation and\nactivation report the current digest when this pin is stale."},pinned_configuration_digest:{$ref:"#/$defs/ManifestDigest"},pinned_policy_digest:{$ref:"#/$defs/ManifestDigest"},project_id:{$ref:"#/$defs/ProjectId"},steps:{items:{$ref:"#/$defs/WorkflowStep"},type:"array"}},required:["definition_id","definition_version","project_id","steps","pinned_policy_digest","pinned_configuration_digest","pinned_catalog_digest"],type:"object"},SM={description:"Strongly typed canonical identity: `WorkflowDefinitionId`.",type:"string"},SN={additionalProperties:!1,properties:{max_width:{format:"uint32",minimum:0,type:"integer"}},required:["max_width"],type:"object"},Sz={description:"Strongly typed canonical identity: `WorkflowOperationRef`.",type:"string"},SD={description:"Strongly typed canonical identity: `WorkflowOutputName`.",type:"string"},SF={additionalProperties:!1,properties:{output_name:{$ref:"#/$defs/WorkflowOutputName"},producer_step_id:{$ref:"#/$defs/WorkflowStepId"}},required:["producer_step_id","output_name"],type:"object"},SL={additionalProperties:!1,properties:{fan_out:{anyOf:[{$ref:"#/$defs/WorkflowFanOut"},{type:"null"}]},inputs:{items:{$ref:"#/$defs/WorkflowOutputReference"},type:"array"},operation:{$ref:"#/$defs/WorkflowOperationRef"},outputs:{items:{$ref:"#/$defs/WorkflowOutputName"},type:"array"},predecessors:{items:{$ref:"#/$defs/WorkflowStepId"},type:"array",uniqueItems:!0},step_id:{$ref:"#/$defs/WorkflowStepId"}},required:["step_id","operation","predecessors","inputs","outputs"],type:"object"},SU={description:"Strongly typed canonical identity: `WorkflowStepId`.",type:"string"},SH={additionalProperties:!1,description:"A provider's claim that one artifact of a fan-out output synthesizes its\nsibling source artifacts.",properties:{cited_source_digests:{description:"Content digests of every source artifact the synthesis consumed.",items:{$ref:"#/$defs/ManifestDigest"},type:"array",uniqueItems:!0},output_name:{$ref:"#/$defs/WorkflowOutputName",description:"The fan-out output the synthesis belongs to."},synthesis_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1",description:"The attempt that produced the synthesis artifact inside that output."}},required:["output_name","synthesis_attempt","cited_source_digests"],type:"object"},SG={enum:["require_clean","allow_untracked_only_for_preflight","read_only_preflight_only"],type:"string"},SB={description:"Strongly typed canonical identity: `WorktreeId`.",type:"string"},SK={description:"Monotonic epoch of the worktree inventory frozen into a stack revision.",format:"uint64",minimum:0,type:"integer"},SJ={description:"Strongly typed canonical identity: `WorktreeInventorySnapshotId`.",type:"string"},SZ={oneOf:[{properties:{kind:{const:"existing_worktree_only",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"sibling_of_primary_checkout",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"repository_local_root",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"configured_root",type:"string"},root_id:{type:"string"}},required:["kind","root_id"],type:"object"}]},SQ={additionalProperties:!1,properties:{abandoned_retention_seconds:{format:"uint64",minimum:1,type:["integer","null"]},automatic_gc:{$ref:"#/$defs/AutomaticWorktreeGcV1"},maximum_retained_per_repository:{format:"uint16",maximum:65535,minimum:1,type:["integer","null"]},terminal_retention_seconds:{format:"uint64",minimum:1,type:["integer","null"]}},required:["automatic_gc"],type:"object"},SX={additionalProperties:!1,properties:{locator:{$ref:"#/$defs/SensitiveFilesystemLocatorV1"},maximum_active_worktrees:{format:"uint16",maximum:65535,minimum:1,type:"integer"},repository_scope:{$ref:"#/$defs/RepositoryPlacementScopeV1"},root_id:{type:"string"}},required:["root_id","locator","repository_scope","maximum_active_worktrees"],type:"object"},SY=[{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,title:"ActiveProjectSurfaceRequestV1",type:"object"},{$defs:{ActiveProjectBranchV1:{additionalProperties:!1,properties:{branch_drifted:{type:"boolean"},branch_resolution:{type:"string"},current_branch:{type:["string","null"]},open_active_branch:{type:["string","null"]},serving_branch:{type:["string","null"]},tracked_branch_count:{format:"uint",minimum:0,type:"integer"},warnings:{items:{type:"string"},type:"array"}},required:["branch_resolution","branch_drifted","tracked_branch_count","warnings"],type:"object"},ActiveProjectResolutionSourceV1:{enum:["active_project"],type:"string"},ActiveProjectStorageV1:{additionalProperties:!1,properties:{class:{type:"string"},data_root:{type:"string"},graph_db_exists:{type:"boolean"},graph_db_path:{type:"string"},graph_db_size_bytes:{format:"uint64",minimum:0,type:"integer"},lcm_payload_root:{type:"string"},mode:{type:"string"},response_handle_root:{type:"string"},sessions_db_path:{type:"string"}},required:["class","mode","data_root","graph_db_path","graph_db_exists","graph_db_size_bytes","sessions_db_path","response_handle_root","lcm_payload_root"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The resolved active project of this MCP session.",properties:{branch:{$ref:"#/$defs/ActiveProjectBranchV1"},project_id:{type:["string","null"]},project_root:{type:"string"},repository_id:{type:"string"},resolution_source:{$ref:"#/$defs/ActiveProjectResolutionSourceV1"},scope_prefix:{type:["string","null"]},storage:{$ref:"#/$defs/ActiveProjectStorageV1"}},required:["repository_id","project_root","resolution_source","storage","branch"],title:"ActiveProjectResultV1",type:"object"},{$defs:{AdminCliScopeV1:{description:"What a cost or analytics action reads: the served project's ledgers and\nsessions, or the whole profile's.",enum:["project","profile"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,description:"Savings and provider-usage cost over `range` (`today`, `7d`, ...).",properties:{action:{const:"cost_summary",type:"string"},range:{type:"string"},scope:{$ref:"#/$defs/AdminCliScopeV1"}},required:["action","range","scope"],type:"object"},{additionalProperties:!1,description:"Import every host's transcripts into the project's session store.",properties:{action:{const:"sessions_import",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"Converge project sessions with Git history.",properties:{action:{const:"sessions_git_sync",type:"string"},dry_run:{type:"boolean"},limit_sessions:{format:"uint",minimum:0,type:"integer"},since:{format:"int64",type:"integer"}},required:["action","since","limit_sessions","dry_run"],type:"object"},{additionalProperties:!1,properties:{action:{const:"sessions_sync_status",type:"string"},idempotency_key:{type:"string"}},required:["action","idempotency_key"],type:"object"},{additionalProperties:!1,properties:{action:{const:"sessions_sync_cancel",type:"string"},idempotency_key:{type:"string"}},required:["action","idempotency_key"],type:"object"},{additionalProperties:!1,properties:{action:{const:"sessions_unfinished",type:"string"},limit:{format:"uint",minimum:0,type:"integer"}},required:["action","limit"],type:"object"},{additionalProperties:!1,description:"Import hook analytics JSONL into the accounting ledger.",properties:{action:{const:"analytics_sync",type:"string"},scope:{$ref:"#/$defs/AdminCliScopeV1"}},required:["action","scope"],type:"object"},{additionalProperties:!1,properties:{action:{const:"analytics_diagnostics",type:"string"},all:{type:"boolean"},no_sync:{type:"boolean"},scope:{$ref:"#/$defs/AdminCliScopeV1"}},required:["action","scope","all","no_sync"],type:"object"},{additionalProperties:!1,description:"Record the served project's saved-token total.",properties:{action:{const:"registry_update",type:"string"},tokens:{format:"uint64",minimum:0,type:"integer"}},required:["action","tokens"],type:"object"},{additionalProperties:!1,properties:{action:{const:"registry_list",type:"string"},limit:{format:"uint",minimum:0,type:"integer"},project_arg:{description:"Checkout to mark active when the caller's connection names no\nproject.",type:["string","null"]},query:{type:["string","null"]}},required:["action","limit"],type:"object"},{additionalProperties:!1,properties:{action:{const:"registry_context",type:"string"},project_arg:{description:"Project path or alias; the caller's project when omitted.",type:["string","null"]}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"registry_empty",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"registry_project_tokens",type:"string"},project_args:{items:{type:"string"},type:"array"}},required:["action","project_args"],type:"object"},{additionalProperties:!1,description:"Plan, or with `apply` execute, collection of registry rows whose\ncheckout is gone.",properties:{action:{const:"registry_gc",type:"string"},apply:{type:"boolean"},prefix:{type:["string","null"]}},required:["action","apply"],type:"object"},{additionalProperties:!1,description:"One project's storage (`project_id` with `project_root`), or one page\nof the profile's.",properties:{action:{const:"storage_report",type:"string"},cursor:{default:null,type:["string","null"]},limit:{default:8,format:"uint",minimum:0,type:"integer"},project_id:{type:["string","null"]},project_root:{type:["string","null"]}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"gain_query",type:"string"},history:{type:"boolean"},project_arg:{type:["string","null"]},since:{format:"int64",type:"integer"}},required:["action","since","history"],type:"object"}],title:"AdminCliSurfaceRequestV1"},{$defs:{AdminCliAnalyticsImportV1:{additionalProperties:!1,properties:{imported:{format:"uint64",minimum:0,type:"integer"},sources:{description:"One row per hook JSONL source: `path`, `imported`, `skipped`, `error`.",items:!0,type:"array"}},required:["imported","sources"],type:"object"},AdminCliCostSummaryV1:{additionalProperties:!1,properties:{range:{type:"string"},summary:{$ref:"#/$defs/AdminCliCostTotalsV1"},today:{$ref:"#/$defs/AdminCliCostTodayV1"}},required:["range","summary","today"],type:"object"},AdminCliCostTodayV1:{additionalProperties:!1,properties:{provider_usage:!0},required:["provider_usage"],type:"object"},AdminCliCostTotalsV1:{additionalProperties:!1,properties:{efficiency_ratio:{description:"Saved over saved-plus-consumed; null when consumption is unmeasured.",format:"double",type:["number","null"]},provider_usage:{description:"The provider-usage cost summary as the session memory prices it."},tokens_saved:{format:"uint64",minimum:0,type:"integer"}},required:["provider_usage","tokens_saved"],type:"object"},AdminCliGainDayV1:{additionalProperties:!1,properties:{calls:{format:"uint64",minimum:0,type:"integer"},day:{description:"Start-of-day epoch seconds (UTC).",format:"int64",type:"integer"},saved_tokens:{format:"uint64",minimum:0,type:"integer"}},required:["day","saved_tokens","calls"],type:"object"},AdminCliGainHistoryV1:{additionalProperties:!1,properties:{history:{items:{$ref:"#/$defs/AdminCliGainDayV1"},type:"array"}},required:["history"],type:"object"},AdminCliGainTotalV1:{additionalProperties:!1,properties:{calls:{format:"uint64",minimum:0,type:"integer"},saved_tokens:{format:"uint64",minimum:0,type:"integer"}},required:["saved_tokens","calls"],type:"object"},AdminCliProjectTokenTotalV1:{additionalProperties:!1,description:"A project whose ledger could not be read reports a null total and the\nreason, never a measured zero.",properties:{error:{type:["string","null"]},project:{type:"string"},tokens:{format:"uint64",minimum:0,type:["integer","null"]}},required:["project"],type:"object"},AdminCliProjectTokensV1:{additionalProperties:!1,properties:{projects:{items:{$ref:"#/$defs/AdminCliProjectTokenTotalV1"},type:"array"}},required:["projects"],type:"object"},AdminCliRegistryContextV1:{oneOf:[{additionalProperties:!1,properties:{aliases:{description:"Alias rows exactly as the registry serializes them.",items:!0,type:"array"},profile_id:{type:"string"},project:{$ref:"#/$defs/PublicCodeProject"},status:{const:"ok",type:"string"},stores:{description:"Store rows exactly as the registry serializes them.",items:!0,type:"array"}},required:["status","profile_id","project","aliases","stores"],type:"object"},{additionalProperties:!1,description:"The call named no project and its connection has none.",properties:{project:{type:"null"},status:{const:"invalid",type:"string"}},required:["status","project"],type:"object"},{additionalProperties:!1,properties:{project:{type:"null"},status:{const:"not_found",type:"string"}},required:["status","project"],type:"object"}]},AdminCliRegistryEmptyV1:{additionalProperties:!1,properties:{empty:{type:"boolean"}},required:["empty"],type:"object"},AdminCliRegistryGcV1:{additionalProperties:!1,description:"The registry collection plan, with its deletion counters filled when it\nwas applied.",properties:{apply:{type:"boolean"},candidate_count:{format:"uint",minimum:0,type:"integer"},candidate_paths:{items:{type:"string"},type:"array"},candidates:{description:"Registry project rows exactly as the registry serializes them.",items:!0,type:"array"},code_project_candidate_count:{format:"uint",minimum:0,type:"integer"},deleted_code_project_count:{format:"uint",minimum:0,type:"integer"},deleted_count:{format:"uint",minimum:0,type:"integer"},deleted_storage_project_count:{format:"uint",minimum:0,type:"integer"},metadata_candidate_count:{format:"uint",minimum:0,type:"integer"},prefix:{type:["string","null"]},protected_code_project_count:{format:"uint",minimum:0,type:"integer"},protected_code_projects:{items:!0,type:"array"},storage_project_candidate_count:{format:"uint",minimum:0,type:"integer"},storage_project_candidates:{items:{type:"string"},type:"array"}},required:["apply","candidate_count","metadata_candidate_count","code_project_candidate_count","storage_project_candidate_count","protected_code_project_count","deleted_count","deleted_code_project_count","deleted_storage_project_count","candidate_paths","candidates","protected_code_projects","storage_project_candidates"],type:"object"},AdminCliRegistryListV1:{oneOf:[{additionalProperties:!1,properties:{limit:{format:"uint",minimum:0,type:"integer"},project_tree:{items:{$ref:"#/$defs/ProjectRepoGroup"},type:"array"},projects:{items:{$ref:"#/$defs/PublicCodeProject"},type:"array"},query:{type:["string","null"]},status:{const:"ok",type:"string"},summary:{$ref:"#/$defs/ProjectRegistrySummary"},truncated:{type:"boolean"}},required:["status","limit","truncated","summary","project_tree","projects"],type:"object"}]},AdminCliRegistryUpdateV1:{additionalProperties:!1,properties:{current:{format:"uint64",minimum:0,type:"integer"},previous:{description:"The total before this write; null when the ledger could not be read.",format:"uint64",minimum:0,type:["integer","null"]},previous_error:{type:["string","null"]}},required:["current"],type:"object"},AdminCliSessionSyncV1:{description:"The daemon session-sync owner's answer.",oneOf:[{additionalProperties:!1,properties:{accepted_at:{$ref:"#/$defs/UtcMicros"},idempotency_key:{type:"string"},operation_id:{type:"string"},status:{const:"accepted",type:"string"}},required:["status","operation_id","idempotency_key","accepted_at"],type:"object"},{additionalProperties:!1,description:"An identical sync was already running; this call joined it.",properties:{accepted_at:{$ref:"#/$defs/UtcMicros"},idempotency_key:{type:"string"},operation_id:{type:"string"},status:{const:"joined",type:"string"}},required:["status","operation_id","idempotency_key","accepted_at"],type:"object"},{additionalProperties:!1,properties:{coalesced_primary:{type:["string","null"]},completed_at:{$ref:"#/$defs/UtcMicros"},coverage:{items:{$ref:"#/$defs/SessionSyncSourceCoverageV1"},type:"array"},failure_codes:{items:{type:"string"},type:"array"},idempotency_key:{type:"string"},operation_id:{type:"string"},source:{$ref:"#/$defs/SessionSyncSourceV1"},source_frontiers:{items:{$ref:"#/$defs/SessionSyncSourceFrontierV1"},type:"array"},stats:{$ref:"#/$defs/SessionSyncStatsV1"},status:{const:"complete",type:"string"},termination:{$ref:"#/$defs/OperationTermination"}},required:["status","operation_id","idempotency_key","source","termination","stats","coverage","source_frontiers","failure_codes","completed_at"],type:"object"},{additionalProperties:!1,properties:{status:{const:"cancelled",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{status:{const:"deadline_exceeded",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{status:{const:"wrong_scope",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{reason_code:{type:"string"},status:{const:"unavailable",type:"string"}},required:["status","reason_code"],type:"object"}]},AdminCliStorageReportV1:{additionalProperties:!1,description:"One storage report page, or one project's report.",properties:{code_generation_retention:{items:!0,type:"array"},code_generation_retention_availability:{items:!0,type:"array"},coverage:!0,full_profile_size:!0,global_db_bytes:{format:"uint64",minimum:0,type:"integer"},profile_root:{type:"string"},stores:{description:"Report rows exactly as the retention report serializes them.",items:!0,type:"array"},unregistered_bytes:{format:"uint64",minimum:0,type:"integer"},unregistered_dir_count:{format:"uint",minimum:0,type:"integer"},user_sessions_db_bytes:{default:0,format:"uint64",minimum:0,type:"integer"}},required:["profile_root","stores","code_generation_retention","code_generation_retention_availability","unregistered_dir_count","unregistered_bytes","global_db_bytes","coverage"],type:"object"},AdminCliUnfinishedSessionsV1:{additionalProperties:!1,properties:{items:{description:"Workflow state rows exactly as the session store serializes them.",items:!0,type:"array"}},required:["items"],type:"object"},OperationTermination:_L,ProjectRegistryEntry:_6,ProjectRegistrySummary:_3,ProjectRepoGroup:_9,PublicCodeProject:va,SessionSyncCoverageV1:{oneOf:[{properties:{outcome:{const:"complete",type:"string"}},required:["outcome"],type:"object"},{properties:{deferred_units:{format:"uint64",minimum:0,type:"integer"},outcome:{const:"partial",type:"string"}},required:["outcome","deferred_units"],type:"object"},{properties:{admitted_units:{format:"uint64",minimum:0,type:"integer"},outcome:{const:"backpressured",type:"string"},rejected_units:{format:"uint64",minimum:0,type:"integer"}},required:["outcome","admitted_units","rejected_units"],type:"object"}]},SessionSyncSourceCoverageV1:{properties:{coverage:{$ref:"#/$defs/SessionSyncCoverageV1"},store_scope:{type:"string"}},required:["store_scope","coverage"],type:"object"},SessionSyncSourceFrontierV1:{description:"Exact canonical observation cursor committed by one source/store authority.",properties:{committed_cursor_json:{type:"string"},scope_json:{type:"string"},source_json:{type:"string"},store_scope:{type:"string"}},required:["store_scope","source_json","scope_json","committed_cursor_json"],type:"object"},SessionSyncSourceV1:{description:"The command that started a session sync, without its options.",oneOf:[{const:"import_transcripts",description:"Hands its remaining historical catch-up to the background refresh\nworkers.",type:"string"},{const:"synchronize_git",description:"A bounded foreground pass; nothing resumes its unfinished coverage.",type:"string"}]},SessionSyncStatsV1:{properties:{commits_attributed:{format:"uint64",minimum:0,type:"integer"},messages_imported:{format:"uint64",minimum:0,type:"integer"},sessions_imported:{format:"uint64",minimum:0,type:"integer"},sessions_scanned:{format:"uint64",minimum:0,type:"integer"},skipped:{format:"uint64",minimum:0,type:"integer"},spans_written:{format:"uint64",minimum:0,type:"integer"}},required:["sessions_imported","messages_imported","sessions_scanned","spans_written","commits_attributed","skipped"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/AdminCliCostSummaryV1"},{$ref:"#/$defs/AdminCliSessionSyncV1"},{$ref:"#/$defs/AdminCliUnfinishedSessionsV1"},{$ref:"#/$defs/AdminCliAnalyticsImportV1"},{$ref:"#/$defs/AdminCliRegistryUpdateV1"},{$ref:"#/$defs/AdminCliRegistryListV1"},{$ref:"#/$defs/AdminCliRegistryContextV1"},{$ref:"#/$defs/AdminCliRegistryEmptyV1"},{$ref:"#/$defs/AdminCliProjectTokensV1"},{$ref:"#/$defs/AdminCliRegistryGcV1"},{$ref:"#/$defs/AdminCliStorageReportV1"},{$ref:"#/$defs/AdminCliGainHistoryV1"},{$ref:"#/$defs/AdminCliGainTotalV1"},{description:"The diagnostics report is the analytics bridge's open document; it\ndecodes last so it never claims another action's body."}],description:"One action's answer.",title:"AdminCliResultV1"},{$defs:{AutomaticFactReceiptStateV1:fD,AutomationReconcileScope:fG},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Every action is a struct variant: an internally tagged unit variant would\nignore keys beside its tag instead of refusing them.",oneOf:[{additionalProperties:!1,description:"Read the project's local usage counter.",properties:{action:{const:"counter_get",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"Reset the project's local usage counter to zero.",properties:{action:{const:"counter_reset",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"Record the project's saved-token total in the profile registry and\nread it back beside the other projects' total.",properties:{action:{const:"status_accounting",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"List terminal automatic-fact receipts.",properties:{action:{const:"automatic_fact_receipt_list",type:"string"},limit:{format:"uint",minimum:0,type:"integer"},state:{anyOf:[{$ref:"#/$defs/AutomaticFactReceiptStateV1"},{type:"null"}],description:"Only receipts in this state (default: every state)."}},required:["action","limit"],type:"object"},{additionalProperties:!1,description:"Read one automatic-fact receipt by its apply id.",properties:{action:{const:"automatic_fact_receipt_view",type:"string"},id:{type:"string"}},required:["action","id"],type:"object"},{additionalProperties:!1,description:"Reconcile automation schedulers with the saved configuration.",properties:{action:{const:"automation_reconcile",type:"string"},scope:{$ref:"#/$defs/AutomationReconcileScope"}},required:["action","scope"],type:"object"}],title:"AdminProjectSurfaceRequestV1"},{$defs:{AdminProjectCounterResetV1:{additionalProperties:!1,properties:{reset:{description:"Always true: a reset that did not settle is a refusal.",type:"boolean"}},required:["reset"],type:"object"},AdminProjectCounterV1:{additionalProperties:!1,properties:{counter:{format:"uint64",minimum:0,type:"integer"}},required:["counter"],type:"object"},AdminProjectStatusAccountingV1:{additionalProperties:!1,properties:{global_tokens_saved:{description:"Tokens the profile's other projects saved; null when they saved none.",format:"uint64",minimum:0,type:["integer","null"]},tokens_saved:{format:"uint64",minimum:0,type:"integer"}},required:["tokens_saved"],type:"object"},AutomaticFactAddRequestV1:{additionalProperties:!1,description:"The add-fact request an automatic apply recorded.",properties:{category:{$ref:"#/$defs/FactCategoryV1"},content:{type:"string"},entities:{items:{type:"string"},type:"array"},metadata:!0,source_label:{type:["string","null"]},tags:{items:{type:"string"},type:"array"},trust:{format:"double",type:"number"}},required:["content","category","tags","entities","trust","metadata"],type:"object"},AutomaticFactEvidenceV1:{additionalProperties:!1,description:"Automation evidence retained with the receipt.",properties:{evidence_hash:{type:["string","null"]},item:!0,validation:!0},type:"object"},AutomaticFactReceiptAvailabilityV1:{oneOf:[{additionalProperties:!1,properties:{state:{const:"available",type:"string"}},required:["state"],type:"object"}]},AutomaticFactReceiptListV1:{additionalProperties:!1,properties:{availability:{$ref:"#/$defs/AutomaticFactReceiptAvailabilityV1"},count:{format:"uint",minimum:0,type:"integer"},next_after_apply_id:{description:"Continue after this apply id; null on the last page.",type:["string","null"]},receipts:{items:{$ref:"#/$defs/AutomaticFactReceiptV1"},type:"array"}},required:["availability","count","receipts"],type:"object"},AutomaticFactReceiptStateV1:fD,AutomaticFactReceiptV1:{additionalProperties:!1,description:"One terminal automatic-fact apply receipt.",properties:{add_fact_request:{$ref:"#/$defs/AutomaticFactAddRequestV1"},applied_fact_id:{description:"Present when the fact was applied.",type:["string","null"]},apply_id:{type:"string"},evidence:{$ref:"#/$defs/AutomaticFactEvidenceV1"},operation_id:{type:"string"},quarantine_reason:{description:"Present when the fact was quarantined.",type:["string","null"]},recorded_at_micros:{format:"int64",type:"integer"},state:{$ref:"#/$defs/AutomaticFactReceiptStateV1"}},required:["apply_id","state","operation_id","add_fact_request","evidence","recorded_at_micros"],type:"object"},AutomaticFactReceiptViewV1:{additionalProperties:!1,properties:{receipt:{$ref:"#/$defs/AutomaticFactReceiptV1"}},required:["receipt"],type:"object"},AutomationReconcileScope:fG,AutomationSchedulerOwnerReconcileOutcome:{additionalProperties:!1,properties:{graph_db_path:{type:"string"},outcome:{$ref:"#/$defs/AutomationSchedulerReconcileOutcome"},project_id:{type:["string","null"]},scope_prefix:{type:["string","null"]},store_root:{type:"string"}},required:["store_root","graph_db_path","outcome"],type:"object"},AutomationSchedulerReconcileOutcome:{description:"What reconciling one automation scheduler did.",enum:["started","running_notified","exiting","finished","retiring","not_configured","lifecycle_inactive","owner_unavailable"],type:"string"},FactCategoryV1:yA,ProfileAutomationReconcileReport:{additionalProperties:!1,description:"Every cached project scheduler of the profile, reconciled.",properties:{cached_owners:{format:"uint",minimum:0,type:"integer"},outcomes:{items:{$ref:"#/$defs/AutomationSchedulerOwnerReconcileOutcome"},type:"array"},scope:{$ref:"#/$defs/AutomationReconcileScope",description:"Always `profile`."},uncached_projects:{$ref:"#/$defs/UncachedProjectReconcileOutcome"}},required:["scope","cached_owners","outcomes","uncached_projects"],type:"object"},ProjectAutomationReconcileReport:{additionalProperties:!1,description:"The served project's scheduler reconcile.",properties:{outcome:{$ref:"#/$defs/AutomationSchedulerReconcileOutcome"},scope:{$ref:"#/$defs/AutomationReconcileScope",description:"Always `project`."}},required:["scope","outcome"],type:"object"},UncachedProjectReconcileOutcome:{description:"A project whose scheduler is not cached reconciles when it next starts.",enum:["deferred_until_project_startup"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/AdminProjectCounterV1"},{$ref:"#/$defs/AdminProjectCounterResetV1"},{$ref:"#/$defs/AdminProjectStatusAccountingV1"},{$ref:"#/$defs/AutomaticFactReceiptListV1"},{$ref:"#/$defs/AutomaticFactReceiptViewV1"},{$ref:"#/$defs/ProjectAutomationReconcileReport"},{$ref:"#/$defs/ProfileAutomationReconcileReport"}],description:"One action's result, in the shape the action has always answered.",title:"AdminProjectResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"`tracedecay_admin_sync` takes no arguments: it reconciles the served\nproject.",title:"AdminSyncSurfaceRequestV1",type:"object"},{$defs:{AdminSyncAdmissionV1:{description:"The code-index scheduler's admission of the reconcile.",oneOf:[{enum:["queued"],type:"string"},{const:"not_applicable",description:"Code indexing does not apply to this project.",type:"string"}]},AdminSyncReconcileScopeV1:{description:"What the reconcile covers.",enum:["authoritative_project"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{project_root:{type:"string"},reconcile_scope:{$ref:"#/$defs/AdminSyncReconcileScopeV1"},status:{$ref:"#/$defs/AdminSyncAdmissionV1"}},required:["reconcile_scope","status","project_root"],title:"AdminSyncResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{depth:{description:"Maximum dependency traversal depth (default: 5, at most 10).",format:"uint32",minimum:0,type:["integer","null"]},files:{description:"List of changed file paths to analyze.",items:{type:"string"},type:"array"},filter:{description:"Custom glob pattern for test files (default: common test patterns).",type:["string","null"]}},required:["files"],title:"AffectedSurfaceRequestV1",type:"object"},{$defs:{AffectedRankingMetadataV1:{additionalProperties:!1,properties:{distance:{type:"string"},recommended_proximity:{items:{type:"string"},type:"array"},strategy:{type:"string"}},required:["strategy","distance","recommended_proximity"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RankedAffectedTestV1:{additionalProperties:!1,properties:{distance:{format:"uint",minimum:0,type:"integer"},path:{type:"string"},proximity:{type:"string"},rank:{format:"uint",minimum:0,type:"integer"}},required:["path","rank","distance","proximity"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{changed_files:{items:{type:"string"},type:"array"},count:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ranked_tests:{items:{$ref:"#/$defs/RankedAffectedTestV1"},type:"array"},ranking_metadata:{$ref:"#/$defs/AffectedRankingMetadataV1"},recommended_tests:{description:"Tests within two dependency hops of a changed file.",items:{type:"string"},type:"array"}},required:["changed_files","count","ranked_tests","recommended_tests","ranking_metadata"],title:"AffectedResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Opaque daemon-minted handle accepted by the first feedback read invocation.",properties:{request_handle:{type:"string"}},required:["request_handle"],title:"FeedbackHandleRequestV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,FeedbackContentIdentityV1:y0,FeedbackCycleId:y2,FeedbackImpactStateV1:gr,FeedbackResultId:go,FeedbackScopeV1:gn,FeedbackTargetV1:ga,FileOccurrenceId:gs,HostInstanceId:gL,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Canonical affected-tests projection returned by `affected_tests`.",properties:{affected_tests:{items:{$ref:"#/$defs/SymbolOccurrenceId"},type:"array"},content_identity:{anyOf:[{$ref:"#/$defs/FeedbackContentIdentityV1"},{type:"null"}]},cycle_id:{$ref:"#/$defs/FeedbackCycleId"},evidence_anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},result_id:{$ref:"#/$defs/FeedbackResultId"},scope:{$ref:"#/$defs/FeedbackScopeV1"},state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},target:{anyOf:[{$ref:"#/$defs/FeedbackTargetV1"},{type:"null"}]}},required:["result_id","cycle_id","scope","affected_tests","evidence_anchors"],title:"CanonicalAffectedTestsProjectionV1",type:"object"},{$defs:{AnalyticsScopeV1:fP,AnalyticsSectionV1:{enum:["tools","hints","facts","automation"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope:{anyOf:[{$ref:"#/$defs/AnalyticsScopeV1"},{type:"null"}],description:'"project" (default) scopes analytics_events to the resolved project;\n"all" reports across every registered project.'},section:{anyOf:[{$ref:"#/$defs/AnalyticsSectionV1"},{type:"null"}],description:"Optional filter to a single section. Omit to return all sections."},window_days:{description:"Lookback window in days for events and automation runs (default: 14,\n1-365).",format:"uint32",maximum:365,minimum:1,type:["integer","null"]}},title:"AnalyticsSurfaceRequestV1",type:"object"},{$defs:{AnalyticsAutomationJobOutcomesV1:{additionalProperties:!1,properties:{failed:{format:"int64",type:"integer"},job:{type:"string"},other:{format:"int64",type:"integer"},skipped:{format:"int64",type:"integer"},succeeded:{format:"int64",type:"integer"}},required:["job","succeeded","failed","skipped","other"],type:"object"},AnalyticsAutomationOutcomesV1:{additionalProperties:!1,description:"`available` is always `true`.",properties:{available:{type:"boolean"},by_job:{items:{$ref:"#/$defs/AnalyticsAutomationJobOutcomesV1"},type:"array"},dashboard_root:{type:"string"},records_considered:{format:"uint",minimum:0,type:"integer"},records_in_window:{format:"uint",minimum:0,type:"integer"},records_truncated:{type:"boolean"}},required:["available","dashboard_root","records_considered","records_in_window","records_truncated","by_job"],type:"object"},AnalyticsAutomationSectionV1:{anyOf:[{$ref:"#/$defs/AnalyticsAutomationOutcomesV1"},{$ref:"#/$defs/AnalyticsLedgerUnavailableV1"},{$ref:"#/$defs/AnalyticsSectionUnavailableV1"}],description:"The automation run outcomes of the resolved project's ledger, or why the\nledger is unavailable."},AnalyticsCanonicalCallNameV1:{additionalProperties:!1,description:"A recorded event name that resolved to a canonical tool under another\nspelling.",properties:{calls:{format:"int64",type:"integer"},canonical_tool_name:{type:"string"},errors:{format:"int64",type:"integer"},event_name:{type:"string"}},required:["event_name","canonical_tool_name","calls","errors"],type:"object"},AnalyticsEventCallNameV1:{additionalProperties:!1,description:"A recorded event name with no advertised canonical tool.",properties:{calls:{format:"int64",type:"integer"},errors:{format:"int64",type:"integer"},event_name:{type:"string"}},required:["event_name","calls","errors"],type:"object"},AnalyticsFactFunnelV1:{additionalProperties:!1,description:"`available` is always `true`.",properties:{available:{type:"boolean"},facts:{format:"uint64",minimum:0,type:"integer"},facts_rated:{format:"uint64",minimum:0,type:"integer"},facts_retrieved:{format:"uint64",minimum:0,type:"integer"},helpful_feedback:{format:"uint64",minimum:0,type:"integer"},project_root:{type:"string"},retrievals:{format:"uint64",minimum:0,type:"integer"},unhelpful_feedback:{format:"uint64",minimum:0,type:"integer"}},required:["available","project_root","facts","retrievals","facts_retrieved","helpful_feedback","unhelpful_feedback","facts_rated"],type:"object"},AnalyticsFactsSectionV1:{anyOf:[{$ref:"#/$defs/AnalyticsFactFunnelV1"},{$ref:"#/$defs/AnalyticsProjectSectionUnavailableV1"},{$ref:"#/$defs/AnalyticsSectionUnavailableV1"}],description:"The fact-store funnel of the resolved project, or why it is unavailable.\n\nThe variants are distinguished by their exact field sets, so each one\ndenies unknown fields and the most specific shape is tried first."},AnalyticsHintCategoryV1:{properties:{category:{type:"string"},emitted:{format:"int64",type:"integer"},followed:{format:"int64",type:"integer"},ignored:{format:"int64",type:"integer"},suppressed:{format:"int64",type:"integer"}},required:["category","emitted","followed","ignored","suppressed"],type:"object"},AnalyticsHintsPayloadV1:{properties:{available:{type:"boolean"},by_category:{items:{$ref:"#/$defs/AnalyticsHintCategoryV1"},type:"array"},error:{default:null,type:["string","null"]},source:{type:"string"}},required:["available","source","by_category"],type:"object"},AnalyticsLedgerUnavailableV1:{additionalProperties:!1,description:"The ledger exists but failed to read. `available` is always `false`.",properties:{available:{type:"boolean"},dashboard_root:{type:"string"},reason:{type:"string"}},required:["available","reason","dashboard_root"],type:"object"},AnalyticsModeReadModelV1:fk,AnalyticsModeV1:fw,AnalyticsProjectSectionUnavailableV1:{additionalProperties:!1,description:"A project-scoped section whose store failed to read. `available` is\nalways `false`.",properties:{available:{type:"boolean"},project_root:{type:"string"},reason:{type:"string"}},required:["available","reason","project_root"],type:"object"},AnalyticsReportStatusV1:{description:"The settled status of an analytics report.",enum:["ok"],type:"string"},AnalyticsScopeV1:fP,AnalyticsSectionUnavailableV1:{additionalProperties:!1,description:"A section the report could not read. `available` is always `false`.",properties:{available:{type:"boolean"},reason:{type:"string"}},required:["available","reason"],type:"object"},AnalyticsTierCountsV1:{additionalProperties:!1,properties:{calls:{format:"int64",type:"integer"},errors:{format:"int64",type:"integer"},tier:{type:"string"}},required:["tier","calls","errors"],type:"object"},AnalyticsToolsSectionV1:{additionalProperties:!1,properties:{aliased_call_names:{items:{$ref:"#/$defs/AnalyticsCanonicalCallNameV1"},type:"array"},available:{type:"boolean"},available_defined_tool_count:{format:"uint",minimum:0,type:"integer"},bound_internal_call_names:{items:{$ref:"#/$defs/AnalyticsEventCallNameV1"},type:"array"},called_available_defined_tool_count:{format:"uint",minimum:0,type:"integer"},raw_distinct_event_name_count:{format:"uint",minimum:0,type:"integer"},tiers:{items:{$ref:"#/$defs/AnalyticsTierCountsV1"},type:"array"},top_tools:{items:{$ref:"#/$defs/AnalyticsTopToolV1"},type:"array"},unknown_or_retired_call_names:{items:{$ref:"#/$defs/AnalyticsEventCallNameV1"},type:"array"},zero_call_available_defined_tools:{$ref:"#/$defs/AnalyticsZeroCallToolsV1"}},required:["available","tiers","top_tools","raw_distinct_event_name_count","called_available_defined_tool_count","available_defined_tool_count","aliased_call_names","bound_internal_call_names","unknown_or_retired_call_names","zero_call_available_defined_tools"],type:"object"},AnalyticsTopToolV1:{additionalProperties:!1,properties:{calls:{format:"int64",type:"integer"},errors:{format:"int64",type:"integer"},tier:{type:"string"},tool_name:{type:"string"}},required:["tool_name","tier","calls","errors"],type:"object"},AnalyticsZeroCallToolsV1:{additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:"integer"},sample:{items:{type:"string"},type:"array"},sample_truncated:{type:"boolean"}},required:["count","sample","sample_truncated"],type:"object"},ComparisonDispositionV1:hI,CostsReadModelV1:yl,CoverageStateV1:yf,LatencyDistributionReadModelV1:gJ,MetricCalibrationV1:_h,MetricCohortV1:_y,MetricCoverageV1:_g,MetricEvidenceClassV1:__,MetricProvenanceV1:_v,MetricSourceV1:_b,MetricTemporalV1:_$,MetricUncertaintyV1:_S,MetricValueV1:_k,ObservabilityHorizonV1:_W,ObservatoryReadModelV1:_N,PerformanceComparisonReadModelV1:_H,ProviderLatencyReadModelV1:vn,RejectedArgumentAnalyticsV1:vh,RejectedArgumentErrorClassV1:vy,RejectedArgumentGroupV1:vg,RejectedArgumentNameV1:v_,RejectedArgumentSurfaceV1:vv},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{automation:{anyOf:[{$ref:"#/$defs/AnalyticsAutomationSectionV1"},{type:"null"}]},costs:{anyOf:[{$ref:"#/$defs/CostsReadModelV1"},{type:"null"}],description:"Present only when no section filter was requested."},event_count:{format:"int64",type:"integer"},event_count_truncated:{type:"boolean"},facts:{anyOf:[{$ref:"#/$defs/AnalyticsFactsSectionV1"},{type:"null"}]},hints:{anyOf:[{$ref:"#/$defs/AnalyticsHintsPayloadV1"},{type:"null"}]},observatory:{anyOf:[{$ref:"#/$defs/ObservatoryReadModelV1"},{type:"null"}],description:"Present only when no section filter was requested."},project_id:{description:'The canonical analytics project key; `None` for `scope: "all"`.',type:["string","null"]},project_root:{type:"string"},scope:{$ref:"#/$defs/AnalyticsScopeV1"},since:{format:"int64",type:"integer"},status:{$ref:"#/$defs/AnalyticsReportStatusV1"},tools:{anyOf:[{$ref:"#/$defs/AnalyticsToolsSectionV1"},{type:"null"}]},window_days:{format:"uint32",minimum:0,type:"integer"}},required:["status","scope","project_root","window_days","since","event_count","event_count_truncated"],title:"AnalyticsResultV1",type:"object"},{$defs:{ManifestDigest:_l,NativeIntegrationApprovalId:_V,NativeIntegrationPreviewId:_I,NativeIntegrationTransactionId:_T},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact one-use apply request.\n\nApply accepts only an unexpired preview identity/digest plus a one-use\ncontent-bound approval. Arbitrary Git arguments, caller-supplied paths,\nSHAs, patches, commit lists, messages, environment, or config are\nunrepresentable.",properties:{approval_digest:{$ref:"#/$defs/ManifestDigest"},approval_id:{$ref:"#/$defs/NativeIntegrationApprovalId"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"}},required:["preview_id","preview_digest","approval_id","approval_digest","transaction_id"],title:"NativeIntegrationApplySurfaceRequest",type:"object"},{$defs:{ActorId:fb,BranchStackEdgeV1:f3,BranchStackId:f9,BranchStackNodeV1:f5,BranchStackRevisionId:f8,BranchStackRevisionV1:f7,BranchStackSourceV1:he,CapabilityId:hl,CodeGenerationId:hy,CommitId:hq,ContentDigest:hD,GitOidV1:gq,GitOperationStateV1:gI,ManifestDigest:_l,MechanicalIntegrationModeV1:_p,NativeIntegrationAnalysisAnchorV1:{additionalProperties:!1,description:"Source-local anchor for a semantic conflict finding.",properties:{generation_id:{$ref:"#/$defs/CodeGenerationId"},logical_path:{type:"string"},source_span:{$ref:"#/$defs/SourceSpan"}},required:["generation_id","logical_path","source_span"],type:"object"},NativeIntegrationAnalysisCoverageV1:{description:"Completeness of one independently evaluated semantic evidence lane.",enum:["complete","partial","unsupported"],type:"string"},NativeIntegrationAnalysisGapV1:{description:"Why one semantic evidence lane cannot authorize integration.",enum:["parser_failure","unresolved_required_edge","withheld_source","stale_evidence","unsupported_language","dynamic_schema","unbound_migration_order","capacity_unavailable","authority_unavailable"],type:"string"},NativeIntegrationAnalysisLaneV1:{additionalProperties:!1,description:"Coverage and exact gaps for one independently evaluated analysis lane.",properties:{coverage:{$ref:"#/$defs/NativeIntegrationAnalysisCoverageV1"},gaps:{items:{$ref:"#/$defs/NativeIntegrationAnalysisGapV1"},type:"array"}},required:["coverage","gaps"],type:"object"},NativeIntegrationAnalysisReportV1:{additionalProperties:!1,description:"Daemon-produced semantic evidence for one exact native candidate tree.",properties:{analyzer_revision:{type:"string"},candidate:{$ref:"#/$defs/NativeIntegrationGenerationBindingV1"},conflicts:{items:{$ref:"#/$defs/NativeIntegrationSemanticConflictV1"},type:"array"},destination:{$ref:"#/$defs/NativeIntegrationGenerationBindingV1"},digest:{$ref:"#/$defs/ManifestDigest"},graph:{$ref:"#/$defs/NativeIntegrationAnalysisLaneV1"},merge_base:{$ref:"#/$defs/NativeIntegrationGenerationBindingV1"},migrations:{$ref:"#/$defs/NativeIntegrationAnalysisLaneV1"},schema:{$ref:"#/$defs/NativeIntegrationAnalysisLaneV1"},source:{$ref:"#/$defs/NativeIntegrationGenerationBindingV1"},tests:{$ref:"#/$defs/NativeIntegrationAnalysisLaneV1"}},required:["merge_base","source","destination","candidate","graph","tests","schema","migrations","conflicts","analyzer_revision","digest"],type:"object"},NativeIntegrationApprovalId:_V,NativeIntegrationDirectionV1:_R,NativeIntegrationGenerationBindingV1:{additionalProperties:!1,description:"One immutable code-generation binding used by native integration analysis.",properties:{content_identity:{$ref:"#/$defs/ContentDigest"},generation_id:{$ref:"#/$defs/CodeGenerationId"},project_id:{$ref:"#/$defs/ProjectId"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},repository_id:{$ref:"#/$defs/RepositoryId"},seal_digest:{$ref:"#/$defs/ManifestDigest"},snapshot_digest:{$ref:"#/$defs/ManifestDigest"},source_revision:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},source_tree:{$ref:"#/$defs/GitOidV1"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["generation_id","project_id","repository_id","snapshot_digest","content_identity","source_tree","seal_digest"],type:"object"},NativeIntegrationPhaseV1:{description:"Durable transaction phase. `RefCommitStarted` is the cancellation boundary.",enum:["prepared","candidate_verified","ref_commit_started","final_state_verification","terminal"],type:"string"},NativeIntegrationPreviewDispositionV1:_q,NativeIntegrationPreviewId:_I,NativeIntegrationSealedStackSnapshotV1:_x,NativeIntegrationSelectionBindingV1:_j,NativeIntegrationSemanticConflictKindV1:{description:"Static conflict class produced from canonical generation evidence.",enum:["divergent_symbol","signature_dependent","test_write_interaction","divergent_schema","migration_order"],type:"string"},NativeIntegrationSemanticConflictV1:{additionalProperties:!1,description:"One deterministic conflict finding with source evidence from both branches.",properties:{destination:{$ref:"#/$defs/NativeIntegrationAnalysisAnchorV1"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},kind:{$ref:"#/$defs/NativeIntegrationSemanticConflictKindV1"},source:{$ref:"#/$defs/NativeIntegrationAnalysisAnchorV1"}},required:["kind","source","destination","evidence_digest"],type:"object"},NativeIntegrationSnapshotProjectionV1:{additionalProperties:!1,description:"Bounded projection of one frozen selection.",properties:{destination_ref:{$ref:"#/$defs/RefId"},frozen_at:{$ref:"#/$defs/UtcMicros"},inventory_epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},selection_digest:{$ref:"#/$defs/ManifestDigest"},source_ref:{$ref:"#/$defs/RefId"}},required:["selection_digest","project_id","repository_id","source_ref","destination_ref","inventory_epoch","frozen_at"],type:"object"},NativeIntegrationStatusProjectionV1:{additionalProperties:!1,description:"Bounded projection of one durable transaction status.",properties:{cancellation_requested:{type:"boolean"},destination_ref:{$ref:"#/$defs/RefId"},phase:{$ref:"#/$defs/NativeIntegrationPhaseV1"},phase_revision:{format:"uint64",minimum:0,type:"integer"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},repository_id:{$ref:"#/$defs/RepositoryId"},terminal_outcome:{anyOf:[{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"},{type:"null"}]},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["transaction_id","preview_id","preview_digest","repository_id","destination_ref","phase","phase_revision","cancellation_requested","updated_at"],type:"object"},NativeIntegrationSurfaceUnavailableV1:{description:"Why a native-integration operation produced no advancing state.\n\nEvery variant is read-only and truthful. None of them authorizes apply, and\na denied or absent target is reported indistinguishably from an unavailable\nauthority so no identity, path, count, or topology leaks.",oneOf:[{enum:["partial","stale","denied","reset_required","durability_uncertain","cancelled","approval_conflict","transaction_conflict","recovery_required","needs_inspection","unknown_transaction"],type:"string"},{const:"authority_unmounted",description:"No native-integration runtime authority is mounted for this daemon.",type:"string"}]},NativeIntegrationTerminalOutcomeV1:_C,NativeIntegrationTransactionId:_T,NativeIntegrationUnavailabilityV1:_O,NativeWorktreeSurfaceResultV1:{oneOf:[{oneOf:[{properties:{coverage:{$ref:"#/$defs/WorktreeCoverageV1"},digest:{$ref:"#/$defs/ManifestDigest"},entries:{items:{$ref:"#/$defs/WorktreeInventoryEntryV1"},type:"array"},epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},observed_at:{$ref:"#/$defs/UtcMicros"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},snapshot_id:{$ref:"#/$defs/WorktreeInventorySnapshotId"},state:{const:"snapshot",type:"string"}},required:["state","scope_set_id","scope_set_revision","scope_set_digest","snapshot_id","epoch","entries","coverage","observed_at","digest"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}],properties:{operation:{const:"inventory",type:"string"}},required:["operation"],type:"object"},{oneOf:[{properties:{clean:{$ref:"#/$defs/WorktreeObservationV1",description:"Whether Git status contains no tracked or untracked changes."},head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},holder:{$ref:"#/$defs/WorktreeObservationV1"},inspection_digest:{$ref:"#/$defs/ManifestDigest"},kind:{anyOf:[{$ref:"#/$defs/WorktreeKindV1"},{type:"null"}]},locked:{$ref:"#/$defs/WorktreeObservationV1"},observed_at:{$ref:"#/$defs/UtcMicros"},operation_state:{anyOf:[{$ref:"#/$defs/GitOperationStateV1"},{type:"null"}]},presence:{$ref:"#/$defs/WorktreePresenceV1"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},state:{const:"inspection",type:"string"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"},unique_data:{$ref:"#/$defs/WorktreeObservationV1"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["state","target","presence","worktree_id","clean","locked","holder","unique_data","observed_at","inspection_digest"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"foreign",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}],properties:{operation:{const:"inspection",type:"string"}},required:["operation"],type:"object"},{oneOf:[{properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},confirmed_at:{$ref:"#/$defs/UtcMicros"},inspection_digest:{$ref:"#/$defs/ManifestDigest"},state:{const:"confirmed",type:"string"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["state","target","inspection_digest","confirmation_digest","confirmed_at"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"needs_inspection",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}],properties:{operation:{const:"confirmation",type:"string"}},required:["operation"],type:"object"},{$ref:"#/$defs/WorktreeCleanupRemovalV1",properties:{operation:{const:"removal",type:"string"}},required:["operation"],type:"object"},{$ref:"#/$defs/WorktreeCleanupReconciliationV1",properties:{operation:{const:"reconciliation",type:"string"}},required:["operation"],type:"object"}]},NativeWorktreeTargetV1:_E,ProjectId:_4,RefId:vm,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,SourceSpan:b$,StackNodeId:bw,UtcMicros:bZ,WorktreeCleanupReconciliationV1:{oneOf:[{properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"removed",type:"string"}},required:["state","confirmation_digest","observed_at"],type:"object"},{properties:{state:{const:"still_present",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"durability_uncertain",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}]},WorktreeCleanupRemovalV1:{oneOf:[{properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"removed",type:"string"}},required:["state","confirmation_digest","observed_at"],type:"object"},{properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"already_removed",type:"string"}},required:["state","confirmation_digest","observed_at"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"durability_uncertain",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}]},WorktreeCoverageV1:{enum:["complete","partial"],type:"string"},WorktreeId:SB,WorktreeInventoryEntryV1:{additionalProperties:!1,properties:{clean:{$ref:"#/$defs/WorktreeObservationV1",description:"Whether Git status contains no tracked or untracked changes."},evidence_digest:{$ref:"#/$defs/ManifestDigest"},head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},holder:{$ref:"#/$defs/WorktreeObservationV1"},kind:{anyOf:[{$ref:"#/$defs/WorktreeKindV1"},{type:"null"}]},locked:{$ref:"#/$defs/WorktreeObservationV1"},observed_at:{$ref:"#/$defs/UtcMicros"},operation:{anyOf:[{$ref:"#/$defs/GitOperationStateV1"},{type:"null"}]},presence:{$ref:"#/$defs/WorktreePresenceV1"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},target:{$ref:"#/$defs/NativeWorktreeTargetV1"},unique_data:{$ref:"#/$defs/WorktreeObservationV1"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["target","presence","clean","locked","holder","unique_data","observed_at","evidence_digest"],type:"object"},WorktreeInventoryEpoch:SK,WorktreeInventorySnapshotId:SJ,WorktreeKindV1:{description:"Native Git worktree kind visible to an authorized caller.",enum:["main","linked","bare"],type:"string"},WorktreeObservationV1:{enum:["yes","no","unknown"],type:"string"},WorktreePresenceV1:{description:"Presence is intentionally not a bool: stale, unavailable and foreign are\npolicy-safe states with different reconciliation consequences.",enum:["present","stale","unavailable","foreign"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One typed result for every native-integration surface operation.",oneOf:[{additionalProperties:!1,description:"Frozen selection summary plus the exact sealed proof preflight accepts.",properties:{outcome:{const:"stack_snapshot",type:"string"},sealed_snapshot:{$ref:"#/$defs/NativeIntegrationSealedStackSnapshotV1"},selection:{$ref:"#/$defs/NativeIntegrationSnapshotProjectionV1"}},required:["outcome","selection","sealed_snapshot"],type:"object"},{additionalProperties:!1,description:"Bounded projection of one immutable preview.\n\nCandidate trees, conflict bodies, and ordered commit objects stay behind the\npreview digest: the surface reports identity, classification, and expiry so\na caller can approve exactly this preview and nothing else.",properties:{analysis:{anyOf:[{$ref:"#/$defs/NativeIntegrationAnalysisReportV1"},{type:"null"}]},created_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/NativeIntegrationPreviewDispositionV1"},expires_at:{$ref:"#/$defs/UtcMicros"},ordered_commit_count:{format:"uint32",minimum:0,type:"integer"},outcome:{const:"preview",type:"string"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},selection:{$ref:"#/$defs/NativeIntegrationSnapshotProjectionV1"}},required:["outcome","preview_id","preview_digest","selection","disposition","ordered_commit_count","created_at","expires_at"],type:"object"},{additionalProperties:!1,description:"Bounded projection of one issued one-use approval.\n\nThe approval digest is the caller's proof-of-issuance handle for apply;\nthe preview binding and expiry are audit metadata. No preview body,\ncandidate tree, or commit content crosses this boundary.",properties:{approval_digest:{$ref:"#/$defs/ManifestDigest"},approval_id:{$ref:"#/$defs/NativeIntegrationApprovalId"},capability:{$ref:"#/$defs/CapabilityId"},expires_at:{$ref:"#/$defs/UtcMicros"},issued_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"approval",type:"string"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},principal:{$ref:"#/$defs/ActorId"},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId",description:"Daemon-minted identity consumed verbatim by apply, status, and cancel."}},required:["outcome","transaction_id","approval_id","preview_id","preview_digest","principal","capability","issued_at","expires_at","approval_digest"],type:"object"},{additionalProperties:!1,description:"Bounded projection of one durable terminal receipt.\n\nThe receipt digest and final ref/tree identity are audit metadata; no patch,\nworktree body, or source content crosses this boundary.",properties:{completed_at:{$ref:"#/$defs/UtcMicros"},final_ref_tip:{type:"string"},final_tree:{type:"string"},outcome:{const:"receipt",type:"string"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},status:{$ref:"#/$defs/NativeIntegrationStatusProjectionV1"},terminal_outcome:{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"}},required:["outcome","status","terminal_outcome","final_ref_tip","final_tree","completed_at","receipt_digest"],type:"object"},{additionalProperties:!1,description:"Bounded projection of one durable transaction status.",properties:{cancellation_requested:{type:"boolean"},destination_ref:{$ref:"#/$defs/RefId"},outcome:{const:"status",type:"string"},phase:{$ref:"#/$defs/NativeIntegrationPhaseV1"},phase_revision:{format:"uint64",minimum:0,type:"integer"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},repository_id:{$ref:"#/$defs/RepositoryId"},terminal_outcome:{anyOf:[{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"},{type:"null"}]},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["outcome","transaction_id","preview_id","preview_digest","repository_id","destination_ref","phase","phase_revision","cancellation_requested","updated_at"],type:"object"},{description:"Cancellation disposition. After the native commit point the committed\nreceipt is returned instead of a cancellation claim.",oneOf:[{enum:["cancellation_requested","commit_point_passed"],type:"string"},{properties:{already_terminal:{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"}},required:["already_terminal"],type:"object"}],properties:{outcome:{const:"cancellation",type:"string"}},required:["outcome"],type:"object"},{$ref:"#/$defs/NativeWorktreeSurfaceResultV1",properties:{outcome:{const:"worktree",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},reason:{$ref:"#/$defs/NativeIntegrationSurfaceUnavailableV1"}},required:["outcome","reason"],type:"object"}],title:"NativeIntegrationSurfaceResultV1"},{$defs:{ManifestDigest:_l,NativeIntegrationPreviewId:_I},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact approval-issuance request (the owner-decided sixth operation).\n\nThe caller names one unexpired preview by exact identity *and* digest;\napproving an identity without its content digest is unrepresentable. The\ndaemon mints the one-use approval bound to the requesting principal, the\napply capability, the current grant lineage, and a bounded expiry, none\nof which the caller can choose.",properties:{preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"}},required:["preview_id","preview_digest"],title:"NativeIntegrationApproveSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_ast_grep_rewrite`.",properties:{dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},path:{type:"string"},pattern:{type:"string"},rewrite:{type:"string"},verify:{default:!1,type:"boolean"}},required:["path","pattern","rewrite"],title:"AstGrepRewriteSurfaceRequestV1",type:"object"},{$defs:{ActorId:fb,AstGrepResult:{description:"Result of an ast-grep rewrite operation.",properties:{diff:{description:"Bounded preview of the would-be change. Populated only on a successful\ndry run; `None` for real edits and for failures.",type:["string","null"]},dry_run:{description:"True when this was a dry run: the rewrite was resolved but nothing was\nwritten.",type:"boolean"},file_path:{type:"string"},message:{type:"string"},pattern:{type:"string"},rewrite:{type:"string"},success:{type:"boolean"}},required:["success","file_path","pattern","rewrite","message"],type:"object"},AuthorityReceipt:{additionalProperties:!1,description:"Proof that this request crossed the current authorization boundary.",properties:{authorized_scope_digest:{$ref:"#/$defs/ManifestDigest"},disclosure:{$ref:"#/$defs/DisclosureClass"},grant_digest:{$ref:"#/$defs/ManifestDigest"},grant_id:{type:"string"},grant_revision:{format:"uint64",minimum:0,type:"integer"},policy:{$ref:"#/$defs/PolicyDecisionRef"},revalidated_at:{$ref:"#/$defs/UtcMicros"}},required:["grant_id","grant_revision","grant_digest","authorized_scope_digest","disclosure","policy","revalidated_at"],type:"object"},CancellationObservation:hn,CancellationStage:ha,ComponentVersion:hC,Deadline:yv,DisclosureClass:{description:"Disclosure ceiling carried by an immutable grant and revalidated at sinks.",enum:["metadata","evidence","sensitive"],type:"string"},EditResult:{description:"Result of a single string replacement edit.",properties:{diff:{description:"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.",type:["string","null"]},dry_run:{description:"True when this was a dry run: validation, spans, and the resulting\ncontent were all computed, but nothing was written to disk.",type:"boolean"},file_path:{type:"string"},matched_str:{type:"string"},message:{type:"string"},new_str:{type:"string"},replaced_span:{description:"The exact source text that was replaced. For `replace_symbol` this is\nthe item's full span, including any leading doc-comment / attribute\nblock, so callers can recover its docs/attrs if the replacement\ndropped them; for `str_replace` it is the matched `old_str` text.\n`None` only on a failed edit, where nothing was resolved to replace.",type:["string","null"]},success:{type:"boolean"}},required:["success","file_path","matched_str","new_str","message"],type:"object"},EffectClass:yR,EffectReceipt:yq,EffectResult:{additionalProperties:!1,description:"Result of an admitted effect. `EffectUnknown` remains a receipt state and\ncannot be remapped into a pre-admission problem.",properties:{authority:{$ref:"#/$defs/AuthorityReceipt"},effect_class:{$ref:"#/$defs/EffectClass"},effect_id:{type:"string"},execution:{$ref:"#/$defs/OperationReceipt"},expected_state:{$ref:"#/$defs/ManifestDigest"},idempotency_key:{type:"string"},payload:{anyOf:[{$ref:"#/$defs/SourceEditDurableEffectPayloadV1"},{type:"null"}]},receipt:{$ref:"#/$defs/EffectReceipt"},reconciliation:{$ref:"#/$defs/ReconciliationState"}},required:["effect_id","effect_class","idempotency_key","authority","expected_state","execution","reconciliation","receipt"],type:"object"},EffectTermination:yI,InsertResult:{description:"Result of an insert-at operation.",properties:{anchor_line:{format:"uint32",minimum:0,type:"integer"},before:{type:"boolean"},content:{type:"string"},diff:{description:"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.",type:["string","null"]},dry_run:{description:"True when this was a dry run: the insertion point was resolved and the\nresulting content computed, but nothing was written to disk.",type:"boolean"},file_path:{type:"string"},message:{type:"string"},success:{type:"boolean"}},required:["success","file_path","anchor_line","content","before","message"],type:"object"},ManifestDigest:_l,MoveHint:{description:"One evidence-based, actionable finding produced by the `move_symbol` impact\nengine. Each hint points at a concrete file/line and carries a suggestion\nthe caller (or a follow-up refactor) can act on. Hints are derived from graph\nedges (callers/callees) and parse-level facts (identifiers, `use` lines,\nmodule declarations), never speculative noise.",properties:{detail:{description:"Human-readable description of what the move breaks or affects.",type:"string"},file:{description:"File the finding concerns (the caller's file, the destination, or the\nsource), project-relative.",type:"string"},kind:{description:"Taxonomy tag: `caller_reference`, `dependency_broken`, `import_needed`,\n`visibility_required`, `collision`, `module_missing`, `cycle_risk`,\n`orphaned_import`, or `cfg_context`.",type:"string"},line:{description:"1-based line the finding concerns, when a specific site is known.",format:"uint32",minimum:0,type:["integer","null"]},suggestion:{description:"The exact change to make (e.g. a `use` line to add, a path to rewrite, a\nvisibility to escalate). `None` when no single mechanical fix applies.",type:["string","null"]}},required:["kind","file","detail"],type:"object"},MoveResult:{description:"Result of a `move_symbol` operation: the moved span, a dry-run diff of the\nsource + destination files, and the centerpiece, the impact report of\neverything the move breaks or that needs attention.",properties:{applied_imports:{description:"`use` lines auto-inserted at the destination because the moved body's\ndependency on them was unambiguous. Reported so the caller sees exactly\nwhat the move added.",items:{type:"string"},type:"array"},dest_file:{type:"string"},diff:{description:"Combined preview diff of the source (removal) and destination (insertion)\nfiles. Populated on a successful dry run; `None` for real moves.",type:["string","null"]},dry_run:{description:"True when this was a dry run: spans, the destination shape, and the\nimpact report were all computed, but nothing was written to disk.",type:"boolean"},impact:{description:"The impact report: every actionable finding. Empty on a truly clean\nmove.",items:{$ref:"#/$defs/MoveHint"},type:"array"},message:{type:"string"},moved_span:{description:"The exact source span that was moved, including its leading\ndoc-comment / attribute block. `None` on failure.",type:["string","null"]},source_file:{type:"string"},success:{type:"boolean"},symbol:{description:"The resolved symbol that was (or would be) moved, `name (kind)`.",type:"string"}},required:["success","symbol","source_file","dest_file","message"],type:"object"},MultiEditResult:{description:"Result of a multi-string replacement edit.",properties:{applied_count:{format:"uint",minimum:0,type:"integer"},diff:{description:"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.",type:["string","null"]},dry_run:{description:"True when this was a dry run: replacements were validated and the\nresulting content computed, but nothing was written to disk.",type:"boolean"},file_path:{type:"string"},message:{type:"string"},success:{type:"boolean"}},required:["success","file_path","applied_count","message"],type:"object"},OperationBudgetUsage:_D,OperationReceipt:_F,OperationTermination:_L,PolicyDecisionRef:{additionalProperties:!1,description:"A policy decision pinned into a receipt or provider identity.",properties:{decision_id:{type:"string"},digest:{$ref:"#/$defs/ManifestDigest"},evaluator_revision:{$ref:"#/$defs/ComponentVersion"},revision:{format:"uint64",minimum:0,type:"integer"}},required:["decision_id","revision","digest","evaluator_revision"],type:"object"},ProjectId:_4,ReconciliationState:{description:"Reconciliation state retained after an admitted effect.",enum:["pending","reconciled","failed"],type:"string"},RefId:vm,RenameDispositionCountsV1:{additionalProperties:!1,properties:{blocked:{format:"uint",minimum:0,type:"integer"},changed:{format:"uint",minimum:0,type:"integer"},skipped:{format:"uint",minimum:0,type:"integer"},unchanged:{format:"uint",minimum:0,type:"integer"}},required:["changed","unchanged","skipped","blocked"],type:"object"},RenameFileEditV1:{additionalProperties:!1,description:"One file a rename changed (or would change), with the exact bound-site count.",properties:{file:{type:"string"},replaced_count:{format:"uint",minimum:0,type:"integer"}},required:["file","replaced_count"],type:"object"},RenameHazardKindV1:{enum:["invalid_identifier","stale_evidence","ambiguous_symbol","namespace_collision","changed_resolution","shadowing","unsupported_syntax","macro_expansion","generated_source","overlapping_site"],type:"string"},RenameHazardV1:{additionalProperties:!1,properties:{blocking:{type:"boolean"},kind:{$ref:"#/$defs/RenameHazardKindV1"},message:{type:"string"},site_id:{type:["string","null"]}},required:["kind","blocking","message"],type:"object"},RenameImpactV1:{additionalProperties:!1,properties:{affected_files:{items:{type:"string"},type:"array"},affected_tests:{items:{type:"string"},type:"array"},callers:{items:{type:"string"},type:"array"},reexports:{items:{type:"string"},type:"array"}},required:["callers","reexports","affected_files","affected_tests"],type:"object"},RenameProtectedValueCategoryV1:{enum:["wire_value","serialized_name","sql_identifier","persisted_name","schema_epoch","hash_domain","protocol_name","contract_snapshot","string_literal","byte_literal"],type:"string"},RenameProtectedValueV1:{additionalProperties:!1,description:"A byte-exact stable value deliberately preserved by the rename.",properties:{category:{$ref:"#/$defs/RenameProtectedValueCategoryV1"},end_byte:{format:"uint64",minimum:0,type:"integer"},exact_bytes:{type:"string"},file:{type:"string"},site_id:{type:"string"},start_byte:{format:"uint64",minimum:0,type:"integer"}},required:["site_id","file","start_byte","end_byte","category","exact_bytes"],type:"object"},RenameResult:{description:"The same typed payload is serialized by application, CLI, and MCP paths.",properties:{diff:{type:["string","null"]},dispositions:{$ref:"#/$defs/RenameDispositionCountsV1"},dry_run:{type:"boolean"},files:{items:{$ref:"#/$defs/RenameFileEditV1"},type:"array"},graph_revision:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Digest of the admitted generation, exact target, same-name symbols,\nand graph edges used to classify bound and protected sites."},hazards:{items:{$ref:"#/$defs/RenameHazardV1"},type:"array"},impact:{$ref:"#/$defs/RenameImpactV1"},message:{type:"string"},new_name:{type:"string"},old_name:{type:"string"},plan_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Digest of the complete typed site/hazard/protected-value manifest."},preview_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Exact candidate-state digest that apply must echo as `expected_state`."},preview_id:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Digest-addressed identity of the bound symbol plus proposed name."},protected_values:{items:{$ref:"#/$defs/RenameProtectedValueV1"},type:"array"},reference_count:{format:"uint",minimum:0,type:"integer"},repository_revision:{default:null,description:"Current Git HEAD when the worktree has one; dirty bytes remain bound by\n`preview_digest` independently of this revision.",type:["string","null"]},sites:{items:{$ref:"#/$defs/RenameSiteV1"},type:"array"},success:{type:"boolean"},symbol:{description:"Qualified name of the renamed symbol at plan time.",type:"string"}},required:["success","symbol","old_name","new_name","reference_count","dispositions","impact","message"],type:"object"},RenameSiteDispositionV1:{enum:["changed","unchanged","skipped","blocked"],type:"string"},RenameSiteKindV1:{enum:["declaration","import","reexport","qualified_path","unqualified_path","annotation","generic_argument","constructor","pattern","trait_declaration","trait_implementation","resolved_call","inherent_method","enum_variant","test","example","documentation","protected_value","unresolved_text"],type:"string"},RenameSiteV1:{additionalProperties:!1,description:"One exact old-name occurrence and the rename planner's disposition.",properties:{disposition:{$ref:"#/$defs/RenameSiteDispositionV1"},end_byte:{format:"uint64",minimum:0,type:"integer"},expected_bytes:{type:"string"},file:{type:"string"},kind:{$ref:"#/$defs/RenameSiteKindV1"},line:{format:"uint32",minimum:0,type:"integer"},reason:{type:"string"},replacement_bytes:{type:"string"},site_id:{type:"string"},source_node_id:{description:"Canonical source `SymbolOccurrenceId` that attested this site.",type:["string","null"]},start_byte:{format:"uint64",minimum:0,type:"integer"}},required:["site_id","kind","disposition","file","line","start_byte","end_byte","expected_bytes","replacement_bytes","reason"],type:"object"},RepositoryId:vb,ResolvedScope:vw,RetrievalAnchorId:vI,SourceEditCancelledResultV1:{description:"Terminal payload when cancellation is observed before an edit commits.",properties:{cancelled:{type:"boolean"},message:{type:"string"},success:{type:"boolean"}},required:["success","cancelled","message"],type:"object"},SourceEditDiagnosticV1:{properties:{code:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},message:{type:"string"}},required:["line","code","message"],type:"object"},SourceEditDurableEffectPayloadV1:{additionalProperties:!1,description:"Body-free source-edit evidence retained inside durable effect receipts.\n\nThis payload intentionally contains no caller-supplied edit text, preview\ndiff, moved span, import, diagnostic, or impact detail. It is also the\nexact replay outcome, so replay never fabricates a live edit body.",properties:{before:{type:["boolean","null"]},cancelled:{type:"boolean"},change_count:{format:"uint",minimum:0,type:["integer","null"]},durable_metadata_only:{type:"boolean"},effect_unknown:{type:"boolean"},failed:{type:"boolean"},files:{items:{type:"string"},type:"array"},finding_count:{format:"uint",minimum:0,type:["integer","null"]},import_count:{format:"uint",minimum:0,type:["integer","null"]},line:{format:"uint32",minimum:0,type:["integer","null"]},message:{type:"string"},observed_state:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Exact candidate-file observation from an inspection attempt."},operation:{$ref:"#/$defs/UseCaseId"},reconciled:{type:"boolean"},success:{type:"boolean"},timed_out:{type:"boolean"}},required:["operation","success","files","failed","cancelled","timed_out","effect_unknown","reconciled","durable_metadata_only","message"],type:"object"},SourceEditEffectUnknownResultV1:{description:"Terminal payload when publication may have occurred and inspection is required.",properties:{effect_unknown:{type:"boolean"},message:{type:"string"},success:{type:"boolean"}},required:["success","effect_unknown","message"],type:"object"},SourceEditFailedResultV1:{description:"Terminal payload when an edit is refused before it can publish an effect.",properties:{failed:{type:"boolean"},message:{type:"string"},success:{type:"boolean"}},required:["success","failed","message"],type:"object"},SourceEditReconciledResultV1:{description:"Terminal payload returned by explicit reconciliation.",properties:{message:{type:"string"},reconciled:{type:"boolean"},success:{type:"boolean"}},required:["success","reconciled","message"],type:"object"},SourceEditTimedOutResultV1:{description:"Terminal payload when an edit deadline expires before commit.",properties:{message:{type:"string"},success:{type:"boolean"},timed_out:{type:"boolean"}},required:["success","timed_out","message"],type:"object"},SourceEditVerificationStateV1:{enum:["clean","errors","unavailable","failed","cancelled"],type:"string"},SourceEditVerificationV1:{properties:{error_count:{format:"uint",minimum:0,type:"integer"},first_errors:{items:{$ref:"#/$defs/SourceEditDiagnosticV1"},type:"array"},message:{type:["string","null"]},state:{$ref:"#/$defs/SourceEditVerificationStateV1"},verdict:{type:"string"},warning_count:{format:"uint",minimum:0,type:"integer"}},required:["state","verdict","error_count","warning_count","first_errors"],type:"object"},UseCaseId:bK,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/SourceEditDurableEffectPayloadV1"},{$ref:"#/$defs/EditResult"},{$ref:"#/$defs/MultiEditResult"},{$ref:"#/$defs/InsertResult"},{$ref:"#/$defs/AstGrepResult"},{$ref:"#/$defs/MoveResult"},{$ref:"#/$defs/RenameResult"},{$ref:"#/$defs/SourceEditFailedResultV1"},{$ref:"#/$defs/SourceEditCancelledResultV1"},{$ref:"#/$defs/SourceEditTimedOutResultV1"},{$ref:"#/$defs/SourceEditEffectUnknownResultV1"},{$ref:"#/$defs/SourceEditReconciledResultV1"}],description:"Canonical result returned directly by every source-edit use case.",properties:{effect:{anyOf:[{$ref:"#/$defs/EffectResult"},{type:"null"}]},expected_state:{$ref:"#/$defs/ManifestDigest"},predicted_state:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},replayed:{type:"boolean"},verification:{anyOf:[{$ref:"#/$defs/SourceEditVerificationV1"},{type:"null"}]}},required:["expected_state","replayed"],title:"SourceEditSurfaceResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{lang:{description:"Optional language key to force (e.g. 'rust', 'typescript', 'python').\nOmit to auto-detect each file from its extension.",type:["string","null"]},max_results:{description:"Maximum number of matches to return (default: 50, max: 200).",format:"uint32",minimum:0,type:["integer","null"]},path_glob:{description:"Optional glob restricting which files are searched, matched against\nproject-relative paths (e.g. 'src/**/*.rs').",type:["string","null"]},pattern:{description:"ast-grep structural pattern (SGPattern syntax), e.g.\n'reserve_stock($$$)' or 'Result<$T, $E>'.",type:"string"}},required:["pattern"],title:"AstGrepSearchSurfaceRequestV1",type:"object"},{$defs:{AstGrepSearchMatchV1:{additionalProperties:!1,properties:{column:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},lang:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},line_text:{type:"string"},match:{type:"string"}},required:["file","line","column","lang","match","line_text"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{files_scanned:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{format:"uint64",minimum:0,type:"integer"},results:{items:{$ref:"#/$defs/AstGrepSearchMatchV1"},type:"array"},truncated:{type:"boolean"}},required:["results","match_count","files_scanned","truncated"],title:"AstGrepSearchResultV1",type:"object"},{$defs:{AutomationRunArtifactKind:{enum:["traces","feedback","generated_evals","validation_gate","optimizer_diagnosis","codex_handoff"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kind:{$ref:"#/$defs/AutomationRunArtifactKind",description:"Artifact kind to read."},run_id:{description:"Automation run id to inspect.",type:"string"}},required:["run_id","kind"],title:"AutomationRunArtifactViewSurfaceRequestV1",type:"object"},{$defs:{AutomationReadStatusV1:fH,AutomationRunArtifact:fB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{artifact:{$ref:"#/$defs/AutomationRunArtifact"},payload:{description:"The hash-verified artifact document, as the run wrote it."},run_id:{type:"string"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","run_id","artifact","payload"],title:"AutomationRunArtifactViewResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum run records to return (default: 50, max: 200).",format:"uint32",maximum:200,minimum:1,type:["integer","null"]}},title:"AutomationRunListSurfaceRequestV1",type:"object"},{$defs:{AgentTaskKind:fS,AutomationReadStatusV1:fH,AutomationRunListEntryV1:{additionalProperties:!1,description:"One run as the list shows it: the ledger record's identity, outcome and\nartifact kinds, without the artifact payloads or operation bodies.",properties:{accepted_count:{format:"uint",minimum:0,type:"integer"},artifact_kinds:{items:{type:"string"},type:"array"},backend:{type:"string"},completed_at:{type:"string"},error:{type:["string","null"]},model:{type:["string","null"]},rejected_count:{format:"uint",minimum:0,type:"integer"},reviewed_count:{format:"uint",minimum:0,type:"integer"},run_id:{type:"string"},skipped_count:{format:"uint",minimum:0,type:"integer"},started_at:{type:"string"},status:{$ref:"#/$defs/AutomationRunStatus"},task:{$ref:"#/$defs/AgentTaskKind"},task_key:{type:"string"},trigger:{$ref:"#/$defs/AutomationTrigger"}},required:["run_id","task","task_key","trigger","backend","status","reviewed_count","accepted_count","rejected_count","skipped_count","started_at","completed_at","artifact_kinds"],type:"object"},AutomationRunPageCompletenessV1:{description:"Whether a run page read every ledger row it examined.",oneOf:[{const:"known",description:"Every examined row decoded.",type:"string"},{const:"partial",description:"The page skipped malformed rows or more runs exist past it.",type:"string"}]},AutomationRunScopeV1:fK,AutomationRunStatus:fJ,AutomationTrigger:fY},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{completeness:{$ref:"#/$defs/AutomationRunPageCompletenessV1"},count:{format:"uint",minimum:0,type:"integer"},has_more:{type:"boolean"},limit:{format:"uint32",minimum:0,type:"integer"},malformed_row_count:{format:"uint",minimum:0,type:"integer"},runs:{items:{$ref:"#/$defs/AutomationRunListEntryV1"},type:"array"},scope:{$ref:"#/$defs/AutomationRunScopeV1"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","scope","runs","count","limit","has_more","malformed_row_count","completeness"],title:"AutomationRunListResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run_id:{description:"Exact automation run id to inspect.",minLength:1,type:"string"}},required:["run_id"],title:"AutomationRunViewSurfaceRequestV1",type:"object"},{$defs:{AgentTaskFailureClass:{oneOf:[{enum:["retryable","permanent","timeout","unavailable","denied","disconnected","malformed_output"],type:"string"},{const:"input_too_large",description:"The backend refused the request because it exceeds its input or\ncontext-window limit.",type:"string"}]},AgentTaskKind:fS,AgentTaskRetryAttempt:{properties:{attempt:{format:"uint32",minimum:0,type:"integer"},backoff_millis:{format:"uint64",minimum:0,type:"integer"},failure_classification:{anyOf:[{$ref:"#/$defs/AgentTaskFailureClass"},{type:"null"}]},succeeded:{type:"boolean"}},required:["attempt","succeeded","backoff_millis"],type:"object"},AutomationReadStatusV1:fH,AutomationRunArtifact:fB,AutomationRunLedgerRecord:{properties:{accepted_count:{format:"uint",minimum:0,type:"integer"},applied_ops:!0,artifacts:{items:{$ref:"#/$defs/AutomationRunArtifact"},type:"array"},backend:{type:"string"},backend_attempt_count:{default:0,format:"uint",minimum:0,type:"integer"},backend_attempts:{items:{$ref:"#/$defs/AgentTaskRetryAttempt"},type:"array"},backend_identity:{description:"The durable backend/configuration identity this run executed under.\n\nA settled deterministic failure stays suppressed only while this\nmatches the identity now configured, so the scheduler can re-admit the\ntask the moment the backend or configuration changes. Records written\nbefore this field existed carry `None` and never suppress: an\nunidentified failure cannot be shown to have failed under the current\nidentity.",type:["string","null"]},completed_at:{type:"string"},completed_at_micros:{format:"int64",type:["integer","null"]},error:{type:["string","null"]},error_classification:{anyOf:[{$ref:"#/$defs/AgentTaskFailureClass"},{type:"null"}]},error_retryable:{type:["boolean","null"]},evidence_hash:{type:["string","null"]},fallback_status:{type:["string","null"]},host_mode:{type:["string","null"]},input_hash:{type:["string","null"]},model:{type:["string","null"]},output_hash:{type:["string","null"]},prompt_version:{type:["string","null"]},proposed_ops:!0,rejected_count:{format:"uint",minimum:0,type:"integer"},rejected_ops:!0,report_ref:!0,response_schema:!0,reviewed_count:{default:0,format:"uint",minimum:0,type:"integer"},run_id:{type:"string"},schema_version:{format:"uint32",minimum:0,type:"integer"},session_evidence_budget_stage:{anyOf:[{$ref:"#/$defs/SessionRetrievalBudgetStageV1"},{type:"null"}],description:"Exhausted retrieval boundary of a `session_evidence_budget_exhausted`\nskip; present exactly on those skips."},skipped_count:{default:0,format:"uint",minimum:0,type:"integer"},started_at:{type:"string"},status:{$ref:"#/$defs/AutomationRunStatus"},strict_json:{type:["boolean","null"]},task:{$ref:"#/$defs/AgentTaskKind"},task_key:{type:"string"},trigger:{$ref:"#/$defs/AutomationTrigger"},validation_report:!0},required:["schema_version","run_id","trigger","task","task_key","backend","status","accepted_count","rejected_count","started_at","completed_at"],type:"object"},AutomationRunScopeV1:fK,AutomationRunStatus:fJ,AutomationTrigger:fY,SessionRetrievalBudgetStageV1:bo},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run:{$ref:"#/$defs/AutomationRunLedgerRecord"},scope:{$ref:"#/$defs/AutomationRunScopeV1"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","scope","run"],title:"AutomationRunViewResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{base:{description:"Base local branch name (e.g. 'main').",type:"string"},cursor:{description:"Authenticated continuation cursor returned by the preceding exact\nbranch-diff page.",type:["string","null"]},file:{description:"Optional file path filter, only show diffs for symbols in this file.",type:["string","null"]},head:{description:"Head local branch name (e.g. 'feature/foo'). Defaults to the current\nbranch.",type:["string","null"]},kind:{description:"Optional kind filter, only show diffs for this symbol kind (e.g.\n'function', 'struct').",type:["string","null"]},limit:{description:"Maximum combined added, removed, and changed results (default: 100,\nat most 256).",format:"uint32",minimum:0,type:["integer","null"]}},required:["base"],title:"BranchDiffSurfaceRequestV1",type:"object"},{$defs:{BranchDiffCompleteV1:{additionalProperties:!1,properties:{base:{type:"string"},base_generation:{type:"string"},base_revision:{type:"string"},base_tree:{type:"string"},changes:{items:{$ref:"#/$defs/BranchSymbolChangeV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},head:{type:"string"},head_generation:{type:"string"},head_revision:{type:"string"},head_tree:{type:"string"},status:{$ref:"#/$defs/GitReadCompleteV1"},summary:{$ref:"#/$defs/BranchDiffSummaryV1"},total_changes:{format:"uint",minimum:0,type:"integer"}},required:["status","base","head","base_revision","base_tree","head_revision","head_tree","base_generation","head_generation","total_changes","summary","changes"],type:"object"},BranchDiffPartialV1:{additionalProperties:!1,properties:{base:{type:"string"},base_generation:{type:"string"},base_revision:{type:"string"},base_tree:{type:"string"},changes:{items:{$ref:"#/$defs/BranchSymbolChangeV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},head:{type:"string"},head_generation:{type:"string"},head_revision:{type:"string"},head_tree:{type:"string"},next_cursor:{type:"string"},reason:{$ref:"#/$defs/GitResultLimitV1"},status:{$ref:"#/$defs/GitReadPartialV1"},summary:{$ref:"#/$defs/BranchDiffSummaryV1"},total_changes:{format:"uint",minimum:0,type:"integer"}},required:["status","reason","base","head","base_revision","base_tree","head_revision","head_tree","base_generation","head_generation","total_changes","next_cursor","summary","changes"],type:"object"},BranchDiffReferenceUnavailableV1:{additionalProperties:!1,description:"Either branch of `base..head` does not resolve to a local commit.",properties:{base_or_head:{description:"The requested range, `base..head`.",type:"string"},reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","base_or_head","reason","retryable"],type:"object"},BranchDiffSummaryV1:{additionalProperties:!1,properties:{added:{format:"uint",minimum:0,type:"integer"},changed:{format:"uint",minimum:0,type:"integer"},removed:{format:"uint",minimum:0,type:"integer"}},required:["added","removed","changed"],type:"object"},BranchDiffUnavailableV1:{additionalProperties:!1,description:"No sealed code-index generations compare the two branches' commits.",properties:{base:{type:"string"},base_generation:{type:["string","null"]},base_revision:{type:"string"},head:{type:"string"},head_generation:{type:["string","null"]},head_revision:{type:"string"},reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","base","head","base_revision","head_revision","reason","retryable"],type:"object"},BranchSymbolChangeV1:{oneOf:[{additionalProperties:!1,properties:{change:{const:"added",type:"string"},symbol:{$ref:"#/$defs/BranchSymbolV1"}},required:["change","symbol"],type:"object"},{additionalProperties:!1,properties:{change:{const:"removed",type:"string"},symbol:{$ref:"#/$defs/BranchSymbolV1"}},required:["change","symbol"],type:"object"},{additionalProperties:!1,properties:{base:{$ref:"#/$defs/BranchSymbolV1"},change:{const:"changed",type:"string"},head:{$ref:"#/$defs/BranchSymbolV1"}},required:["change","base","head"],type:"object"}]},BranchSymbolV1:{additionalProperties:!1,description:"A symbol in one branch's sealed generation.",properties:{content_digest:{type:"string"},file:{type:"string"},file_identity:{type:"string"},file_occurrence_id:{type:"string"},kind:{type:"string"},name:{type:"string"},qualified_name:{type:"string"},symbol_identity:{type:"string"},symbol_occurrence_id:{type:"string"}},required:["symbol_identity","symbol_occurrence_id","file_identity","file_occurrence_id","name","qualified_name","kind","file","content_digest"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GitReadCompleteV1:gj,GitReadPartialV1:gC,GitReadUnavailableV1:gT,GitResultLimitV1:gO,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/BranchDiffCompleteV1"},{$ref:"#/$defs/BranchDiffPartialV1"},{$ref:"#/$defs/BranchDiffUnavailableV1"},{$ref:"#/$defs/BranchDiffReferenceUnavailableV1"}],title:"BranchDiffResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{description:"Continuation cursor returned as `next_cursor` by the preceding page\nwith the same `limit`.",type:["string","null"]},limit:{description:"Maximum local refs to return (default: 100, at most 128).",format:"uint32",minimum:0,type:["integer","null"]}},title:"BranchListSurfaceRequestV1",type:"object"},{$defs:{BranchListPageV1:{additionalProperties:!1,properties:{examined:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},limit:{format:"uint",minimum:0,type:"integer"},next_cursor:{type:["string","null"]},reason:{anyOf:[{$ref:"#/$defs/GitReferenceLimitV1"},{type:"null"}]},snapshot_count:{format:"uint",minimum:0,type:"integer"},snapshots:{items:{$ref:"#/$defs/BranchSnapshotEntryV1"},type:"array"},status:{$ref:"#/$defs/GitPageStatusV1"}},required:["status","snapshot_count","examined","limit","snapshots"],type:"object"},BranchReadUnavailableV1:{additionalProperties:!1,description:"A local branch read refused before any snapshot was taken.",properties:{reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","reason","retryable"],type:"object"},BranchSnapshotEntryV1:{additionalProperties:!1,properties:{branch:{type:"string"},source_revision:{type:"string"},source_tree:{type:"string"}},required:["branch","source_revision","source_tree"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GitPageStatusV1:gx,GitReadUnavailableV1:gT,GitReferenceLimitV1:{enum:["reference_limit"],type:"string"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/BranchListPageV1"},{$ref:"#/$defs/BranchReadUnavailableV1"}],title:"BranchListResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{branch:{description:"Exact local branch name to search.",type:"string"},cursor:{description:"Authenticated continuation cursor returned by the preceding exact\nbranch-search page.",type:["string","null"]},limit:{description:"Maximum number of results to return (default: 10, at most 500).",format:"uint32",minimum:0,type:["integer","null"]},query:{description:"Search query string to match against symbol names.",type:"string"}},required:["branch","query"],title:"BranchSearchSurfaceRequestV1",type:"object"},{$defs:{BranchReferenceUnavailableV1:{additionalProperties:!1,description:"The named branch does not resolve to a local commit.",properties:{branch:{type:"string"},reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","branch","reason","retryable"],type:"object"},BranchSearchHitV1:{additionalProperties:!1,properties:{branch:{type:"string"},candidate:{$ref:"#/$defs/RankedCandidate"},code_generation:{type:"string"},kind:{type:["string","null"]},name:{type:["string","null"]},path:{type:["string","null"]},qualified_name:{type:["string","null"]},source_reference:{type:"string"},source_revision:{type:"string"},source_tree:{type:"string"}},required:["candidate","branch","source_reference","source_revision","source_tree","code_generation"],type:"object"},BranchSearchPageV1:{additionalProperties:!1,properties:{branch:{type:"string"},code_generation:{type:"string"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},next_cursor:{type:["string","null"]},reason:{anyOf:[{$ref:"#/$defs/GitResultLimitV1"},{type:"null"}]},results:{items:{$ref:"#/$defs/BranchSearchHitV1"},type:"array"},source_reference:{type:"string"},source_revision:{type:"string"},source_tree:{type:"string"},status:{$ref:"#/$defs/GitPageStatusV1"}},required:["status","branch","source_reference","source_revision","source_tree","code_generation","results"],type:"object"},BranchSearchUnavailableV1:{additionalProperties:!1,description:"No sealed code-index generation answers for the branch's commit.",properties:{branch:{type:"string"},code_generation:{type:["string","null"]},reason:{type:"string"},retryable:{type:"boolean"},source_revision:{type:"string"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","branch","source_revision","reason","retryable"],type:"object"},CalibrationProfileId:hi,CandidateContribution:hs,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComponentRevision:hj,EvidenceRole:yC,ExactClass:yT,FileOccurrenceId:gs,FixedPointScore:gc,FreshnessCompatibilityV1:gl,FusedCandidate:gp,GitPageStatusV1:gx,GitReadUnavailableV1:gT,GitResultLimitV1:gO,LogicalCopyClusterId:_i,LogicalEvidenceId:_o,OccurrenceProvenance:_z,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RankedCandidate:{additionalProperties:!1,description:"A fused candidate with its final deterministic ordinal.",properties:{candidate:{$ref:"#/$defs/FusedCandidate"},final_ordinal:{format:"uint32",minimum:0,type:"integer"}},required:["candidate","final_ordinal"],type:"object"},RankingDecision:vp,RankingDecisionKind:vu,RepositoryId:vb,RetrievalAnchorId:vI,RetrievalSourceRoleV1:vC,RetrieverKind:vO,ScoreDomainId:v2,SessionOrThreadId:v7,SourceFreshness:by,SourceInstanceKey:bg,SourceNamespace:bv,SourceOccurrenceId:bb,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/BranchSearchPageV1"},{$ref:"#/$defs/BranchSearchUnavailableV1"},{$ref:"#/$defs/BranchReferenceUnavailableV1"}],title:"BranchSearchResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{qualified_name:{description:"The exact qualified name to look up.",type:"string"}},required:["qualified_name"],title:"ByQualifiedNameSurfaceRequestV1",type:"object"},{$defs:{PrimitiveSymbolLocationV1:_1},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Every indexed symbol sharing one qualified name (overloads, generics,\nseparate impl blocks).",items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},title:"ByQualifiedNameResultV1",type:"array"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{from_node_id:{type:"string"},maximum_depth:{default:8,format:"uint32",minimum:0,type:"integer"},to_node_id:{type:"string"}},required:["from_node_id","to_node_id"],title:"CallChainPrimitiveRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{edge_kinds:{items:{type:"string"},type:"array"},node_ids:{items:{type:"string"},type:"array"}},required:["node_ids","edge_kinds"],title:"CallChainPrimitiveResult",type:"object"},{$defs:{NativeIntegrationTransactionId:_T},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"}},required:["transaction_id"],title:"NativeIntegrationCancelSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{from_ref:{description:"Starting git ref (commit, branch, tag).",type:"string"},to_ref:{description:"Ending git ref (commit, branch, tag).",type:"string"}},required:["from_ref","to_ref"],title:"ChangelogSurfaceRequestV1",type:"object"},{$defs:{ChangelogCompleteV1:{additionalProperties:!1,properties:{base_generation:{type:"string"},changed_file_count:{format:"uint",minimum:0,type:"integer"},changed_files:{items:{type:"string"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},from_ref:{type:"string"},head_generation:{type:"string"},status:{$ref:"#/$defs/GitReadCompleteV1"},symbol_changes_coverage:{$ref:"#/$defs/SymbolChangesCompleteV1"},symbols_added:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},symbols_modified:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},symbols_removed:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},to_ref:{type:"string"}},required:["status","from_ref","to_ref","changed_file_count","changed_files","base_generation","head_generation","symbols_added","symbols_removed","symbols_modified","symbol_changes_coverage"],type:"object"},ChangelogPartialV1:{additionalProperties:!1,description:"The tree diff without symbol changes: the refs are not both exact local\nbranches with sealed generations.",properties:{changed_file_count:{format:"uint",minimum:0,type:"integer"},changed_files:{items:{type:"string"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},from_ref:{type:"string"},status:{$ref:"#/$defs/GitReadPartialV1"},symbol_changes_coverage:{$ref:"#/$defs/SymbolChangesUnavailableV1"},symbols_added:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},symbols_modified:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},symbols_removed:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},to_ref:{type:"string"}},required:["status","from_ref","to_ref","changed_file_count","changed_files","symbols_added","symbols_removed","symbols_modified","symbol_changes_coverage"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GitComparedSymbolV1:gy,GitReadCompleteV1:gj,GitReadPartialV1:gC,GitReadUnavailableV1:gT,GitToolErrorKindV1:gW,GitToolErrorV1:gM,GitToolFailureV1:gN,GitToolOperationV1:gz,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,SymbolChangesCompleteV1:{additionalProperties:!1,properties:{status:{$ref:"#/$defs/GitReadCompleteV1"}},required:["status"],type:"object"},SymbolChangesUnavailableV1:bV},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/ChangelogCompleteV1"},{$ref:"#/$defs/ChangelogPartialV1"},{$ref:"#/$defs/GitToolFailureV1"}],title:"ChangelogResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of cycles to report, largest first (default: 25, max:\n200). The response always states the total detected and how many were\nomitted.",format:"uint32",minimum:0,type:["integer","null"]},member_limit:{description:"Maximum member files listed per reported cycle (default: 12, max:\n200). Each entry states its true member_count and\nomitted_member_count.",format:"uint32",minimum:0,type:["integer","null"]}},title:"CircularSurfaceRequestV1",type:"object"},{$defs:{CircularCycleV1:{additionalProperties:!1,description:"One reported file cycle: the members that fit the member bound, plus the\ncomponent's true size so the omission is stated rather than hidden.",properties:{member_count:{format:"uint64",minimum:0,type:"integer"},members:{items:{type:"string"},type:"array"},omitted_member_count:{format:"uint64",minimum:0,type:"integer"}},required:["members","member_count","omitted_member_count"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cycle_count:{format:"uint64",minimum:0,type:"integer"},cycles:{items:{$ref:"#/$defs/CircularCycleV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},limit:{format:"uint64",minimum:0,type:"integer"},member_limit:{format:"uint64",minimum:0,type:"integer"},omitted_cycle_count:{format:"uint64",minimum:0,type:"integer"},reported_cycle_count:{format:"uint64",minimum:0,type:"integer"}},required:["cycle_count","reported_cycle_count","omitted_cycle_count","limit","member_limit","cycles"],title:"CircularResultV1",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{maximum_depth:{default:3,format:"uint32",minimum:0,type:"integer"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},node_id:{type:"string"},resolve_trait_dispatch:{default:!0,type:"boolean"},scope:{$ref:"#/$defs/CodeQueryScope",default:{generation:"code-generation:unpinned-latest.v1",path_prefix:null}}},required:["node_id"],title:"CodeCalleesSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,SymbolPrimitiveRecord:bI,SymbolRelationRecord:bx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/SymbolRelationRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{maximum_depth:{default:3,format:"uint32",minimum:0,type:"integer"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},node_id:{type:"string"},scope:{$ref:"#/$defs/SymbolGraphScope",default:{path_prefix:null}}},required:["node_id"],title:"CodeCallersSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeGraphReadFreshnessV1:hg,PrimitiveSupportGap:_Y,SymbolPrimitiveRecord:bI,SymbolRelationRecord:bx,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Bounded semantic result shared by the compatibility surfaces. Rendering,\ntransport envelopes, and MCP content blocks remain outside this contract.",properties:{freshness:{$ref:"#/$defs/CodeGraphReadFreshnessV1"},generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/SymbolRelationRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},related_edge_count:{format:"uint64",minimum:0,type:["integer","null"]},support_gaps:{items:{$ref:"#/$defs/PrimitiveSupportGap"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]},truncated:{type:"boolean"}},required:["generation","freshness","items","truncated","support_gaps"],title:"SymbolGraphPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},node_id:{type:"string"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["node_id","scope","meta"],title:"CodeNavigationSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,SymbolPrimitiveRecord:bI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeQueryScope:hV,ExactTechnicalTermKindV1:yO,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kind:{anyOf:[{$ref:"#/$defs/ExactTechnicalTermKindV1"},{type:"null"}]},literal:{type:"string"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["literal","scope","meta"],title:"CodeExactOccurrenceSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeOccurrenceRecord:hP,CodeSearchChunkId:hR,ExactOccurrenceRecord:{additionalProperties:!1,properties:{matched_kind:{$ref:"#/$defs/ExactTechnicalTermKindV1"},matched_literal:{type:"string"},occurrence:{$ref:"#/$defs/CodeOccurrenceRecord"}},required:["occurrence","matched_kind","matched_literal"],type:"object"},ExactTechnicalTermKindV1:yO,FileOccurrenceId:gs,SourceSpan:b$,SymbolOccurrenceId:bq},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/ExactOccurrenceRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeFacetDimension:hh,CodeGenerationId:hy,CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{dimension:{$ref:"#/$defs/CodeFacetDimension"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["dimension","scope","meta"],title:"CodeFacetSurfaceRequest",type:"object"},{$defs:{CodeFacetDimension:hh,CodeFacetRecord:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},dimension:{$ref:"#/$defs/CodeFacetDimension"},value:{type:"string"}},required:["dimension","value","count"],type:"object"},CodeGenerationId:hy},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/CodeFacetRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ImplementationSelector:{oneOf:[{properties:{name:{type:"string"},selector:{const:"trait",type:"string"}},required:["selector","name"],type:"object"},{properties:{name:{type:"string"},selector:{const:"method",type:"string"}},required:["selector","name"],type:"object"}]},ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},scope:{$ref:"#/$defs/SymbolGraphScope",default:{path_prefix:null}},selector:{$ref:"#/$defs/ImplementationSelector"}},required:["selector"],title:"CodeImplementationsSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeGraphReadFreshnessV1:hg,ImplementationRecord:{additionalProperties:!1,description:"One implementation match with its exact source: the implementing\nimpl/class block (methods included) for a trait selector, or the function\nbody for a method selector.",properties:{body:{type:"string"},dispatch_from:{description:"Trait or interface node a trait-selector match was reached through.",type:["string","null"]},edge_kind:{type:"string"},symbol:{$ref:"#/$defs/SymbolPrimitiveRecord"}},required:["symbol","edge_kind","body"],type:"object"},PrimitiveSupportGap:_Y,SymbolPrimitiveRecord:bI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Bounded semantic result shared by the compatibility surfaces. Rendering,\ntransport envelopes, and MCP content blocks remain outside this contract.",properties:{freshness:{$ref:"#/$defs/CodeGraphReadFreshnessV1"},generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/ImplementationRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},related_edge_count:{format:"uint64",minimum:0,type:["integer","null"]},support_gaps:{items:{$ref:"#/$defs/PrimitiveSupportGap"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]},truncated:{type:"boolean"}},required:["generation","freshness","items","truncated","support_gaps"],title:"SymbolGraphPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeLexicalField:{description:"Typed code fields accepted by the generation-owned lexical authority.",enum:["symbol_name","qualified_name","path","signature","documentation","body_text","preamble_text","exact_term","subtoken"],type:"string"},CodeLexicalFieldFilter:{additionalProperties:!1,properties:{field:{$ref:"#/$defs/CodeLexicalField"},include:{type:"boolean"}},required:["field","include"],type:"object"},CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Serializable adapter DTO for the request-local phrase query view.\n\nThe callable application request deliberately keeps its sanitized query\nnon-serializable. The owning runtime supplies the exact sanitizer\nrevisions when converting this transport DTO.",properties:{field_filters:{default:[],items:{$ref:"#/$defs/CodeLexicalFieldFilter"},type:"array"},fuzzy_budget:{default:0,format:"uint32",minimum:0,type:"integer"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},phrases:{items:{type:"string"},type:"array"},query:{type:"string"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["query","phrases","scope","meta"],title:"CodePhraseSearchSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeOccurrenceRecord:hP,CodeSearchChunkId:hR,FileOccurrenceId:gs,LexicalOccurrenceRecord:{additionalProperties:!1,properties:{matched_phrases:{items:{type:"string"},type:"array"},matched_terms:{items:{type:"string"},type:"array"},occurrence:{$ref:"#/$defs/CodeOccurrenceRecord"},score_micros:{format:"uint64",minimum:0,type:"integer"}},required:["occurrence","score_micros","matched_phrases","matched_terms"],type:"object"},SourceSpan:b$,SymbolOccurrenceId:bq},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/LexicalOccurrenceRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{is_async:{type:["boolean","null"]},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},params:{default:[],items:{type:"string"},type:"array"},returns:{type:["string","null"]},scope:{$ref:"#/$defs/SymbolGraphScope",default:{path_prefix:null}}},title:"CodeSignatureSearchSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeGraphReadFreshnessV1:hg,PrimitiveSupportGap:_Y,SymbolPrimitiveRecord:bI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Bounded semantic result shared by the compatibility surfaces. Rendering,\ntransport envelopes, and MCP content blocks remain outside this contract.",properties:{freshness:{$ref:"#/$defs/CodeGraphReadFreshnessV1"},generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},related_edge_count:{format:"uint64",minimum:0,type:["integer","null"]},support_gaps:{items:{$ref:"#/$defs/PrimitiveSupportGap"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]},truncated:{type:"boolean"}},required:["generation","freshness","items","truncated","support_gaps"],title:"SymbolGraphPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{lazy_index_ignored_dependencies:{type:"boolean"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},query:{type:"string"},scope:{$ref:"#/$defs/SymbolGraphScope"}},required:["query","scope","lazy_index_ignored_dependencies","meta"],title:"CodeSymbolSearchSurfaceRequest",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["scope","meta"],title:"CodeTimelineSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeTimelineRecord:{additionalProperties:!1,properties:{file_count:{format:"uint64",minimum:0,type:"integer"},generation:{$ref:"#/$defs/CodeGenerationId"},indexed_at:{$ref:"#/$defs/UtcMicros"},symbol_count:{format:"uint64",minimum:0,type:"integer"}},required:["generation","indexed_at","file_count","symbol_count"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/CodeTimelineRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{maximum_depth:{default:5,format:"uint32",minimum:0,type:"integer"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},node_id:{type:"string"},scope:{$ref:"#/$defs/SymbolGraphScope",default:{path_prefix:null}}},required:["node_id"],title:"CodeTypeHierarchySurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeGraphReadFreshnessV1:hg,PrimitiveSupportGap:_Y,SymbolPrimitiveRecord:bI,TypeHierarchyRecord:{additionalProperties:!1,properties:{depth:{format:"uint32",minimum:0,type:"integer"},edge_kind:{type:"string"},parent_node_id:{type:"string"},symbol:{$ref:"#/$defs/SymbolPrimitiveRecord"}},required:["symbol","parent_node_id","edge_kind","depth"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Bounded semantic result shared by the compatibility surfaces. Rendering,\ntransport envelopes, and MCP content blocks remain outside this contract.",properties:{freshness:{$ref:"#/$defs/CodeGraphReadFreshnessV1"},generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/TypeHierarchyRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},related_edge_count:{format:"uint64",minimum:0,type:["integer","null"]},support_gaps:{items:{$ref:"#/$defs/PrimitiveSupportGap"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]},truncated:{type:"boolean"}},required:["generation","freshness","items","truncated","support_gaps"],title:"SymbolGraphPage",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{staged_only:{description:"If true, compare pinned HEAD with immutable staged index blobs. The\ndefault compares HEAD with captured working-tree bytes, including\nuntracked files: a staged edit undone in the working tree cancels out.",type:["boolean","null"]}},title:"CommitContextSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,CommitCategoryV1:{description:"The commit category the changed file roles suggest.",enum:["feature/fix (source + tests)","feature/fix/refactor","test","chore/docs/config"],type:"string"},CommitContextSummaryV1:{additionalProperties:!1,properties:{changed_files:{items:{$ref:"#/$defs/CommitFileRoleV1"},type:"array"},comparison:{anyOf:[{$ref:"#/$defs/GitContextComparisonV1"},{type:"null"}]},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},recent_commits:{items:{type:"string"},type:"array"},source_coverage:{anyOf:[{$ref:"#/$defs/GitContextSourceCoverageV1"},{type:"null"}]},suggested_category:{anyOf:[{$ref:"#/$defs/CommitCategoryV1"},{type:"null"}],description:"Absent when the worktree has no changes."},summary:{type:"string"},symbols_by_role:{additionalProperties:!1,properties:{config:{items:{$ref:"#/$defs/CommitSymbolEntryV1"},type:"array"},docs:{items:{$ref:"#/$defs/CommitSymbolEntryV1"},type:"array"},source:{items:{$ref:"#/$defs/CommitSymbolEntryV1"},type:"array"},test:{items:{$ref:"#/$defs/CommitSymbolEntryV1"},type:"array"}},type:"object"}},required:["changed_files","symbols_by_role","recent_commits","summary"],type:"object"},CommitFileRoleV1:{additionalProperties:!1,properties:{comparison:{anyOf:[{$ref:"#/$defs/GitContextFileComparisonV1"},{type:"null"}]},file:{type:"string"},role:{$ref:"#/$defs/GitFileRoleV1"},symbols:{format:"uint",minimum:0,type:"integer"}},required:["file","role","symbols"],type:"object"},CommitSymbolEntryV1:{anyOf:[{$ref:"#/$defs/CommitSymbolV1"},{$ref:"#/$defs/ConfigSummaryV1"}]},CommitSymbolV1:{additionalProperties:!1,properties:{change:{anyOf:[{$ref:"#/$defs/GitDeclarationChangeKindV1"},{type:"null"}]},file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},source_side:{anyOf:[{$ref:"#/$defs/GitContextSourceSideV1"},{type:"null"}]}},required:["name","kind","file","line"],type:"object"},ConfigSummaryKindV1:hT,ConfigSummaryV1:hO,GitChangeKindV1:gh,GitContextComparisonV1:gg,GitContextFileComparisonV1:{additionalProperties:!1,properties:{after_blob:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},before_blob:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},change:{$ref:"#/$defs/GitChangeKindV1"},previous_file:{type:["string","null"]}},required:["change"],type:"object"},GitContextSourceConsistencyV1:{oneOf:[{enum:["immutable_blobs"],type:"string"},{const:"per_file_worktree_capture",description:"Each file is checked around its bounded read; this is not an atomic\nsnapshot of the entire working tree.",type:"string"}]},GitContextSourceCoverageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},consistency:{$ref:"#/$defs/GitContextSourceConsistencyV1"},gaps:{items:{$ref:"#/$defs/GitContextSourceGapV1"},type:"array"},git:{$ref:"#/$defs/GitCoverageV1"}},required:["complete","git","gaps","consistency"],type:"object"},GitContextSourceGapV1:{additionalProperties:!1,properties:{file:{type:"string"},reason:{type:"string"}},required:["file","reason"],type:"object"},GitContextSourceSideV1:{enum:["before","after"],type:"string"},GitCoverageV1:gv,GitDeclarationChangeKindV1:{enum:["added","removed","modified","signature_changed","visibility_changed","renamed","ambiguous_overload"],type:"string"},GitDegradationV1:gb,GitFileRoleV1:gS,GitOidV1:gq,GitToolErrorKindV1:gW,GitToolErrorV1:gM,GitToolFailureV1:gN,GitToolOperationV1:gz,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/CommitContextSummaryV1"},{$ref:"#/$defs/GitToolFailureV1"}],title:"CommitContextResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},node_kind:{description:"Filter by node kind (default: every kind).",type:["string","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"ComplexitySurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComplexityAnalysisV1:hx,ComplexityReportEntryV1:{additionalProperties:!1,properties:{branches:{format:"uint32",minimum:0,type:["integer","null"]},complexity_analysis:{$ref:"#/$defs/ComplexityAnalysisV1"},cyclomatic_complexity:{description:"The counters are `None` when `complexity_analysis` reports the bounded\nwalk did not cover the body.",format:"uint32",minimum:0,type:["integer","null"]},fan_in:{format:"uint64",minimum:0,type:"integer"},fan_out:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},lines:{format:"uint32",minimum:0,type:"integer"},loops:{format:"uint32",minimum:0,type:["integer","null"]},max_nesting:{format:"uint32",minimum:0,type:["integer","null"]},name:{type:"string"},score:{format:"uint64",minimum:0,type:"integer"}},required:["id","name","kind","file","line","lines","complexity_analysis","fan_out","fan_in","score"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{formula:{type:"string"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},note:{type:"string"},ranking:{items:{$ref:"#/$defs/ComplexityReportEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["formula","note","result_count","ranking"],title:"ComplexityReportV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exactly one of `path` or `glob` names the files to query.",properties:{glob:{description:"Glob pattern to match multiple config files (e.g. '**/Cargo.toml').\nMutually exclusive with 'path'.",type:["string","null"]},key:{description:"Dot-separated key path (e.g. 'package.version',\n'dependencies.tokio.version').",type:"string"},path:{description:"Project-relative path to a single config file (e.g. 'Cargo.toml').\nMutually exclusive with 'glob'.",type:["string","null"]}},required:["key"],title:"ConfigSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ConfigKeyFoundV1:{additionalProperties:!1,properties:{file:{type:"string"},key:{type:"string"},line:{description:"The first line whose text starts with the key's leaf segment.",format:"uint32",minimum:0,type:["integer","null"]},value:!0},required:["file","key","value"],type:"object"},ConfigKeyMissingV1:{additionalProperties:!1,description:"`value` is always null and `found` always false; both stay on the wire\nso a missing key reads the same as it always has.",properties:{file:{type:"string"},found:{type:"boolean"},key:{type:"string"},value:{type:"null"}},required:["file","key","value","found"],type:"object"},ConfigMatchV1:{anyOf:[{$ref:"#/$defs/ConfigParseErrorV1"},{$ref:"#/$defs/ConfigKeyMissingV1"},{$ref:"#/$defs/ConfigKeyFoundV1"}],description:"One queried config file: the file's parse error, the key's absence, or the\nkey's value and defining line.\n\nThe variants are distinguished by their exact field sets, so each one\ndenies unknown fields and the most specific shapes are tried first."},ConfigParseErrorV1:{additionalProperties:!1,properties:{error:{type:"string"},file:{type:"string"}},required:["file","error"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{description:"Files where the key was found or that failed to parse.",format:"uint",minimum:0,type:"integer"},matches:{items:{$ref:"#/$defs/ConfigMatchV1"},type:"array"}},required:["match_count","matches"],title:"ConfigResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{default:null,description:"The previous page's `next_cursor`, valid only with the same `limit`.",type:["string","null"]},limit:{format:"uint",minimum:0,type:"integer"}},required:["limit"],title:"ConfigurationAuditRequestV1",type:"object"},{$defs:{ActorId:fb,ConfigurationAuditEvent:{additionalProperties:!1,description:"Append-only audit record. `target_commitment` is event-scoped and cannot be\njoined across audit events; a caller must be separately authorized before\nany canonical target is resolved by the store/application layer.",properties:{actor_id:{$ref:"#/$defs/ActorId"},base_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},event_id:{$ref:"#/$defs/ConfigurationAuditEventId"},event_kind:{$ref:"#/$defs/ConfigurationAuditEventKindV1"},idempotency_key:{anyOf:[{$ref:"#/$defs/ConfigurationIdempotencyKey"},{type:"null"}]},occurred_at:{$ref:"#/$defs/UtcMicros"},operation_digest:{$ref:"#/$defs/ManifestDigest"},receipt_id:{anyOf:[{$ref:"#/$defs/ConfigurationReceiptId"},{type:"null"}]},result_revision_id:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},safe_reason_code:{type:["string","null"]},target_commitment:{$ref:"#/$defs/ManifestDigest"}},required:["event_id","event_kind","actor_id","base_revision_id","operation_digest","target_commitment","occurred_at"],type:"object"},ConfigurationAuditEventId:{description:"Strongly typed canonical identity: `ConfigurationAuditEventId`.",type:"string"},ConfigurationAuditEventKindV1:{enum:["dry_run_created","applied","rejected","expired","activation_failed","rollback_dry_run_created","rollback_applied","recovered"],type:"string"},ConfigurationIdempotencyKey:hE,ConfigurationReceiptId:hW,ConfigurationRevisionId:hM,ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",properties:{events:{items:{$ref:"#/$defs/ConfigurationAuditEvent"},type:"array"},next_cursor:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]}},required:["events"],title:"ConfigurationAuditPage",type:"object"},{$defs:{AccessRuleId:fv,ActorId:fb,AnalyzerEnvironmentVariable:fV,AnalyzerExecutableId:fR,AnalyzerExecutableReferenceV1:fq,AnalyzerLanguageId:fI,AnalyzerLanguageSelectionV1:fx,AnalyzerPrivacyClassV1:fj,AnalyzerResourceLimitsV1:fC,AnalyzerRestartPolicyV1:fT,AnalyzerSettingsV1:fO,AnalyzerStructuredValueV1:fE,AuthorityRef:fM,AutomaticWorktreeGcV1:fF,AutomationBackendV1:fL,AutomationHostModeV1:fU,AutomationSettingsV1:fZ,AutomationTaskSetV1:fQ,AutomationTaskSettingsV1:fX,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CodeIndexWorkerSelectionV1:hw,ConfigurationDirectMutationRequestV1:{oneOf:[{properties:{key:{$ref:"#/$defs/SettingKey"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"},operation:{const:"set",type:"string"},value:{$ref:"#/$defs/ConfigurationValueV1"}},required:["operation","layer","key","value"],type:"object"},{properties:{key:{$ref:"#/$defs/SettingKey"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"},operation:{const:"unset",type:"string"}},required:["operation","layer","key"],type:"object"}]},ConfigurationIdempotencyKey:hE,ConfigurationLayerIdV1:hA,ConfigurationRevisionId:hM,ConfigurationValueV1:hz,ContextScoutConfigurationLimitsV1:hB,ContextScoutConfigurationModeV1:hK,ContextScoutConfigurationStateV1:hJ,ContextScoutConfiguredModelPathV1:hZ,ContextScoutIntentKindV1:h6,ContextScoutIntentSettingsV1:h3,ContextScoutSettingsV1:yn,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,DecisionEngineSettingsV1:yb,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,IntentQuestionSettingsV1:gB,IntentWindowSettingsV1:gK,LcmSummarizerExecutableV1:g9,LcmSummarizerExecutablesV1:g5,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,QueryCollectionId:vd,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RuleEffect:vD,ScopeAccessRule:vG,ScopeAccessSubjectV1:vB,ScopeControlOperationV1:vK,ScopeSourceBinding:v1,SensitiveFilesystemLocatorV1:v4,SettingKey:ba,SourceBindingId:bh,SourceKindV1:b_,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkContentLocationClassV1:$u,WorkEffortClassV1:$y,WorkEgressPolicy:$g,WorkExecutableBindingV1:$b,WorkExecutableCapabilityV1:$$,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExpertiseCategoryV1:$V,WorkExpertiseConsentV1:$R,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkOrdinalBandV1:$U,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteCandidateV1:Sg,WorkRouteExecutionProfileV1:Sv,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"},mutations:{items:{$ref:"#/$defs/ConfigurationDirectMutationRequestV1"},type:"array"}},required:["mutations","expected_revision","idempotency_key"],title:"ConfigurationBatchRequestV1",type:"object"},{$defs:{AccessPolicyDigest:f_,ConfigurationReceiptId:hW,ConfigurationRevisionId:hM,ConfigurationSettlementAuthorityV1:{additionalProperties:!1,description:"Original authorization evidence pinned to a durable configuration effect.\nA retry reauthorizes access separately without replacing these fields.",properties:{policy_digest:{$ref:"#/$defs/AccessPolicyDigest"},policy_epoch:{format:"uint64",minimum:0,type:"integer"},revalidated_at:{$ref:"#/$defs/UtcMicros"}},required:["policy_epoch","policy_digest","revalidated_at"],type:"object"},ConfigurationSnapshotId:hN,ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",properties:{base_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},created_at:{$ref:"#/$defs/UtcMicros"},effective_deadline_at:{$ref:"#/$defs/UtcMicros"},operation_digest:{$ref:"#/$defs/ManifestDigest"},receipt_id:{$ref:"#/$defs/ConfigurationReceiptId"},result_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},settlement_authority:{$ref:"#/$defs/ConfigurationSettlementAuthorityV1"},snapshot_id:{$ref:"#/$defs/ConfigurationSnapshotId"}},required:["receipt_id","base_revision_id","result_revision_id","snapshot_id","operation_digest","settlement_authority","created_at","effective_deadline_at"],title:"ConfigurationMutationReceipt",type:"object"},{$defs:{SettingKey:ba},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{key:{$ref:"#/$defs/SettingKey"}},required:["key"],title:"ConfigurationGetRequestV1",type:"object"},{$defs:{AccessRuleId:fv,ActorId:fb,AnalyzerEnvironmentVariable:fV,AnalyzerExecutableId:fR,AnalyzerExecutableReferenceV1:fq,AnalyzerLanguageId:fI,AnalyzerLanguageSelectionV1:fx,AnalyzerPrivacyClassV1:fj,AnalyzerResourceLimitsV1:fC,AnalyzerRestartPolicyV1:fT,AnalyzerSettingsV1:fO,AnalyzerStructuredValueV1:fE,AuthorityRef:fM,AutomaticWorktreeGcV1:fF,AutomationBackendV1:fL,AutomationHostModeV1:fU,AutomationSettingsV1:fZ,AutomationTaskSetV1:fQ,AutomationTaskSettingsV1:fX,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CandidateDispositionV1:{enum:["winning","overridden","rejected","defaulted"],type:"string"},CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CodeIndexWorkerSelectionV1:hw,ConfigurationCandidateV1:{additionalProperties:!1,description:"Resolution provenance is intentionally distinct from behavior. Moving the\nsame winner between layers can change this material without changing the\neffective behavior digest.",properties:{disposition:{$ref:"#/$defs/CandidateDispositionV1"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"},revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},safe_reason:{type:["string","null"]}},required:["layer","revision_id","disposition"],type:"object"},ConfigurationLayerIdV1:hA,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,ConfigurationValueV1:hz,ContextScoutConfigurationLimitsV1:hB,ContextScoutConfigurationModeV1:hK,ContextScoutConfigurationStateV1:hJ,ContextScoutConfiguredModelPathV1:hZ,ContextScoutIntentKindV1:h6,ContextScoutIntentSettingsV1:h3,ContextScoutSettingsV1:yn,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,DecisionEngineSettingsV1:yb,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,IntentQuestionSettingsV1:gB,IntentWindowSettingsV1:gK,LcmSummarizerExecutableV1:g9,LcmSummarizerExecutablesV1:g5,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,QueryCollectionId:vd,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RuleEffect:vD,ScopeAccessRule:vG,ScopeAccessSubjectV1:vB,ScopeControlOperationV1:vK,ScopeSourceBinding:v1,SensitiveFilesystemLocatorV1:v4,SettingKey:ba,SourceBindingId:bh,SourceKindV1:b_,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkContentLocationClassV1:$u,WorkEffortClassV1:$y,WorkEgressPolicy:$g,WorkExecutableBindingV1:$b,WorkExecutableCapabilityV1:$$,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExpertiseCategoryV1:$V,WorkExpertiseConsentV1:$R,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkOrdinalBandV1:$U,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteCandidateV1:Sg,WorkRouteExecutionProfileV1:Sv,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",properties:{candidates:{items:{$ref:"#/$defs/ConfigurationCandidateV1"},type:"array"},effective_behavior_digest:{$ref:"#/$defs/ManifestDigest"},effective_value:{$ref:"#/$defs/ConfigurationValueV1"},key:{$ref:"#/$defs/SettingKey"},resolution_provenance_digest:{$ref:"#/$defs/ManifestDigest"},revision_id:{$ref:"#/$defs/ConfigurationRevisionId",description:"Current configuration revision accepted by mutation `expected_revision` CAS."},snapshot_id:{$ref:"#/$defs/ConfigurationSnapshotId",description:"Content identity of the fully resolved configuration snapshot."}},required:["key","effective_value","revision_id","snapshot_id","effective_behavior_digest","resolution_provenance_digest","candidates"],title:"ResolvedSetting",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Typed input for the configuration list read through the daemon\ninvocation boundary.",title:"ConfigurationListRequestV1",type:"object"},{$defs:{RestartRequirementV1:{enum:["none","analyzer_restart","daemon_restart"],type:"string"},SettingKey:ba,SettingSensitivityV1:{enum:["public","sensitive"],type:"string"},SettingSummary:{properties:{key:{$ref:"#/$defs/SettingKey"},restart_requirement:{$ref:"#/$defs/RestartRequirementV1"},sensitivity:{$ref:"#/$defs/SettingSensitivityV1"}},required:["key","sensitivity","restart_requirement"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",items:{$ref:"#/$defs/SettingSummary"},title:"Array_of_SettingSummary",type:"array"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,title:"ConfigurationObservedStateRequestV1",type:"object"},{$defs:{ActivationDriftV1:{enum:["current","never_activated","pending_restart","activation_failed"],type:"string"},ComponentConfigurationState:{properties:{activation_error_code:{type:["string","null"]},component:{type:"string"},desired_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},drift:{$ref:"#/$defs/ActivationDriftV1"},last_working_revision_id:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},observed_revision_id:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},restart_required:{type:"boolean"}},required:["component","desired_revision_id","restart_required","drift"],type:"object"},ConfigurationRevisionId:hM},$schema:"https://json-schema.org/draft/2020-12/schema",items:{$ref:"#/$defs/ComponentConfigurationState"},title:"Array_of_ComponentConfigurationState",type:"array"},{$defs:{ChangePlanId:hu,ConfigurationIdempotencyKey:hE,ConfigurationRevisionId:hM,ManifestDigest:_l},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_base_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"},operation_digest:{$ref:"#/$defs/ManifestDigest"},plan_id:{$ref:"#/$defs/ChangePlanId"}},required:["plan_id","expected_base_revision_id","operation_digest","idempotency_key"],title:"ConfigurationProtectedApplyRequestV1",type:"object"},{$defs:{AccessRuleId:fv,ActorId:fb,AuthorityRef:fM,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,ConfigurationRevisionId:hM,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProtectedChange:{description:"The protected configuration operation set. Ordinary scalar mutations are\nintentionally absent; they activate directly after validation.",oneOf:[{properties:{kind:{const:"bind_source",type:"string"},value:{$ref:"#/$defs/ScopeSourceBinding"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"rebind_source",type:"string"},value:{$ref:"#/$defs/ScopeSourceBinding"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"unbind_source",type:"string"},value:{properties:{binding_id:{$ref:"#/$defs/SourceBindingId"}},required:["binding_id"],type:"object"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"upsert_access_rule",type:"string"},value:{$ref:"#/$defs/ScopeAccessRule"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"remove_access_rule",type:"string"},value:{properties:{rule_id:{$ref:"#/$defs/AccessRuleId"}},required:["rule_id"],type:"object"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"replace_work_topology_policy",type:"string"},value:{$ref:"#/$defs/WorkTopologyPolicyV1"}},required:["kind","value"],type:"object"}]},ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RuleEffect:vD,ScopeAccessRule:vG,ScopeAccessSubjectV1:vB,ScopeControlOperationV1:vK,ScopeSourceBinding:v1,SensitiveFilesystemLocatorV1:v4,SourceBindingId:bh,SourceKindV1:b_,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{change:{$ref:"#/$defs/ProtectedChange"},expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"}},required:["change","expected_revision"],title:"ConfigurationProtectedPreviewRequestV1",type:"object"},{$defs:{AccessPolicyDigest:f_,ActorId:fb,ChangePlanId:hu,ConfigurationRevisionId:hM,ManifestDigest:_l,RedactedConfigurationChangeV1:{additionalProperties:!1,properties:{after_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},before_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},operation:{$ref:"#/$defs/ScopeControlOperationV1"},setting_key:{$ref:"#/$defs/SettingKey"}},required:["setting_key","operation"],type:"object"},ScopeControlOperationV1:vK,SettingKey:ba,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Immutable dry-run result. It contains no raw locator, secret, target\nidentity, or plaintext configuration value.",properties:{actor_id:{$ref:"#/$defs/ActorId"},authorization_policy_digest:{$ref:"#/$defs/AccessPolicyDigest"},base_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},created_at:{$ref:"#/$defs/UtcMicros"},expires_at:{$ref:"#/$defs/UtcMicros"},membership_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},operation_digest:{$ref:"#/$defs/ManifestDigest"},plan_id:{$ref:"#/$defs/ChangePlanId"},policy_epoch:{format:"uint64",minimum:0,type:"integer"},redacted_changes:{items:{$ref:"#/$defs/RedactedConfigurationChangeV1"},type:"array"},resolved_scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["plan_id","actor_id","base_revision_id","operation_digest","resolved_scope_digest","authorization_policy_digest","policy_epoch","expires_at","created_at","redacted_changes"],title:"ProtectedChangePlan",type:"object"},{$defs:{ConfigurationRevisionId:hM,RollbackModeV1:{enum:["all_or_nothing","partial"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{mode:{$ref:"#/$defs/RollbackModeV1"},target_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"}},required:["target_revision_id","mode"],title:"ConfigurationRollbackPreviewRequestV1",type:"object"},{$defs:{AccessRuleId:fv,ActorId:fb,AnalyzerEnvironmentVariable:fV,AnalyzerExecutableId:fR,AnalyzerExecutableReferenceV1:fq,AnalyzerLanguageId:fI,AnalyzerLanguageSelectionV1:fx,AnalyzerPrivacyClassV1:fj,AnalyzerResourceLimitsV1:fC,AnalyzerRestartPolicyV1:fT,AnalyzerSettingsV1:fO,AnalyzerStructuredValueV1:fE,AuthorityRef:fM,AutomaticWorktreeGcV1:fF,AutomationBackendV1:fL,AutomationHostModeV1:fU,AutomationSettingsV1:fZ,AutomationTaskSetV1:fQ,AutomationTaskSettingsV1:fX,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CodeIndexWorkerSelectionV1:hw,ConfigurationIdempotencyKey:hE,ConfigurationLayerIdV1:hA,ConfigurationRevisionId:hM,ConfigurationValueV1:hz,ContextScoutConfigurationLimitsV1:hB,ContextScoutConfigurationModeV1:hK,ContextScoutConfigurationStateV1:hJ,ContextScoutConfiguredModelPathV1:hZ,ContextScoutIntentKindV1:h6,ContextScoutIntentSettingsV1:h3,ContextScoutSettingsV1:yn,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,DecisionEngineSettingsV1:yb,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,IntentQuestionSettingsV1:gB,IntentWindowSettingsV1:gK,LcmSummarizerExecutableV1:g9,LcmSummarizerExecutablesV1:g5,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,QueryCollectionId:vd,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RuleEffect:vD,ScopeAccessRule:vG,ScopeAccessSubjectV1:vB,ScopeControlOperationV1:vK,ScopeSourceBinding:v1,SensitiveFilesystemLocatorV1:v4,SettingKey:ba,SourceBindingId:bh,SourceKindV1:b_,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkContentLocationClassV1:$u,WorkEffortClassV1:$y,WorkEgressPolicy:$g,WorkExecutableBindingV1:$b,WorkExecutableCapabilityV1:$$,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExpertiseCategoryV1:$V,WorkExpertiseConsentV1:$R,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkOrdinalBandV1:$U,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteCandidateV1:Sg,WorkRouteExecutionProfileV1:Sv,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Typed revision-CAS input for a configuration write through the daemon\ninvocation boundary.",properties:{expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"},key:{$ref:"#/$defs/SettingKey"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"},value:{$ref:"#/$defs/ConfigurationValueV1"}},required:["layer","key","value","expected_revision","idempotency_key"],title:"ConfigurationSetRequestV1",type:"object"},{$defs:{ConfigurationIdempotencyKey:hE,ConfigurationLayerIdV1:hA,ConfigurationRevisionId:hM,ProjectId:_4,QueryCollectionId:vd,SettingKey:ba,UserProfileId:bJ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"},key:{$ref:"#/$defs/SettingKey"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"}},required:["layer","key","expected_revision","idempotency_key"],title:"ConfigurationUnsetRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of literal sites to return (default: 100, max: 1000).",format:"uint32",minimum:0,type:["integer","null"]},struct:{description:"Struct name to search literal sites of (e.g. 'GraphStats', 'Config').",type:"string"}},required:["struct"],title:"ConstructorsSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ConstructorFieldCoverageV1:{description:"Whether a literal site's field lists are complete relative to the\nstruct's graph definition.",enum:["complete","unknown"],type:"string"},ConstructorResolutionReasonV1:{enum:["ambiguous_simple_name","syntax_only_simple_name"],type:"string"},ConstructorResolutionStatusV1:{description:"Syntax alone cannot link same-name types across modules, so every\nresolution is unverified.",enum:["unverified"],type:"string"},ConstructorSiteV1:{additionalProperties:!1,properties:{field_coverage:{$ref:"#/$defs/ConstructorFieldCoverageV1"},fields:{items:{type:"string"},type:"array"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},missing_fields:{items:{type:"string"},type:"array"},update_fields:{items:{type:"string"},type:"array"}},required:["file","line","fields","update_fields","missing_fields","field_coverage"],type:"object"},ConstructorsNotFoundV1:{additionalProperties:!1,properties:{found:{description:"Always `false`: no struct, class, or case class has the name.",type:"boolean"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{format:"uint64",minimum:0,type:"integer"},message:{type:"string"},sites:{items:{$ref:"#/$defs/ConstructorSiteV1"},type:"array"},struct:{type:"string"}},required:["found","struct","message","match_count","sites"],type:"object"},ConstructorsReportV1:{additionalProperties:!1,properties:{candidate_count:{format:"uint64",minimum:0,type:"integer"},expected_fields:{description:"`None` when the name resolves to more than one definition.",items:{type:"string"},type:["array","null"]},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{format:"uint64",minimum:0,type:"integer"},resolution_reason:{$ref:"#/$defs/ConstructorResolutionReasonV1"},resolution_status:{$ref:"#/$defs/ConstructorResolutionStatusV1"},sites:{items:{$ref:"#/$defs/ConstructorSiteV1"},type:"array"},struct:{type:"string"}},required:["struct","candidate_count","resolution_status","resolution_reason","match_count","sites"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/ConstructorsNotFoundV1"},{$ref:"#/$defs/ConstructorsReportV1"}],title:"ConstructorsResultV1"},{$defs:{ContextModeV1:hL},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{budget_tokens:{description:"Cap the ranked sections of the answer at about this many tokens.\nQuotas are fixed shares of the budget. The cut is reported on the result.",format:"uint32",minimum:0,type:["integer","null"]},include_code:{type:["boolean","null"]},include_memory:{type:["boolean","null"]},lexical_anchors:{description:"Exact identifiers or technical terms the answer must be about. Each\nruns as its own lexical route: hits carrying an anchor outrank hits\ncarrying none, exact hits included, every anchor with matches keeps at\nleast its best sites through the lane cap, and `lexical_anchors` in the\nresult reports each anchor's outcome: the sites this result returns\nand, by reason, the admitted sites it could not carry. Bounded and\nvalidated by the retrieval kernel; a\nviolation is a typed request rejection. Identifiers the task names\n(`snake_case`, `camelCase`, `a::b`) are anchored after these.",items:{type:"string"},type:["array","null"]},max_code_blocks:{format:"uint32",minimum:0,type:["integer","null"]},max_nodes:{format:"uint32",minimum:0,type:["integer","null"]},memory_limit:{format:"uint32",minimum:0,type:["integer","null"]},memory_min_trust:{format:"double",type:["number","null"]},mode:{anyOf:[{$ref:"#/$defs/ContextModeV1"},{type:"null"}]},prefer_symbol:{description:"Add a symbol-name lexical route for the identifier-shaped words of the\ntask text.",type:["boolean","null"]},task:{type:"string"}},required:["task"],title:"ContextSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ContextCodeBlockV1:{additionalProperties:!1,properties:{code:{type:"string"},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},node_id:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["node_id","file","start_line","end_line","code"],type:"object"},ContextExtensionPointV1:{additionalProperties:!1,description:"A public trait or interface among the context's selected symbols.",properties:{file:{type:"string"},implementor_count:{format:"uint",minimum:0,type:"integer"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","file","line","implementor_count"],type:"object"},ContextLexicalAnchorV1:hF,ContextModeV1:hL,ContextPlanV1:{additionalProperties:!1,description:"Plan-mode enrichment: where the selected code can be extended and which\ntest files reach it.",properties:{extension_points:{items:{$ref:"#/$defs/ContextExtensionPointV1"},type:"array"},test_files:{description:"Test files calling the selected symbols within two hops; absent when\nno symbol was selected to trace from.",items:{type:"string"},type:["array","null"]}},required:["extension_points"],type:"object"},ContextRelatedOmissionV1:{additionalProperties:!1,description:"Related symbols `context` ranked but did not return.",properties:{omitted:{description:"Ranked related symbols the `max_nodes` cut dropped.",format:"uint",minimum:0,type:"integer"},total:{description:"Distinct related symbols the walk found and ranked.",format:"uint",minimum:0,type:"integer"},total_is_lower_bound:{description:"The neighbor walk stopped at its row limit, so `total` is a lower\nbound.",type:"boolean"}},required:["total","omitted","total_is_lower_bound"],type:"object"},ContextRetrievalPlanV1:{additionalProperties:!1,description:"The retrieval plan `context` executed: which stages ran, what each\nadmitted, and where a budget bounded the answer. Lane-level serving state\nstays in `coverage`.",properties:{code:{$ref:"#/$defs/ContextStageV1",description:"Source bodies for selected symbols, bounded by `max_code_blocks`."},graph:{$ref:"#/$defs/ContextStageV1",description:"Candidates resolved to verified graph symbols."},memory:{$ref:"#/$defs/ContextStageV1",description:"Project memory facts, bounded by `memory_limit`."},related:{$ref:"#/$defs/ContextStageV1",description:"Ranked neighbors of the selected symbols, bounded by `max_nodes`."},search:{$ref:"#/$defs/ContextStageV1",description:"Ranked code-index candidates, bounded by `max_nodes`."}},required:["search","graph","related","code","memory"],type:"object"},ContextRetrievalRouteV1:{description:"Which retrieval route `context` ran.\n\n`name` is the preferred-symbol route. `prose` is the ordinary task\nroute. A caller that omits `prefer_symbol` gets `name` only when the\ntask is one identifier or one `Type.method` / `path::name` token.",enum:["name","prose"],type:"string"},ContextSearchMatchV1:{additionalProperties:!1,properties:{anchor_id:{type:"string"},anchors:{description:"Lexical anchors, the caller's and then the task's identifiers, whose\nroute ranked this match; the anchor receipt counts it as returned.",items:{type:"string"},type:"array"},exact_class:{type:"string"},file:{type:"string"},kind:{type:"string"},name:{type:"string"},qualified_name:{type:"string"},rank:{format:"uint32",minimum:0,type:"integer"},utility_micros:{format:"uint64",minimum:0,type:"integer"}},required:["anchor_id","name","qualified_name","kind","file","exact_class","rank","utility_micros"],type:"object"},ContextStageV1:{description:"What one `context` stage ran with and kept.",oneOf:[{description:"The request did not ask for this stage.",properties:{state:{const:"not_requested",type:"string"}},required:["state"],type:"object"},{description:"A stage this one reads from produced nothing to work on.",properties:{state:{const:"skipped",type:"string"}},required:["state"],type:"object"},{description:"The stage's authority could not answer.",properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"},{description:"The stage admitted `admitted` entries under `budget`. `truncated` is\ntrue when it stopped at that budget, so more entries may exist.",properties:{admitted:{format:"uint32",minimum:0,type:"integer"},budget:{format:"uint32",minimum:0,type:"integer"},state:{const:"ran",type:"string"},truncated:{type:"boolean"}},required:["state","budget","admitted","truncated"],type:"object"}]},FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LexicalAnchorDropReasonV1:_e,LexicalAnchorDropV1:_t,LocatorDigest:_r,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveLaneCompleteV1:_J,PrimitiveLaneStateV1:{enum:["stale","partial","unavailable"],type:"string"},PrimitiveLaneStatusV1:{anyOf:[{$ref:"#/$defs/PrimitiveLaneCompleteV1"},{properties:{generation:{type:["string","null"]},reason:{type:["string","null"]},status:{$ref:"#/$defs/PrimitiveLaneStateV1"}},required:["status"],type:"object"}]},PrimitiveRecallV1:_Q,PrimitiveSearchCoverageV1:{additionalProperties:!1,properties:{exact:{$ref:"#/$defs/PrimitiveLaneStatusV1"},graph:{$ref:"#/$defs/PrimitiveLaneStatusV1"},lexical:{$ref:"#/$defs/PrimitiveLaneStatusV1"},recall:{$ref:"#/$defs/PrimitiveRecallV1"}},required:["exact","lexical","graph","recall"],type:"object"},PrimitiveSearchFreshnessV1:_X,PrimitiveSymbolLocationV1:_1,PrimitiveUnavailableEvidenceV1:_0,PrimitiveUnavailableStatusV1:_2,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,TokenBudgetCutV1:bD,TokenBudgetSectionV1:bF,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{code:{items:{$ref:"#/$defs/ContextCodeBlockV1"},type:"array"},code_generation:{type:["string","null"]},coverage:{$ref:"#/$defs/PrimitiveSearchCoverageV1"},freshness:{$ref:"#/$defs/PrimitiveSearchFreshnessV1",description:"Freshness of the served code generation, derived from the typed lane\ncoverage and the daemon scheduler's worktree state."},lexical_anchors:{description:"Outcome of every caller `lexical_anchors` entry, then of each\nidentifier the task names; empty when there are neither.",items:{$ref:"#/$defs/ContextLexicalAnchorV1"},type:"array"},memory_graph_coverage:{anyOf:[{$ref:"#/$defs/FactSearchGraphCoverageV1"},{type:"null"}]},memory_matches:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},memory_matches_error:{type:["string","null"]},mode:{$ref:"#/$defs/ContextModeV1"},oversized_symbols:{description:"Matched symbols whose declaration is larger than one code block.\nTheir code is withheld rather than served as a partial window.",items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},type:"array"},plan:{anyOf:[{$ref:"#/$defs/ContextPlanV1"},{type:"null"}],description:"Present in plan mode when the verified graph answered."},related_omission:{anyOf:[{$ref:"#/$defs/ContextRelatedOmissionV1"},{type:"null"}],description:"Present when related symbols were left out: by the `max_nodes` cut,\nor because the neighbor walk stopped at its row limit."},related_symbols:{description:"Neighbors of `symbols`, ranked before the `max_nodes` cut: best edge\nkind to a selected symbol (calls, implements, extends, `type_of`,\nreturns, receives, uses, annotates, contains), then total degree\ndescending, then qualified name.",items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},type:"array"},retrieval:{$ref:"#/$defs/ContextRetrievalPlanV1"},route:{$ref:"#/$defs/ContextRetrievalRouteV1"},search_matches:{items:{$ref:"#/$defs/ContextSearchMatchV1"},type:"array"},symbols:{items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},type:"array"},task:{type:"string"},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."},verified_graph_evidence:{anyOf:[{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"},{type:"null"}]}},required:["task","route","mode","freshness","symbols","related_symbols","code","coverage","memory_matches","retrieval"],title:"ContextResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"}},required:["address"],title:"ContextScoutExactAddressRequestV1",type:"object"},{$defs:{ContextScoutLimitsV1:h9,ContextScoutModelOutcomeV1:h8},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{exhausted:{type:"boolean"},last_estimated_cost_microusd:{format:"uint64",minimum:0,type:["integer","null"]},last_input_tokens:{format:"uint64",minimum:0,type:["integer","null"]},last_model_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutModelOutcomeV1"},{type:"null"}]},last_output_tokens:{format:"uint64",minimum:0,type:["integer","null"]},limits:{$ref:"#/$defs/ContextScoutLimitsV1"}},required:["limits","exhausted"],title:"ContextScoutBudgetResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU,ContextScoutWorkV1:yc},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},idempotency_key:{type:"string"},work:{$ref:"#/$defs/ContextScoutWorkV1"}},required:["address","work","idempotency_key"],title:"ContextScoutCancelRequestV1",type:"object"},{$defs:{ContextScoutStoreOutcomeV1:ya},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{outcome:{$ref:"#/$defs/ContextScoutStoreOutcomeV1"}},required:["outcome"],title:"ContextScoutMutationResultV1",type:"object"},{$defs:{ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutRuntimeModeV1:yr,ContextScoutServiceStateV1:yi},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{configured_model:{anyOf:[{$ref:"#/$defs/ContextScoutModelBackendV1"},{type:"null"}]},configured_model_available:{type:"boolean"},deterministic_available:{type:"boolean"},last_model_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutModelOutcomeV1"},{type:"null"}]},mode:{$ref:"#/$defs/ContextScoutRuntimeModeV1"},state:{$ref:"#/$defs/ContextScoutServiceStateV1"}},required:["state","mode","deterministic_available","configured_model_available"],title:"ContextScoutCapabilityResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU,ContextScoutClaimWindowV1:{enum:["idle_window","on_request"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},idempotency_key:{type:"string"},window:{$ref:"#/$defs/ContextScoutClaimWindowV1"}},required:["address","window","idempotency_key"],title:"ContextScoutClaimRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,ContextScoutAddressV1:hU,ContextScoutCategoryV1:hH,ContextScoutClaimHandleV1:hG,ContextScoutDeliveryWindowV1:hY,ContextScoutEvidenceAvailabilityV1:h1,ContextScoutEvidenceProjectionV1:h0,ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutModelReceiptV1:h7,ContextScoutRouteV1:yt,ContextScoutSessionWindowV1:yo,ContextScoutSuggestionProjectionV1:ys,ContextScoutWorkV1:yc,ManifestDigest:_l,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{claim:{$ref:"#/$defs/ContextScoutClaimHandleV1"},outcome:{const:"claimed",type:"string"},suggestion:{$ref:"#/$defs/ContextScoutSuggestionProjectionV1"}},required:["outcome","claim","suggestion"],type:"object"},{properties:{outcome:{const:"empty",type:"string"}},required:["outcome"],type:"object"}],title:"ContextScoutClaimResultV1"},{$defs:{ContextScoutAddressV1:hU,ContextScoutClaimHandleV1:hG,ContextScoutDeliveryOutcomeV1:hQ,ContextScoutWorkV1:yc,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},claim:{$ref:"#/$defs/ContextScoutClaimHandleV1"},delivered_at:{$ref:"#/$defs/UtcMicros"},idempotency_key:{type:"string"},outcome:{$ref:"#/$defs/ContextScoutDeliveryOutcomeV1"}},required:["address","claim","delivered_at","outcome","idempotency_key"],title:"ContextScoutDeliveryRequestV1",type:"object"},{$defs:{ContextScoutDeliveryOutcomeV1:hQ,ContextScoutDeliveryReceiptV1:hX,ContextScoutStoreOutcomeV1:ya,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{outcome:{$ref:"#/$defs/ContextScoutStoreOutcomeV1"},receipt:{$ref:"#/$defs/ContextScoutDeliveryReceiptV1"}},required:["outcome","receipt"],title:"ContextScoutDeliveryResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},limit:{default:8,format:"uint",minimum:0,type:"integer"}},required:["address"],title:"ContextScoutRecentRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,ContextScoutAddressV1:hU,ContextScoutCategoryV1:hH,ContextScoutDeliveryOutcomeV1:hQ,ContextScoutDeliveryReceiptV1:hX,ContextScoutDeliveryWindowV1:hY,ContextScoutEvidenceAvailabilityV1:h1,ContextScoutEvidenceProjectionV1:h0,ContextScoutFeedbackKindV1:h2,ContextScoutFeedbackV1:h4,ContextScoutLimitsV1:h9,ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutModelReceiptV1:h7,ContextScoutRecentDeliveryV1:ye,ContextScoutRecentResultV1:{additionalProperties:!1,properties:{configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},deliveries:{items:{$ref:"#/$defs/ContextScoutRecentDeliveryV1"},type:"array"},observed_at:{$ref:"#/$defs/UtcMicros"},omitted:{format:"uint",minimum:0,type:"integer"},pending:{items:{$ref:"#/$defs/ContextScoutSuggestionProjectionV1"},type:"array"}},required:["configuration_revision","observed_at","pending","deliveries","omitted"],type:"object"},ContextScoutRouteV1:yt,ContextScoutRuntimeModeV1:yr,ContextScoutServiceStateV1:yi,ContextScoutSessionWindowV1:yo,ContextScoutStatusResultV1:{additionalProperties:!1,properties:{active_suggestions:{format:"uint",minimum:0,type:"integer"},configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},last_delivery_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutDeliveryOutcomeV1"},{type:"null"}]},last_feedback:{anyOf:[{$ref:"#/$defs/ContextScoutFeedbackKindV1"},{type:"null"}]},last_model_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutModelOutcomeV1"},{type:"null"}]},last_model_receipt:{anyOf:[{$ref:"#/$defs/ContextScoutModelReceiptV1"},{type:"null"}]},last_route:{anyOf:[{$ref:"#/$defs/ContextScoutRouteV1"},{type:"null"}]},last_suppression:{anyOf:[{$ref:"#/$defs/ContextScoutSuppressionV1"},{type:"null"}]},limits:{$ref:"#/$defs/ContextScoutLimitsV1"},mode:{$ref:"#/$defs/ContextScoutRuntimeModeV1"},model_path:{anyOf:[{$ref:"#/$defs/ContextScoutModelBackendV1"},{type:"null"}]},state:{$ref:"#/$defs/ContextScoutServiceStateV1"}},required:["configuration_revision","state","mode","limits","active_suggestions"],type:"object"},ContextScoutSuggestionProjectionV1:ys,ContextScoutSuppressionV1:yd,ContextScoutWorkV1:yc,ManifestDigest:_l,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{recent:{$ref:"#/$defs/ContextScoutRecentResultV1"},status:{$ref:"#/$defs/ContextScoutStatusResultV1"}},required:["status","recent"],title:"ContextScoutExplanationResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU,ContextScoutDeliveryOutcomeV1:hQ,ContextScoutDeliveryReceiptV1:hX,ContextScoutFeedbackKindV1:h2,ContextScoutFeedbackV1:h4,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},feedback:{$ref:"#/$defs/ContextScoutFeedbackV1"},idempotency_key:{type:"string"},receipt:{$ref:"#/$defs/ContextScoutDeliveryReceiptV1"}},required:["address","receipt","feedback","idempotency_key"],title:"ContextScoutFeedbackRequestV1",type:"object"},{$defs:{ConfigurationIdempotencyKey:hE,ConfigurationRevisionId:hM,ContextScoutAddressV1:hU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"}},required:["address","expected_revision","idempotency_key"],title:"ContextScoutControlRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,ContextScoutAddressV1:hU,ContextScoutCategoryV1:hH,ContextScoutDeliveryOutcomeV1:hQ,ContextScoutDeliveryReceiptV1:hX,ContextScoutDeliveryWindowV1:hY,ContextScoutEvidenceAvailabilityV1:h1,ContextScoutEvidenceProjectionV1:h0,ContextScoutFeedbackKindV1:h2,ContextScoutFeedbackV1:h4,ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutModelReceiptV1:h7,ContextScoutRecentDeliveryV1:ye,ContextScoutRouteV1:yt,ContextScoutSessionWindowV1:yo,ContextScoutSuggestionProjectionV1:ys,ContextScoutWorkV1:yc,ManifestDigest:_l,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},deliveries:{items:{$ref:"#/$defs/ContextScoutRecentDeliveryV1"},type:"array"},observed_at:{$ref:"#/$defs/UtcMicros"},omitted:{format:"uint",minimum:0,type:"integer"},pending:{items:{$ref:"#/$defs/ContextScoutSuggestionProjectionV1"},type:"array"}},required:["configuration_revision","observed_at","pending","deliveries","omitted"],title:"ContextScoutRecentResultV1",type:"object"},{$defs:{ContextScoutDeliveryOutcomeV1:hQ,ContextScoutFeedbackKindV1:h2,ContextScoutLimitsV1:h9,ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutModelReceiptV1:h7,ContextScoutRouteV1:yt,ContextScoutRuntimeModeV1:yr,ContextScoutServiceStateV1:yi,ContextScoutSuppressionV1:yd},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{active_suggestions:{format:"uint",minimum:0,type:"integer"},configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},last_delivery_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutDeliveryOutcomeV1"},{type:"null"}]},last_feedback:{anyOf:[{$ref:"#/$defs/ContextScoutFeedbackKindV1"},{type:"null"}]},last_model_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutModelOutcomeV1"},{type:"null"}]},last_model_receipt:{anyOf:[{$ref:"#/$defs/ContextScoutModelReceiptV1"},{type:"null"}]},last_route:{anyOf:[{$ref:"#/$defs/ContextScoutRouteV1"},{type:"null"}]},last_suppression:{anyOf:[{$ref:"#/$defs/ContextScoutSuppressionV1"},{type:"null"}]},limits:{$ref:"#/$defs/ContextScoutLimitsV1"},mode:{$ref:"#/$defs/ContextScoutRuntimeModeV1"},model_path:{anyOf:[{$ref:"#/$defs/ContextScoutModelBackendV1"},{type:"null"}]},state:{$ref:"#/$defs/ContextScoutServiceStateV1"}},required:["configuration_revision","state","mode","limits","active_suggestions"],title:"ContextScoutStatusResultV1",type:"object"},{$defs:{CouplingDirectionV1:yp},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{direction:{anyOf:[{$ref:"#/$defs/CouplingDirectionV1"},{type:"null"}],description:"fan_in: files depended on by the most others. fan_out: files that\ndepend on the most others (default: fan_in)."},limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"CouplingSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,CouplingDirectionV1:yp,CouplingEntryV1:{additionalProperties:!1,properties:{coupled_files:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"}},required:["file","coupled_files"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{direction:{$ref:"#/$defs/CouplingDirectionV1"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ranking:{items:{$ref:"#/$defs/CouplingEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["direction","result_count","ranking"],title:"CouplingResultV1",type:"object"},{$defs:{DashboardActionV1:{description:"What `tracedecay_dashboard` does.",enum:["start","stop"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{action:{anyOf:[{$ref:"#/$defs/DashboardActionV1"},{type:"null"}],description:'Action to perform (default: "start"). "stop" shuts down a previously\nstarted dashboard if any.'},host:{description:'Loopback host address to bind: 127.0.0.1, localhost, or ::1\n(default: "127.0.0.1"). Wildcard, LAN, public IPs, and other\nhostnames are rejected.',type:["string","null"]},port:{description:"Port to listen on; 0 picks an ephemeral port (default: 7341).",format:"uint16",maximum:65535,minimum:0,type:["integer","null"]}},title:"DashboardSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{host:{type:"string"},port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},status:{const:"started",type:"string"},url:{type:"string"}},required:["status","url","host","port"],type:"object"},{additionalProperties:!1,description:"A dashboard that was already bound when `start` was asked again.",properties:{host:{type:"string"},port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},requested_host:{type:"string"},requested_port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},requested_port_honored:{description:"Whether the bound port is the one asked for (always true for 0).",type:"boolean"},status:{const:"already_running",type:"string"},url:{type:"string"}},required:["status","url","host","port","requested_host","requested_port","requested_port_honored"],type:"object"},{additionalProperties:!1,description:"The bound server is shutting down.",properties:{host:{type:"string"},port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},requested_host:{type:"string"},requested_port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},requested_port_honored:{description:"Whether the bound port is the one asked for (always true for 0).",type:"boolean"},status:{const:"stopping",type:"string"},url:{type:"string"}},required:["status","url","host","port","requested_host","requested_port","requested_port_honored"],type:"object"},{additionalProperties:!1,properties:{previous_url:{type:"string"},status:{const:"stopped",type:"string"}},required:["status","previous_url"],type:"object"},{additionalProperties:!1,properties:{status:{const:"not_running",type:"string"}},required:["status"],type:"object"}],title:"DashboardResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_public:{description:"When true, do NOT exclude pub items. Default false.",type:["boolean","null"]},kinds:{description:'Node kinds to check (default: ["function", "method"]).',items:{type:"string"},type:["array","null"]},limit:{description:"Maximum symbols to return (default: 100, max: 1000).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter reported symbols to files under this directory path (e.g.\n'crates/tracedecay-mcp'). Omit for the entire codebase.",type:["string","null"]}},title:"DeadCodeSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DeadCodeSymbolV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},signature:{type:["string","null"]}},required:["id","name","kind","file","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{dead_code_count:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},symbols:{items:{$ref:"#/$defs/DeadCodeSymbolV1"},type:"array"}},required:["dead_code_count","symbols"],title:"DeadCodeResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of chains to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path.",type:["string","null"]}},title:"DependencyDepthSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DependencyDepthChainV1:{additionalProperties:!1,properties:{chain:{items:{type:"string"},type:"array"},depth:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"}},required:["file","depth","chain"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"`ideal_depth` is `ceil(log2(file_count))`.",properties:{chains:{items:{$ref:"#/$defs/DependencyDepthChainV1"},type:"array"},depth_score:{format:"double",type:"number"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ideal_depth:{format:"uint64",minimum:0,type:"integer"},max_depth:{format:"uint64",minimum:0,type:"integer"}},required:["max_depth","ideal_depth","depth_score","chains"],title:"DependencyDepthResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Addresses indexed symbols by node id or by qualified name; the node id\nwins when both are present.",properties:{node_id:{description:"Look up a single node by its ID instead of qualified_name.",type:["string","null"]},qualified_name:{description:"The exact, case-sensitive qualified name to look up. A bare short name\ndoes not match; resolve it with find_exact_symbol first.",type:["string","null"]}},title:"SymbolSelectorSurfaceRequestV1",type:"object"},{$defs:{DeriveAnnotationV1:{additionalProperties:!1,properties:{evidence_class:{$ref:"#/$defs/DeriveEvidenceClassV1"},name:{type:"string"},unavailable_fields:{items:{type:"string"},type:"array"}},required:["name","evidence_class","unavailable_fields"],type:"object"},DeriveEvidenceClassV1:{description:"How a derive name is known: read from the declaration's attributes, not\nfrom macro expansion.",enum:["syntax_exact"],type:"string"},DerivesSymbolV1:{additionalProperties:!1,properties:{derives:{items:{$ref:"#/$defs/DeriveAnnotationV1"},type:"array"},file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"}},required:["node_id","name","qualified_name","kind","file","line","derives"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Derive annotations of every addressed symbol; empty when no symbol matched.",items:{$ref:"#/$defs/DerivesSymbolV1"},title:"DerivesResultV1",type:"array"},{$defs:{DiagnoseSeverityFilterV1:{description:"Compiler severity the diagnose report keeps.",enum:["error","warning","all"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cargo_output:{description:"Raw stderr text from `cargo check` / `cargo clippy` / `rustc`.",type:"string"},include_callers:{description:"Attach up to 5 callers per diagnostic (default: true).",type:["boolean","null"]},max_diagnostics:{description:"Cap on diagnostics in the response (default: 50, at most 500).",format:"uint32",minimum:0,type:["integer","null"]},severity:{anyOf:[{$ref:"#/$defs/DiagnoseSeverityFilterV1"},{type:"null"}],description:"Filter by severity (default: all)."}},required:["cargo_output"],title:"DiagnoseSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DiagnoseItemV1:{additionalProperties:!1,properties:{callers:{description:"Absent when the request turned caller attachment off.",items:{$ref:"#/$defs/DiagnoseSymbolV1"},type:["array","null"]},code:{type:["string","null"]},column:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},message:{type:"string"},node:{anyOf:[{$ref:"#/$defs/DiagnoseSymbolV1"},{type:"null"}]},severity:{$ref:"#/$defs/DiagnoseSeverityV1"}},required:["severity","message","file","line","column"],type:"object"},DiagnosePublicationV1:{description:"Outcome of publishing the parsed diagnostics into the managed store.",oneOf:[{additionalProperties:!1,properties:{reason:{type:"string"},status:{const:"skipped",type:"string"},unresolved:{items:{type:"string"},type:["array","null"]}},required:["status","reason"],type:"object"},{additionalProperties:!1,properties:{cleared:{format:"uint64",minimum:0,type:"integer"},generation:{type:"string"},inserted:{format:"uint64",minimum:0,type:"integer"},publication_revision:{format:"uint64",minimum:0,type:"integer"},rejected:{items:{type:"string"},type:"array"},status:{const:"published",type:"string"},unresolved:{items:{type:"string"},type:"array"}},required:["status","generation","publication_revision","inserted","cleared","unresolved","rejected"],type:"object"},{additionalProperties:!1,properties:{reason:{type:"string"},status:{const:"failed",type:"string"}},required:["status","reason"],type:"object"}]},DiagnoseSeverityV1:{description:"Severity of one parsed compiler diagnostic.",enum:["error","warning","note","help"],type:"string"},DiagnoseSymbolV1:{additionalProperties:!1,description:"The graph symbol a diagnostic line falls in, or one of its callers.",properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},kind:{type:"string"},line:{description:"One-based display line.",format:"uint32",minimum:0,type:"integer"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["node_id","name","kind","qualified_name","file","line","start_line","end_line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{diagnostics:{items:{$ref:"#/$defs/DiagnoseItemV1"},type:"array"},diagnostics_parsed:{format:"uint64",minimum:0,type:"integer"},diagnostics_returned:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},mapped_to_node:{format:"uint64",minimum:0,type:"integer"},published:{$ref:"#/$defs/DiagnosePublicationV1"},truncated:{type:"boolean"},unmapped:{format:"uint64",minimum:0,type:"integer"}},required:["diagnostics_parsed","diagnostics_returned","mapped_to_node","unmapped","truncated","published","diagnostics"],title:"DiagnoseResultV1",type:"object"},{$defs:{DiagnosticsPrimitiveScope:{oneOf:[{enum:["workspace"],type:"string"},{additionalProperties:!1,properties:{package:{type:"string"}},required:["package"],type:"object"},{additionalProperties:!1,properties:{file:{type:"string"}},required:["file"],type:"object"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{default:null,type:["string","null"]},maximum_diagnostics:{format:"uint32",minimum:0,type:"integer"},scope:{$ref:"#/$defs/DiagnosticsPrimitiveScope"}},required:["scope","maximum_diagnostics"],title:"DiagnosticsPrimitiveRequest",type:"object"},{$defs:{CodeGenerationId:hy,CommitId:hq,ComponentVersion:hC,ContentDigest:hD,DiagnosticEvidenceClassV1:{description:"Evidence class for one diagnostic record. Evidence class is part of\ncanonical diagnostic identity.",oneOf:[{const:"observed_current",description:"Directly observed against the exact clean generation it names.",type:"string"},{const:"producer_reported",description:"Reported by the cataloged producer for the exact clean generation.",type:"string"},{const:"derived_structural",description:"Derived from TraceDecay structural/graph analysis of the generation.",type:"string"},{const:"unknown_unsupported",description:"The evidence class cannot be established; the record is retained for\naudit but must not be treated as current truth.",type:"string"}]},DiagnosticPrimitiveRecord:{additionalProperties:!1,properties:{diagnostic:{$ref:"#/$defs/GenerationDiagnosticV1"},logical_path:{type:"string"}},required:["logical_path","diagnostic"],type:"object"},DiagnosticProducerKindV1:{description:"The cataloged producer kinds that may publish durable diagnostics.\nRuntime, storage, migration,\nconfiguration, session, or daemon-health findings without a truthful\nsource range are Doctor or application findings and never become\n`GenerationDiagnosticV1` records.",enum:["upstream_compiler","language_server","tracedecay_structural","tracedecay_graph_integrity","tracedecay_policy","tracedecay_code_health","generation_consistency","authorized_external_analyzer"],type:"string"},DiagnosticProvenanceV1:{additionalProperties:!1,description:"Producer provenance for one diagnostic. Diagnostic identity includes\nproducer provenance: identical findings from the same logical producer and\nrevision collapse; findings from distinct producers remain distinct.",properties:{analyzer_revision:{$ref:"#/$defs/ComponentVersion"},configuration_revision:{$ref:"#/$defs/ComponentVersion"},producer:{$ref:"#/$defs/ProviderId"},producer_kind:{$ref:"#/$defs/DiagnosticProducerKindV1"},sanitization_receipt:{anyOf:[{$ref:"#/$defs/SanitizationReceiptId"},{type:"null"}]}},required:["producer_kind","producer","analyzer_revision","configuration_revision"],type:"object"},DiagnosticRecordStateV1:{description:"Current-vs-stale typing for a durable diagnostic record. Publication is\nversion-monotone: a newer clean generation clears the prior publication\ndeterministically, and stale findings cannot cross snapshots.\nStale and historical records remain queryable through\napplication APIs but are excluded from active publication.",oneOf:[{description:"Current for exactly the clean generation named by the record.",properties:{kind:{const:"current",type:"string"}},required:["kind"],type:"object"},{description:"A clean generation completed and deterministically removed this\nfinding (resolution, deletion, source-revision drift, or content or\ngeneration change).",properties:{cleared_in_generation:{$ref:"#/$defs/CodeGenerationId"},kind:{const:"cleared",type:"string"}},required:["kind","cleared_in_generation"],type:"object"}]},DiagnosticSeverityV1:y$,FileOccurrenceId:gs,GenerationDiagnosticV1:{additionalProperties:!1,description:"One durable, generation-bound diagnostic record. Its diagnostic payload,\nscope, and producer provenance form observation identity; the display\nmessage remains sanitized product data.",properties:{code:{description:"Stable producer diagnostic code (for example `E0308`).",type:"string"},collected_at:{$ref:"#/$defs/UtcMicros",description:"Time the server first accepted this evidence observation. Compiler\noutput does not carry a trustworthy producer capture time, and an exact\nsemantic replay retains the first accepted value."},content_digest:{$ref:"#/$defs/ContentDigest",description:"Content digest of the attached file inside the generation."},diagnostic_anchor:{$ref:"#/$defs/RetrievalAnchorId",description:"Retrieval anchor addressing this record. The code index's\n`GenerationDiagnosticAttachmentV1::diagnostic_anchor` points here."},evidence_class:{$ref:"#/$defs/DiagnosticEvidenceClassV1"},file_occurrence_id:{$ref:"#/$defs/FileOccurrenceId",description:"Canonical file identity the diagnostic attaches to."},generation_id:{$ref:"#/$defs/CodeGenerationId",description:"The immutable clean code-intelligence generation this record is bound\nto. Findings never cross generations."},message:{description:"Sanitized display message; bounded by [`MAX_DIAGNOSTIC_MESSAGE_BYTES`].",type:"string"},message_digest:{$ref:"#/$defs/ManifestDigest",description:"Integrity digest over the sanitized message."},provenance:{$ref:"#/$defs/DiagnosticProvenanceV1"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},repository:{$ref:"#/$defs/RepositoryId"},severity:{$ref:"#/$defs/DiagnosticSeverityV1"},source_revision:{anyOf:[{$ref:"#/$defs/CommitId"},{type:"null"}]},span:{$ref:"#/$defs/SourceSpan",description:"Range encoding inside the sanitized file (byte range; mutable line\nnumbers are never identity)."},state:{$ref:"#/$defs/DiagnosticRecordStateV1",description:"Current-vs-stale typing; publication is version-monotone."},symbol_occurrence_id:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}],description:"Enclosing symbol occurrence, when exact attachment is possible."},worktree:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["diagnostic_anchor","generation_id","repository","file_occurrence_id","content_digest","span","code","severity","message","message_digest","provenance","evidence_class","collected_at","state"],type:"object"},ManifestDigest:_l,ProviderId:vo,RefId:vm,RepositoryId:vb,RetrievalAnchorId:vI,SanitizationReceiptId:{description:"Strongly typed canonical identity: `SanitizationReceiptId`.",type:"string"},SourceSpan:b$,SymbolOccurrenceId:bq,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{clean_generation:{type:"boolean"},diagnostics:{items:{$ref:"#/$defs/DiagnosticPrimitiveRecord"},type:"array"},findings_cleared:{type:"boolean"},generation_id:{$ref:"#/$defs/CodeGenerationId"},next_cursor:{type:["string","null"]}},required:["generation_id","clean_generation","findings_cleared","diagnostics"],title:"DiagnosticsPrimitiveResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{budget_tokens:{description:"Cap the symbol, test, and co-change sections at about this many tokens.",format:"uint32",minimum:0,type:["integer","null"]},depth:{description:"Maximum impact traversal depth (default: 2, at most 10).",format:"uint32",minimum:0,type:["integer","null"]},files:{description:"Files to inspect prospectively. All indexed declarations in these files\nare candidates; this does not select exact Git-changed declarations.",items:{type:"string"},type:"array"}},required:["files"],title:"DiffContextSurfaceRequestV1",type:"object"},{$defs:{CoChangeUnavailableV1:hf,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GitContextComparisonV1:gg,GitContextSymbolV1:g_,GitOidV1:gq,IncompatibleCallSiteV1:{additionalProperties:!1,description:"A call site whose argument count cannot invoke the new parameter list.",properties:{arguments:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","file","line","arguments"],type:"object"},MissingCoChangePartnerV1:_w,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,SignatureEditStatusV1:{description:"How a modified function's parameter list compares with HEAD.",enum:["contract_change"],type:"string"},SignatureEditV1:{additionalProperties:!1,description:"A Rust free function whose parameter count differs from HEAD.",properties:{file:{type:"string"},incompatible:{items:{$ref:"#/$defs/IncompatibleCallSiteV1"},type:"array"},new_parameters:{format:"uint32",minimum:0,type:["integer","null"]},old_parameters:{format:"uint32",minimum:0,type:["integer","null"]},status:{$ref:"#/$defs/SignatureEditStatusV1"},symbol:{type:"string"}},required:["symbol","file","status","incompatible"],type:"object"},TestGateV1:{additionalProperties:!1,description:"Whether tests reach the symbols in a diff's blast radius.\n\n`pass` and exit 0 when every counted symbol is reached. `fail` and exit 4\nname the ones that are not. `incomplete` and exit 0 mean the caller walk\nstopped before that absence is known.",properties:{exit_code:{format:"uint8",maximum:255,minimum:0,type:"integer"},untested:{items:{type:"string"},type:"array"},verdict:{type:"string"}},required:["verdict","exit_code","untested"],type:"object"},TokenBudgetCutV1:bD,TokenBudgetSectionV1:bF},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{affected_tests:{items:{type:"string"},type:"array"},changed_files:{items:{type:"string"},type:"array"},co_change_unavailable:{anyOf:[{$ref:"#/$defs/CoChangeUnavailableV1"},{type:"null"}],description:"Present when Git history could not be mined for co-change partners."},comparison:{anyOf:[{$ref:"#/$defs/GitContextComparisonV1"},{type:"null"}]},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},impact_complete:{description:"False when the impact walk stopped at its depth or budget with callers\nstill unexplored.",type:"boolean"},impacted_symbols:{items:{$ref:"#/$defs/GitContextSymbolV1"},type:"array"},impacted_symbols_count:{format:"uint",minimum:0,type:"integer"},missing_co_change_partners:{description:"Files that usually change with a changed file, per bounded Git\nhistory, but are absent from this change set.",items:{$ref:"#/$defs/MissingCoChangePartnerV1"},type:"array"},modified_symbols:{items:{$ref:"#/$defs/GitContextSymbolV1"},type:"array"},signature_edits:{description:"Rust free functions whose parameter count changed since HEAD, with the\ncall sites that list cannot accept. Omitted when nothing changed.",items:{$ref:"#/$defs/SignatureEditV1"},type:"array"},test_gate:{$ref:"#/$defs/TestGateV1",description:"Symbols in this diff that no test reaches, and the verdict a CLI exits on."},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."}},required:["changed_files","modified_symbols","impacted_symbols_count","impacted_symbols","impact_complete","affected_tests","missing_co_change_partners","test_gate"],title:"DiffContextResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of files in the per-file breakdown, highest node count\nfirst (default: 100, max: 1000). Ignored when summary is true; the\nresponse states total_file_count and omitted_file_count.",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Directory or file path prefix to filter (e.g.\n'src/main/java/com/example'). Omit for entire codebase.",type:["string","null"]},summary:{description:"If true, aggregate counts across all matching files instead of\nper-file breakdown (default: false).",type:["boolean","null"]}},title:"DistributionSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DistributionFileV1:{additionalProperties:!1,properties:{file:{type:"string"},kinds:{items:{$ref:"#/$defs/DistributionKindCountV1"},type:"array"}},required:["file","kinds"],type:"object"},DistributionKindCountV1:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},kind:{type:"string"}},required:["kind","count"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Flattening the tagged view keeps `path_filter` ahead of `mode` on the\nwire; serde cannot deny unknown fields through a flattened member.",oneOf:[{properties:{distribution:{items:{$ref:"#/$defs/DistributionKindCountV1"},type:"array"},mode:{const:"summary",type:"string"},total_kinds:{format:"uint64",minimum:0,type:"integer"}},required:["mode","total_kinds","distribution"],type:"object"},{properties:{file_count:{format:"uint64",minimum:0,type:"integer"},files:{items:{$ref:"#/$defs/DistributionFileV1"},type:"array"},mode:{const:"per_file",type:"string"},omitted_file_count:{format:"uint64",minimum:0,type:"integer"},total_file_count:{format:"uint64",minimum:0,type:"integer"}},required:["mode","file_count","total_file_count","omitted_file_count","files"],type:"object"}],properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},path_filter:{type:["string","null"]}},title:"DistributionResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 50, at most 500).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Directory or file path prefix to filter (e.g. 'src/main'). Omit for\nentire codebase.",type:["string","null"]}},title:"DocCoverageSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DocCoverageFileV1:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},symbols:{items:{$ref:"#/$defs/DocCoverageSymbolV1"},type:"array"}},required:["file","count","symbols"],type:"object"},DocCoverageSymbolV1:{additionalProperties:!1,properties:{id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},signature:{type:["string","null"]}},required:["id","name","kind","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{complete:{type:"boolean"},file_count:{format:"uint64",minimum:0,type:"integer"},files:{items:{$ref:"#/$defs/DocCoverageFileV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},limit:{format:"uint64",minimum:0,type:"integer"},omitted_count:{format:"uint64",minimum:0,type:"integer"},path_filter:{type:["string","null"]},returned_count:{format:"uint64",minimum:0,type:"integer"},total_undocumented:{format:"uint64",minimum:0,type:"integer"}},required:["total_undocumented","returned_count","omitted_count","complete","limit","file_count","files"],title:"DocCoverageResultV1",type:"object"},{$defs:{DsmShapeV1:yw},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{max_files:{description:"Maximum files in matrix format (default: 30, at most 200).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path.",type:["string","null"]},shape:{anyOf:[{$ref:"#/$defs/DsmShapeV1"},{type:"null"}],description:"DSM data shape: stats, clusters, or matrix (default: stats)."}},title:"DsmSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DsmClusterV1:{additionalProperties:!1,properties:{boundary_edges:{format:"uint64",minimum:0,type:"integer"},directory:{type:"string"},file_count:{format:"uint64",minimum:0,type:"integer"},incoming_edges:{format:"uint64",minimum:0,type:"integer"},internal_edges:{format:"uint64",minimum:0,type:"integer"},outgoing_edges:{format:"uint64",minimum:0,type:"integer"}},required:["directory","file_count","internal_edges","outgoing_edges","incoming_edges","boundary_edges"],type:"object"},DsmMatrixV1:{additionalProperties:!1,properties:{files:{items:{type:"string"},type:"array"},matrix:{items:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},type:"array"},type:"array"},note:{type:"string"}},required:["files","matrix","note"],type:"object"},DsmShapeV1:yw,DsmStatsV1:{additionalProperties:!1,properties:{clusters:{format:"uint64",minimum:0,type:"integer"},density:{format:"double",type:"number"},edges:{format:"uint64",minimum:0,type:"integer"},files:{format:"uint64",minimum:0,type:"integer"},largest_cluster:{format:"uint64",minimum:0,type:"integer"}},required:["files","edges","density","clusters","largest_cluster"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{clusters:{items:{$ref:"#/$defs/DsmClusterV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},matrix:{anyOf:[{$ref:"#/$defs/DsmMatrixV1"},{type:"null"}]},shape:{$ref:"#/$defs/DsmShapeV1"},stats:{$ref:"#/$defs/DsmStatsV1"}},required:["shape","stats","clusters"],title:"DsmResultV1",type:"object"},{$defs:{FactEventId:yz,FactFeedbackActionV1:yD,FactId:yF,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{action:{$ref:"#/$defs/FactFeedbackActionV1"},expected_last_event_id:{anyOf:[{$ref:"#/$defs/FactEventId"},{type:"null"}]},fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},reason:{type:["string","null"]},source_label:{type:["string","null"]}},required:["fact_id","action"],title:"FactFeedbackRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactFeedbackActionV1:yD,FactFeedbackV1:{additionalProperties:!1,properties:{action:{$ref:"#/$defs/FactFeedbackActionV1"},event_id:{$ref:"#/$defs/FactEventId"},fact_id:{$ref:"#/$defs/FactId"},helpful_count:{format:"uint64",minimum:0,type:"integer"},new_trust_millionths:{format:"uint32",minimum:0,type:"integer"},old_trust_millionths:{format:"uint32",minimum:0,type:"integer"},trust_delta_millionths:{format:"int32",type:"integer"},unhelpful_count:{format:"uint64",minimum:0,type:"integer"}},required:["event_id","fact_id","action","old_trust_millionths","new_trust_millionths","trust_delta_millionths","helpful_count","unhelpful_count"],type:"object"},FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},fact:{$ref:"#/$defs/FactProjectionV1"},feedback:{$ref:"#/$defs/FactFeedbackV1"}},required:["fact","feedback","commit"],title:"FactFeedbackResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},content:{type:"string"},entities:{default:[],items:{type:"string"},type:"array"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},metadata:{additionalProperties:!0,type:["object","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},source_label:{type:["string","null"]},tags:{default:[],items:{type:"string"},type:"array"},trust:{format:"double",type:["number","null"]}},required:["content"],title:"FactStoreAddRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactStoreAddCommitV1:{oneOf:[{additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},disposition:{const:"added",type:"string"},fact:{$ref:"#/$defs/FactProjectionV1"}},required:["disposition","fact","commit"],type:"object"},{additionalProperties:!1,properties:{closest_fact_id:{$ref:"#/$defs/FactId"},commit:{$ref:"#/$defs/FactCommitReceiptV1"},disposition:{const:"near_duplicate",type:"string"},fact:{$ref:"#/$defs/FactProjectionV1"},similarity_millionths:{format:"uint32",minimum:0,type:"integer"}},required:["disposition","fact","closest_fact_id","similarity_millionths","commit"],type:"object"},{additionalProperties:!1,properties:{closest_fact_id:{$ref:"#/$defs/FactId"},commit:{$ref:"#/$defs/FactCommitReceiptV1"},disposition:{const:"possible_conflict",type:"string"},fact:{$ref:"#/$defs/FactProjectionV1"},similarity_millionths:{format:"uint32",minimum:0,type:"integer"}},required:["disposition","fact","closest_fact_id","similarity_millionths","commit"],type:"object"}]},FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{outcome:{const:"secret_rejected",type:"string"}},required:["outcome"],type:"object"},{additionalProperties:!1,properties:{closest_fact_id:{$ref:"#/$defs/FactId"},fact:{$ref:"#/$defs/FactProjectionV1"},outcome:{const:"normalized_duplicate",type:"string"}},required:["outcome","fact","closest_fact_id"],type:"object"},{additionalProperties:!1,properties:{outcome:{const:"committed",type:"string"},result:{$ref:"#/$defs/FactStoreAddCommitV1"}},required:["outcome","result"],type:"object"}],title:"FactStoreAddResultV1"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},threshold_millionths:{format:"uint32",minimum:0,type:["integer","null"]}},title:"FactStoreContradictRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactContradictionV1:{additionalProperties:!1,properties:{existing_fact:{$ref:"#/$defs/FactV1"},new_content:{type:"string"},score_millionths:{format:"uint32",minimum:0,type:"integer"},why:{type:["string","null"]}},required:["existing_fact","new_content","score_millionths"],type:"object"},FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{contradictions:{items:{$ref:"#/$defs/FactContradictionV1"},type:"array"},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","contradictions"],title:"FactStoreContradictResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Closed public launcher for the automatic Memory Curator.\n\nRun identity, task selection, operations, proposals, approval, and apply\nauthority are deliberately absent and rejected by `deny_unknown_fields`.",properties:{fact_review_limit:{default:24,format:"uint32",maximum:1e3,minimum:1,type:"integer"},min_confidence_millionths:{default:72e4,format:"uint32",maximum:1e6,minimum:0,type:"integer"}},title:"FactStoreCurateRequestV1",type:"object"},{$defs:{AutomationTaskV1:{description:"Automation capability selected after one registered application admission.",enum:["memory_curator","session_reflector","skill_writer","combined_review","user_job"],type:"string"},FactStoreCurateStateV1:{description:"Lifecycle state a `fact_store_curate` receipt reports.",oneOf:[{const:"started",description:"The run was admitted and continues on the daemon.",type:"string"}]},ManifestDigest:_l,RunId:vF},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Receipt of one admitted automatic curation.\n\nThe curator runs on the daemon after this receipt is returned. Its terminal\nis the automation run ledger record for `run_id`, read with\n`automation_run_view`.",properties:{request_digest:{$ref:"#/$defs/ManifestDigest"},run_id:{$ref:"#/$defs/RunId"},state:{$ref:"#/$defs/FactStoreCurateStateV1"},task:{$ref:"#/$defs/AutomationTaskV1"}},required:["run_id","task","request_digest","state"],title:"FactStoreCurateResultV1",type:"object"},{$defs:{FactId:yF,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["fact_id"],title:"FactStoreGetRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactFeedbackActionV1:yD,FactFeedbackDetailsAvailabilityV1:{enum:["available","redacted","unknown"],type:"string"},FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,TrustHistoryEntryV1:{additionalProperties:!1,properties:{action:{$ref:"#/$defs/FactFeedbackActionV1"},details_availability:{$ref:"#/$defs/FactFeedbackDetailsAvailabilityV1"},event_id:{$ref:"#/$defs/FactEventId"},new_trust_millionths:{format:"uint32",minimum:0,type:"integer"},occurred_at:{$ref:"#/$defs/UtcMicros"},old_trust_millionths:{format:"uint32",minimum:0,type:"integer"},reason:{type:["string","null"]},source_label:{type:["string","null"]}},required:["event_id","occurred_at","action","old_trust_millionths","new_trust_millionths","details_availability"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactProjectionV1"},trust_history:{items:{$ref:"#/$defs/TrustHistoryEntryV1"},type:"array"}},required:["fact","trust_history"],title:"FactStoreGetResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},title:"FactStoreListRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{facts:{items:{$ref:"#/$defs/FactProjectionV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","facts"],title:"FactStoreListResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},entity:{type:"string"},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["entity"],title:"FactStoreProbeRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{graph_coverage:{$ref:"#/$defs/FactSearchGraphCoverageV1"},hits:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","hits","graph_coverage"],title:"FactStoreProbeResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},entities:{items:{type:"string"},minItems:1,type:"array"},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["entities"],title:"FactStoreReasonRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{graph_coverage:{$ref:"#/$defs/FactSearchGraphCoverageV1"},hits:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","hits","graph_coverage"],title:"FactStoreReasonResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},entity:{type:"string"},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["entity"],title:"FactStoreRelatedRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{graph_coverage:{$ref:"#/$defs/FactSearchGraphCoverageV1"},hits:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","hits","graph_coverage"],title:"FactStoreRelatedResultV1",type:"object"},{$defs:{FactEventId:yz,FactId:yF,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_last_event_id:{anyOf:[{$ref:"#/$defs/FactEventId"},{type:"null"}]},fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["fact_id"],title:"FactStoreRemoveRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},fact:{$ref:"#/$defs/FactProjectionV1"},outcome:{const:"removed",type:"string"},remaining_fact_count:{format:"uint64",minimum:0,type:"integer"}},required:["outcome","fact","remaining_fact_count","commit"],type:"object"},{additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactProjectionV1"},outcome:{const:"already_removed",type:"string"},remaining_fact_count:{format:"uint64",minimum:0,type:"integer"}},required:["outcome","fact","remaining_fact_count"],type:"object"}],title:"FactStoreRemoveResultV1"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},query:{type:"string"}},required:["query"],title:"FactStoreSearchRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactRetrievalTelemetryDegradationV1:{enum:["unavailable","saturated"],type:"string"},FactRetrievalTelemetryV1:{description:"Whether an explicit search recorded retrieval telemetry for its hits.\n\nThe telemetry write is recall bookkeeping, not part of the returned\nevidence: when only that lane is unavailable the search still delivers its\nresult and reports the degradation here instead of refusing the read.",oneOf:[{additionalProperties:!1,description:"The result had no hits, so there was nothing to record.",properties:{kind:{const:"not_applicable",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,description:"The selected store is mounted read-only; recording is never attempted.",properties:{kind:{const:"read_only",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{fact_count:{format:"uint",minimum:0,type:"integer"},kind:{const:"recorded",type:"string"}},required:["kind","fact_count"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"degraded",type:"string"},reason:{$ref:"#/$defs/FactRetrievalTelemetryDegradationV1"}},required:["kind","reason"],type:"object"}]},FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Explicit search additionally records retrieval telemetry for its returned\nhits; `retrieval_telemetry` reports whether that recall bookkeeping\nhappened, so a served result can truthfully carry a degraded write lane.",properties:{graph_coverage:{$ref:"#/$defs/FactSearchGraphCoverageV1"},hits:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"},retrieval_telemetry:{$ref:"#/$defs/FactRetrievalTelemetryV1"}},required:["owner","hits","graph_coverage","retrieval_telemetry"],title:"FactStoreSearchResultV1",type:"object"},{$defs:{FactEventId:yz,FactId:yF,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Mark `fact_id` as superseded by `superseded_by`. The old fact leaves the\ndefault retrieval surfaces but stays readable by id through its history;\npayload and trust are never rewritten.",properties:{expected_last_event_id:{anyOf:[{$ref:"#/$defs/FactEventId"},{type:"null"}]},fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},superseded_by:{$ref:"#/$defs/FactId"}},required:["fact_id","superseded_by"],title:"FactStoreSupersedeRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactId:yF,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Outcome of an explicit supersession. `superseded` carries the durable\ncommit receipt of the `Curated { SupersededBy }` lineage event;\n`already_superseded` reports the successor already recorded for the fact.",oneOf:[{additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},fact_id:{$ref:"#/$defs/FactId"},outcome:{const:"superseded",type:"string"},superseded_by:{$ref:"#/$defs/FactId"}},required:["outcome","fact_id","superseded_by","commit"],type:"object"},{additionalProperties:!1,properties:{fact_id:{$ref:"#/$defs/FactId"},outcome:{const:"already_superseded",type:"string"},superseded_by:{$ref:"#/$defs/FactId"}},required:["outcome","fact_id","superseded_by"],type:"object"}],title:"FactStoreSupersedeResultV1"},{$defs:{FactCategoryV1:yA,FactEventId:yz,FactId:yF,FactSourceLabelPatchV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"set",type:"string"},value:{type:"string"}},required:["kind","value"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"clear",type:"string"}},required:["kind"],type:"object"}]},MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},content:{type:["string","null"]},entities:{items:{type:"string"},type:["array","null"]},expected_last_event_id:{anyOf:[{$ref:"#/$defs/FactEventId"},{type:"null"}]},fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},metadata:{additionalProperties:!0,type:["object","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},source_label:{anyOf:[{$ref:"#/$defs/FactSourceLabelPatchV1"},{type:"null"}]},tags:{items:{type:"string"},type:["array","null"]},trust:{format:"double",type:["number","null"]}},required:["fact_id"],title:"FactStoreUpdateRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},fact:{$ref:"#/$defs/FactProjectionV1"},trust_delta_millionths:{format:"int32",type:"integer"}},required:["fact","trust_delta_millionths","commit"],title:"FactStoreUpdateResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Explicit advisory-cycle trigger for one document in the admitted project.",properties:{document_uri:{type:"string"}},required:["document_uri"],title:"FeedbackAdvisoryCycleSurfaceRequestV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,DiagnosticSeverityV1:y$,FeedbackAdvisoryCycleWireV1:{additionalProperties:!1,description:"One canonical cycle result plus whether its durable publication committed.\n\n`published` intentionally remains adjacent to the cycle fields on the\nwire: publication is a property of this exact cycle, not of a page or a\nlater lookup.",properties:{advisory_only:{type:"boolean"},advisory_provider_states:{items:{$ref:"#/$defs/FeedbackAdvisoryProviderStateV1"},type:"array"},affected_tests_state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},baseline_states:{items:{$ref:"#/$defs/FeedbackBaselineStateV1"},type:"array"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},content_identity:{anyOf:[{$ref:"#/$defs/FeedbackContentIdentityV1"},{type:"null"}]},cycle_id:{$ref:"#/$defs/FeedbackCycleId"},durability:{$ref:"#/$defs/FeedbackDurabilityV1"},findings:{items:{$ref:"#/$defs/FeedbackFindingV1"},type:"array"},impact:{anyOf:[{$ref:"#/$defs/FeedbackImpactV1"},{type:"null"}]},impact_state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},omitted_findings:{format:"uint64",minimum:0,type:"integer"},policy_digest:{$ref:"#/$defs/ManifestDigest"},provider_states:{items:{$ref:"#/$defs/ProviderEvaluationStateV1"},type:"array"},published:{type:"boolean"},result_id:{$ref:"#/$defs/FeedbackResultId"},returned_findings:{format:"uint64",minimum:0,type:"integer"},scope:{$ref:"#/$defs/FeedbackScopeV1"},termination:{$ref:"#/$defs/FeedbackCycleTerminationV1"},total_findings:{format:"uint64",minimum:0,type:"integer"}},required:["result_id","cycle_id","scope","durability","policy_digest","configuration_digest","termination","provider_states","baseline_states","findings","total_findings","returned_findings","omitted_findings","advisory_only","published"],type:"object"},FeedbackAdvisoryFindingHandleV1:{additionalProperties:!1,description:"One daemon-minted read-handle pair for a finding in the published cycle.",properties:{expansion_handle:{type:["string","null"]},finding_id:{$ref:"#/$defs/FeedbackFindingId"},get_handle:{type:"string"},retrieval_anchor_id:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]}},required:["finding_id","get_handle"],type:"object"},FeedbackAdvisoryProviderStateV1:yY,FeedbackAdvisoryReadHandlesV1:{additionalProperties:!1,description:"Daemon-minted handles for reads over this exact publication.",properties:{affected_tests_handle:{type:"string"},diagnostics_handle:{type:"string"},impact_handle:{type:"string"},list_handle:{type:"string"}},required:["diagnostics_handle","impact_handle","affected_tests_handle","list_handle"],type:"object"},FeedbackBaselineStateV1:y1,FeedbackContentIdentityV1:y0,FeedbackCycleId:y2,FeedbackCycleTerminationV1:y4,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackDurabilityV1:y5,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingV1:gt,FeedbackImpactStateV1:gr,FeedbackImpactV1:gi,FeedbackResultId:go,FeedbackScopeV1:gn,FeedbackTargetV1:ga,FileOccurrenceId:gs,HostInstanceId:gL,ManifestDigest:_l,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact advisory-cycle payload serialized by the mounted daemon route.",properties:{cycle:{$ref:"#/$defs/FeedbackAdvisoryCycleWireV1"},finding_handles:{items:{$ref:"#/$defs/FeedbackAdvisoryFindingHandleV1"},type:"array"},read_handles:{anyOf:[{$ref:"#/$defs/FeedbackAdvisoryReadHandlesV1"},{type:"null"}]}},required:["cycle","finding_handles"],title:"FeedbackAdvisoryCycleSurfaceResultV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,DiagnosticSeverityV1:y$,FeedbackAdvisoryProviderStateV1:yY,FeedbackBaselineStateV1:y1,FeedbackContentIdentityV1:y0,FeedbackCycleId:y2,FeedbackCycleResultV1:{additionalProperties:!1,description:"One deterministic result for one trigger. The result represents a\nterminal advisory evaluation and contains no next-action execution hook.",properties:{advisory_only:{type:"boolean"},advisory_provider_states:{items:{$ref:"#/$defs/FeedbackAdvisoryProviderStateV1"},type:"array"},affected_tests_state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},baseline_states:{items:{$ref:"#/$defs/FeedbackBaselineStateV1"},type:"array"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},content_identity:{anyOf:[{$ref:"#/$defs/FeedbackContentIdentityV1"},{type:"null"}]},cycle_id:{$ref:"#/$defs/FeedbackCycleId"},durability:{$ref:"#/$defs/FeedbackDurabilityV1"},findings:{items:{$ref:"#/$defs/FeedbackFindingV1"},type:"array"},impact:{anyOf:[{$ref:"#/$defs/FeedbackImpactV1"},{type:"null"}]},impact_state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},omitted_findings:{format:"uint64",minimum:0,type:"integer"},policy_digest:{$ref:"#/$defs/ManifestDigest"},provider_states:{items:{$ref:"#/$defs/ProviderEvaluationStateV1"},type:"array"},result_id:{$ref:"#/$defs/FeedbackResultId"},returned_findings:{format:"uint64",minimum:0,type:"integer"},scope:{$ref:"#/$defs/FeedbackScopeV1"},termination:{$ref:"#/$defs/FeedbackCycleTerminationV1"},total_findings:{format:"uint64",minimum:0,type:"integer"}},required:["result_id","cycle_id","scope","durability","policy_digest","configuration_digest","termination","provider_states","baseline_states","findings","total_findings","returned_findings","omitted_findings","advisory_only"],type:"object"},FeedbackCycleTerminationV1:y4,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackDurabilityV1:y5,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingV1:gt,FeedbackImpactStateV1:gr,FeedbackImpactV1:gi,FeedbackResultId:go,FeedbackScopeV1:gn,FeedbackTargetV1:ga,FileOccurrenceId:gs,HostInstanceId:gL,ManifestDigest:_l,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cycle:{$ref:"#/$defs/FeedbackCycleResultV1"}},required:["cycle"],title:"FeedbackDiagnosticsReadResultV1",type:"object"},{$defs:{AnchorExpandResult:{additionalProperties:!1,properties:{anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"}},required:["anchors"],type:"object"},CommitId:hq,DiagnosticSeverityV1:y$,FeedbackCycleId:y2,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingReadV1:ge,FeedbackFindingV1:gt,FeedbackResultId:go,FeedbackScopeV1:gn,FileOccurrenceId:gs,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expansion:{$ref:"#/$defs/AnchorExpandResult"},finding:{$ref:"#/$defs/FeedbackFindingReadV1"}},required:["finding","expansion"],title:"FeedbackExpandResultV1",type:"object"},{$defs:{CommitId:hq,DiagnosticSeverityV1:y$,FeedbackCycleId:y2,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingReadV1:ge,FeedbackFindingV1:gt,FeedbackResultId:go,FeedbackScopeV1:gn,FileOccurrenceId:gs,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{finding:{$ref:"#/$defs/FeedbackFindingReadV1"}},required:["finding"],title:"FeedbackGetResultV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,FeedbackContentIdentityV1:y0,FeedbackCycleId:y2,FeedbackImpactStateV1:gr,FeedbackImpactV1:gi,FeedbackResultId:go,FeedbackScopeV1:gn,FeedbackTargetV1:ga,FileOccurrenceId:gs,HostInstanceId:gL,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Canonical impact projection returned by `feedback_impact`.\n\nThe daemon-side projection owner (usecases) re-exports this type; it lives\nhere so the catalog contribution can register its schema body as the single\nRust-owned wire authority. Results project from an authorized completed\ncycle, and the canonical response wire remains consumable by typed SDKs.",properties:{content_identity:{anyOf:[{$ref:"#/$defs/FeedbackContentIdentityV1"},{type:"null"}]},cycle_id:{$ref:"#/$defs/FeedbackCycleId"},impact:{anyOf:[{$ref:"#/$defs/FeedbackImpactV1"},{type:"null"}]},result_id:{$ref:"#/$defs/FeedbackResultId"},scope:{$ref:"#/$defs/FeedbackScopeV1"},state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]}},required:["result_id","cycle_id","scope"],title:"CanonicalFeedbackImpactProjectionV1",type:"object"},{$defs:{CommitId:hq,DiagnosticSeverityV1:y$,FeedbackCycleId:y2,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingReadV1:ge,FeedbackFindingV1:gt,FeedbackResultId:go,FeedbackScopeV1:gn,FileOccurrenceId:gs,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{findings:{items:{$ref:"#/$defs/FeedbackFindingReadV1"},type:"array"}},required:["findings"],title:"FeedbackListResultV1",type:"object"},{$defs:{UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"}},required:["observed_at"],title:"FeedbackProximityReadRequestV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,FeedbackProximityAccessKindV1:{enum:["read","write"],type:"string"},FeedbackProximityCloneHandleV1:{additionalProperties:!1,properties:{retrieval_anchor_ids:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},source_generation:{$ref:"#/$defs/CodeGenerationId"},source_symbol:{$ref:"#/$defs/SymbolOccurrenceId"}},required:["source_generation","source_symbol","retrieval_anchor_ids"],type:"object"},FeedbackProximityConflictDifferenceV1:{additionalProperties:!1,properties:{difference_digest:{$ref:"#/$defs/ManifestDigest"},file:{$ref:"#/$defs/FileOccurrenceId"},span:{$ref:"#/$defs/SourceSpan"}},required:["file","span","difference_digest"],type:"object"},FeedbackProximityConflictHandleV1:{additionalProperties:!1,properties:{common_base_revision:{$ref:"#/$defs/CommitId"},differences:{items:{$ref:"#/$defs/FeedbackProximityConflictDifferenceV1"},type:"array"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},left_head_revision:{$ref:"#/$defs/CommitId"},right_head_revision:{$ref:"#/$defs/CommitId"}},required:["common_base_revision","left_head_revision","right_head_revision","evidence_digest","differences"],type:"object"},FeedbackProximityEncounterV1:{additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/ProximityCoverageV1"},encounter_id:{$ref:"#/$defs/ManifestDigest"},expires_at:{$ref:"#/$defs/UtcMicros"},interval:{$ref:"#/$defs/FeedbackProximityIntervalV1"},observed_at:{$ref:"#/$defs/UtcMicros"},participants:{items:{$ref:"#/$defs/FeedbackProximityParticipantV1"},type:"array"},relation:{$ref:"#/$defs/FeedbackProximityRelationV1"},scope:{$ref:"#/$defs/FeedbackScopeV1"}},required:["encounter_id","scope","interval","participants","relation","observed_at","expires_at","coverage"],type:"object"},FeedbackProximityIntervalV1:{additionalProperties:!1,properties:{end:{$ref:"#/$defs/UtcMicros"},start:{$ref:"#/$defs/UtcMicros"}},required:["start","end"],type:"object"},FeedbackProximityOmissionV1:{enum:["active_session_limit","session_activity_limit","recent_observation_limit","edited_path_limit","encounter_limit","missing_participant_observation","missing_participant_worktree","missing_participant_revision","missing_code_address","clone_coverage_partial","conflict_evidence_unavailable","code_index_revision_mismatch"],type:"string"},FeedbackProximityParticipantV1:{additionalProperties:!1,properties:{access:{$ref:"#/$defs/FeedbackProximityAccessKindV1"},activity:{$ref:"#/$defs/FeedbackProximityIntervalV1"},address:{$ref:"#/$defs/ProximityAddressV1"},agent_id:{$ref:"#/$defs/AgentInstanceId"},branch_ref:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},head_revision:{anyOf:[{$ref:"#/$defs/CommitId"},{type:"null"}]},source:{$ref:"#/$defs/ObservationSourceIdentityV1"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]},worktree_root:{type:"string"}},required:["source","agent_id","worktree_root","access","activity","address"],type:"object"},FeedbackProximityReadPageV1:{additionalProperties:!1,properties:{encounters:{items:{$ref:"#/$defs/FeedbackProximityEncounterV1"},type:"array"},expires_at:{$ref:"#/$defs/UtcMicros"},observed_at:{$ref:"#/$defs/UtcMicros"},scope:{$ref:"#/$defs/FeedbackScopeV1"},source_generation:{$ref:"#/$defs/CodeGenerationId"}},required:["scope","source_generation","observed_at","expires_at","encounters"],type:"object"},FeedbackProximityRelationV1:{oneOf:[{additionalProperties:!1,properties:{relation_kind:{const:"code_neighborhood_candidate",type:"string"},warning_class:{$ref:"#/$defs/ProximityWarningClassV1"}},required:["relation_kind","warning_class"],type:"object"},{additionalProperties:!1,properties:{clone_handle:{$ref:"#/$defs/FeedbackProximityCloneHandleV1"},relation_kind:{const:"shared_code_candidate",type:"string"},warning_class:{$ref:"#/$defs/ProximityWarningClassV1"}},required:["relation_kind","warning_class","clone_handle"],type:"object"},{additionalProperties:!1,properties:{relation_kind:{const:"overlapping_edit",type:"string"},warning_class:{$ref:"#/$defs/ProximityWarningClassV1"}},required:["relation_kind","warning_class"],type:"object"},{additionalProperties:!1,properties:{conflict_handle:{$ref:"#/$defs/FeedbackProximityConflictHandleV1"},relation_kind:{const:"confirmed_conflict",type:"string"}},required:["relation_kind","conflict_handle"],type:"object"}]},FeedbackScopeV1:gn,FileOccurrenceId:gs,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProjectId:_4,ProviderId:vo,ProximityAddressV1:{additionalProperties:!1,description:"A privacy-scoped code address. It identifies the coarse changed-code shape\nbut carries no other actor, session, or private-source content.",properties:{file:{$ref:"#/$defs/FileOccurrenceId"},scope:{$ref:"#/$defs/FeedbackScopeV1"},span:{anyOf:[{$ref:"#/$defs/SourceSpan"},{type:"null"}]},symbol:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}]}},required:["scope","file"],type:"object"},ProximityCoverageV1:{enum:["complete","partial","stale","unavailable","denied","private"],type:"string"},ProximityWarningClassV1:{enum:["same_file","overlapping_range","same_symbol","same_package","same_crate","neighborhood","shared_caller","shared_dependency","shared_test"],type:"string"},RefId:vm,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{page:{$ref:"#/$defs/FeedbackProximityReadPageV1"},state:{const:"complete",type:"string"}},required:["state","page"],type:"object"},{additionalProperties:!1,properties:{page:{$ref:"#/$defs/FeedbackProximityReadPageV1"},state:{const:"complete_zero",type:"string"}},required:["state","page"],type:"object"},{additionalProperties:!1,properties:{omissions:{items:{$ref:"#/$defs/FeedbackProximityOmissionV1"},type:"array"},page:{$ref:"#/$defs/FeedbackProximityReadPageV1"},state:{const:"partial",type:"string"}},required:["state","page","omissions"],type:"object"},{additionalProperties:!1,properties:{omissions:{items:{$ref:"#/$defs/FeedbackProximityOmissionV1"},type:"array"},page:{$ref:"#/$defs/FeedbackProximityReadPageV1"},state:{const:"stale",type:"string"}},required:["state","page","omissions"],type:"object"},{additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"denied",type:"string"}},required:["state","observed_at"],type:"object"},{additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"unavailable",type:"string"}},required:["state","observed_at"],type:"object"}],title:"FeedbackProximityReadResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{field:{description:"Field name. Bare name ('last_sync_at') matches across structs;\nqualified form ('GraphStats::last_sync_at') narrows to one struct's\nfield.",type:"string"},limit:{description:"Maximum sites per kind (default: 200, max: 2000).",format:"uint32",minimum:0,type:["integer","null"]},writes_only:{description:"When true, returns only write_sites and omits reads. Default false.",type:["boolean","null"]}},required:["field"],title:"FieldSitesSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,FieldSiteV1:{additionalProperties:!1,properties:{enclosing:{type:["string","null"]},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},snippet:{type:"string"}},required:["file","line","snippet"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"`read_count` and `read_sites` are absent when the request asked for\nwrites only.",properties:{field:{type:"string"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},qualifier:{type:["string","null"]},qualifier_applied:{type:"boolean"},read_count:{format:"uint64",minimum:0,type:["integer","null"]},read_sites:{items:{$ref:"#/$defs/FieldSiteV1"},type:["array","null"]},write_count:{format:"uint64",minimum:0,type:"integer"},write_sites:{items:{$ref:"#/$defs/FieldSiteV1"},type:"array"}},required:["field","qualifier_applied","write_count","write_sites"],title:"FieldSitesResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{file:{type:"string"}},required:["file"],title:"FileDependentsPrimitiveRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{dependent_files:{items:{type:"string"},type:"array"},file:{type:"string"}},required:["file","dependent_files"],title:"FileDependentsPrimitiveResult",type:"object"},{$defs:{FilesLayoutV1:gd},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{layout:{anyOf:[{$ref:"#/$defs/FilesLayoutV1"},{type:"null"}],description:"File listing layout: flat (one per line) or grouped by directory\n(default: grouped)."},path:{description:"Filter to files under this directory path.",type:["string","null"]},pattern:{description:"Filter files matching this glob pattern (e.g. '**/*.rs').",type:["string","null"]}},title:"FilesSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexOmittedSourceV1:hb,CodeIndexOmittedSourcesV1:h$,CodeIndexSourceOmissionReasonV1:hS,CodeIndexStalenessStateV1:hk,FilesLayoutV1:gd,IndexedFileV1:{additionalProperties:!1,properties:{bytes:{format:"uint64",minimum:0,type:"integer"},path:{type:"string"},symbols:{format:"uint64",minimum:0,type:"integer"}},required:["path","symbols","bytes"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:"integer"},files:{items:{$ref:"#/$defs/IndexedFileV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},layout:{$ref:"#/$defs/FilesLayoutV1"},worktree_omitted_sources:{anyOf:[{$ref:"#/$defs/CodeIndexOmittedSourcesV1"},{type:"null"}],description:"Sources the serving snapshot captured for the whole worktree but does\nnot index, unfiltered by `path` or `pattern`."}},required:["count","layout","files"],title:"FilesResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{lazy_index_ignored_dependencies:{description:"Opt in to bounded indexing of ignored dependency entry files when an\nimport hint matches (default: false).",type:["boolean","null"]},limit:{description:"Maximum matches to return (default: 20, max: 200).",format:"uint32",minimum:0,type:["integer","null"]},name:{description:"Exact bare symbol name (no `::`, no glob).",type:"string"}},required:["name"],title:"FindExactSymbolSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,FindExactSymbolMatchV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},qualified_name:{type:"string"},signature:{type:["string","null"]}},required:["id","name","qualified_name","kind","file","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},matches:{items:{$ref:"#/$defs/FindExactSymbolMatchV1"},type:"array"},name:{type:"string"},suggestions:{description:"Nearest indexed bare names when `count` is 0. Empty when the query\nmatched, or when it is not itself a bare identifier.",items:{type:"string"},type:"array"}},required:["name","count","matches"],title:"FindExactSymbolResultV1",type:"object"},{$defs:{GiniMetricV1:gu,GiniScopeV1:gm},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Number of top outliers to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},metric:{anyOf:[{$ref:"#/$defs/GiniMetricV1"},{type:"null"}],description:"Metric to measure inequality for (default: complexity)."},path:{description:"Filter to files under this directory path.",type:["string","null"]},scope:{anyOf:[{$ref:"#/$defs/GiniScopeV1"},{type:"null"}],description:"Aggregate per file or per symbol (default: file)."}},title:"GiniSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GiniMetricV1:gu,GiniOutlierV1:{additionalProperties:!1,properties:{name:{type:"string"},pct_of_max:{format:"double",type:"number"},value:{format:"double",type:"number"}},required:["name","value","pct_of_max"],type:"object"},GiniScopeV1:gm,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},gini:{format:"double",type:"number"},incomplete_complexity_symbols:{description:"Symbols left out because their bounded complexity walk did not cover\nthe body; their counters are lower bounds and measure nothing here.",format:"uint64",minimum:0,type:"integer"},interpretation:{type:"string"},metric:{$ref:"#/$defs/GiniMetricV1"},outliers:{items:{$ref:"#/$defs/GiniOutlierV1"},type:"array"},scope:{$ref:"#/$defs/GiniScopeV1"},total_items:{format:"uint64",minimum:0,type:"integer"}},required:["gini","interpretation","total_items","metric","scope","incomplete_complexity_symbols","outliers"],title:"GiniResultV1",type:"object"},{$defs:{GitIndexPreviewId:gV,ManifestDigest:_l},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Public MCP/CLI request to apply one immutable Git index preview.",properties:{idempotency_key:{type:"string"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/GitIndexPreviewId"}},required:["preview_id","preview_digest","idempotency_key"],title:"GitApplySurfaceRequest",type:"object"},{$defs:{GitIndexPreviewId:gV,GitIndexReceiptId:{description:"Strongly typed canonical identity: `GitIndexReceiptId`.",type:"string"},GitIndexReceiptOutcomeV1:{description:"Terminal outcome a recovery record can prove without re-running a native\nmutation.",enum:["committed","aborted_no_change","needs_inspection"],type:"string"},GitIndexTransactionId:{description:"Strongly typed canonical identity: `GitIndexTransactionId`.",type:"string"},GitIndexTransactionOperationV1:gR,GitOidV1:gq,ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Durable, integrity-protected receipt for one Git index transaction.",properties:{committed_at:{$ref:"#/$defs/UtcMicros"},final_snapshot_captured:{description:"Whether `final_snapshot_digest`, `new_index_tree`, and `new_head` came\nfrom a post-outcome native observation. An unavailable observation is\nvalid only for a terminal outcome that does not claim a commit.",type:"boolean"},final_snapshot_digest:{$ref:"#/$defs/ManifestDigest",description:"Digest of a snapshot that was actually captured after the terminal\nobservation. When `final_snapshot_captured` is false this retains the\nexpected snapshot digest only as a stable schema placeholder; callers\nmust not treat it as an observation."},new_head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},new_index_tree:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},old_head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},old_index_tree:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},old_snapshot_digest:{$ref:"#/$defs/ManifestDigest"},operation:{$ref:"#/$defs/GitIndexTransactionOperationV1"},outcome:{$ref:"#/$defs/GitIndexReceiptOutcomeV1"},preview_id:{$ref:"#/$defs/GitIndexPreviewId"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},receipt_id:{$ref:"#/$defs/GitIndexReceiptId"},selected_hunk_digests:{items:{$ref:"#/$defs/ManifestDigest"},type:"array"},transaction_id:{$ref:"#/$defs/GitIndexTransactionId"}},required:["receipt_id","transaction_id","preview_id","operation","old_snapshot_digest","final_snapshot_digest","final_snapshot_captured","selected_hunk_digests","outcome","committed_at","receipt_digest"],title:"GitIndexTransactionReceiptV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_blame` surface.",properties:{follow_renames:{default:!1,type:"boolean"},max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]},path:{type:"string"}},required:["path"],title:"GitBlameSurfaceRequest",type:"object"},{$defs:{GitBlameAvailabilityV1:{description:"Why blame/line provenance is unavailable for a path.",enum:["available","path_not_tracked","unborn_branch","binary_file"],type:"string"},GitBlameLineV1:{additionalProperties:!1,description:"Line provenance for one final (current) line.",properties:{author:{$ref:"#/$defs/GitCommitIdentityV1"},boundary:{description:"True when the origin commit is a history boundary (e.g. shallow root).",type:"boolean"},commit:{$ref:"#/$defs/GitOidV1"},final_line:{description:"1-based line number in the blamed revision.",format:"uint32",minimum:0,type:"integer"},origin_line:{description:"1-based line number in the origin commit.",format:"uint32",minimum:0,type:"integer"},previous:{anyOf:[{$ref:"#/$defs/GitBlamePreviousV1"},{type:"null"}]}},required:["final_line","origin_line","commit","author","boundary"],type:"object"},GitBlamePreviousV1:{additionalProperties:!1,description:"Rename-following evidence for one blamed line (`previous` record).",properties:{commit:{$ref:"#/$defs/GitOidV1"},path:{type:"string"}},required:["commit","path"],type:"object"},GitBlameV1:{additionalProperties:!1,description:"Typed blame result: per-line provenance plus boundary, rename-following,\nand unavailable states.",properties:{availability:{$ref:"#/$defs/GitBlameAvailabilityV1"},coverage:{$ref:"#/$defs/GitCoverageV1"},lines:{items:{$ref:"#/$defs/GitBlameLineV1"},type:"array"},path:{type:"string"},repository:{$ref:"#/$defs/RepositoryId"}},required:["repository","path","lines","availability","coverage"],type:"object"},GitBlobExpectationV1:gf,GitChangeKindV1:gh,GitCommitIdentityV1:{additionalProperties:!1,description:"Author/committer identity and timestamp evidence for one commit.",properties:{at:{$ref:"#/$defs/UtcMicros"},email:{type:"string"},name:{type:"string"}},required:["name","email","at"],type:"object"},GitCommitMetadataV1:{additionalProperties:!1,description:"Bounded commit metadata. The full message is not retained;\n`message_digest` is its canonical digest evidence.",properties:{author:{$ref:"#/$defs/GitCommitIdentityV1"},commit:{$ref:"#/$defs/GitOidV1"},committer:{$ref:"#/$defs/GitCommitIdentityV1"},message_digest:{$ref:"#/$defs/ManifestDigest"},parents:{items:{$ref:"#/$defs/GitOidV1"},type:"array"},subject:{description:"First line of the commit message, bounded at capture.",type:"string"},tree:{$ref:"#/$defs/GitOidV1"}},required:["commit","tree","parents","author","committer","subject","message_digest"],type:"object"},GitCoverageV1:gv,GitDegradationV1:gb,GitDiffScopeV1:{description:"Diff scope: unstaged worktree changes, staged index changes, or an exact\ncommit range. Range diffs are read-only evidence and carry no index\nrelationship, so they cannot mint an applicable `HunkRefV1`.",oneOf:[{properties:{scope:{const:"working_tree",type:"string"}},required:["scope"],type:"object"},{properties:{scope:{const:"staged",type:"string"}},required:["scope"],type:"object"},{properties:{base:{$ref:"#/$defs/GitOidV1"},head:{$ref:"#/$defs/GitOidV1"},scope:{const:"commit_range",type:"string"}},required:["scope","base","head"],type:"object"}]},GitDiffV1:{additionalProperties:!1,description:"Typed diff result for one scope with explicit coverage.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},files:{items:{$ref:"#/$defs/GitFileDiffV1"},type:"array"},repository:{$ref:"#/$defs/RepositoryId"},scope:{$ref:"#/$defs/GitDiffScopeV1"}},required:["repository","scope","files","coverage"],type:"object"},GitFileDiffV1:{additionalProperties:!1,description:"One file's structured diff record: change kind, modes, blob identities,\nbinary/submodule classification, bounded line totals, and hunks.",properties:{binary:{type:"boolean"},change:{$ref:"#/$defs/GitChangeKindV1"},deletions:{format:"uint32",minimum:0,type:["integer","null"]},hunks:{items:{$ref:"#/$defs/GitHunkV1"},type:"array"},insertions:{description:"Inserted/deleted line totals; absent for binary and submodule records.",format:"uint32",minimum:0,type:["integer","null"]},new_blob:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},new_mode:{anyOf:[{$ref:"#/$defs/GitFileModeV1"},{type:"null"}]},old_blob:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},old_mode:{anyOf:[{$ref:"#/$defs/GitFileModeV1"},{type:"null"}]},original_path:{description:"Source path for a rename or copy.",type:["string","null"]},path:{type:"string"},submodule:{description:"True when the entry is a gitlink (submodule) change.",type:"boolean"}},required:["path","change","binary","submodule","hunks"],type:"object"},GitFileModeV1:g$,GitHeadStateV1:gk,GitHistoryV1:{additionalProperties:!1,description:"Bounded commit history in native traversal order. `truncated` is true\nwhen the capture bound cut the walk; shallow/partial-clone boundaries are\ncoverage degradations, never silently clean.",properties:{commits:{items:{$ref:"#/$defs/GitCommitMetadataV1"},type:"array"},coverage:{$ref:"#/$defs/GitCoverageV1"},repository:{$ref:"#/$defs/RepositoryId"},truncated:{type:"boolean"}},required:["repository","commits","truncated","coverage"],type:"object"},GitHunkPreviewEntryV1:{additionalProperties:!1,description:"One minted hunk selection: the canonical selection digest plus the\n`HunkRef` identity evidence it selects.",properties:{digest:{$ref:"#/$defs/ManifestDigest"},hunk:{$ref:"#/$defs/HunkRefV1"}},required:["digest","hunk"],type:"object"},GitHunkPreviewInputV1:{additionalProperties:!1,description:"Bounded, expiring preview input minted by `git_hunks` from one exact\ndaemon-captured repository snapshot.",properties:{expires_at:{$ref:"#/$defs/UtcMicros"},hunks:{items:{$ref:"#/$defs/GitHunkPreviewEntryV1"},type:"array"},preview_input_id:{$ref:"#/$defs/GitIndexPreviewId"},repository_snapshot_digest:{$ref:"#/$defs/ManifestDigest"}},required:["preview_input_id","repository_snapshot_digest","expires_at","hunks"],type:"object"},GitHunkV1:{additionalProperties:!1,description:"One structured diff hunk. The hunk body is not retained; `patch_digest`\nis the canonical digest of the normalized header plus body lines, which\nis the stable hunk identity evidence.",properties:{new_lines:{format:"uint32",minimum:0,type:"integer"},new_start:{format:"uint32",minimum:0,type:"integer"},old_lines:{format:"uint32",minimum:0,type:"integer"},old_start:{format:"uint32",minimum:0,type:"integer"},patch_digest:{$ref:"#/$defs/ManifestDigest"},section:{description:"Function/section heading from the hunk header when Git emitted one.",type:["string","null"]}},required:["old_start","old_lines","new_start","new_lines","patch_digest"],type:"object"},GitIndexEntryExpectationV1:gP,GitIndexPreviewId:gV,GitOidV1:gq,GitOperationStateV1:gI,GitQueryEnvelopeV1:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitStatusSummaryV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitQueryEnvelopeV12:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitDiffV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitQueryEnvelopeV13:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitHistoryV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitQueryEnvelopeV14:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitBlameV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitQueryEnvelopeV15:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitHunkPreviewInputV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitStatusSummaryV1:{additionalProperties:!1,description:"Bounded status summary derived from the typed\n[`tracedecay_domain::git::GitStatusV1`]: HEAD and operation state,\nper-class counts, and a bounded sorted sample of changed paths.",properties:{changed_paths:{description:"Sorted, de-duplicated changed paths, truncated at the query entry bound.",items:{type:"string"},type:"array"},conflicted:{format:"uint32",minimum:0,type:"integer"},head:{$ref:"#/$defs/GitHeadStateV1"},ignored:{format:"uint32",minimum:0,type:"integer"},operation:{$ref:"#/$defs/GitOperationStateV1"},repository:{$ref:"#/$defs/RepositoryId"},schema_version:{type:"string"},staged:{format:"uint32",minimum:0,type:"integer"},unstaged:{format:"uint32",minimum:0,type:"integer"},untracked:{format:"uint32",minimum:0,type:"integer"}},required:["repository","head","operation","staged","unstaged","conflicted","untracked","ignored","changed_paths","schema_version"],type:"object"},HunkDirectionV1:gU,HunkRefV1:gH,ManifestDigest:_l,RepositoryId:vb,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Actual payload emitted by each public Git read operation.",oneOf:[{properties:{query:{const:"status",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV1"}},required:["query","result"],type:"object"},{properties:{query:{const:"diff",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV12"}},required:["query","result"],type:"object"},{properties:{query:{const:"history",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV13"}},required:["query","result"],type:"object"},{properties:{query:{const:"blame",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV14"}},required:["query","result"],type:"object"},{properties:{query:{const:"hunks",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV15"}},required:["query","result"],type:"object"}],title:"GitReadResultV1"},{$defs:{GitOidV1:gq,GitSurfaceDiffScopeV1:gA},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_diff` surface.",properties:{base:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]},scope:{$ref:"#/$defs/GitSurfaceDiffScopeV1",default:"working_tree"}},title:"GitDiffSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_history` surface.",properties:{count:{format:"uint32",minimum:0,type:["integer","null"]},first_parent:{default:!1,type:"boolean"},follow:{default:!1,type:"boolean"},max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]},path:{type:["string","null"]}},title:"GitHistorySurfaceRequest",type:"object"},{$defs:{GitSurfaceDiffScopeV1:gA},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_hunks` surface.\n\nThe daemon captures exact repository state itself and injects the private\npreview binding after capture, so the public wire carries only the diff\nscope (commit ranges cannot mint applicable hunks).",properties:{max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]},scope:{$ref:"#/$defs/GitSurfaceDiffScopeV1",default:"working_tree"}},title:"GitHunksSurfaceRequest",type:"object"},{$defs:{GitIndexPreviewId:gV,GitIndexTransactionOperationV1:gR,ManifestDigest:_l},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Public MCP/CLI request for one daemon-owned Git index preview.",properties:{operation:{$ref:"#/$defs/GitIndexTransactionOperationV1"},preview_input_id:{anyOf:[{$ref:"#/$defs/GitIndexPreviewId"},{type:"null"}],default:null,description:"Hunk preview input minted by `git_hunks`; required for stage/unstage."},selected_hunk_digests:{default:[],description:"Selection digests drawn from the referenced preview input.",items:{$ref:"#/$defs/ManifestDigest"},type:"array"}},required:["operation"],title:"GitPreviewSurfaceRequest",type:"object"},{$defs:{GitBlobExpectationV1:gf,GitCoverageV1:gv,GitDegradationV1:gb,GitFileModeV1:g$,GitHeadStateV1:gk,GitIndexEntryExpectationV1:gP,GitIndexPreviewDispositionV1:{description:"Whether a captured preview may reach the daemon's native apply path.",oneOf:[{properties:{state:{const:"applicable",type:"string"}},required:["state"],type:"object"},{properties:{reason:{$ref:"#/$defs/GitIndexUnsupportedStateV1"},state:{const:"unsupported",type:"string"}},required:["state","reason"],type:"object"}]},GitIndexPreviewId:gV,GitIndexTransactionOperationV1:gR,GitIndexUnsupportedStateV1:{description:"Why a preview is intentionally read-only. A caller must re-preview after\nresolving the condition; no variant grants a relaxed or partial apply.",enum:["bare_repository","detached_head","unborn_branch","index_lock_present","external_git_driver","unmerged_index","intent_to_add","split_index","sparse_index","unreadable_index","conflicted_working_tree","unreadable_working_tree","in_progress_operation","unsupported_object_format","binary_hunk","submodule","symlink","file_mode_only","rename_or_copy","filters_or_end_of_line","partial_hunk_selection"],type:"string"},GitObjectFormatV1:{description:"Repository object format, derived from object-id length.",enum:["sha1","sha256"],type:"string"},GitOidV1:gq,GitOperationStateV1:gI,HunkDirectionV1:gU,HunkRefV1:gH,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RepositoryIndexSnapshotV1:{additionalProperties:!1,properties:{checksum:{$ref:"#/$defs/ManifestDigest"},state:{$ref:"#/$defs/RepositoryIndexStateV1"},tree_id:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},unmerged_stage_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]}},required:["checksum","state"],type:"object"},RepositoryIndexStateV1:{enum:["clean","staged","unmerged","intent_to_add","split","sparse","unreadable"],type:"string"},RepositoryStateSnapshotV1:{additionalProperties:!1,description:"Immutable content-addressed native repository state. Missing/partial\nevidence remains typed by fields and coverage instead of being upgraded to\na guessed clean snapshot.",properties:{adapter_revision:{description:"Revision of the fixed native adapter that interpreted this state.",type:["string","null"]},attributes_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},captured_at:{$ref:"#/$defs/UtcMicros"},configuration_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},coverage:{$ref:"#/$defs/GitCoverageV1"},filesystem_capabilities_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},git_version:{description:"Exact native Git implementation observed by the fixed adapter. A\nread-only partial snapshot may omit this, but omitted native evidence\nis never mutation eligible.",type:["string","null"]},head:{$ref:"#/$defs/GitHeadStateV1"},index:{$ref:"#/$defs/RepositoryIndexSnapshotV1"},object_format:{$ref:"#/$defs/GitObjectFormatV1"},observation_epoch:{format:"uint64",minimum:0,type:"integer"},operation_state:{$ref:"#/$defs/GitOperationStateV1"},project_id:{$ref:"#/$defs/ProjectId"},refs_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Digest of the complete native ref namespace at capture time."},repository_id:{$ref:"#/$defs/RepositoryId"},snapshot_id:{type:"string"},sparse_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},submodule_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},working_tree:{$ref:"#/$defs/RepositoryWorkingTreeSnapshotV1"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["snapshot_id","project_id","repository_id","observation_epoch","object_format","head","index","working_tree","operation_state","captured_at","coverage"],type:"object"},RepositoryWorkingTreeSnapshotV1:{additionalProperties:!1,properties:{ignored_collision_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},state:{$ref:"#/$defs/RepositoryWorkingTreeStateV1"},tracked_digest:{$ref:"#/$defs/ManifestDigest"},untracked_name_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]}},required:["state","tracked_digest"],type:"object"},RepositoryWorkingTreeStateV1:{enum:["clean","tracked_dirty","untracked_only","mixed","conflicted","unreadable"],type:"string"},UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Immutable, content-bound preview for one daemon-serialized index\ntransaction. Applicability is only a precondition: the daemon must capture\nand compare the entire snapshot and every contained `HunkRefV1` again\nimmediately before a native mutation.",properties:{candidate_index_tree:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},created_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/GitIndexPreviewDispositionV1"},expires_at:{$ref:"#/$defs/UtcMicros"},operation:{$ref:"#/$defs/GitIndexTransactionOperationV1"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/GitIndexPreviewId"},repository_snapshot:{$ref:"#/$defs/RepositoryStateSnapshotV1"},repository_snapshot_digest:{$ref:"#/$defs/ManifestDigest"},selected_hunks:{items:{$ref:"#/$defs/HunkRefV1"},type:"array"}},required:["preview_id","operation","repository_snapshot","repository_snapshot_digest","selected_hunks","disposition","created_at","expires_at","preview_digest"],title:"GitIndexPreviewV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_status` surface.",properties:{max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]}},title:"GitStatusSurfaceRequest",type:"object"},{$defs:{StackDeliveryWatermarkId:bk,StackSignalId:bP},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The public, transport-neutral request for one durable stack signal.",properties:{expected_watermark_id:{anyOf:[{$ref:"#/$defs/StackDeliveryWatermarkId"},{type:"null"}]},signal_id:{anyOf:[{$ref:"#/$defs/StackSignalId"},{type:"null"}]}},title:"GitHubStackSignalExpandSurfaceRequest",type:"object"},{$defs:{BranchStackRevisionId:f8,GitHubStackSignalEvidenceRefV1:{additionalProperties:!1,description:"Bounded evidence for the exact signal the coordinator authorized.\n\nProvider payloads, paths, commit bodies, and delivery recipients remain\nbehind the durable signal evidence rather than copied to this result.",properties:{github_stack_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},kind:{$ref:"#/$defs/StackSignalKindV1"},native_source:{$ref:"#/$defs/GitHubStackSignalNativeSourceV1"},observed_at:{$ref:"#/$defs/UtcMicros"},signal_id:{$ref:"#/$defs/StackSignalId"},stack_revision_digest:{$ref:"#/$defs/ManifestDigest"},stack_revision_id:{$ref:"#/$defs/BranchStackRevisionId"},state_digest:{$ref:"#/$defs/ManifestDigest"},watermark_id:{$ref:"#/$defs/StackDeliveryWatermarkId"}},required:["signal_id","watermark_id","kind","stack_revision_id","stack_revision_digest","state_digest","observed_at","native_source"],type:"object"},GitHubStackSignalExpandUnavailableV1:{description:"Truthful non-success outcomes for signal expansion.\n\n`Concealed` intentionally combines absent and unauthorized signal handles;\nexposing that distinction would turn this operation into a signal probe.",enum:["concealed","stale","native_evidence_unavailable","authority_unmounted","cancelled"],type:"string"},GitHubStackSignalNativePreviewV1:{additionalProperties:!1,description:"Exact branch pair and native preflight that produced the selected signal.",properties:{destination_ref:{$ref:"#/$defs/RefId"},destination_tip:{$ref:"#/$defs/GitOidV1"},direction:{$ref:"#/$defs/NativeIntegrationDirectionV1"},disposition:{$ref:"#/$defs/NativeIntegrationPreviewDispositionV1"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},source_ref:{$ref:"#/$defs/RefId"},source_tip:{$ref:"#/$defs/GitOidV1"}},required:["preview_id","preview_digest","direction","source_ref","destination_ref","source_tip","destination_tip","disposition"],type:"object"},GitHubStackSignalNativeSourceV1:{oneOf:[{properties:{preview:{$ref:"#/$defs/GitHubStackSignalNativePreviewV1"},source:{const:"preflight",type:"string"}},required:["source","preview"],type:"object"},{properties:{preview:{$ref:"#/$defs/GitHubStackSignalNativePreviewV1"},source:{const:"terminal",type:"string"},terminal:{$ref:"#/$defs/GitHubStackSignalNativeTerminalV1"}},required:["source","preview","terminal"],type:"object"}]},GitHubStackSignalNativeTerminalV1:{additionalProperties:!1,properties:{completed_at:{$ref:"#/$defs/UtcMicros"},final_ref_tip:{$ref:"#/$defs/GitOidV1"},outcome:{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"}},required:["transaction_id","receipt_digest","outcome","final_ref_tip","completed_at"],type:"object"},GitOidV1:gq,ManifestDigest:_l,MechanicalIntegrationModeV1:_p,NativeIntegrationDirectionV1:_R,NativeIntegrationPreviewDispositionV1:_q,NativeIntegrationPreviewId:_I,NativeIntegrationTerminalOutcomeV1:_C,NativeIntegrationTransactionId:_T,NativeIntegrationUnavailabilityV1:_O,RefId:vm,StackDeliveryWatermarkId:bk,StackSignalId:bP,StackSignalKindV1:{description:"Durable classification of one GitHub stack transition.",enum:["dependency_ready","actual_conflict","stack_tip_drift","pull_request_drift","ci_evaluated_commit_drift","integration_committed","integration_needs_inspection"],type:"string"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{evidence:{$ref:"#/$defs/GitHubStackSignalEvidenceRefV1"},outcome:{const:"expanded",type:"string"}},required:["outcome","evidence"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},reason:{$ref:"#/$defs/GitHubStackSignalExpandUnavailableV1"}},required:["outcome","reason"],type:"object"}],title:"GitHubStackSignalExpandSurfaceResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"GodClassSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GodClassEntryV1:{additionalProperties:!1,properties:{fields:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},methods:{format:"uint64",minimum:0,type:"integer"},name:{type:"string"},total_members:{format:"uint64",minimum:0,type:"integer"}},required:["id","name","kind","file","line","methods","fields","total_members"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ranking:{items:{$ref:"#/$defs/GodClassEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["result_count","ranking"],title:"GodClassResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{case_sensitive:{description:"Match case-sensitively (default: false = case-insensitive).",type:["boolean","null"]},context_lines:{description:"Lines of surrounding context to include per hit (default: 0, max: 3).",format:"uint32",minimum:0,type:["integer","null"]},fixed_strings:{description:"Treat pattern as a literal string instead of a regex (default: false).",type:["boolean","null"]},max_results:{description:"Maximum number of matching lines to return (default: 50, max: 200).",format:"uint32",minimum:0,type:["integer","null"]},path_glob:{description:"Optional glob restricting which files are searched, matched against\nproject-relative paths (e.g. 'src/**/*.rs').",type:["string","null"]},pattern:{description:"Content to search for. Treated as a regular expression unless\nfixed_strings is true.",type:"string"}},required:["pattern"],title:"GrepSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,CoverageCompleteness:yu,CoverageDomainState:ym,EvidenceCoverage:yx,EvidenceDomain:yj,GrepGraphEnrichmentV1:{description:"Whether the verified graph resolved each hit's enclosing symbol. Hits are\nthe lexical answer either way.",oneOf:[{additionalProperties:!1,properties:{enriched:{format:"uint64",minimum:0,type:"integer"},returned:{format:"uint64",minimum:0,type:"integer"},status:{const:"complete",type:"string"}},required:["status","enriched","returned"],type:"object"},{additionalProperties:!1,properties:{detail:{type:"string"},reason_code:{type:"string"},retryable:{type:"boolean"},status:{const:"unavailable",type:"string"}},required:["status","reason_code","retryable","detail"],type:"object"}]},GrepMatchV1:{additionalProperties:!1,properties:{after:{items:{type:"string"},type:"array"},before:{items:{type:"string"},type:"array"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},node_id:{type:["string","null"]},symbol:{description:"The smallest verified graph symbol enclosing the hit.",type:["string","null"]},text:{type:"string"}},required:["file","line","text"],type:"object"},GrepScanOmissionsV1:{additionalProperties:!1,description:"What the bounded scan skipped, by cause; absent when it skipped nothing.",properties:{oversized_files:{description:"Files larger than the interactive scan byte limit.",format:"uint64",minimum:0,type:"integer"},oversized_lines:{description:"Lines longer than the scan line byte limit.",format:"uint64",minimum:0,type:"integer"},unavailable_sources:{description:"Source candidates that could not be read during the scan.",format:"uint64",minimum:0,type:"integer"}},required:["oversized_files","oversized_lines","unavailable_sources"],type:"object"},Omission:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},domain:{$ref:"#/$defs/EvidenceDomain"},reason:{$ref:"#/$defs/OmissionReason"}},required:["domain","count","reason"],type:"object"},OmissionReason:{description:"Safe reason why authorized requested evidence was omitted.",oneOf:[{enum:["budget","redacted","unavailable","unsupported","stale","failed","cancelled","timed_out","conflict"],type:"string"},{const:"macro_body_unparsed",description:"Evidence came from a macro body that was not expanded, so what the\nexpansion defines or calls is not covered.",type:"string"},{const:"import_unmodeled",description:"A caller sits under a `use` whose binding the index could not model\n(a glob in a block or inline module), so whether it calls the target\nis not covered.",type:"string"},{const:"cursor_expired",description:"The continuation cursor can no longer be redeemed (its lifetime ended\nor the snapshot it pages is gone); restart the request without it.",type:"string"},{const:"cursor_foreign",description:"The continuation cursor was issued for another project, worktree, or\nref; redeem it where it was issued.",type:"string"}]},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/EvidenceCoverage"},files_scanned:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},graph_enrichment:{$ref:"#/$defs/GrepGraphEnrichmentV1"},match_count:{format:"uint64",minimum:0,type:"integer"},omissions:{items:{$ref:"#/$defs/Omission"},type:"array"},results:{items:{$ref:"#/$defs/GrepMatchV1"},type:"array"},scan_omissions:{$ref:"#/$defs/GrepScanOmissionsV1"},truncated:{type:"boolean"}},required:["results","match_count","files_scanned","truncated","coverage","omissions","graph_enrichment"],title:"GrepSearchResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{details:{description:"If true, include full dimension breakdown (default: false).",type:["boolean","null"]},path:{description:"Filter to files under this directory path.",type:["string","null"]}},title:"HealthSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,HealthAcyclicityV1:{additionalProperties:!1,properties:{edges_in_cycles:{format:"uint64",minimum:0,type:"integer"},score:{format:"double",type:"number"},source:{type:"string"}},required:["score","edges_in_cycles","source"],type:"object"},HealthCoverageDisciplineV1:{additionalProperties:!1,properties:{score:{format:"double",type:"number"},skip_test_coverage_count:{format:"uint64",minimum:0,type:"integer"},source:{type:"string"},total_fns:{format:"uint64",minimum:0,type:"integer"}},required:["score","skip_test_coverage_count","total_fns","source"],type:"object"},HealthDepthV1:{additionalProperties:!1,properties:{ideal_chain:{format:"uint64",minimum:0,type:"integer"},max_chain:{format:"uint64",minimum:0,type:"integer"},score:{format:"double",type:"number"},source:{type:"string"}},required:["score","max_chain","ideal_chain","source"],type:"object"},HealthDimensionsV1:{additionalProperties:!1,properties:{acyclicity:{$ref:"#/$defs/HealthAcyclicityV1"},coverage_discipline:{$ref:"#/$defs/HealthCoverageDisciplineV1"},depth:{$ref:"#/$defs/HealthDepthV1"},equality:{$ref:"#/$defs/HealthEqualityV1"},modularity:{$ref:"#/$defs/HealthModularityV1"},redundancy:{$ref:"#/$defs/HealthRedundancyV1"}},required:["acyclicity","depth","equality","redundancy","modularity","coverage_discipline"],type:"object"},HealthEqualityV1:{additionalProperties:!1,properties:{gini:{format:"double",type:"number"},incomplete_complexity_symbols:{format:"uint64",minimum:0,type:"integer"},interpretation:{type:"string"},score:{format:"double",type:"number"},source:{type:"string"}},required:["score","gini","interpretation","incomplete_complexity_symbols","source"],type:"object"},HealthModularityV1:{additionalProperties:!1,properties:{components_after_hub_removal:{format:"uint64",minimum:0,type:"integer"},interpretation:{type:"string"},score:{format:"double",type:"number"},source:{type:"string"}},required:["score","interpretation","components_after_hub_removal","source"],type:"object"},HealthRedundancyV1:{additionalProperties:!1,properties:{dead_count:{format:"uint64",minimum:0,type:"integer"},score:{format:"double",type:"number"},source:{type:"string"},total_fns:{format:"uint64",minimum:0,type:"integer"}},required:["score","dead_count","total_fns","source"],type:"object"},HealthWeightsV1:{additionalProperties:!1,properties:{note:{type:"string"}},required:["note"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"`dimensions` and `weights` are present exactly when the request asked for\n`details`.",properties:{dimensions:{anyOf:[{$ref:"#/$defs/HealthDimensionsV1"},{type:"null"}]},files_analyzed:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},panel:{description:"Measured dimension names, worst score first, then\n`no evidence: name (reason), ...` for the dimensions the scope gave\nnothing to measure. An empty scope reads\n`no evidence: 0 files in scope`.",type:"string"},quality_signal:{description:"Geometric mean of the dimensions, scaled to 0-10000. A breakdown of\n`panel`, not a number to maximize. Dimensions that `panel` lists under\n`no evidence:` enter it at their formula value for an empty\nmeasurement, so it does not summarize such a scope: an empty scope\nreads 10000 and one file reads 0.",format:"uint32",minimum:0,type:"integer"},weights:{anyOf:[{$ref:"#/$defs/HealthWeightsV1"},{type:"null"}]}},required:["quality_signal","files_analyzed"],title:"HealthResultV1",type:"object"},{$defs:{PageRequest:_U,ResultProjection:vP,RetrievalOrder:vx,RetrievalRequestMeta:vj,TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{before_cursor:{description:"A prior result's after_cursor. A cursor recorded under another health\ndefinition, or before definitions were recorded, is refused with\n`application.health-delta.definition-mismatch` or\n`application.health-delta.definition-unrecorded`; omit it to record a\nnew baseline.",type:["string","null"]},meta:{$ref:"#/$defs/RetrievalRequestMeta"},path_prefix:{type:["string","null"]}},required:["meta"],title:"HealthDeltaRequest",type:"object"},{$defs:{HealthDeltaCoverageV1:{additionalProperties:!1,properties:{completeness:{description:"`complete` when both points analyzed files, otherwise `unknown`.",type:"string"},denominator:{format:"uint64",minimum:0,type:["integer","null"]},eligible:{description:"Files the `after` point analyzed.",format:"uint64",minimum:0,type:["integer","null"]},visited:{format:"uint64",minimum:0,type:["integer","null"]}},required:["completeness"],type:"object"},HealthDeltaCurrentnessV1:{additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"},state:{type:"string"}},required:["state","observed_at"],type:"object"},HealthDeltaPointV1:{additionalProperties:!1,properties:{dimensions:{additionalProperties:{$ref:"#/$defs/HealthDimensionPointV1"},type:"object"},files_analyzed:{format:"uint64",minimum:0,type:"integer"},function_denominator:{format:"uint64",minimum:0,type:"integer"},observed_at:{$ref:"#/$defs/UtcMicros"},quality_signal:{format:"uint32",minimum:0,type:"integer"},watermark:{$ref:"#/$defs/ManifestDigest"}},required:["watermark","observed_at","quality_signal","files_analyzed","function_denominator","dimensions"],type:"object"},HealthDeltaScopeV1:{additionalProperties:!1,properties:{path_prefix:{type:["string","null"]},project_id:{type:["string","null"]},scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest"],type:"object"},HealthDimensionDeltaV1:{additionalProperties:!1,properties:{after_denominator:{format:"uint64",minimum:0,type:["integer","null"]},after_ppm:{format:"uint64",minimum:0,type:"integer"},before_denominator:{format:"uint64",minimum:0,type:["integer","null"]},before_ppm:{format:"uint64",minimum:0,type:"integer"},delta_ppm:{format:"int64",type:"integer"},status:{description:"`improved` or `degraded` when the score moved more than 1000 ppm,\notherwise `unchanged`. `no_evidence` when either point's scope gave\nthe dimension nothing to measure, so its scores are formula values.",type:"string"}},required:["before_ppm","after_ppm","delta_ppm","status"],type:"object"},HealthDimensionPointV1:{additionalProperties:!1,properties:{denominator:{format:"uint64",minimum:0,type:["integer","null"]},score_ppm:{format:"uint64",minimum:0,type:"integer"}},required:["score_ppm"],type:"object"},ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{$ref:"#/$defs/HealthDeltaPointV1"},after_cursor:{type:"string"},before:{$ref:"#/$defs/HealthDeltaPointV1"},before_cursor:{type:"string"},coverage:{$ref:"#/$defs/HealthDeltaCoverageV1"},currentness:{$ref:"#/$defs/HealthDeltaCurrentnessV1"},delta:{format:"int64",type:"integer"},dimensions:{additionalProperties:{$ref:"#/$defs/HealthDimensionDeltaV1"},type:"object"},pass:{description:"True when both points analyzed files and quality_signal did not drop.",type:"boolean"},schema_version:{format:"uint32",minimum:0,type:"integer"},scope:{$ref:"#/$defs/HealthDeltaScopeV1"}},required:["schema_version","scope","before","after","before_cursor","after_cursor","pass","delta","dimensions","coverage","currentness"],title:"HealthDeltaResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The health read takes no parameters: it reports one serving status, with no\npage, projection, or temporal selection to make. The page and deadline\ncontrols every surface supplies travel in the dispatch envelope, not here.",title:"HealthReadRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{status:{type:"string"}},required:["status"],title:"HealthReadResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_pending_payloads:{default:!1,description:"Include staged Hermes skill-write payloads (default: false).",type:"boolean"},include_skill_bodies:{default:!1,description:"Include bounded SKILL.md contents (default: false).",type:"boolean"}},title:"HermesSkillBridgeSurfaceRequestV1",type:"object"},{$defs:{AutomationReadStatusV1:fH,HermesPendingSkillWrite:{properties:{action:{type:["string","null"]},created_at:!0,id:{type:"string"},name:{type:["string","null"]},origin:{type:["string","null"]},payload:!0,source_path:{type:"string"},summary:{type:["string","null"]}},required:["id","source_path"],type:"object"},HermesSkillBridgeContracts:{properties:{discovery_policy:{type:"string"},lifecycle_owner:{type:"string"},mutation_policy:{type:"string"}},required:["lifecycle_owner","mutation_policy","discovery_policy"],type:"object"},HermesSkillBridgeSnapshot:{properties:{agent_home:{type:"string"},archive_count:{format:"uint",minimum:0,type:"integer"},contracts:{$ref:"#/$defs/HermesSkillBridgeContracts"},pending_skill_corrupt_count:{format:"uint",minimum:0,type:"integer"},pending_skill_count:{format:"uint",minimum:0,type:"integer"},pending_skills:{items:{$ref:"#/$defs/HermesPendingSkillWrite"},type:"array"},skill_count:{format:"uint",minimum:0,type:"integer"},skills:{items:{$ref:"#/$defs/HermesSkillSummary"},type:"array"},skills_dir:{type:"string"},usage_record_count:{format:"uint",minimum:0,type:"integer"},usage_records:{additionalProperties:!0,description:"Hermes-owned usage telemetry keyed by skill name, as Hermes wrote it.",type:"object"}},required:["agent_home","skills_dir","skill_count","pending_skill_count","pending_skill_corrupt_count","usage_record_count","archive_count","skills","pending_skills","usage_records","contracts"],type:"object"},HermesSkillSummary:{properties:{body_markdown:{type:["string","null"]},category:{type:["string","null"]},description:{type:["string","null"]},name:{type:"string"},path:{type:"string"},pending_write_ids:{items:{type:"string"},type:"array"},usage:!0},required:["name","path","pending_write_ids"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{bridge:{$ref:"#/$defs/HermesSkillBridgeSnapshot"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","bridge"],title:"HermesSkillBridgeResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,description:"Reset the project's local token counter.",properties:{action:{const:"reset_counter",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"Admit one Hook V2 envelope for the bound project.",properties:{action:{const:"hook_v2_admit",type:"string"},envelope:!0,native_lifecycle:!0,native_session_id:{description:"The host's native session id; it binds only when it hashes to the\nenvelope's protected session.",type:["string","null"]}},required:["action","envelope"],type:"object"},{additionalProperties:!1,description:"Commit a Context Scout delivery receipt for guidance the last\nadmission handed out.",properties:{action:{const:"hook_v2_delivery_receipt",type:"string"},receipt:!0},required:["action","receipt"],type:"object"},{additionalProperties:!1,description:"Acknowledge delivery of an advisory feedback notice.",properties:{action:{const:"hook_v2_feedback_notice_delivery",type:"string"},envelope:!0,feedback_notice:!0},required:["action","envelope","feedback_notice"],type:"object"},{additionalProperties:!1,description:"Land a host transcript in the owning session store.",properties:{action:{const:"ingest_transcript",type:"string"},event_json:{description:"The host's raw hook event, for providers that locate the transcript\nfrom it.",type:["string","null"]},max_new_bytes:{description:"Byte budget for this pass across every scanned source.",format:"uint64",minimum:0,type:["integer","null"]},messages:{description:"One turn the host inlined instead of a source to scan.",items:!0,type:["array","null"]},provider:{type:"string"},session_id:{type:["string","null"]},user_scope:{description:"Land the transcript in the profile's user store instead of the\nproject's.",type:"boolean"}},required:["action","provider","user_scope"],type:"object"},{additionalProperties:!1,description:"Codex `PostCompact` pressure evidence.",properties:{action:{const:"codex_compact",type:"string"},event_json:{type:"string"}},required:["action","event_json"],type:"object"},{additionalProperties:!1,description:"Claude `PostCompact` pressure evidence; `user_scope` routes it to the\nprofile.",properties:{action:{const:"claude_compact",type:"string"},event_json:{type:"string"},user_scope:{type:"boolean"}},required:["action","event_json","user_scope"],type:"object"},{additionalProperties:!1,description:"Cursor `preCompact` pressure evidence.",properties:{action:{const:"cursor_compact",type:"string"},event_json:{type:"string"}},required:["action","event_json"],type:"object"},{additionalProperties:!1,description:"Record a Hermes terminal receipt without a project route.",properties:{action:{const:"hermes_receipt",type:"string"},event:!0},required:["action","event"],type:"object"},{additionalProperties:!1,description:"Admit a native event without a project route into the profile's\nHook V2 ledger.",properties:{action:{const:"hook_v2_profile_admit",type:"string"},admission:!0},required:["action","admission"],type:"object"}],title:"HookRuntimeSurfaceRequestV1"},{$defs:{ContextScoutAddressV1:hU,ContextScoutStoreStatusV1:{enum:["stored","duplicate","superseded","unavailable"],type:"string"},HermesReceiptStatusV1:{oneOf:[{const:"recorded",description:"A terminal receipt was recorded.",type:"string"},{const:"ingested",description:"The turn was marked ingested and no receipt awaits review.",type:"string"},{const:"awaiting_transcript",description:"A receipt awaits a transcript that has not landed yet.",type:"string"}]},HookIngestAdmissionV1:{additionalProperties:!1,description:"The admission authority's verdict on one transcript ingest.",properties:{reason_code:{type:["string","null"]},retryable:{type:"boolean"},status:{description:"The session host-admission status, in its wire spelling.",type:"string"}},required:["status","retryable"],type:"object"},HookOrchestrationAdmissionV1:{description:"Outcome of admitting one hook envelope into the registered orchestrator.",enum:["enqueued","backpressured","unsupported_trigger","unavailable"],type:"string"},HookRuntimeDispositionV1:{description:"How the hook transport should treat a Hook V2 envelope.",oneOf:[{enum:["accepted"],type:"string"},{const:"catchup_required",description:"The published binding no longer authorizes the envelope; the host\nmust catch up before sending again.",type:"string"}]},HookV2RejectionReasonV1:{oneOf:[{const:"admission_identity_conflict",description:"The same event identity previously carried different bytes.",type:"string"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{action:{const:"reset_counter",type:"string"},reset:{type:"boolean"}},required:["action","reset"],type:"object"},{oneOf:[{properties:{context_scout_address:{anyOf:[{$ref:"#/$defs/ContextScoutAddressV1"},{type:"null"}]},disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},feedback_notice:{description:"The advisory `AdvisoryHookLookupNoticeV1` waiting for this\nworktree."},github_stack_signal_available:{type:"boolean"},orchestration:{$ref:"#/$defs/HookOrchestrationAdmissionV1"},ready_guidance:{description:"The hook's `HookReadyGuidanceV1`, when admission claimed one."},status:{const:"accepted",type:"string"}},required:["status","disposition","orchestration","github_stack_signal_available"],type:"object"},{description:"This exact envelope was already admitted; a retry may still receive\nguidance retained before a lost host response.",properties:{context_scout_address:{anyOf:[{$ref:"#/$defs/ContextScoutAddressV1"},{type:"null"}]},disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},ready_guidance:!0,status:{const:"exact_duplicate",type:"string"}},required:["status","disposition"],type:"object"},{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},reason:{anyOf:[{$ref:"#/$defs/HookV2RejectionReasonV1"},{type:"null"}]},status:{const:"rejected",type:"string"}},required:["status","disposition"],type:"object"},{description:"Idempotency could not be recorded, so nothing was admitted.",properties:{status:{const:"backpressured",type:"string"}},required:["status"],type:"object"},{properties:{status:{const:"unavailable",type:"string"}},required:["status"],type:"object"}],properties:{action:{const:"hook_v2_admit",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"hook_v2_delivery_receipt",type:"string"},status:{$ref:"#/$defs/ContextScoutStoreStatusV1"}},required:["action","status"],type:"object"},{oneOf:[{properties:{status:{const:"stored",type:"string"}},required:["status"],type:"object"},{properties:{status:{const:"unavailable",type:"string"}},required:["status"],type:"object"},{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},status:{const:"rejected",type:"string"}},required:["status","disposition"],type:"object"}],properties:{action:{const:"hook_v2_feedback_notice_delivery",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"ingest_transcript",type:"string"},admission:{$ref:"#/$defs/HookIngestAdmissionV1"},bytes_consumed:{format:"uint64",minimum:0,type:["integer","null"]},completed:{description:"False when the byte budget left work for a later pass.",type:"boolean"},cursor_advances:{format:"uint64",minimum:0,type:["integer","null"]},cursor_duplicates:{format:"uint64",minimum:0,type:["integer","null"]},deferred_by_byte_cap:{type:["boolean","null"]},deferred_sources:{format:"uint64",minimum:0,type:["integer","null"]},hint_outcomes:{description:"How emitted hook hints settled against the new project activity."},messages_upserted:{format:"uint64",minimum:0,type:"integer"},observation_duplicates:{format:"uint64",minimum:0,type:["integer","null"]},observations_committed:{format:"uint64",minimum:0,type:["integer","null"]},projection_duplicates:{format:"uint64",minimum:0,type:["integer","null"]},projections_completed:{format:"uint64",minimum:0,type:["integer","null"]},projections_skipped:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:"string"},records_quarantined:{format:"uint64",minimum:0,type:["integer","null"]},records_rejected:{format:"uint64",minimum:0,type:["integer","null"]},source_bytes_scanned:{format:"uint64",minimum:0,type:["integer","null"]},status:{type:"string"},user_scope:{type:"boolean"}},required:["action","provider","user_scope","completed","status","admission","messages_upserted"],type:"object"},{anyOf:[{description:"The LCM authority settled the compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},relation_projection_status:!0,retry_status:{type:["string","null"]},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],type:"object"},{description:"The LCM authority answered without a compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],type:"object"},{description:"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.",properties:{reason:{type:"string"},relation_projection_status:!0,status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids"],type:"object"},{description:"The host event named no session to compact.",properties:{messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"}},required:["status","reason","messages_upserted"],type:"object"}],description:"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.",properties:{action:{const:"codex_compact",type:"string"}},required:["action"],type:"object"},{anyOf:[{description:"The LCM authority settled the compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},relation_projection_status:!0,retry_status:{type:["string","null"]},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],type:"object"},{description:"The LCM authority answered without a compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],type:"object"},{description:"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.",properties:{reason:{type:"string"},relation_projection_status:!0,status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids"],type:"object"},{description:"The host event named no session to compact.",properties:{messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"}},required:["status","reason","messages_upserted"],type:"object"}],description:"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.",properties:{action:{const:"claude_compact",type:"string"}},required:["action"],type:"object"},{anyOf:[{description:"The LCM authority settled the compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},relation_projection_status:!0,retry_status:{type:["string","null"]},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],type:"object"},{description:"The LCM authority answered without a compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],type:"object"},{description:"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.",properties:{reason:{type:"string"},relation_projection_status:!0,status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids"],type:"object"},{description:"The host event named no session to compact.",properties:{messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"}},required:["status","reason","messages_upserted"],type:"object"}],description:"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.",properties:{action:{const:"cursor_compact",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"hermes_receipt",type:"string"},status:{$ref:"#/$defs/HermesReceiptStatusV1"}},required:["action","status"],type:"object"},{oneOf:[{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},status:{const:"accepted",type:"string"}},required:["status","disposition"],type:"object"},{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},status:{const:"exact_duplicate",type:"string"}},required:["status","disposition"],type:"object"},{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},status:{const:"rejected",type:"string"}},required:["status","disposition"],type:"object"},{properties:{status:{const:"unavailable",type:"string"}},required:["status"],type:"object"}],properties:{action:{const:"hook_v2_profile_admit",type:"string"}},required:["action"],type:"object"}],title:"HookRuntimeResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of hotspots to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]}},title:"HotspotsSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,HotspotV1:{additionalProperties:!1,properties:{churn:{description:"Commits touching `file` in the last 90 days. Absent when git history\ncould not be read; `0` means the file had no commits in that window.",format:"uint64",minimum:0,type:["integer","null"]},file:{type:"string"},id:{type:"string"},incoming:{format:"uint64",minimum:0,type:"integer"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},outgoing:{format:"uint64",minimum:0,type:"integer"},total:{format:"uint64",minimum:0,type:"integer"}},required:["id","name","kind","file","line","incoming","outgoing","total"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},hotspot_count:{format:"uint64",minimum:0,type:"integer"},hotspots:{items:{$ref:"#/$defs/HotspotV1"},type:"array"},unavailable_fields:{description:"Names a measurement this result could not make. `churn` means the\nranking is connectivity alone.",items:{type:"string"},type:"array"}},required:["hotspot_count","hotspots"],title:"HotspotsResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{max_depth:{format:"uint32",minimum:0,type:["integer","null"]},node_id:{type:"string"}},required:["node_id"],title:"NodeDepthSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ImpactNodeV1:{additionalProperties:!1,properties:{depth:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line","depth"],type:"object"},ImpactRadiusV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},node_count:{format:"uint",minimum:0,type:"integer"},nodes:{items:{$ref:"#/$defs/ImpactNodeV1"},type:"array"},unavailable_fields:{items:{type:"string"},type:"array"}},required:["node_count","complete","unavailable_fields","nodes"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveNotFoundV1:_Z,PrimitiveSearchFreshnessV1:_X,PrimitiveSymbolLocationV1:_1},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/ImpactRadiusV1"},{$ref:"#/$defs/PrimitiveNotFoundV1"}],title:"ImpactResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"InheritanceDepthSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,InheritanceDepthEntryV1:{additionalProperties:!1,properties:{depth:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line","depth"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ranking:{items:{$ref:"#/$defs/InheritanceDepthEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["result_count","ranking"],title:"InheritanceDepthResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_insert_at`.",properties:{anchor:{type:"string"},before:{default:!1,type:"boolean"},content:{type:"string"},dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},path:{type:"string"},verify:{default:!1,type:"boolean"}},required:["path","anchor","content"],title:"InsertAtSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_insert_at_symbol`.",properties:{content:{type:"string"},dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},position:{default:"after",type:"string"},symbol:{type:"string"},verify:{default:!1,type:"boolean"}},required:["symbol","content"],title:"InsertAtSymbolSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},node_kind:{description:"Filter by node kind (e.g. 'class', 'method', 'function', 'interface',\n'enum', 'struct').",type:["string","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"LargestSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,LargestEntryV1:{additionalProperties:!1,properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},lines:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["id","name","kind","file","start_line","end_line","lines"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},node_kind_filter:{type:["string","null"]},ranking:{items:{$ref:"#/$defs/LargestEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["result_count","ranking"],title:"LargestResultV1",type:"object"},{$defs:{LcmDescribeTargetV1:{oneOf:[{properties:{kind:{const:"session",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"summary_node",type:"string"},node_id:{type:"string"}},required:["kind","node_id"],type:"object"},{properties:{kind:{const:"external_payload",type:"string"},payload_ref:{type:"string"}},required:["kind","payload_ref"],type:"object"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{provider:{type:"string"},session_id:{type:"string"},target:{anyOf:[{$ref:"#/$defs/LcmDescribeTargetV1"},{type:"null"}]}},required:["provider","session_id"],title:"LcmDescribeRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,CompactLineageEdgeV1:{additionalProperties:!1,properties:{authority:{type:"string"},authorized:{type:"boolean"},kind:{type:"string"},knowledge_at:{format:"int64",type:"integer"},object_anchor_id:{type:"string"},subject_anchor_id:{type:"string"},supporting_anchor_ids:{items:{type:"string"},type:"array"}},required:["kind","subject_anchor_id","object_anchor_id","knowledge_at","authority","authorized","supporting_anchor_ids"],type:"object"},HydrationStateResultV1:gG,LcmContentRangeV1:gQ,LcmDescribeExternalPayloadV1:{additionalProperties:!1,properties:{byte_count:{format:"uint64",minimum:0,type:"integer"},char_count:{format:"uint64",minimum:0,type:"integer"},content_hash:{type:"string"},content_preview:{type:"string"},created_at:{format:"int64",type:"integer"},kind:{type:"string"},message_id:{type:"string"},metadata_json:{type:["string","null"]},payload_ref:{type:"string"},provider:{type:"string"},session_id:{type:"string"}},required:["payload_ref","provider","session_id","message_id","kind","content_hash","byte_count","char_count","created_at","content_preview"],type:"object"},LcmDescribeSourceOverviewV1:{additionalProperties:!1,properties:{expand_hint:{type:["string","null"]},node_id:{type:["string","null"]},role:{type:["string","null"]},source_kind:{type:"string"},source_ref:{$ref:"#/$defs/LcmSourceRefV1"},source_token_count:{format:"int64",type:["integer","null"]},storage_kind:{anyOf:[{$ref:"#/$defs/LcmStorageKindV1"},{type:"null"}]},store_id:{format:"int64",type:["integer","null"]},summary_token_count:{format:"int64",type:["integer","null"]}},required:["source_kind","source_ref"],type:"object"},LcmDescribeSummaryNodeV1:{additionalProperties:!1,properties:{children:{items:{$ref:"#/$defs/LcmDescribeSourceOverviewV1"},type:"array"},conversation_id:{type:"string"},created_at:{format:"int64",type:"integer"},depth:{format:"int64",type:"integer"},expand_hint:{type:["string","null"]},metadata_json:{type:["string","null"]},node_id:{type:"string"},source_count:{format:"uint",minimum:0,type:"integer"},source_time_end:{format:"int64",type:["integer","null"]},source_time_start:{format:"int64",type:["integer","null"]},source_token_count:{format:"int64",type:"integer"},summary_token_count:{format:"int64",type:"integer"}},required:["node_id","conversation_id","depth","summary_token_count","source_token_count","created_at","source_count","children"],type:"object"},LcmDescriptionV1:{additionalProperties:!1,properties:{external_payload:{anyOf:[{$ref:"#/$defs/LcmDescribeExternalPayloadV1"},{type:"null"}]},external_payload_count:{format:"int64",type:"integer"},first_store_id:{format:"int64",type:["integer","null"]},last_store_id:{format:"int64",type:["integer","null"]},provider:{type:"string"},raw_message_count:{format:"int64",type:"integer"},raw_messages:{items:{$ref:"#/$defs/LcmRawMessageOverviewV1"},type:"array"},session_id:{type:"string"},session_token_estimate:{format:"int64",type:["integer","null"]},summary_node:{anyOf:[{$ref:"#/$defs/LcmDescribeSummaryNodeV1"},{type:"null"}]},summary_node_count:{format:"int64",type:"integer"},summary_nodes:{items:{$ref:"#/$defs/LcmSummaryNodeOverviewV1"},type:"array"},target:{type:"string"},unpublished_message_count:{description:"Raw messages the session's active temporal generation has not\npublished; transcript reads cannot page them yet.",format:"int64",type:"integer"}},required:["target","provider","session_id","raw_message_count","unpublished_message_count","summary_node_count","external_payload_count","raw_messages","summary_nodes"],type:"object"},LcmRawMessageOverviewV1:{additionalProperties:!1,properties:{content_preview:{type:"string"},content_range:{$ref:"#/$defs/LcmContentRangeV1"},message_id:{type:"string"},payload_ref:{type:["string","null"]},role:{type:"string"},storage_kind:{$ref:"#/$defs/LcmStorageKindV1"},store_id:{format:"int64",type:"integer"}},required:["message_id","store_id","role","storage_kind","content_preview","content_range"],type:"object"},LcmRetrievalOutcomeV1:g4,LcmSourceRefV1:g6,LcmStorageKindV1:g3,LcmSummaryNodeOverviewV1:{additionalProperties:!1,properties:{conversation_id:{type:"string"},created_at:{format:"int64",type:"integer"},depth:{format:"int64",type:"integer"},node_id:{type:"string"},source_count:{format:"uint",minimum:0,type:"integer"},summary_preview:{type:"string"}},required:["node_id","conversation_id","depth","summary_preview","source_count","created_at"],type:"object"},LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalFreshnessV1:bA,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},description:{anyOf:[{$ref:"#/$defs/LcmDescriptionV1"},{type:"null"}]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},grain:{type:["string","null"]},lineage:{items:{$ref:"#/$defs/CompactLineageEdgeV1"},type:["array","null"]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},retrieval:{anyOf:[{$ref:"#/$defs/LcmRetrievalOutcomeV1"},{type:"null"}]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},session_id:{type:["string","null"]},state:{anyOf:[{$ref:"#/$defs/HydrationStateResultV1"},{type:"null"}]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status"],title:"LcmDescribeResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,title:"LcmDoctorRequestV1",type:"object"},{$defs:{LcmAuthorityOutcomeV1:gZ,LcmConvergenceStateV1:gX,LcmConvergenceV1:gY,LcmDoctorFindingKindV1:{enum:["trigger_audit_drift","occurrence_fts_corruption","summary_fts_corruption","missing_anchor","missing_receipt","invalid_generation","multi_active_generation","cursor_chain_absent","cursor_key_absent","ownership_drift","stuck_refresh","stuck_binding","stuck_progress","stuck_receipt","migration_gap","compatibility_drift","relation_graph_unavailable","relation_graph_corruption","relation_graph_cycle","stale_summary_closure"],type:"string"},LcmDoctorFindingV1:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},kind:{$ref:"#/$defs/LcmDoctorFindingKindV1"}},required:["kind","count"],type:"object"},LcmDoctorHealthStatusV1:{enum:["complete","partial","unavailable","locked"],type:"string"},LcmDoctorHealthV1:{additionalProperties:!1,properties:{findings:{items:{$ref:"#/$defs/LcmDoctorFindingV1"},type:"array"},reason:{type:["string","null"]},status:{$ref:"#/$defs/LcmDoctorHealthStatusV1"}},required:["status","findings"],type:"object"},LcmDoctorProjectionStateV1:g1,LcmDoctorProjectionV1:g0,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{authority_outcome:{$ref:"#/$defs/LcmAuthorityOutcomeV1"},health:{anyOf:[{$ref:"#/$defs/LcmDoctorHealthV1"},{type:"null"}]},projection:{anyOf:[{$ref:"#/$defs/LcmDoctorProjectionV1"},{type:"null"}],description:"Absent when the diagnosed store has no refresh worker (profile mounts)."},reason:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"}},required:["status","authority_outcome"],title:"LcmDoctorResultV1",type:"object"},{$defs:{LcmExpandTargetV1:{oneOf:[{properties:{kind:{const:"canonical_occurrence",type:"string"},message_id:{type:"string"}},required:["kind","message_id"],type:"object"},{properties:{kind:{const:"raw_message",type:"string"},store_id:{format:"uint64",minimum:0,type:"integer"}},required:["kind","store_id"],type:"object"},{properties:{kind:{const:"summary_node",type:"string"},node_id:{type:"string"}},required:["kind","node_id"],type:"object"},{properties:{kind:{const:"external_payload",type:"string"},payload_ref:{type:"string"}},required:["kind","payload_ref"],type:"object"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{content_limit:{format:"uint64",minimum:0,type:["integer","null"]},content_offset:{format:"uint64",minimum:0,type:["integer","null"]},cursor:{type:["string","null"]},provider:{type:"string"},session_id:{type:"string"},source_limit:{format:"uint64",minimum:0,type:["integer","null"]},target:{$ref:"#/$defs/LcmExpandTargetV1"}},required:["provider","session_id","target"],title:"LcmExpandRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,HydrationStateResultV1:gG,LcmContentRangeV1:gQ,LcmExpandedSourceV1:{additionalProperties:!1,properties:{content:{type:"string"},content_range:{anyOf:[{$ref:"#/$defs/LcmContentRangeV1"},{type:"null"}]},content_truncated:{type:"boolean"},raw_message:{anyOf:[{$ref:"#/$defs/LcmRawMessageV1"},{type:"null"}]},raw_message_metadata:{anyOf:[{$ref:"#/$defs/LcmRawMessageMetadataV1"},{type:"null"}]},source_ref:{$ref:"#/$defs/LcmSourceRefV1"},state:{$ref:"#/$defs/HydrationStateResultV1"},summary_node:{anyOf:[{$ref:"#/$defs/LcmSummaryNodeV1"},{type:"null"}]}},required:["source_ref","state","content","content_truncated"],type:"object"},LcmExpansionV1:{additionalProperties:!1,properties:{content:{type:"string"},content_range:{$ref:"#/$defs/LcmContentRangeV1"},from_current_session:{type:["boolean","null"]},kind:{type:"string"},payload_ref:{type:["string","null"]},raw_message:{anyOf:[{$ref:"#/$defs/LcmRawMessageV1"},{type:"null"}]},raw_message_metadata:{anyOf:[{$ref:"#/$defs/LcmRawMessageMetadataV1"},{type:"null"}]},source_pagination:{anyOf:[{$ref:"#/$defs/LcmSourcePaginationV1"},{type:"null"}]},summary_node:{anyOf:[{$ref:"#/$defs/LcmSummaryNodeV1"},{type:"null"}]},summary_sources:{items:{$ref:"#/$defs/LcmExpandedSourceV1"},type:"array"}},required:["kind","content","content_range","summary_sources"],type:"object"},LcmRawMessageMetadataV1:{additionalProperties:!1,properties:{content_hash:{type:"string"},message_id:{type:"string"},metadata_json:{type:["string","null"]},ordinal:{format:"int64",type:"integer"},payload_ref:{type:["string","null"]},provider:{type:"string"},role:{type:"string"},session_id:{type:"string"},storage_kind:{$ref:"#/$defs/LcmStorageKindV1"},store_id:{format:"int64",type:"integer"},timestamp:{format:"int64",type:["integer","null"]}},required:["provider","message_id","session_id","store_id","role","ordinal","content_hash","storage_kind"],type:"object"},LcmRawMessageV1:g2,LcmRetrievalOutcomeV1:g4,LcmSourcePaginationV1:{additionalProperties:!1,properties:{has_more:{type:"boolean"},remaining_sources:{format:"uint",minimum:0,type:"integer"},returned_sources:{format:"uint",minimum:0,type:"integer"},source_limit:{format:"uint",minimum:0,type:"integer"},total_sources:{format:"uint",minimum:0,type:"integer"}},required:["source_limit","returned_sources","total_sources","has_more","remaining_sources"],type:"object"},LcmSourceRefV1:g6,LcmStorageKindV1:g3,LcmSummaryNodeV1:g8,LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalFreshnessV1:bA,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},expansion:{anyOf:[{$ref:"#/$defs/LcmExpansionV1"},{type:"null"}]},grain:{type:["string","null"]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},retrieval:{anyOf:[{$ref:"#/$defs/LcmRetrievalOutcomeV1"},{type:"null"}]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},session_id:{type:["string","null"]},state:{anyOf:[{$ref:"#/$defs/HydrationStateResultV1"},{type:"null"}]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status"],title:"LcmExpandResultV1",type:"object"},{$defs:{LcmNodeIdV1:{anyOf:[{type:"string"},{format:"uint64",minimum:0,type:"integer"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{context_max_tokens:{format:"uint64",minimum:0,type:["integer","null"]},cursor:{type:["string","null"]},max_results:{format:"uint64",minimum:0,type:["integer","null"]},max_tokens:{format:"uint64",minimum:0,type:["integer","null"]},node_ids:{items:{$ref:"#/$defs/LcmNodeIdV1"},type:["array","null"]},prompt:{type:"string"},provider:{type:"string"},query:{type:["string","null"]},session_id:{type:"string"}},required:["provider","session_id","prompt"],title:"LcmExpandQueryRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,HydrationStateResultV1:gG,LcmContentRangeV1:gQ,LcmExpandQueryBudgetV1:{additionalProperties:!1,properties:{requested_max_chars:{format:"uint",minimum:0,type:"integer"},used_chars:{format:"uint",minimum:0,type:"integer"}},required:["requested_max_chars","used_chars"],type:"object"},LcmExpandQueryContextBlockV1:{additionalProperties:!1,properties:{content:{type:"string"},content_range:{$ref:"#/$defs/LcmContentRangeV1"},kind:{type:"string"},node_id:{type:["string","null"]},raw_message:{anyOf:[{$ref:"#/$defs/LcmRawMessageV1"},{type:"null"}]},source_ref:{anyOf:[{$ref:"#/$defs/LcmSourceRefV1"},{type:"null"}]},summary_node:{anyOf:[{$ref:"#/$defs/LcmSummaryNodeV1"},{type:"null"}]}},required:["kind","content","content_range"],type:"object"},LcmExpandQueryMatchV1:{additionalProperties:!1,properties:{kind:{type:"string"},node_id:{type:["string","null"]},snippet:{type:"string"},store_id:{format:"int64",type:["integer","null"]}},required:["kind","snippet"],type:"object"},LcmExpandQueryPaginationV1:{additionalProperties:!1,properties:{has_more:{type:"boolean"},kind:{type:"string"},next_content_offset:{format:"uint64",minimum:0,type:["integer","null"]},node_id:{type:["string","null"]},source_ref:{anyOf:[{$ref:"#/$defs/LcmSourceRefV1"},{type:"null"}]},state:{anyOf:[{$ref:"#/$defs/HydrationStateResultV1"},{type:"null"}]}},required:["kind","has_more"],type:"object"},LcmExpandQuerySynthesisPromptV1:{additionalProperties:!1,properties:{system:{type:"string"},user:{type:"string"},user_prompt_truncated_for_mcp:{type:["boolean","null"]}},required:["system","user"],type:"object"},LcmRawMessageV1:g2,LcmSourceRefV1:g6,LcmStorageKindV1:g3,LcmSummaryNodeV1:g8,LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{answer:{type:["string","null"]},capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},context_blocks:{items:{$ref:"#/$defs/LcmExpandQueryContextBlockV1"},type:"array"},context_budget:{anyOf:[{$ref:"#/$defs/LcmExpandQueryBudgetV1"},{type:"null"}]},context_max_tokens:{format:"uint",minimum:0,type:["integer","null"]},context_pagination:{items:{$ref:"#/$defs/LcmExpandQueryPaginationV1"},type:["array","null"]},context_truncated:{type:["boolean","null"]},contract_truncated:{type:["boolean","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},matches:{items:{$ref:"#/$defs/LcmExpandQueryMatchV1"},type:["array","null"]},max_tokens:{format:"uint",minimum:0,type:["integer","null"]},mcp_response_truncated:{type:["boolean","null"]},mcp_truncation_reason:{type:["string","null"]},needs_synthesis:{type:["boolean","null"]},node_ids:{items:{type:"string"},type:["array","null"]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},prompt:{type:["string","null"]},prompt_truncated_for_mcp:{type:["boolean","null"]},provider:{type:["string","null"]},query:{type:["string","null"]},query_truncated_for_mcp:{type:["boolean","null"]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},session_id:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},synthesis_prompt:{anyOf:[{$ref:"#/$defs/LcmExpandQuerySynthesisPromptV1"},{type:"null"}]},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status","context_blocks"],title:"LcmExpandQueryResultV1",type:"object"},{$defs:{LcmGrepSortV1:{enum:["recency","relevance","hybrid"],type:"string"},LcmRoleV1:{enum:["system","user","assistant","tool","unknown"],type:"string"},LcmSearchScopeV1:{enum:["current","session","all"],type:"string"},MessageRelationshipScopeV1:_m,MessageTypeFilterV1:_f,RetainedTimeFilterV1:vq,TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{branch:{type:["string","null"]},commit:{type:["string","null"]},cursor:{type:["string","null"]},end_time:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},include_summaries:{type:["boolean","null"]},limit:{format:"uint64",minimum:0,type:["integer","null"]},message_type:{anyOf:[{$ref:"#/$defs/MessageTypeFilterV1"},{type:"null"}]},provider:{type:["string","null"]},query:{type:"string"},relationship_scope:{anyOf:[{$ref:"#/$defs/MessageRelationshipScopeV1"},{type:"null"}]},role:{anyOf:[{$ref:"#/$defs/LcmRoleV1"},{type:"null"}]},scope:{anyOf:[{$ref:"#/$defs/LcmSearchScopeV1"},{type:"null"}]},session_id:{type:["string","null"]},sort:{anyOf:[{$ref:"#/$defs/LcmGrepSortV1"},{type:"null"}]},source:{type:["string","null"]},start_time:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},temporal_mode:{anyOf:[{$ref:"#/$defs/TemporalModeV1"},{type:"null"}]},worktree:{type:["string","null"]}},required:["query"],title:"LcmGrepRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,HydrationStateResultV1:gG,LcmGrepHitV1:{additionalProperties:!1,properties:{kind:{type:"string"},message_id:{type:["string","null"]},node_id:{type:["string","null"]},provider:{type:"string"},role:{type:["string","null"]},score:{format:"double",type:"number"},session_id:{type:"string"},snippet:{type:"string"},store_id:{format:"int64",type:["integer","null"]}},required:["kind","provider","session_id","snippet","score"],type:"object"},LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},count:{format:"uint",minimum:0,type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},hits:{items:{$ref:"#/$defs/LcmGrepHitV1"},type:"array"},message_type:{type:["string","null"]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},query:{type:["string","null"]},relationship_scope:{type:["string","null"]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},sort:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status","hits"],title:"LcmGrepResultV1",type:"object"},{$defs:{TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{content_limit:{format:"uint64",minimum:0,type:["integer","null"]},content_offset:{format:"uint64",minimum:0,type:["integer","null"]},cursor:{type:["string","null"]},end_time:{format:"uint64",minimum:0,type:["integer","null"]},limit:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},role:{type:["string","null"]},roles:{items:{type:"string"},type:["array","null"]},session_id:{type:"string"},start_time:{format:"uint64",minimum:0,type:["integer","null"]},temporal_mode:{anyOf:[{$ref:"#/$defs/TemporalModeV1"},{type:"null"}]}},required:["session_id"],title:"LcmLoadSessionRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,HydrationStateResultV1:gG,LcmContentRangeV1:gQ,LcmMessageV1:{additionalProperties:!1,properties:{content:{type:"string"},content_hash:{type:["string","null"]},content_range:{$ref:"#/$defs/LcmContentRangeV1"},message_id:{type:"string"},metadata_json:{type:["string","null"]},ordinal:{format:"int64",type:"integer"},payload_ref:{type:["string","null"]},provider:{type:"string"},role:{type:"string"},session_id:{type:"string"},storage_kind:{$ref:"#/$defs/LcmStorageKindV1"},store_id:{format:"int64",type:["integer","null"]},timestamp:{format:"int64",type:["integer","null"]}},required:["provider","message_id","session_id","role","ordinal","content","content_range","storage_kind"],type:"object"},LcmStorageKindV1:g3,LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},content_limit:{format:"uint",minimum:0,type:["integer","null"]},content_limit_clamped_from:{format:"uint",minimum:0,type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},messages:{items:{$ref:"#/$defs/LcmMessageV1"},type:"array"},omitted:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},session_id:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status","messages"],title:"LcmLoadSessionResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{deep:{type:["boolean","null"]},provider:{type:["string","null"]},session_id:{type:["string","null"]}},title:"LcmStatusRequestV1",type:"object"},{$defs:{LcmAuthorityOutcomeV1:gZ,LcmConfigStatusV1:{additionalProperties:!1,properties:{compression_boundary_cooldown_seconds:{format:"int64",type:"integer"},fresh_tail_count:{format:"uint",minimum:0,type:"integer"},summary_fan_in:{format:"uint",minimum:0,type:"integer"}},required:["fresh_tail_count","summary_fan_in","compression_boundary_cooldown_seconds"],type:"object"},LcmConvergenceStateV1:gX,LcmConvergenceV1:gY,LcmDagDepthStatusV1:{additionalProperties:!1,properties:{count:{format:"int64",type:"integer"},source_tokens:{format:"int64",type:"integer"},tokens:{format:"int64",type:"integer"}},required:["count","tokens","source_tokens"],type:"object"},LcmDagStatusV1:{additionalProperties:!1,properties:{compression_ratio:{type:"string"},depths:{additionalProperties:{$ref:"#/$defs/LcmDagDepthStatusV1"},type:"object"},total_nodes:{format:"int64",type:"integer"},total_source_tokens:{format:"int64",type:"integer"},total_tokens:{format:"int64",type:"integer"}},required:["total_nodes","total_tokens","total_source_tokens","compression_ratio","depths"],type:"object"},LcmDoctorProjectionStateV1:g1,LcmDoctorProjectionV1:g0,LcmLifecycleStatusV1:{additionalProperties:!1,properties:{current_frontier_store_id:{format:"int64",type:["integer","null"]},current_session_id:{type:["string","null"]},frontier_count:{format:"int64",type:"integer"},last_finalized_frontier_store_id:{format:"int64",type:["integer","null"]},last_finalized_session_id:{type:["string","null"]},lifecycle_state_count:{format:"int64",type:"integer"},maintenance_debt_count:{format:"int64",type:"integer"}},required:["lifecycle_state_count","frontier_count","maintenance_debt_count"],type:"object"},LcmPayloadCoverageStateV1:{enum:["complete","partial"],type:"string"},LcmPayloadCoverageV1:{additionalProperties:!1,properties:{reason:{type:["string","null"]},scanned_files:{format:"int64",type:"integer"},scanned_metadata_refs:{format:"int64",type:"integer"},state:{$ref:"#/$defs/LcmPayloadCoverageStateV1"}},required:["state","scanned_metadata_refs","scanned_files"],type:"object"},LcmPayloadGcStatusV1:{additionalProperties:!1,properties:{grace_seconds:{format:"int64",type:"integer"},last_gc_at:{format:"int64",type:["integer","null"]},last_gc_duration_ms:{format:"uint64",minimum:0,type:["integer","null"]},last_gc_error:{type:["string","null"]},last_gc_status:{type:["string","null"]},last_reaped_bytes:{format:"uint64",minimum:0,type:["integer","null"]},last_reaped_refs:{format:"int64",type:["integer","null"]},next_run_eligible_at:{format:"int64",type:["integer","null"]},reap_missing_metadata_after_seconds:{format:"int64",type:"integer"}},required:["grace_seconds","reap_missing_metadata_after_seconds"],type:"object"},LcmPayloadStatusV1:{additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/LcmPayloadCoverageV1"},externalized_count:{format:"int64",type:"integer"},gc_candidate_count:{format:"int64",type:"integer"},integrity_mismatch_count:{format:"int64",type:["integer","null"]},missing_count:{format:"int64",type:"integer"},missing_placeholder_file_count:{format:"int64",type:"integer"},missing_placeholder_metadata_count:{format:"int64",type:"integer"},orphan_file_bytes:{format:"uint64",minimum:0,type:"integer"},orphan_file_count:{format:"int64",type:"integer"},placeholder_ref_count:{format:"int64",type:"integer"},reclaimable_bytes:{format:"uint64",minimum:0,type:"integer"},reclaimable_bytes_after_grace:{format:"uint64",minimum:0,type:"integer"},referenced_bytes:{format:"uint64",minimum:0,type:"integer"},referenced_count:{format:"int64",type:"integer"},root_contained:{type:"boolean"},tombstoned_count:{format:"int64",type:"integer"},total_bytes:{format:"uint64",minimum:0,type:"integer"},unreferenced_count:{format:"int64",type:"integer"}},required:["coverage","externalized_count","missing_count","unreferenced_count","placeholder_ref_count","missing_placeholder_metadata_count","missing_placeholder_file_count","gc_candidate_count","root_contained","orphan_file_count","tombstoned_count","referenced_count","total_bytes","referenced_bytes","orphan_file_bytes","reclaimable_bytes","reclaimable_bytes_after_grace"],type:"object"},LcmRedactionStatusV1:{additionalProperties:!1,properties:{enabled:{type:"boolean"},lossy_records:{format:"int64",type:"integer"}},required:["enabled","lossy_records"],type:"object"},LcmStatusV1:{additionalProperties:!1,properties:{config:{$ref:"#/$defs/LcmConfigStatusV1"},dag:{$ref:"#/$defs/LcmDagStatusV1"},external_payload_count:{format:"int64",type:"integer"},lifecycle:{$ref:"#/$defs/LcmLifecycleStatusV1"},maintenance_debt_count:{format:"int64",type:"integer"},missing_payload_count:{format:"int64",type:"integer"},payload:{$ref:"#/$defs/LcmPayloadStatusV1"},payload_gc:{$ref:"#/$defs/LcmPayloadGcStatusV1"},raw_message_count:{format:"int64",type:"integer"},redaction:{$ref:"#/$defs/LcmRedactionStatusV1"},schema_version:{format:"int64",type:"integer"},store:{$ref:"#/$defs/LcmStoreStatusV1"},summary_convergence:{$ref:"#/$defs/LcmSummaryConvergenceStatusV1"},summary_node_count:{format:"int64",type:"integer"},unreferenced_payload_count:{format:"int64",type:"integer"}},required:["schema_version","raw_message_count","summary_node_count","external_payload_count","missing_payload_count","unreferenced_payload_count","maintenance_debt_count","store","dag","config","payload","payload_gc","lifecycle","summary_convergence","redaction"],type:"object"},LcmStoreStatusV1:{additionalProperties:!1,properties:{estimated_tokens:{format:"int64",type:"integer"},messages:{format:"int64",type:"integer"},token_estimate:{$ref:"#/$defs/LcmStoreTokenCoverageV1"}},required:["messages","estimated_tokens","token_estimate"],type:"object"},LcmStoreTokenCoverageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},next_after_store_id:{format:"int64",type:["integer","null"]},scanned_messages:{format:"int64",type:"integer"}},required:["complete","scanned_messages"],type:"object"},LcmSummaryConvergenceReasonV1:{additionalProperties:!1,properties:{reason:{type:"string"},session_count:{format:"int64",type:"integer"},state:{$ref:"#/$defs/LcmSummaryConvergenceStateV1"}},required:["state","reason","session_count"],type:"object"},LcmSummaryConvergenceStateV1:{enum:["pending","retryable","current","unavailable","permanent"],type:"string"},LcmSummaryConvergenceStatusV1:{additionalProperties:!1,description:"Retained-session summary convergence queue: disjoint per-state session\ncounts and the reasons parked or failed sessions record.",properties:{current_session_count:{format:"int64",type:"integer"},pending_session_count:{format:"int64",type:"integer"},permanent_session_count:{format:"int64",type:"integer"},reasons:{items:{$ref:"#/$defs/LcmSummaryConvergenceReasonV1"},type:"array"},retryable_session_count:{format:"int64",type:"integer"},unavailable_session_count:{format:"int64",type:"integer"}},required:["pending_session_count","retryable_session_count","current_session_count","unavailable_session_count","permanent_session_count","reasons"],type:"object"},RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{authority_outcome:{anyOf:[{$ref:"#/$defs/LcmAuthorityOutcomeV1"},{type:"null"}]},deep:{type:["boolean","null"]},lcm:{anyOf:[{$ref:"#/$defs/LcmStatusV1"},{type:"null"}]},message:{type:["string","null"]},projection:{anyOf:[{$ref:"#/$defs/LcmDoctorProjectionV1"},{type:"null"}],description:"The store's refresh-worker serving and convergence state. Absent when\nno refresh worker serves the store."},provider:{type:["string","null"]},reason:{type:["string","null"]},session_id:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"}},required:["status"],title:"LcmStatusResultV1",type:"object"},{$defs:{MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},title:"MemoryStatusRequestV1",type:"object"},{$defs:{FactCommitOwnerV1:yM,MemoryAlgebraV1:{additionalProperties:!1,properties:{estimated_capacity:{description:"Heuristic D / ln(D) count of bound items one vector can superpose\nbefore cosine similarity degrades. Each fact has its own vector, so\nthis is neither a limit on stored facts nor a recall guarantee.",format:"uint64",minimum:0,type:"integer"},hrr_dim:{description:"Width of each encoded vector.",format:"uint64",minimum:0,type:"integer"},name:{description:"Vector algebra the fact encodings use. Current daemons report `map_c`;\nearlier releases reported `amari_fhrr` for the same encoding.",type:"string"}},required:["name","hrr_dim","estimated_capacity"],type:"object"},MemoryFeedbackFunnelV1:{additionalProperties:!1,properties:{access_count_total:{format:"uint64",minimum:0,type:"integer"},feedback_total:{format:"uint64",minimum:0,type:"integer"},rated_fact_count:{format:"uint64",minimum:0,type:"integer"},retrieval_count_total:{format:"uint64",minimum:0,type:"integer"},retrieved_fact_count:{format:"uint64",minimum:0,type:"integer"},seen_to_feedback_ratio:{format:"uint64",minimum:0,type:["integer","null"]}},required:["retrieval_count_total","access_count_total","retrieved_fact_count","rated_fact_count","feedback_total"],type:"object"},MemoryStatusV1:{additionalProperties:!1,properties:{algebra:{$ref:"#/$defs/MemoryAlgebraV1"},below_default_recall_threshold_count:{format:"uint64",minimum:0,type:"integer"},entity_count:{format:"uint64",minimum:0,type:"integer"},fact_count:{format:"uint64",minimum:0,type:"integer"},feedback_funnel:{$ref:"#/$defs/MemoryFeedbackFunnelV1"},helpful_count:{format:"uint64",minimum:0,type:"integer"},owner:{$ref:"#/$defs/FactCommitOwnerV1"},trust_025_050_count:{format:"uint64",minimum:0,type:"integer"},trust_050_075_count:{format:"uint64",minimum:0,type:"integer"},trust_075_100_count:{format:"uint64",minimum:0,type:"integer"},trust_0_025_count:{format:"uint64",minimum:0,type:"integer"},unhelpful_count:{format:"uint64",minimum:0,type:"integer"}},required:["owner","fact_count","entity_count","algebra","trust_0_025_count","trust_025_050_count","trust_050_075_count","trust_075_100_count","below_default_recall_threshold_count","helpful_count","unhelpful_count","feedback_funnel"],type:"object"},ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{memory:{$ref:"#/$defs/MemoryStatusV1"}},required:["memory"],title:"MemoryStatusResultV1",type:"object"},{$defs:{MessageRelationshipScopeV1:_m,MessageTypeFilterV1:_f,ProjectId:_4,RetainedTimeFilterV1:vq},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_message_search`.",properties:{branch:{type:["string","null"]},commit:{type:["string","null"]},cursor:{type:["string","null"]},goals:{default:!1,type:"boolean"},include_subagents:{type:["boolean","null"]},limit:{format:"uint64",minimum:0,type:["integer","null"]},message_type:{anyOf:[{$ref:"#/$defs/MessageTypeFilterV1"},{type:"null"}]},parent_session_id:{type:["string","null"]},project_key:{type:["string","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},provider:{type:["string","null"]},query:{type:["string","null"]},require_fresh:{description:"Freshness precondition: stale or partial coverage returns\n`refresh_required` instead of stored evidence. The read never refreshes.",type:["boolean","null"]},scope:{anyOf:[{$ref:"#/$defs/MessageRelationshipScopeV1"},{type:"null"}]},since:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},until:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},workflow_agent:{type:["string","null"]},workflow_run:{type:["string","null"]},worktree:{type:["string","null"]}},title:"MessageSearchRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,GitScopeV1:gE,HydrationStateResultV1:gG,MessageSearchHitV1:{additionalProperties:!1,properties:{message:{$ref:"#/$defs/SessionMessageV1"},project_id:{type:["string","null"]},root:{type:["string","null"]},score:{format:"double",type:"number"},session:{$ref:"#/$defs/SessionRecordV1"}},required:["session","message","score"],type:"object"},RetainedErrorV1:vV,RetainedNextActionV1:{additionalProperties:!1,properties:{action:{type:"string"},kind:{type:"string"},reason:{type:"string"},tool:{type:"string"}},required:["kind","tool","action","reason"],type:"object"},RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionMessageV1:{additionalProperties:!1,properties:{kind:{type:["string","null"]},message_id:{type:"string"},metadata_json:{type:["string","null"]},model:{type:["string","null"]},ordinal:{format:"int64",type:"integer"},provider:{type:"string"},role:{type:"string"},session_id:{type:"string"},source_offset:{format:"int64",type:["integer","null"]},source_path:{type:["string","null"]},text:{type:"string"},timestamp:{format:"int64",type:["integer","null"]},tool_names:{type:["string","null"]}},required:["provider","message_id","session_id","role","ordinal","text"],type:"object"},SessionRecordV1:{additionalProperties:!1,properties:{agent_id:{type:["string","null"]},ended_at:{format:"int64",type:["integer","null"]},is_subagent:{type:"boolean"},metadata_json:{type:["string","null"]},parent_session_id:{type:["string","null"]},parent_tool_use_id:{type:["string","null"]},project_key:{type:"string"},project_path:{type:"string"},provider:{type:"string"},session_id:{type:"string"},started_at:{format:"int64",type:["integer","null"]},title:{type:["string","null"]},transcript_path:{type:["string","null"]}},required:["provider","session_id","project_key","project_path","is_subagent"],type:"object"},SessionSourceCoverageV1:bn,TemporalCoverageOmissionV1:{oneOf:[{properties:{detail:{type:"string"},kind:{const:"root_continuation_unavailable",type:"string"},strict_population:{$ref:"#/$defs/TemporalPopulationCountV1"}},required:["kind","strict_population","detail"],type:"object"}]},TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalFreshnessV1:bA,TemporalMetadataV1:{additionalProperties:!1,properties:{anchors:{items:{type:"string"},type:"array"},coverage:{$ref:"#/$defs/TemporalCoverageV1"},coverage_omissions:{items:{$ref:"#/$defs/TemporalCoverageOmissionV1"},type:"array"},explanations:{items:{$ref:"#/$defs/TemporalExplanationV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/TemporalFreshnessV1"},{type:"null"}]},next_cursor:{type:["string","null"]},omissions:{items:{$ref:"#/$defs/TemporalOmissionV1"},type:"array"},source_coverage:{items:{$ref:"#/$defs/SessionSourceCoverageV1"},type:"array"},watermarks:{$ref:"#/$defs/TemporalWatermarksV1"}},required:["anchors","watermarks","coverage","explanations"],type:"object"},TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalPopulationCountV1:{oneOf:[{properties:{count:{format:"uint64",minimum:0,type:"integer"},kind:{const:"exact",type:"string"}},required:["kind","count"],type:"object"},{properties:{count:{format:"uint64",minimum:0,type:"integer"},kind:{const:"at_least",type:"string"}},required:["kind","count"],type:"object"}]},TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},git_filter:{anyOf:[{$ref:"#/$defs/GitScopeV1"},{type:"null"}]},git_filter_applied:{type:["boolean","null"]},goals:{type:"boolean"},include_subagents:{type:"boolean"},message:{type:["string","null"]},message_type:{type:"string"},next_action:{anyOf:[{$ref:"#/$defs/RetainedNextActionV1"},{type:"null"}]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},outcome:{$ref:"#/$defs/RetainedOutcomeStatusV1"},parent_session_id:{type:["string","null"]},project_key:{type:["string","null"]},provider:{type:"string"},query:{type:["string","null"]},refresh_required:{type:"boolean"},requested_provider:{type:["string","null"]},require_fresh:{type:"boolean"},results:{items:{$ref:"#/$defs/MessageSearchHitV1"},type:["array","null"]},scope:{type:"string"},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},since:{format:"int64",type:["integer","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},store_scope:{type:["string","null"]},temporal:{anyOf:[{$ref:"#/$defs/TemporalMetadataV1"},{type:"null"}]},until:{format:"int64",type:["integer","null"]},workflow_agent:{type:["string","null"]},workflow_filter_applied:{type:["boolean","null"]},workflow_run:{type:["string","null"]},workflow_run_parent_session:{type:["string","null"]}},required:["require_fresh","goals","include_subagents","message_type","outcome","provider","refresh_required","scope","status"],title:"MessageSearchResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{path:{type:"string"}},required:["path"],title:"ModuleApiPrimitiveRequest",type:"object"},{$defs:{SymbolPrimitiveRecord:bI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{path:{type:"string"},symbols:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"}},required:["path","symbols"],title:"ModuleApiPrimitiveResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_move_symbol`.",properties:{dest_file:{type:"string"},dry_run:{default:!0,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},symbol:{type:"string"}},required:["symbol","dest_file"],title:"MoveSymbolSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_multi_str_replace`.",properties:{dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},path:{type:"string"},replacements:{description:"Ordered `[old, new]` pairs, matching the existing MCP tool wire form.",items:{maxItems:2,minItems:2,prefixItems:[{type:"string"},{type:"string"}],type:"array"},type:"array"},verify:{default:!1,type:"boolean"}},required:["path","replacements"],title:"MultiStrReplaceSurfaceRequestV1",type:"object"},{$defs:{NativeIntegrationTransactionId:_T},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"}},required:["transaction_id"],title:"NativeIntegrationStatusSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{node_id:{type:"string"}},required:["node_id"],title:"NodeSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComplexityAnalysisV1:hx,NodeDetailsV1:{additionalProperties:!1,properties:{branches:{description:"Exact counters; `None`, and listed in `unavailable_fields`, when\n`complexity_analysis` reports the bounded walk did not cover the body.",format:"uint32",minimum:0,type:["integer","null"]},complexity_analysis:{$ref:"#/$defs/ComplexityAnalysisV1"},cost_to_expand:{$ref:"#/$defs/NodeExpansionCostV1"},cyclomatic_complexity:{format:"uint32",minimum:0,type:["integer","null"]},derives:{items:{type:"string"},type:"array"},docstring:{type:["string","null"]},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},id:{type:"string"},is_async:{type:"boolean"},kind:{type:"string"},loops:{format:"uint32",minimum:0,type:["integer","null"]},max_nesting:{format:"uint32",minimum:0,type:["integer","null"]},name:{type:"string"},qualified_name:{type:"string"},signature:{type:["string","null"]},start_line:{format:"uint32",minimum:0,type:"integer"},unavailable_fields:{items:{type:"string"},type:"array"},visibility:{type:"string"}},required:["id","name","kind","qualified_name","file","start_line","end_line","is_async","derives","visibility","complexity_analysis","cost_to_expand","unavailable_fields"],type:"object"},NodeExpansionCostV1:_A,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveNotFoundV1:_Z,PrimitiveSearchFreshnessV1:_X,PrimitiveSymbolLocationV1:_1},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/NodeDetailsV1"},{$ref:"#/$defs/PrimitiveNotFoundV1"}],title:"NodeResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One project-scoped horizon for the canonical Observatory and Costs models.",properties:{window_days:{default:14,format:"uint16",maximum:365,minimum:1,type:"integer"}},title:"ObservatoryReadRequestV1",type:"object"},{$defs:{AnalyticsModeReadModelV1:fk,AnalyticsModeV1:fw,ComparisonDispositionV1:hI,CostsReadModelV1:yl,CoverageStateV1:yf,LatencyDistributionReadModelV1:gJ,MetricCalibrationV1:_h,MetricCohortV1:_y,MetricCoverageV1:_g,MetricEvidenceClassV1:__,MetricProvenanceV1:_v,MetricSourceV1:_b,MetricTemporalV1:_$,MetricUncertaintyV1:_S,MetricValueV1:_k,ObservabilityHorizonV1:_W,ObservatoryReadModelV1:_N,PerformanceComparisonReadModelV1:_H,ProviderLatencyReadModelV1:vn,RejectedArgumentAnalyticsV1:vh,RejectedArgumentErrorClassV1:vy,RejectedArgumentGroupV1:vg,RejectedArgumentNameV1:v_,RejectedArgumentSurfaceV1:vv},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Canonical project-scoped observability and costs read models.",properties:{costs:{$ref:"#/$defs/CostsReadModelV1"},observatory:{$ref:"#/$defs/ObservatoryReadModelV1"}},required:["observatory","costs"],title:"ObservatoryReadResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kinds:{items:{type:"string"},type:["array","null"]},limit:{format:"uint32",minimum:0,type:["integer","null"]},source_dir:{type:"string"}},required:["source_dir"],title:"PortOrderSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PortCycleAnchorV1:{additionalProperties:!1,properties:{file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},rationale:{type:["string","null"]}},required:["name","file","line"],type:"object"},PortCycleFileV1:{additionalProperties:!1,properties:{file:{type:"string"},members_in_cycle:{format:"uint",minimum:0,type:"integer"}},required:["file","members_in_cycle"],type:"object"},PortCycleSymbolV1:{additionalProperties:!1,properties:{file:{type:"string"},in_cycle_in_degree:{format:"uint",minimum:0,type:"integer"},in_cycle_out_degree:{format:"uint",minimum:0,type:"integer"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","file","line","in_cycle_out_degree","in_cycle_in_degree"],type:"object"},PortCycleV1:{additionalProperties:!1,properties:{break_point_candidate:{anyOf:[{$ref:"#/$defs/PortCycleAnchorV1"},{type:"null"}]},entry_point:{anyOf:[{$ref:"#/$defs/PortCycleAnchorV1"},{type:"null"}]},files:{items:{$ref:"#/$defs/PortCycleFileV1"},type:"array"},note:{type:"string"},size:{format:"uint",minimum:0,type:"integer"},symbols:{items:{$ref:"#/$defs/PortCycleSymbolV1"},type:"array"}},required:["size","files","symbols","note"],type:"object"},PortOrderLevelV1:{additionalProperties:!1,properties:{description:{type:"string"},level:{format:"uint",minimum:0,type:"integer"},symbols:{items:{$ref:"#/$defs/PortOrderSymbolV1"},type:"array"}},required:["level","description","symbols"],type:"object"},PortOrderSymbolV1:{additionalProperties:!1,properties:{depends_on:{items:{type:"string"},type:["array","null"]},file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","file","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cycles:{items:{$ref:"#/$defs/PortCycleV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},levels:{items:{$ref:"#/$defs/PortOrderLevelV1"},type:"array"},returned:{format:"uint",minimum:0,type:"integer"},source_dir:{type:"string"},total_symbols:{format:"uint",minimum:0,type:"integer"}},required:["source_dir","total_symbols","returned","levels","cycles"],title:"PortOrderResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kinds:{items:{type:"string"},type:["array","null"]},source_dir:{type:"string"},target_dir:{type:"string"}},required:["source_dir","target_dir"],title:"PortStatusSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PortMatchedSymbolV1:{additionalProperties:!1,properties:{name:{type:"string"},source_file:{type:"string"},source_kind:{type:"string"},target_file:{type:"string"},target_kind:{type:"string"}},required:["name","source_kind","target_kind","source_file","target_file"],type:"object"},PortTargetOnlySymbolV1:{additionalProperties:!1,properties:{file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","file","line"],type:"object"},PortUnmatchedSymbolV1:{additionalProperties:!1,properties:{kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage_percent:{format:"double",type:"number"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},matched:{format:"uint",minimum:0,type:"integer"},matched_symbols:{items:{$ref:"#/$defs/PortMatchedSymbolV1"},type:"array"},source_count:{format:"uint",minimum:0,type:"integer"},source_dir:{type:"string"},target_count:{format:"uint",minimum:0,type:"integer"},target_dir:{type:"string"},target_only:{format:"uint",minimum:0,type:"integer"},target_only_symbols:{items:{$ref:"#/$defs/PortTargetOnlySymbolV1"},type:"array"},unmatched:{format:"uint",minimum:0,type:"integer"},unmatched_by_file:{additionalProperties:{items:{$ref:"#/$defs/PortUnmatchedSymbolV1"},type:"array"},type:"object"}},required:["source_dir","target_dir","source_count","target_count","matched","unmatched","target_only","coverage_percent","unmatched_by_file","matched_symbols","target_only_symbols"],title:"PortStatusResultV1",type:"object"},{$defs:{PrContextViewV1:_G},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{base_ref:{description:"Base branch or ref (default: the matching retained PR base, otherwise\nthe detected repository default branch). A short branch name selects the descendant of its\nlocal and origin tracking tips; use an explicit ref when they diverge.",type:["string","null"]},budget_tokens:{description:"Approximate whole-result JSON token budget for the brief (default: 4000).\nIn symbols view, budgets the existing symbol, test, and module sections.",format:"uint32",minimum:0,type:["integer","null"]},cursor:{description:"Authenticated continuation cursor; accepted only with view `symbols`.",type:["string","null"]},head_ref:{description:"Head branch or ref (default: 'HEAD'). Accepts local branches,\nremote-tracking refs such as origin/topic, full refs, and Git revision\nexpressions.",type:["string","null"]},maximum_symbols:{description:"Maximum symbols returned on a symbols-view page (default: 200, clamped to 1-500).",format:"uint32",minimum:0,type:["integer","null"]},pull_request:{description:"Select a retained PR number for this checkout when several are known.",format:"uint64",minimum:0,type:["integer","null"]},refresh_github:{default:!1,description:"Explicitly refresh the configured matching GitHub PR within the caller\ndeadline. By default, read retained authorized evidence. CI stays retained.",type:"boolean"},view:{$ref:"#/$defs/PrContextViewV1",default:"brief",description:"Compact PR briefing by default; `symbols` requests exact symbol pages."}},title:"PrContextSurfaceRequestV1",type:"object"},{$defs:{CoChangeUnavailableV1:hf,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ConfigSummaryKindV1:hT,ConfigSummaryV1:hO,GitCommitSubjectV1:{additionalProperties:!1,properties:{hash:{type:"string"},subject:{type:"string"}},required:["hash","subject"],type:"object"},GitComparedSymbolV1:gy,GitContextSymbolV1:g_,GitFileChangeStatusV1:{enum:["added","deleted","modified"],type:"string"},GitFileChangeV1:{additionalProperties:!1,properties:{path:{type:"string"},status:{$ref:"#/$defs/GitFileChangeStatusV1"}},required:["path","status"],type:"object"},GitFileRoleV1:gS,GitReadCompleteV1:gj,GitReadPartialV1:gC,GitReadUnavailableV1:gT,GitToolErrorKindV1:gW,GitToolErrorV1:gM,GitToolFailureV1:gN,GitToolOperationV1:gz,MissingCoChangePartnerV1:_w,PrAnalysisCoverageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},direct_call_edges_admitted:{format:"uint",minimum:0,type:"integer"},impact_bytes_admitted:{format:"uint",minimum:0,type:"integer"},impact_nodes_admitted:{format:"uint",minimum:0,type:"integer"},impact_nodes_returned:{format:"uint",minimum:0,type:"integer"},impact_partial:{type:"boolean"},seed_symbols_analyzed:{format:"uint",minimum:0,type:"integer"},symbols_complete:{type:"boolean"},symbols_returned:{format:"uint",minimum:0,type:"integer"}},required:["seed_symbols_analyzed","symbols_returned","symbols_complete","impact_nodes_admitted","impact_nodes_returned","direct_call_edges_admitted","impact_bytes_admitted","impact_partial","complete"],type:"object"},PrContextAreaV1:{additionalProperties:!1,properties:{additions:{format:"uint64",minimum:0,type:"integer"},area:{type:"string"},deletions:{format:"uint64",minimum:0,type:"integer"},files:{format:"uint",minimum:0,type:"integer"}},required:["area","files","additions","deletions"],type:"object"},PrContextBriefBudgetV1:{additionalProperties:!1,properties:{areas_omitted:{format:"uint",minimum:0,type:"integer"},checks_omitted:{format:"uint",minimum:0,type:"integer"},commits_omitted:{format:"uint",minimum:0,type:"integer"},discussions_omitted:{format:"uint",minimum:0,type:"integer"},entry_points_omitted:{format:"uint",minimum:0,type:"integer"},estimated_tokens:{description:"Whole-result JSON byte estimate, divided by four; not a tokenizer count.",format:"uint32",minimum:0,type:"integer"},files_omitted:{format:"uint",minimum:0,type:"integer"},impact_omitted:{format:"uint",minimum:0,type:"integer"},over_budget:{type:"boolean"},quality_omitted:{format:"uint",minimum:0,type:"integer"},requested_tokens:{format:"uint32",minimum:0,type:"integer"}},required:["requested_tokens","estimated_tokens","over_budget","files_omitted","entry_points_omitted","discussions_omitted","checks_omitted","impact_omitted","commits_omitted","areas_omitted","quality_omitted"],type:"object"},PrContextBriefV1:{additionalProperties:!1,properties:{additions:{format:"uint64",minimum:0,type:"integer"},areas:{items:{$ref:"#/$defs/PrContextAreaV1"},type:"array"},base:{type:"string"},base_oid:{type:"string"},budget:{$ref:"#/$defs/PrContextBriefBudgetV1"},changes:{items:{$ref:"#/$defs/PrContextFileV1"},type:"array"},commits:{items:{$ref:"#/$defs/GitCommitSubjectV1"},type:"array"},deletions:{format:"uint64",minimum:0,type:"integer"},entry_points:{description:"Prioritized places to begin reading the change, with exact revisions.",items:{$ref:"#/$defs/PrContextEntryPointV1"},type:"array"},files_changed:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}]},graph_analysis:{$ref:"#/$defs/PrContextSourceV1"},head:{type:"string"},head_oid:{type:"string"},hosted:{$ref:"#/$defs/PrContextHostedV1"},impact:{items:{$ref:"#/$defs/PrContextImpactV1"},type:"array"},merge_base:{type:"string"},next_steps:{items:{type:"string"},type:"array"},quality:{items:{$ref:"#/$defs/PrContextQualityV1"},type:"array"},source_analysis:{$ref:"#/$defs/PrContextSourceV1"},view:{$ref:"#/$defs/PrContextViewV1"}},required:["view","base","head","base_oid","head_oid","merge_base","files_changed","additions","deletions","commits","hosted","areas","changes","entry_points","impact","quality","source_analysis","graph_analysis","next_steps","budget"],type:"object"},PrContextCheckV1:{additionalProperties:!1,properties:{conclusion:{type:["string","null"]},evidence_anchor:{type:"string"},failed_step:{type:["string","null"]},head:{type:"string"},locations:{items:{$ref:"#/$defs/PrContextLocationV1"},type:"array"},matches_head:{type:"boolean"},name:{type:"string"},observed_at:{format:"int64",type:"integer"},status:{type:"string"},workflow:{type:"string"}},required:["name","workflow","status","head","matches_head","observed_at","evidence_anchor","locations"],type:"object"},PrContextCompleteV1:{additionalProperties:!1,properties:{added:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},affected_tests:{items:{type:"string"},type:"array"},affected_tests_coverage:{$ref:"#/$defs/PrSelectionCoverageV1"},analysis_coverage:{$ref:"#/$defs/PrAnalysisCoverageV1"},base:{type:"string"},base_oid:{type:"string"},changes:{items:{$ref:"#/$defs/GitFileChangeV1"},type:"array"},co_change_unavailable:{anyOf:[{$ref:"#/$defs/CoChangeUnavailableV1"},{type:"null"}],description:"Present when Git history could not be mined for co-change partners."},commits:{items:{$ref:"#/$defs/GitCommitSubjectV1"},type:"array"},files_changed:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},graph_generation:{type:"string"},head:{type:"string"},head_oid:{type:"string"},impacted_modules:{items:{type:"string"},type:"array"},impacted_modules_coverage:{$ref:"#/$defs/PrSelectionCoverageV1"},merge_base:{type:"string"},missing_co_change_partners:{description:"Files that usually change with a changed file, per bounded Git\nhistory, but are absent from this change set.",items:{$ref:"#/$defs/MissingCoChangePartnerV1"},type:"array"},modified:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},next_cursor:{type:["string","null"]},removed:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},status:{$ref:"#/$defs/GitReadCompleteV1"},symbol_changes_coverage:{$ref:"#/$defs/PrSymbolChangesCompleteV1"},symbol_page:{$ref:"#/$defs/PrSymbolPageV1"},symbols_added:{format:"uint",minimum:0,type:"integer"},symbols_modified:{format:"uint",minimum:0,type:"integer"},symbols_removed:{format:"uint",minimum:0,type:"integer"},test_files_changed:{items:{type:"string"},type:"array"},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."}},required:["status","base","head","base_oid","head_oid","merge_base","graph_generation","commits","files_changed","changes","missing_co_change_partners","symbols_added","symbols_removed","symbols_modified","added","removed","modified","symbol_changes_coverage","symbol_page","analysis_coverage","test_files_changed","affected_tests","affected_tests_coverage","impacted_modules","impacted_modules_coverage"],type:"object"},PrContextDiscussionV1:{additionalProperties:!1,properties:{author:{description:"Provider login when retained; an opaque author anchor is not a login.",type:["string","null"]},body_anchor:{type:["string","null"]},event_at:{description:"Provider activity time in UTC microseconds: comment update/creation or\nreview submission. Absent when not retained or not parseable.",format:"int64",type:["integer","null"]},file:{type:["string","null"]},id:{type:"string"},kind:{type:"string"},lifecycle:{type:"string"},line:{format:"uint64",minimum:0,type:["integer","null"]},matches_head:{type:"boolean"},observed_at:{format:"int64",type:"integer"},review_state:{type:"string"},text:{type:["string","null"]},text_truncated:{type:"boolean"},thread_id:{type:["string","null"]},url:{type:["string","null"]}},required:["id","kind","lifecycle","review_state","text_truncated","observed_at","matches_head"],type:"object"},PrContextEntryPointV1:{additionalProperties:!1,properties:{after_excerpt:{anyOf:[{$ref:"#/$defs/PrContextExcerptV1"},{type:"null"}]},after_signature:{type:["string","null"]},after_signature_truncated:{default:!1,type:"boolean"},before_excerpt:{anyOf:[{$ref:"#/$defs/PrContextExcerptV1"},{type:"null"}]},before_signature:{type:["string","null"]},before_signature_truncated:{default:!1,type:"boolean"},change:{type:"string"},location:{$ref:"#/$defs/PrContextLocationV1"},node_id:{description:"Exact-head graph occurrence accepted by source_body and impact.\nAbsent when graph provenance or declaration matching is unavailable.",type:["string","null"]},reason:{type:"string"},revision:{type:"string"},symbol:{type:"string"}},required:["location","revision","symbol","change","reason"],type:"object"},PrContextExcerptV1:{additionalProperties:!1,properties:{location:{$ref:"#/$defs/PrContextLocationV1"},revision:{type:"string"},text:{type:"string"},truncated:{description:"True when this is only an excerpt of the declaration.",type:"boolean"}},required:["revision","location","text","truncated"],type:"object"},PrContextFileV1:{additionalProperties:!1,properties:{additions:{format:"uint32",minimum:0,type:["integer","null"]},change:{type:"string"},deletions:{format:"uint32",minimum:0,type:["integer","null"]},file:{type:"string"},previous_file:{type:["string","null"]},role:{$ref:"#/$defs/GitFileRoleV1"}},required:["file","change","role"],type:"object"},PrContextGraphPendingV1:{additionalProperties:!1,description:"The git comparison while the verified graph generation is still warming.",properties:{added:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},affected_tests:{items:{type:"string"},type:"array"},affected_tests_coverage:{$ref:"#/$defs/PrSelectionCoverageV1"},analysis_coverage:{$ref:"#/$defs/PrAnalysisCoverageV1"},base:{type:"string"},base_oid:{type:"string"},changes:{items:{$ref:"#/$defs/GitFileChangeV1"},type:"array"},co_change_unavailable:{anyOf:[{$ref:"#/$defs/CoChangeUnavailableV1"},{type:"null"}],description:"Present when Git history could not be mined for co-change partners."},commits:{items:{$ref:"#/$defs/GitCommitSubjectV1"},type:"array"},files_changed:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},graph_generation:{description:"No verified generation was admitted.",type:["string","null"]},head:{type:"string"},head_oid:{type:"string"},impacted_modules:{items:{type:"string"},type:"array"},impacted_modules_coverage:{$ref:"#/$defs/PrSelectionCoverageV1"},merge_base:{type:"string"},message:{type:"string"},missing_co_change_partners:{description:"Files that usually change with a changed file, per bounded Git\nhistory, but are absent from this change set.",items:{$ref:"#/$defs/MissingCoChangePartnerV1"},type:"array"},modified:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},next_cursor:{type:["string","null"]},status:{$ref:"#/$defs/GitReadPartialV1"},symbol_page:{$ref:"#/$defs/PrSymbolPageV1"},symbols_added:{format:"uint",minimum:0,type:"integer"},symbols_modified:{format:"uint",minimum:0,type:"integer"},test_files_changed:{items:{type:"string"},type:"array"},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."},verified_graph_evidence:{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"}},required:["status","message","base","head","base_oid","head_oid","merge_base","commits","files_changed","changes","missing_co_change_partners","symbols_added","symbols_modified","added","modified","symbol_page","analysis_coverage","test_files_changed","affected_tests","affected_tests_coverage","impacted_modules","impacted_modules_coverage","verified_graph_evidence"],type:"object"},PrContextHostedV1:{additionalProperties:!1,properties:{checks:{items:{$ref:"#/$defs/PrContextCheckV1"},type:"array"},checks_total:{format:"uint",minimum:0,type:"integer"},ci_source:{$ref:"#/$defs/PrContextSourceV1"},discussions:{items:{$ref:"#/$defs/PrContextDiscussionV1"},type:"array"},discussions_total:{format:"uint",minimum:0,type:"integer"},pull_request:{anyOf:[{$ref:"#/$defs/PrContextPullRequestV1"},{type:"null"}]},required_checks_known:{description:"A retained CI inventory is not an enumeration of required checks.",type:"boolean"},source:{$ref:"#/$defs/PrContextSourceV1"}},required:["source","ci_source","discussions","checks","discussions_total","checks_total","required_checks_known"],type:"object"},PrContextImpactV1:{additionalProperties:!1,properties:{changed_symbol:{type:"string"},consumer:{type:"string"},consumer_changed:{description:"Whether the consumer's file is in the PR diff; this does not imply\nthat the consumer declaration itself changed.",type:"boolean"},location:{$ref:"#/$defs/PrContextLocationV1"},node_id:{description:"Exact-head consumer occurrence accepted by source_body and impact.",type:["string","null"]},relation:{type:"string"}},required:["changed_symbol","consumer","location","relation","consumer_changed"],type:"object"},PrContextLocationV1:{additionalProperties:!1,properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"}},required:["file","line","end_line"],type:"object"},PrContextPullRequestV1:{additionalProperties:!1,properties:{description:{description:"Sanitized retained description, when the provider supplied it.",type:["string","null"]},description_truncated:{type:"boolean"},draft:{type:"boolean"},matches_head:{type:"boolean"},number:{format:"uint64",minimum:0,type:"integer"},observed_at:{format:"int64",type:"integer"},observed_head:{type:"string"},state:{type:"string"},title:{type:"string"}},required:["number","title","state","draft","description_truncated","observed_head","observed_at","matches_head"],type:"object"},PrContextQualityV1:{additionalProperties:!1,properties:{observation:{type:"string"},signal:{type:"string"}},required:["signal","observation"],type:"object"},PrContextSourceStateV1:{enum:["ready","partial","stale","unavailable","not_published","denied","not_mounted","ambiguous","not_found"],type:"string"},PrContextSourceV1:{additionalProperties:!1,properties:{detail:{type:"string"},state:{$ref:"#/$defs/PrContextSourceStateV1"}},required:["state","detail"],type:"object"},PrContextSymbolsUnavailableV1:{additionalProperties:!1,description:"The git comparison while exact base/head symbol comparison is unavailable\nor does not describe the verified graph's head generation.",properties:{added:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},base:{type:"string"},base_oid:{type:"string"},changes:{items:{$ref:"#/$defs/GitFileChangeV1"},type:"array"},co_change_unavailable:{anyOf:[{$ref:"#/$defs/CoChangeUnavailableV1"},{type:"null"}],description:"Present when Git history could not be mined for co-change partners."},commits:{items:{$ref:"#/$defs/GitCommitSubjectV1"},type:"array"},files_changed:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},graph_generation:{type:"string"},head:{type:"string"},head_oid:{type:"string"},merge_base:{type:"string"},message:{type:"string"},missing_co_change_partners:{description:"Files that usually change with a changed file, per bounded Git\nhistory, but are absent from this change set.",items:{$ref:"#/$defs/MissingCoChangePartnerV1"},type:"array"},modified:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},next_cursor:{type:["string","null"]},removed:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},status:{$ref:"#/$defs/GitReadPartialV1"},symbol_changes_coverage:{$ref:"#/$defs/SymbolChangesUnavailableV1"},symbols_added:{format:"uint",minimum:0,type:"integer"},symbols_modified:{format:"uint",minimum:0,type:"integer"},symbols_removed:{format:"uint",minimum:0,type:"integer"},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."}},required:["status","message","base","head","base_oid","head_oid","merge_base","graph_generation","commits","files_changed","changes","missing_co_change_partners","symbols_added","symbols_removed","symbols_modified","added","removed","modified","symbol_changes_coverage"],type:"object"},PrContextViewV1:_G,PrCoverageSelectionV1:{enum:["unavailable","deterministic_bounded_prefix"],type:"string"},PrSelectionCoverageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},selection:{$ref:"#/$defs/PrCoverageSelectionV1"}},required:["complete","selection"],type:"object"},PrSymbolChangesCompleteV1:{additionalProperties:!1,properties:{base_generation:{type:"string"},head_generation:{type:"string"},status:{$ref:"#/$defs/GitReadCompleteV1"}},required:["status","base_generation","head_generation"],type:"object"},PrSymbolEntryV1:{anyOf:[{$ref:"#/$defs/GitContextSymbolV1"},{$ref:"#/$defs/ConfigSummaryV1"}]},PrSymbolPageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},continuation_available:{type:"boolean"},has_more:{type:"boolean"},limit:{format:"uint",minimum:0,type:"integer"},returned:{format:"uint",minimum:0,type:"integer"},selection:{$ref:"#/$defs/PrSymbolSelectionV1"}},required:["limit","returned","has_more","complete","selection","continuation_available"],type:"object"},PrSymbolSelectionV1:{enum:["unavailable","stable_prefix"],type:"string"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,PrimitiveUnavailableEvidenceV1:_0,PrimitiveUnavailableStatusV1:_2,SymbolChangesUnavailableV1:bV,TokenBudgetCutV1:bD,TokenBudgetSectionV1:bF},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/PrContextBriefV1"},{$ref:"#/$defs/PrContextCompleteV1"},{$ref:"#/$defs/PrContextSymbolsUnavailableV1"},{$ref:"#/$defs/PrContextGraphPendingV1"},{$ref:"#/$defs/GitToolFailureV1"}],title:"PrContextResultV1"},{$defs:{BranchStackEdgeV1:f3,BranchStackId:f9,BranchStackNodeV1:f5,BranchStackRevisionId:f8,BranchStackRevisionV1:f7,BranchStackSourceV1:he,CommitId:hq,ManifestDigest:_l,MechanicalIntegrationModeV1:_p,NativeIntegrationDirectionV1:_R,NativeIntegrationSealedStackSnapshotV1:_x,NativeIntegrationSelectionBindingV1:_j,ProjectId:_4,RefId:vm,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,StackNodeId:bw,WorktreeId:SB,WorktreeInventoryEpoch:SK,WorktreeInventorySnapshotId:SJ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Read-only preflight over one frozen snapshot identity.\n\n`preferred_mode` selects only one of the three fixed mechanical encodings.\nIt cannot change topology, commit order, or the commit set.",properties:{preferred_mode:{anyOf:[{$ref:"#/$defs/MechanicalIntegrationModeV1"},{type:"null"}],default:null},snapshot:{$ref:"#/$defs/NativeIntegrationSealedStackSnapshotV1"}},required:["snapshot"],title:"NativeIntegrationPreflightSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{path:{description:"Project path or registered alias to resolve.",type:["string","null"]},project_selector:{additionalProperties:!1,default:null,description:"Registered project id to inspect. Omit to use path or the active\nproject.",properties:{project_id:{description:"Registered project id to query.",type:"string"}},required:["project_id"],type:"object"}},title:"ProjectContextSurfaceRequestV1",type:"object"},{$defs:{PublicCodeProject:va},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One registered project's context, or the registry's typed miss.",oneOf:[{additionalProperties:!1,properties:{aliases:{description:"Alias rows exactly as the registry serializes them.",items:!0,type:"array"},is_active:{type:"boolean"},project:{$ref:"#/$defs/PublicCodeProject"},registry_path:{type:"string"},status:{const:"ok",type:"string"},stores:{description:"Store rows exactly as the registry serializes them.",items:!0,type:"array"}},required:["status","is_active","registry_path","project","aliases","stores"],type:"object"},{additionalProperties:!1,description:"The registry answered and no registered project matches the selector.",properties:{aliases:{items:!0,type:"array"},project:{type:"null"},registry_path:{type:"string"},status:{const:"not_found",type:"string"},stores:{items:!0,type:"array"}},required:["status","registry_path","project","aliases","stores"],type:"object"}],title:"ProjectContextResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum projects to return (default: 25, max: 100).",format:"uint",minimum:0,type:["integer","null"]}},title:"ProjectListSurfaceRequestV1",type:"object"},{$defs:{ProjectRegistryEntry:_6,ProjectRegistrySummary:_3,ProjectRepoGroup:_9,PublicCodeProject:va},$schema:"https://json-schema.org/draft/2020-12/schema",description:"A bounded page of the profile's registered projects.",oneOf:[{additionalProperties:!1,properties:{limit:{format:"uint",minimum:0,type:"integer"},project_tree:{items:{$ref:"#/$defs/ProjectRepoGroup"},type:"array"},projects:{items:{$ref:"#/$defs/PublicCodeProject"},type:"array"},query:{type:["string","null"]},registry_path:{type:"string"},status:{const:"ok",type:"string"},summary:{$ref:"#/$defs/ProjectRegistrySummary"},title:{type:"string"},truncated:{type:"boolean"}},required:["status","title","registry_path","limit","truncated","summary","project_tree","projects"],type:"object"}],title:"ProjectRegistryListingResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum projects to return (default: 10, max: 50).",format:"uint",minimum:0,type:["integer","null"]},query:{description:"Case-insensitive substring query over registry project metadata.",type:"string"}},required:["query"],title:"ProjectSearchSurfaceRequestV1",type:"object"},{$defs:{PageRequest:_U},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{page:{$ref:"#/$defs/PageRequest"},qualified_name:{type:"string"}},required:["qualified_name","page"],title:"QualifiedNamePrimitiveRequest",type:"object"},{$defs:{SymbolPrimitiveRecord:bI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},symbols:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["symbols"],title:"QualifiedNamePrimitiveResult",type:"object"},{$defs:{RankDirectionV1:vc,RankEdgeKindV1:vl},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{direction:{anyOf:[{$ref:"#/$defs/RankDirectionV1"},{type:"null"}],description:"Edge direction: 'incoming' ranks targets (default, e.g.\nmost-implemented interface), 'outgoing' ranks sources (e.g. class that\nimplements the most interfaces)."},edge_kind:{$ref:"#/$defs/RankEdgeKindV1",description:"The relationship type to rank by (e.g. 'implements' to find\nmost-implemented interfaces)."},limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},node_kind:{description:"Optional filter for node kind (e.g. 'interface', 'class', 'trait',\n'function', 'method').",type:["string","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},required:["edge_kind"],title:"RankSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RankDirectionV1:vc,RankEdgeKindV1:vl,RankEntryV1:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line","count"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{direction:{$ref:"#/$defs/RankDirectionV1"},edge_kind:{$ref:"#/$defs/RankEdgeKindV1"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},node_kind_filter:{type:["string","null"]},ranking:{items:{$ref:"#/$defs/RankEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["edge_kind","direction","result_count","ranking"],title:"RankResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of cycles to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"RecursionSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RecursionCycleV1:{additionalProperties:!1,description:"One call cycle; `chain` repeats its first symbol at the end.",properties:{chain:{items:{$ref:"#/$defs/RecursionSymbolV1"},type:"array"},length:{format:"uint64",minimum:0,type:"integer"}},required:["length","chain"],type:"object"},RecursionSymbolV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cycle_count:{format:"uint64",minimum:0,type:"integer"},cycles:{items:{$ref:"#/$defs/RecursionCycleV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."}},required:["cycle_count","cycles"],title:"RecursionResultV1",type:"object"},{$defs:{CommitId:hq,ProjectId:_4,ProviderId:vo,RedundancyScopeV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"repository",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"path",type:"string"},path:{type:"string"}},required:["kind","path"],type:"object"},{additionalProperties:!1,properties:{changed_paths:{items:{type:"string"},type:"array"},head_commit_id:{$ref:"#/$defs/CommitId"},kind:{const:"pull_request",type:"string"},provider:{$ref:"#/$defs/ProviderId"},pull_request_id:{type:"string"}},required:["kind","provider","pull_request_id","head_commit_id","changed_paths"],type:"object"}]},RepositoryId:vb,SimilarMatchClassV1:bc},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{type:["string","null"]},family_limit:{description:"Preferred family page size, 1 through 100.",format:"uint32",maximum:100,minimum:1,type:"integer"},include_generated_paths:{type:"boolean"},match_classes:{items:{$ref:"#/$defs/SimilarMatchClassV1"},type:"array"},member_limit:{description:"Members listed per family, at least 2.",format:"uint32",minimum:2,type:"integer"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},scope:{$ref:"#/$defs/RedundancyScopeV1"},work_limit:{description:"Clone-index work budget for this page, 3 through 10000. A page that\nexhausts it reports partial coverage.",format:"uint32",maximum:1e4,minimum:3,type:"integer"}},required:["project_id","repository_id","match_classes","scope","include_generated_paths","family_limit","member_limit","work_limit"],title:"RedundancySurfaceRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ManifestDigest:_l,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,ProjectId:_4,RedundancyCoverageV1:{oneOf:[{additionalProperties:!1,properties:{examined_families:{format:"uint",minimum:0,type:"integer"},examined_members:{format:"uint",minimum:0,type:"integer"},status:{const:"complete",type:"string"}},required:["status","examined_families","examined_members"],type:"object"},{additionalProperties:!1,properties:{examined_families:{format:"uint",minimum:0,type:"integer"},examined_members:{format:"uint",minimum:0,type:"integer"},reason:{$ref:"#/$defs/RedundancyPartialReasonV1"},status:{const:"partial",type:"string"}},required:["status","reason","examined_families","examined_members"],type:"object"}]},RedundancyFamilyV1:{additionalProperties:!1,properties:{family:{$ref:"#/$defs/SimilarFamilyV1"},generated_members:{items:{$ref:"#/$defs/SymbolOccurrenceId"},type:"array"},reviewable_source_bytes:{format:"uint64",minimum:0,type:"integer"},total_member_count:{format:"uint",minimum:0,type:"integer"}},required:["family","total_member_count","reviewable_source_bytes","generated_members"],type:"object"},RedundancyPartialReasonV1:{enum:["family_limit","work_limit"],type:"string"},RedundancyRankingV1:{enum:["reviewable_source_bytes"],type:"string"},RepositoryId:vb,SimilarFamilyV1:bd,SimilarMatchClassV1:bc,SimilarOccurrenceV1:bl,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/RedundancyCoverageV1"},families:{items:{$ref:"#/$defs/RedundancyFamilyV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},next_cursor:{type:["string","null"]},ranked_by:{$ref:"#/$defs/RedundancyRankingV1"},source_generation:{$ref:"#/$defs/CodeGenerationId"}},required:["source_generation","ranked_by","families","coverage"],title:"RedundancyResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,title:"RemoteStatusSurfaceRequestV1",type:"object"},{$defs:{AuthorityEpoch:{description:"Monotonic epoch of the writer authority for a shard.",format:"uint64",minimum:0,type:"integer"},BrainId:f1,BrainNodeId:{description:"Strongly typed canonical identity: `BrainNodeId`.",type:"string"},CurrentRemoteAuthorityStateV1:{description:"Truthful authority lookup state. Missing evidence is never represented as\nan available authority or a successful empty response.",oneOf:[{properties:{state:{const:"available",type:"string"},value:{$ref:"#/$defs/CurrentRemoteAuthorityV1"}},required:["state","value"],type:"object"},{properties:{state:{const:"partial",type:"string"},value:{properties:{known_fence:{anyOf:[{$ref:"#/$defs/RemoteWriterFenceV1"},{type:"null"}]},missing:{items:{$ref:"#/$defs/RemoteAuthorityUnavailableReasonV1"},type:"array",uniqueItems:!0},observed_at:{$ref:"#/$defs/UtcMicros"}},required:["missing","observed_at"],type:"object"}},required:["state","value"],type:"object"},{properties:{state:{const:"unavailable",type:"string"},value:{properties:{observed_at:{$ref:"#/$defs/UtcMicros"},reason:{$ref:"#/$defs/RemoteAuthorityUnavailableReasonV1"}},required:["reason","observed_at"],type:"object"}},required:["state","value"],type:"object"}]},CurrentRemoteAuthorityV1:{additionalProperties:!1,description:"Authenticated current authority for a mutable shard.",properties:{credential_revision:{description:"Revision of the authority node's current enrollment credential.",format:"uint64",minimum:0,type:"integer"},fence:{$ref:"#/$defs/RemoteWriterFenceV1"},observed_at:{$ref:"#/$defs/UtcMicros"}},required:["fence","credential_revision","observed_at"],type:"object"},DoctorCoverageCompletenessV1:yk,ProjectionGenerationId:_5,RemoteAuthorityUnavailableReasonV1:{oneOf:[{enum:["registry_unavailable","placement_unknown","authority_unreachable","authority_authentication_failed","caller_authentication_failed","enrollment_expired","enrollment_revoked","insufficient_capability","scope_mismatch","fence_unverified","protocol_incompatible"],type:"string"},{const:"writer_authority_unpublished",description:"The RemoteNode store has never had a writer authority published for\nthis Brain, so no capture, replay, query, or failover can bind to one.",type:"string"}]},RemoteListenerReadV1:{enum:["serving","disabled","degraded"],type:"string"},RemoteOperationalReadinessV1:{enum:["unconfigured","partial","ready","recovery_required"],type:"string"},RemoteOperationalStatusV1:{additionalProperties:!1,properties:{authority:{$ref:"#/$defs/CurrentRemoteAuthorityStateV1"},enrollment_configured:{type:"boolean"},failover_in_progress:{type:"boolean"},observed_at:{$ref:"#/$defs/UtcMicros"},readiness:{$ref:"#/$defs/RemoteOperationalReadinessV1"},recovery_required:{type:"boolean"},replay_coverage_complete:{type:"boolean"},spool:{$ref:"#/$defs/RemoteSpoolOperationalStatusV1"}},required:["readiness","enrollment_configured","authority","spool","replay_coverage_complete","failover_in_progress","recovery_required","observed_at"],type:"object"},RemoteSpoolOperationalStatusV1:{additionalProperties:!1,properties:{has_sequence_gap:{type:"boolean"},pending_count:{format:"uint64",minimum:0,type:"integer"},quarantined_count:{format:"uint64",minimum:0,type:"integer"}},required:["pending_count","quarantined_count","has_sequence_gap"],type:"object"},RemoteWriterFenceV1:{additionalProperties:!1,description:"The complete single-writer identity for one mutable shard.",properties:{authority_epoch:{$ref:"#/$defs/AuthorityEpoch"},authority_node_id:{$ref:"#/$defs/BrainNodeId"},brain_id:{$ref:"#/$defs/BrainId"},generation_id:{$ref:"#/$defs/ProjectionGenerationId"},placement_revision:{format:"uint64",minimum:0,type:"integer"},shard_id:{$ref:"#/$defs/ShardId"}},required:["brain_id","shard_id","generation_id","placement_revision","authority_epoch","authority_node_id"],type:"object"},ShardId:{description:"Strongly typed canonical identity: `ShardId`.",type:"string"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Typed read of the Remote Brain operational plane as observed from the\nmounted daemon authorities. Every operator surface (Doctor, CLI, MCP,\ndashboard) reads this one shape; `Unavailable` is reserved for a genuinely\nunmounted or unreadable authority, never a rendering shortcut.",oneOf:[{properties:{coverage:{$ref:"#/$defs/DoctorCoverageCompletenessV1"},kind:{const:"observed",type:"string"},listener:{$ref:"#/$defs/RemoteListenerReadV1"},status:{$ref:"#/$defs/RemoteOperationalStatusV1"}},required:["kind","listener","status","coverage"],type:"object"},{properties:{kind:{const:"unconfigured",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"unavailable",type:"string"}},required:["kind"],type:"object"}],title:"RemoteOperationalStatusReadV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{new_name:{type:["string","null"]},node_id:{type:"string"}},required:["node_id"],title:"RenamePreviewPrimitiveRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveNotFoundV1:_Z,PrimitiveSearchFreshnessV1:_X,PrimitiveSymbolLocationV1:_1,RenamePreviewNodeV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},qualified_name:{type:"string"},snippet:{type:["string","null"]}},required:["id","name","qualified_name","kind","file","line"],type:"object"},RenamePreviewPrimitiveResultV1:{additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},new_name:{type:["string","null"]},node:{$ref:"#/$defs/RenamePreviewNodeV1"},note:{type:"string"},read_only:{type:"boolean"},reference_count:{format:"uint",minimum:0,type:"integer"},references:{items:{$ref:"#/$defs/RenamePreviewReferenceV1"},type:"array"},symbol:{type:"string"},text_only_matches:{items:{$ref:"#/$defs/RenamePreviewTextOnlyMatchV1"},type:"array"}},required:["read_only","note","symbol","node","reference_count","references","text_only_matches"],type:"object"},RenamePreviewReferenceV1:{additionalProperties:!1,properties:{edge_kind:{type:"string"},file:{type:"string"},from_kind:{type:"string"},from_name:{type:"string"},from_node_id:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},snippet:{type:["string","null"]}},required:["from_node_id","from_name","from_kind","edge_kind","file","line"],type:"object"},RenamePreviewTextOnlyMatchV1:{additionalProperties:!1,properties:{file:{type:"string"},note:{type:"string"},text_only_count:{format:"uint",minimum:0,type:"integer"}},required:["file","text_only_count","note"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/RenamePreviewPrimitiveResultV1"},{$ref:"#/$defs/PrimitiveNotFoundV1"}],title:"RenamePreviewPrimitiveOutcomeV1"},{$defs:{ManifestDigest:_l,RenamePreviewAcceptanceV1:{additionalProperties:!1,description:"Exact preview material an apply must echo. Preview calls omit this value;\napply rejects any mismatch before publishing a file.",properties:{graph_revision:{$ref:"#/$defs/ManifestDigest"},plan_digest:{$ref:"#/$defs/ManifestDigest"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/ManifestDigest"},repository_revision:{default:null,type:["string","null"]}},required:["preview_id","preview_digest","plan_digest","graph_revision"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_rename_symbol`.\n\nThe five identity fields consume the preview's exact symbol identity; the\nflattened control consumes its exact candidate-state digest.",properties:{accepted_preview:{anyOf:[{$ref:"#/$defs/RenamePreviewAcceptanceV1"},{type:"null"}],description:"Exact output identity from the accepted dry-run preview. Required when\n`dry_run=false` and omitted when computing a preview."},dry_run:{default:!0,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},file:{type:"string"},idempotency_key:{type:["string","null"]},kind:{type:"string"},new_name:{type:"string"},node_id:{description:"Canonical `SymbolOccurrenceId` returned by `tracedecay_rename_preview`.",type:"string"},old_name:{type:"string"},qualified_name:{type:"string"},verify:{default:!0,type:"boolean"}},required:["node_id","qualified_name","kind","file","old_name","new_name"],title:"RenameSymbolSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_replace_symbol`.",properties:{dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},new_source:{type:"string"},symbol:{type:"string"},verify:{default:!1,type:"boolean"}},required:["symbol","new_source"],title:"ReplaceSymbolSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{handle:{description:"The required `handle` argument copied exactly from a truncated MCP\nresponse envelope.",type:"string"},max_chars:{description:"Maximum characters requested for this page. Values above the safe\nresponse-frame budget are clamped.",format:"uint64",minimum:1,type:["integer","null"]},offset:{default:0,description:"Character offset into the immutable stored response (default: 0). Use\nthe prior page's next_offset.",format:"uint64",minimum:0,type:["integer","null"]}},required:["handle"],title:"RetrieveSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RetrieveHandleExpiredV1:{additionalProperties:!1,description:"The record expired and was removed.",properties:{content:{description:"Always null: the expired content was removed.",type:["string","null"]},created_at:{format:"int64",type:"integer"},expired:{description:"Always `true`.",type:"boolean"},expires_at:{format:"int64",type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},handle:{type:"string"},message:{type:"string"},reason_code:{type:"string"},retry_instruction:{type:"string"},retryable:{type:"boolean"}},required:["handle","expired","reason_code","message","retryable","retry_instruction","created_at","expires_at"],type:"object"},RetrieveHandleMissingV1:{additionalProperties:!1,description:"No record exists under the handle in this project's store.",properties:{content:{description:"Always null: nothing is stored under the handle.",type:["string","null"]},expired:{description:"Always null: an absent record has no expiry to report.",type:["boolean","null"]},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},handle:{type:"string"},message:{type:"string"},reason_code:{type:"string"},retry_instruction:{type:"string"},retryable:{type:"boolean"}},required:["handle","reason_code","message","retryable","retry_instruction"],type:"object"},RetrievedPageV1:{additionalProperties:!1,description:"One page of the stored response, sized so its response frame fits the\nresponse budget.",properties:{content:{type:"string"},created_at:{format:"int64",type:"integer"},expired:{description:"Always `false`: a page is only served from a live record.",type:"boolean"},expires_at:{format:"int64",type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},handle:{type:"string"},has_more:{type:"boolean"},next_offset:{description:"Where the next page starts; absent on the last page.",format:"uint64",minimum:0,type:["integer","null"]},offset:{format:"uint64",minimum:0,type:"integer"},original_chars:{format:"uint64",minimum:0,type:"integer"},total_chars:{format:"uint64",minimum:0,type:"integer"}},required:["handle","expired","original_chars","total_chars","offset","has_more","created_at","expires_at","content"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/RetrievedPageV1"},{$ref:"#/$defs/RetrieveHandleMissingV1"},{$ref:"#/$defs/RetrieveHandleExpiredV1"}],description:"What a retrieve found under the handle.",title:"RetrieveResultV1"},{$defs:{TestProfileV1:{description:"The cargo profile an affected-test run builds with.",enum:["debug","release"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{changed_paths:{description:"Explicit manifest of project-relative file paths used to compute\naffected tests.",items:{type:"string"},type:"array"},max_tests:{description:"Cap on tests dispatched in a single invocation, 1 through 500\n(default: 100).",format:"uint64",maximum:500,minimum:1,type:["integer","null"]},profile:{anyOf:[{$ref:"#/$defs/TestProfileV1"},{type:"null"}],description:"Cargo profile (default: debug)."},timeout_secs:{description:"Maximum wall time in seconds before the cargo subprocess is killed,\n1 through 300 (default: 300).",format:"uint64",maximum:300,minimum:1,type:["integer","null"]}},required:["changed_paths"],title:"RunAffectedTestsSurfaceRequestV1",type:"object"},{$defs:{AffectedTestErrorV1:{additionalProperties:!1,description:"Why a run failed or was refused.",properties:{kind:{type:"string"},message:{type:"string"},operation:{type:"string"}},required:["kind","operation","message"],type:"object"},AffectedTestOutcomeV1:{additionalProperties:!1,description:"One observed libtest outcome.",properties:{covers_source_ids:{description:"Graph symbols this test was selected to cover.",items:{type:"string"},type:"array"},passed:{type:"boolean"},test:{type:"string"}},required:["test","passed","covers_source_ids"],type:"object"},AffectedTestRunV1:{additionalProperties:!1,description:"A dispatched run, completed or failed, with what it observed.",properties:{dispatched_tests:{items:{type:"string"},type:"array"},error:{anyOf:[{$ref:"#/$defs/AffectedTestErrorV1"},{type:"null"}],description:"Present when the run did not complete."},exit_code:{format:"int32",type:["integer","null"]},failed:{format:"uint64",minimum:0,type:"integer"},ignored:{description:"Dispatched tests libtest reported as ignored.",format:"uint64",minimum:0,type:"integer"},passed:{format:"uint64",minimum:0,type:"integer"},results:{items:{$ref:"#/$defs/AffectedTestOutcomeV1"},type:"array"},stderr_tail:{type:"string"},stdout_tail:{type:"string"},terminal:{$ref:"#/$defs/ManagedTestTerminalV1"},total_observed:{format:"uint64",minimum:0,type:"integer"},truncated:{description:"More affected tests existed than `max_tests` admitted.",type:"boolean"}},required:["passed","failed","ignored","total_observed","dispatched_tests","truncated","results","stderr_tail","stdout_tail","terminal"],type:"object"},AffectedTestsNotRunV1:{additionalProperties:!1,description:"No test was dispatched: nothing covers the change, or the request was\nrefused before a run began.",properties:{error:{anyOf:[{$ref:"#/$defs/AffectedTestErrorV1"},{type:"null"}]},failed:{description:"Always 0.",format:"uint64",minimum:0,type:"integer"},note:{type:["string","null"]},passed:{description:"Always 0.",format:"uint64",minimum:0,type:"integer"},results:{description:"Always empty.",items:{$ref:"#/$defs/AffectedTestOutcomeV1"},type:"array"}},required:["passed","failed","results"],type:"object"},CancellationObservation:hn,CancellationStage:ha,Deadline:yv,ManagedTestTerminalV1:{additionalProperties:!1,description:"The managed test-run operation the run was recorded under.",properties:{operation_id:{type:"string"},receipt:{$ref:"#/$defs/OperationReceipt"},result_tool:{description:"The tool that reads the recorded results back.",type:"string"},session_id:{description:"The requesting session the run is recorded against; null when the\nrequest carried no session.",type:["string","null"]}},required:["operation_id","result_tool","receipt"],type:"object"},OperationBudgetUsage:_D,OperationReceipt:_F,OperationTermination:_L,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/AffectedTestRunV1"},{$ref:"#/$defs/AffectedTestsNotRunV1"}],title:"RunAffectedTestsResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{authority_audit:{default:!1,description:"Run the exhaustive observation-authority audit and include\nauthority_audit_ok (true = audit ran and passed, false = audit ran and\nfailed, null = audit did not run or finish), authority_audit_reason\n(typed: authority_invariant_failed, authority_store_unavailable,\nauthority_store_missing, authority_audit_not_run,\nauthority_audit_budget_exceeded), and\nauthority_audit_error (observed detail) in database telemetry. Also\nincludes session-temporal health. Default false.",type:"boolean"},doctor_report:{default:!1,description:"Include the daemon-owned canonical Doctor report and typed per-table\ngrowth evidence. Default false.",type:"boolean"},session_ingest_health:{default:!1,description:"Include Cursor transcript-ingest health from the daemon-retained\nproject session authority. Default false.",type:"boolean"},session_temporal_health:{default:!1,description:"Include session-temporal health without the authority audit. Default\nfalse.",type:"boolean"},startup_health:{default:!1,description:"Ask a connection's first request for only the daemon-mounted database\nintegrity telemetry, for post-update startup validation; the daemon\ncore answers that probe before a project owner exists, and a project\nowner's snapshot already carries the same telemetry. Default false.",type:"boolean"}},title:"RuntimeSurfaceRequestV1",type:"object"},{$defs:{DoctorCoverageCompletenessV1:yk,DoctorCoverageStatementV1:{description:"A bounded, human-readable coverage statement plus its completeness.",properties:{completeness:{$ref:"#/$defs/DoctorCoverageCompletenessV1"},statement:{type:"string"}},required:["completeness","statement"],type:"object"},DoctorEvidenceRefV1:{description:"A typed reference to one piece of evidence Doctor composed into a finding.\n\nThe `family` records which audited input surface produced the evidence, so\na finding may cross-cite evidence from more than one family without losing\nprovenance.",properties:{family:{$ref:"#/$defs/DoctorFindingFamilyV1"},reference:{$ref:"#/$defs/DoctorEvidenceReferenceV1"}},required:["family","reference"],type:"object"},DoctorEvidenceReferenceV1:{description:"Durable, non-disclosing reference to one owning-authority evidence\nrecord (for example a `FeedbackFindingId`, configuration revision, or\nruntime read coverage anchor). Doctor stores the reference only; the\nowning authority remains the single source of the record.",type:"string"},DoctorEvidenceStateV1:{description:"Exact Doctor evidence states.\n\nMissing, partial, or unknown truth never becomes healthy or clean. Only\n[`DoctorEvidenceStateV1::HealthyCompleteCoverage`] asserts a healthy result,\nand only when its finding carries complete coverage (see\n[`DoctorFindingV1::new`]).",oneOf:[{const:"unsupported",description:"The owning authority does not support this evidence on this platform.",type:"string"},{const:"absent",description:"The evidence source is supported but produced nothing.",type:"string"},{const:"stale",description:"The evidence exists but is behind the current generation/watermark.",type:"string"},{const:"degraded",description:"The evidence proves a degraded but observed condition.",type:"string"},{const:"partial",description:"Only part of the evidence was observed.",type:"string"},{const:"unknown",description:"The evidence state could not be determined.",type:"string"},{const:"denied",description:"Authorization to read the evidence was denied.",type:"string"},{const:"healthy_complete_coverage",description:"The evidence proves a healthy condition with complete coverage.",type:"string"}]},DoctorFamilyConsultationV1:{description:"Whether a family was consulted from an observed source or is unavailable.",oneOf:[{description:"A source produced observed evidence for this family.",properties:{status:{const:"consulted",type:"string"}},required:["status"],type:"object"},{description:"Complete family coverage was unavailable. Storage may still carry\nfindings from resolved producers when an independent producer failed.",properties:{reason:{$ref:"#/$defs/DoctorFamilyUnavailableReasonV1"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},DoctorFamilyCoverageV1:{description:"The consultation status of one finding family within a report.",properties:{consultation:{$ref:"#/$defs/DoctorFamilyConsultationV1"},family:{$ref:"#/$defs/DoctorFindingFamilyV1"}},required:["family","consultation"],type:"object"},DoctorFamilyUnavailableReasonV1:{description:"Why complete coverage of a finding family was unavailable.",oneOf:[{const:"unwired",description:"No source port is wired for this family in this composition.",type:"string"},{const:"unsupported",description:"The source is unsupported on this build/platform.",type:"string"},{const:"absent",description:"The source is supported but produced nothing.",type:"string"},{const:"denied",description:"The source read was denied.",type:"string"},{const:"unknown",description:"The source state could not be determined.",type:"string"},{const:"unavailable",description:"The source could not be reached. Named separately from `Unknown`: the\nsource is identified and its unreachability is an observation, not an\nundetermined state.",type:"string"},{const:"reset_required",description:"The source must be rebuilt before it can be read again.",type:"string"},{const:"corrupt",description:"The source was read and found corrupt.",type:"string"}]},DoctorFindingFamilyV1:{description:"Stable Doctor finding families.\n\nThe initial list covers advisory findings from\nBrain, Explorer, Loom, Code, and Observatory, plus the daemon\ncore doctor checks (graph quick-check, temporal health, configuration\ndrift, code-index mount state, session ingest).\nEach family maps to one audited typed input surface. The set is kept small\nand honest; new families are added through a future versioned enum rather\nthan by widening the meaning of an existing variant.",oneOf:[{const:"advisory",description:"advisory/scout findings (GitHub review, CI localization,\nproximity, context scout): `crate::advisory` / domain feedback.",type:"string"},{const:"configuration",description:"Desired-versus-effective configuration and compatibility drift from\n`ProjectConfigurationRuntime` / `ConfigurationControlPlane`.",type:"string"},{const:"storage_runtime",description:"Store, graph, and temporal runtime health plus migration coverage\n(`RuntimeReadOperationV1` health family, `StoreRuntimeClientLease`).",type:"string"},{const:"storage",description:"Storage retention, size, and efficiency over canonical observability\nread models. Distinct from [`Self::StorageRuntime`] health: this\nfamily surfaces over-budget stores, identity-drift orphans, incident\ndebris, and retention backlog. The typed\nsubclass vocabulary is [`DoctorStorageFindingKindV1`].",type:"string"},{const:"language_server",description:"Language-server / analyzer engine status from the LSP gateway's\n`AnalyzerState`.",type:"string"},{const:"code_index",description:"Code index mount state (mounted, indexing, stale, unmounted,\nincompatible, parked).",type:"string"},{const:"observability",description:"Denominator-safe measurement and telemetry health from analytics,\naccounting read models, and session ingest.",type:"string"},{const:"memory",description:"Retained daemon memory as the resident-memory inventory reports it:\nRSS against the admission limit and pressure line, and each retained\nowner's bytes.",type:"string"}]},DoctorFindingV1:{description:"One canonical Doctor finding.\n\nA finding pins its diagnosis `family`, its evidence `state`, the typed\nevidence it composed, and a coverage statement. Construction enforces the\ninvariants that keep unknown/partial evidence from collapsing into a\nhealthy or clean result.",properties:{coverage:{$ref:"#/$defs/DoctorCoverageStatementV1"},evidence:{items:{$ref:"#/$defs/DoctorEvidenceRefV1"},type:"array"},family:{$ref:"#/$defs/DoctorFindingFamilyV1"},state:{$ref:"#/$defs/DoctorEvidenceStateV1"}},required:["family","state","evidence","coverage"],type:"object"},DoctorReportCoverageV1:{description:"The report-wide coverage statement: which families were consulted versus\nunavailable, plus an overall completeness and a bounded human statement.",properties:{completeness:{$ref:"#/$defs/DoctorCoverageCompletenessV1"},families:{items:{$ref:"#/$defs/DoctorFamilyCoverageV1"},type:"array"},statement:{$ref:"#/$defs/DoctorCoverageStatementV1"}},required:["families","completeness","statement"],type:"object"},DoctorReportEntryV1:{description:"One entry in a Doctor report: a canonical finding plus, for the storage\nfamily, its typed subclass. The subclass is present only for storage findings\n(a non-storage entry never carries one).",properties:{finding:{$ref:"#/$defs/DoctorFindingV1"},storage_kind:{anyOf:[{$ref:"#/$defs/DoctorStorageFindingKindV1"},{type:"null"}]}},required:["finding"],type:"object"},DoctorReportV1:{description:"One composed Doctor report.\n\nThe report carries one or more entries per family (findings are never merged\nby label) plus a coverage statement that enumerates every family consulted\nversus unavailable. Severity (the finding's evidence state) and evidence\nquality (coverage completeness) are kept as separate dimensions: a degraded\nfinding with complete coverage does not weaken report completeness, and only\ngenuinely complete coverage with every finding healthy makes the whole report\nassert health.",properties:{coverage:{$ref:"#/$defs/DoctorReportCoverageV1"},entries:{items:{$ref:"#/$defs/DoctorReportEntryV1"},type:"array"}},required:["entries","coverage"],type:"object"},DoctorStorageFindingKindV1:{description:"Typed subclasses of the [`DoctorFindingFamilyV1::Storage`] finding family.\n\nThe storage family never reports a silent overage: each subclass names one\nobservable retention/size condition Doctor surfaces over canonical size\nobservability read models. The set is closed and grows only through a future\nversioned enum, never by widening an existing subclass.",oneOf:[{const:"over_budget_store",description:"A store exceeds its owner-configured soft size budget.",type:"string"},{const:"orphan_store",description:"A store whose project identity no longer resolves to a live repository\nroot (identity-drift orphan), reported with age and size.",type:"string"},{const:"incident_debris_present",description:"Recovery/corruption artifacts are present beside a store and awaiting\ndeletion.",type:"string"},{const:"retention_backlog",description:"Retention-eligible rows or stores are past their window and awaiting\noffload/collection.",type:"string"},{const:"table_growth",description:"Per-table SQLite payload growth observed between two retained\nwatermarks, including baseline and unavailable measurement states.",type:"string"},{const:"schema_convergence_incomplete",description:"A store whose background schema convergence (the authority-invariant\naudit and projection retry re-arming that follow admission) has not\ncompleted: it is still pending, still running, or stopped on a failure.\nThe daemon serves meanwhile, so this is the surface that says which\nstore has not converged and why.",type:"string"},{const:"wal_checkpoint_pinned",description:"A store whose WAL checkpoint cannot restart the log because a reader\nstill holds a read slot past the checkpoint fence: a wedged reader of\nthis daemon or another process, named in the evidence. Writes run\nuntil the WAL reaches its ceiling, then wait.",type:"string"}]},LanguageServerAnalyzerStateV1:{description:"State of one analyzer as the daemon owner holds it.\n\n`Inactive` is the one state the aggregate never takes: the language has no\nfiles in the project, so Doctor does not grade it, but `lsp servers` still\nlists it from this same read so both surfaces share one authority.",enum:["ready","available","refreshing","disabled","unavailable","crashed","inactive"],type:"string"},LanguageServerAnalyzerV1:{description:"Live state of one analyzer the daemon resolved for the current project.\n\n`LanguageServerStateV1` is the aggregate the finding is graded on; this is\nthe per-analyzer evidence behind it, so an operator learns *which*\nexecutable is missing and how to install it, resolved by the daemon\nprocess (the only PATH that matters, since the daemon spawns analyzers)\nrather than by whichever shell ran the CLI.",properties:{command:{description:"The configured executable, after any operator command override.",type:"string"},detail:{description:"The owner's last recorded error for this analyzer, when one exists.",type:["string","null"]},executable_found:{description:"Whether the daemon process finds `command` on its own PATH. For an\nactive analyzer `state` is the finer verdict (a rustup proxy whose\ntoolchain lacks the component is found yet `Unavailable`); for an\ninactive one this is the only availability evidence.",type:"boolean"},install:{description:"The first install command the adapter advertises, when one exists.",type:["string","null"]},language:{description:"Adapter language (`typescript`, `rust`, …).",type:"string"},state:{$ref:"#/$defs/LanguageServerAnalyzerStateV1"}},required:["language","command","state","executable_found"],type:"object"},LanguageServerReadV1:{description:"One live read from the daemon language-server/analyzer owner.",oneOf:[{description:"The owner observed all project-active analyzer states.",properties:{analyzers:{default:[],description:"Every analyzer the owner resolved, active or not; the aggregate\n`state` covers the active ones only.",items:{$ref:"#/$defs/LanguageServerAnalyzerV1"},type:"array"},coverage:{$ref:"#/$defs/DoctorCoverageCompletenessV1"},kind:{const:"observed",type:"string"},state:{$ref:"#/$defs/LanguageServerStateV1"}},required:["kind","state","coverage"],type:"object"},{description:"Language-server inspection is unsupported on this build/platform.",properties:{kind:{const:"unsupported",type:"string"}},required:["kind"],type:"object"},{description:"No project-active analyzer is configured. The owner's inactive\nanalyzers are still carried so `lsp servers` can list them.",properties:{analyzers:{default:[],items:{$ref:"#/$defs/LanguageServerAnalyzerV1"},type:"array"},kind:{const:"absent",type:"string"}},required:["kind"],type:"object"},{description:"Authorization to inspect analyzer state was denied.",properties:{kind:{const:"denied",type:"string"}},required:["kind"],type:"object"},{description:"Analyzer state could not be determined.",properties:{kind:{const:"unknown",type:"string"}},required:["kind"],type:"object"}]},LanguageServerStateV1:{description:"Aggregate state of the project-active language-server analyzers.",oneOf:[{const:"ready",description:"Every active analyzer is ready.",type:"string"},{const:"available",description:"At least one analyzer is installed but has not produced a ready snapshot.",type:"string"},{const:"refreshing",description:"At least one analyzer is currently refreshing/indexing.",type:"string"},{const:"disabled",description:"At least one project analyzer is disabled.",type:"string"},{const:"unavailable",description:"At least one project analyzer executable is unavailable.",type:"string"},{const:"crashed",description:"At least one analyzer process crashed.",type:"string"}]},RuntimeDoctorReportV1:{description:"The daemon's canonical Doctor report as this route could read it.",oneOf:[{additionalProperties:!1,properties:{kind:{const:"observed",type:"string"},language_servers:{$ref:"#/$defs/LanguageServerReadV1"},report:{$ref:"#/$defs/DoctorReportV1"},schema_convergences:{items:{$ref:"#/$defs/SchemaConvergenceFindingV1"},type:"array"},table_growth_evidence:{items:{$ref:"#/$defs/TableGrowthDoctorEvidenceV1"},type:"array"}},required:["kind","report","table_growth_evidence","schema_convergences","language_servers"],type:"object"},{additionalProperties:!1,description:"The reader is mounted and the read failed.",properties:{kind:{const:"unknown",type:"string"},language_servers:{$ref:"#/$defs/LanguageServerReadV1"},schema_convergences:{items:{$ref:"#/$defs/SchemaConvergenceFindingV1"},type:"array"},table_growth_evidence:{items:{$ref:"#/$defs/TableGrowthDoctorEvidenceV1"},type:"array"}},required:["kind","table_growth_evidence","schema_convergences","language_servers"],type:"object"},{additionalProperties:!1,description:"No Doctor reader is mounted on this route.",properties:{kind:{const:"unsupported",type:"string"},language_servers:{$ref:"#/$defs/LanguageServerReadV1"},schema_convergences:{items:{$ref:"#/$defs/SchemaConvergenceFindingV1"},type:"array"},table_growth_evidence:{items:{$ref:"#/$defs/TableGrowthDoctorEvidenceV1"},type:"array"}},required:["kind","table_growth_evidence","schema_convergences","language_servers"],type:"object"}]},SchemaConvergenceFindingV1:vL,SchemaConvergenceStageV1:vU,SchemaConvergenceStateV1:vH,StorageByteSizeV1:{description:"A byte size measurement. A newtype keeps sizes from being confused with\ncounts, ratios, or timestamps in the read models and producers.",format:"uint64",minimum:0,type:"integer"},StoreKeyV1:{description:"Logical name of one owner-profile store (for example `sessions.db`,\n`graph.db`, or `projects/proj_x`). Never an absolute on-disk path.",type:"string"},TableGrowthDoctorEvidenceV1:{description:"Contract-independent evidence ready to wrap in a future `TableGrowth`\nStorage finding once that generated-contract variant is available.",oneOf:[{properties:{current_bytes:{$ref:"#/$defs/StorageByteSizeV1"},current_observed_at:{$ref:"#/$defs/UtcMicros"},growth_bytes:{$ref:"#/$defs/StorageByteSizeV1"},kind:{const:"significant_growth",type:"string"},previous_bytes:{$ref:"#/$defs/StorageByteSizeV1"},previous_observed_at:{$ref:"#/$defs/UtcMicros"},store:{$ref:"#/$defs/StoreKeyV1"},table:{$ref:"#/$defs/TableNameV1"}},required:["kind","store","table","previous_bytes","current_bytes","growth_bytes","previous_observed_at","current_observed_at"],type:"object"},{properties:{kind:{const:"baseline_established",type:"string"},observed_at:{$ref:"#/$defs/UtcMicros"},store:{$ref:"#/$defs/StoreKeyV1"},tables_observed:{format:"uint64",minimum:0,type:"integer"}},required:["kind","store","observed_at","tables_observed"],type:"object"},{properties:{current_bytes:{$ref:"#/$defs/StorageByteSizeV1"},kind:{const:"table_baseline_pending",type:"string"},observed_at:{$ref:"#/$defs/UtcMicros"},store:{$ref:"#/$defs/StoreKeyV1"},table:{$ref:"#/$defs/TableNameV1"}},required:["kind","store","table","current_bytes","observed_at"],type:"object"},{properties:{kind:{const:"unsupported",type:"string"},store:{$ref:"#/$defs/StoreKeyV1"}},required:["kind","store"],type:"object"},{properties:{kind:{const:"denied",type:"string"},store:{$ref:"#/$defs/StoreKeyV1"}},required:["kind","store"],type:"object"},{properties:{kind:{const:"unknown",type:"string"},reason:{$ref:"#/$defs/TableGrowthUnavailableReasonV1"},store:{$ref:"#/$defs/StoreKeyV1"}},required:["kind","store","reason"],type:"object"}]},TableGrowthUnavailableReasonV1:{description:"Why a per-table payload-growth measurement is unavailable.",oneOf:[{const:"not_yet_measured",description:"No maintenance pass has measured this store yet.",type:"string"},{const:"reader_unavailable",description:"No reader could be leased within the measurement's wait.",type:"string"},{const:"deadline_exceeded",description:"The `dbstat` walk was interrupted by its deadline.",type:"string"},{const:"cancelled",description:"The `dbstat` walk was cancelled.",type:"string"},{const:"storage_corrupt",description:"The store reported corruption.",type:"string"},{const:"storage_infrastructure",description:"The store failed with an infrastructure error.",type:"string"},{const:"storage_other",description:"The store failed for another reason.",type:"string"},{const:"invalid_table_name",description:"`dbstat` named a table that is not a valid table identifier.",type:"string"},{const:"clock_regressed",description:"The previous watermark is later than the current measurement.",type:"string"},{const:"exceeds_measurement_budget",description:"The store is larger than the `dbstat` walk can cover within its\ndeadline.",type:"string"}]},TableNameV1:{description:"A physical table name inside a store, used for per-table growth telemetry.",type:"string"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Process, database, and session-observation telemetry for the running\ndaemon, with the sections the request opted into.",properties:{captured_at:{description:"Unix epoch seconds.",format:"uint64",minimum:0,type:"integer"},cursor_session_ingest:!0,cursor_session_placeholder_paths:{items:{type:"string"},type:["array","null"]},database:{description:"Store telemetry, with the authority-audit verdict when it ran."},doctor_report:{anyOf:[{$ref:"#/$defs/RuntimeDoctorReportV1"},{type:"null"}]},host_os:{type:"string"},process:{description:"Cached process sample."},session_temporal_health:!0,tracedecay_version:{type:"string"}},required:["captured_at","tracedecay_version","host_os","process","database"],title:"RuntimeResultV1",type:"object"},{$defs:{SearchLexicalAliasV1:{additionalProperties:!1,description:"One named query-time vocabulary alias.",properties:{alternative:{maxLength:128,type:"string"},strict_query:{maxLength:128,type:"string"}},required:["strict_query","alternative"],type:"object"},SearchLexicalFieldFilterV1:{additionalProperties:!1,properties:{field:{$ref:"#/$defs/SearchLexicalFieldV1"},include:{type:"boolean"}},required:["field","include"],type:"object"},SearchLexicalFieldV1:{description:"A lexical posting field a search may include or exclude.",enum:["symbol_name","qualified_name","path","signature","documentation","body_text","preamble_text","exact_term","subtoken"],type:"string"},SearchLexicalProximityV1:{additionalProperties:!1,description:"Ordered terms that must occur in one field within `maximum_gap`\nintervening tokens of each other.",properties:{maximum_gap:{format:"uint32",maximum:8,minimum:0,type:"integer"},terms:{items:{type:"string"},maxItems:8,minItems:2,type:"array"}},required:["terms","maximum_gap"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{description:"Authenticated opaque continuation returned as next_cursor. Repeat the same query and lexical options with it.",type:["string","null"]},lazy_index_ignored_dependencies:{description:"Opt in to bounded indexing of ignored dependency entry files when an import hint matches (default: false).",type:["boolean","null"]},lexical_aliases:{description:"Named query-time vocabulary aliases. The strict query always ranks first. Alias-only hits follow it with the strict query, alternative, and configured-vocabulary reason disclosed.",items:{$ref:"#/$defs/SearchLexicalAliasV1"},maxItems:8,type:["array","null"]},lexical_anchors:{description:"Exact identifiers or technical terms (e.g. 'reserve_stock', 'Foo::bar', 'E0308') that the answer must be about. Each is ranked through the lexical lane as its own route: a hit carrying an anchor outranks every hit that carries none, exact hits included, every anchor with matches keeps at least its best sites through the lane cap, and `lexical_anchors` in the response reports each anchor's outcome (`matched` rows, `admitted` sites this response returns, `dropped` admitted sites it could not carry with the reason, `unmatched`, or `not_served`). Ranked retrieval, not exhaustive grep (use tracedecay_grep for that). Each result names the routes that ranked it. At most 8 anchors, each one whitespace-free term of at most 128 bytes, no repeats.",items:{type:"string"},maxItems:8,type:["array","null"]},lexical_field_filters:{description:"Include or exclude lexical symbol_name, qualified_name, path, signature, documentation, body_text, preamble_text, exact_term, or subtoken fields.",items:{$ref:"#/$defs/SearchLexicalFieldFilterV1"},maxItems:9,type:["array","null"]},lexical_phrases:{description:"Exact lexical phrases to rank through n-gram candidate pruning.",items:{type:"string"},maxItems:4,type:["array","null"]},lexical_proximities:{description:"Ordered lexical terms that must occur within the bounded intervening-token gap.",items:{$ref:"#/$defs/SearchLexicalProximityV1"},maxItems:4,type:["array","null"]},limit:{description:"Maximum number of results to return (default: 10)",format:"uint64",minimum:0,type:["integer","null"]},prefer_symbol:{description:"Add a lexical route restricted to symbol-name matches for the identifier-shaped words of the query. Omitted, it runs when the query is name-shaped (at least half its content words are identifiers such as 'getUserById' or 'Foo::bar'); true forces it, false suppresses it. `query_route` in the response reports the decision and its margin. Query words such as class/struct/function/find/explain are ignored; 'Foo::bar' and 'Foo.bar' contribute 'bar'.",type:["boolean","null"]},query:{description:"Search query string to match against symbol names",type:"string"}},required:["query"],title:"SearchSurfaceRequestV1",type:"object"},{$defs:{ApplicationProblemDetailV1:fA,CalibrationProfileId:hi,CandidateContribution:hs,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComponentRevision:hj,ContextLexicalAnchorV1:hF,DaemonServiceUnitObservationV1:y_,DiagnosticsSearchedTsconfigV1:yS,EvidenceRole:yC,ExactClass:yT,FileOccurrenceId:gs,FixedPointScore:gc,FreshnessCompatibilityV1:gl,FusedCandidate:gp,LexicalAnchorDropReasonV1:_e,LexicalAnchorDropV1:_t,LogicalCopyClusterId:_i,LogicalEvidenceId:_o,OccurrenceProvenance:_z,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveLaneCompleteV1:_J,PrimitiveRecallV1:_Q,PrimitiveSearchFreshnessV1:_X,PrimitiveUnavailableEvidenceV1:_0,PrimitiveUnavailableStatusV1:_2,RankingDecision:vp,RankingDecisionKind:vu,RepositoryId:vb,RetrievalAnchorId:vI,RetrievalSourceRoleV1:vC,RetrieverKind:vO,ScoreDomainId:v2,SearchCompleteV1:{additionalProperties:!1,properties:{code_generation:{type:"string"},coverage:{$ref:"#/$defs/SearchCoverageV1"},external_import_hint:{anyOf:[{$ref:"#/$defs/SearchExternalImportHintV1"},{type:"null"}]},freshness:{$ref:"#/$defs/PrimitiveSearchFreshnessV1",description:"Freshness of the served code generation, derived from the typed lane\ncoverage and the daemon scheduler's worktree state."},lexical_anchors:{description:"Outcome of every caller `lexical_anchors` entry, beside the routes.",items:{$ref:"#/$defs/ContextLexicalAnchorV1"},type:["array","null"]},lexical_routes:{description:"Every lexical route fused into this page; present only when a route\nbeyond the strict query ran or ranked a result.",items:{$ref:"#/$defs/SearchLexicalRouteV1"},type:["array","null"]},next_cursor:{description:"Authenticated continuation for the next page; null on the last page.",type:["string","null"]},query_fallback_digest:{type:"string"},query_route:{anyOf:[{$ref:"#/$defs/SearchQueryRouteV1"},{type:"null"}],description:"Which lane the query's shape selected, and its margin."},results:{items:{$ref:"#/$defs/SearchResultRowV1"},type:"array"},scope_prefix:{description:"The session's scope prefix. Ranked candidates carry no file path, so\nthe scope is reported and not applied.",type:["string","null"]},scope_prefix_applied:{type:["boolean","null"]},verified_graph_evidence:{anyOf:[{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"},{type:"null"}]}},required:["freshness","code_generation","query_fallback_digest","coverage","results"],type:"object"},SearchCoverageV1:{additionalProperties:!1,description:"Per-lane recall of one search, so a full-recall answer is told apart from\none produced while a lane was down.",properties:{exact:{$ref:"#/$defs/SearchLaneStatusV1"},graph:{$ref:"#/$defs/SearchLaneStatusV1"},lexical:{$ref:"#/$defs/SearchLaneStatusV1"},recall:{$ref:"#/$defs/PrimitiveRecallV1"}},required:["exact","lexical","graph","recall"],type:"object"},SearchDisplayUnavailableV1:{description:"Why a ranked candidate's display metadata was not hydrated: the answering\ngeneration no longer matches the request (`stale`), its record is\nincompatible or does not bind the candidate (`incompatible`, `invalid`),\nthe read failed (`internal`), the hydration budget was spent\n(`budget_exceeded`), or the request was cancelled (`cancelled`).",enum:["stale","incompatible","invalid","internal","budget_exceeded","cancelled"],type:"string"},SearchExternalImportCandidatesV1:{additionalProperties:!1,properties:{candidates:{items:{$ref:"#/$defs/SearchExternalImportV1"},type:"array"},evidence:{type:"string"},message:{type:"string"},resolution_status:{type:"string"},suggested_action:{type:"string"}},required:["message","evidence","resolution_status","candidates","suggested_action"],type:"object"},SearchExternalImportHintV1:{anyOf:[{$ref:"#/$defs/SearchExternalImportCandidatesV1"},{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"}],description:"Advisory evidence that a sparse search matched external-module imports,\nor why that evidence could not be read."},SearchExternalImportV1:{additionalProperties:!1,properties:{import_file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},module:{type:"string"},symbol:{description:"The imported name; null for a whole-module import.",type:["string","null"]}},required:["module","import_file","line"],type:"object"},SearchLaneStateV1:{description:"A lane that did not serve the current complete generation. A partial\nlane names its generation and reason when it has them, null otherwise.",oneOf:[{additionalProperties:!1,properties:{generation:{type:"string"},status:{const:"stale",type:"string"}},required:["status","generation"],type:"object"},{additionalProperties:!1,properties:{generation:{type:["string","null"]},reason:{type:["string","null"]},status:{const:"partial",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{reason:{type:"string"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},SearchLaneStatusV1:{anyOf:[{$ref:"#/$defs/PrimitiveLaneCompleteV1"},{$ref:"#/$defs/SearchLaneStateV1"}]},SearchLexicalAlternativeReasonV1:{description:"Why the lexical lane tried a configured alternative.",enum:["configured_vocabulary_alias"],type:"string"},SearchLexicalRouteV1:{description:"One lexical route fused into the page, with its display label.",oneOf:[{additionalProperties:!1,description:"The caller's strict lexical query.",properties:{label:{type:"string"},route:{const:"query",type:"string"}},required:["route","label"],type:"object"},{additionalProperties:!1,description:"One caller-supplied exact identifier or term.",properties:{anchor:{type:"string"},label:{type:"string"},route:{const:"anchor",type:"string"}},required:["route","anchor","label"],type:"object"},{additionalProperties:!1,description:"Identifier-shaped tokens of the query, restricted to symbol names.",properties:{label:{type:"string"},route:{const:"preferred_symbol",type:"string"},tokens:{items:{type:"string"},type:"array"}},required:["route","tokens","label"],type:"object"},{additionalProperties:!1,description:"Identifier and path components recovered from the strict query.",properties:{label:{type:"string"},route:{const:"identifier_split",type:"string"},strict_query:{type:"string"},terms:{items:{type:"string"},type:"array"}},required:["route","strict_query","terms","label"],type:"object"},{additionalProperties:!1,description:"A configured query-time vocabulary alternative.",properties:{alternative:{type:"string"},label:{type:"string"},reason:{$ref:"#/$defs/SearchLexicalAlternativeReasonV1"},route:{const:"alias",type:"string"},strict_query:{type:"string"}},required:["route","strict_query","alternative","reason","label"],type:"object"}]},SearchQueryRouteDeciderV1:{description:"Who chose the query route: the query-shape gate or the caller's\n`prefer_symbol`.",enum:["query_shape","caller"],type:"string"},SearchQueryRouteKindV1:{description:"Which lexical lane the query's shape selected.",oneOf:[{const:"name",description:"The symbol-name route ran beside the strict query.",type:"string"},{const:"prose",description:"The strict query ran without the symbol-name route.",type:"string"}]},SearchQueryRouteV1:{additionalProperties:!1,description:"The query-shape routing decision behind a page.",properties:{decided_by:{$ref:"#/$defs/SearchQueryRouteDeciderV1"},margin:{description:"Distance from the name gate in [-0.5, 0.5]: the share of the query's\ncontent words that are identifier-shaped, minus one half. The gate\nselects `name` at or above 0. Reported when the caller decided too.\nIt describes query shape only and is not an answerability signal.",format:"double",type:"number"},route:{$ref:"#/$defs/SearchQueryRouteKindV1"}},required:["route","margin","decided_by"],type:"object"},SearchResultDisplayV1:{additionalProperties:!1,properties:{kind:{type:"string"},name:{type:"string"},path:{type:"string"},qualified_name:{type:"string"}},required:["name","qualified_name","kind","path"],type:"object"},SearchResultRowV1:{additionalProperties:!1,description:"One ranked candidate with its generation-bound display metadata.",properties:{candidate:{$ref:"#/$defs/FusedCandidate"},display:{anyOf:[{$ref:"#/$defs/SearchResultDisplayV1"},{type:"null"}]},display_unavailable:{anyOf:[{$ref:"#/$defs/SearchDisplayUnavailableV1"},{type:"null"}],description:"Why `display` is absent from this ranked candidate."},final_ordinal:{format:"uint32",minimum:0,type:"integer"},lexical_routes:{description:"The lexical routes that ranked this candidate.",items:{$ref:"#/$defs/SearchRouteMatchV1"},type:["array","null"]},node_id:{description:"The graph symbol to read with `tracedecay_source_body`.",type:["string","null"]}},required:["candidate","final_ordinal"],type:"object"},SearchRouteMatchV1:{additionalProperties:!1,description:"One route that ranked a candidate, named by its route label.",properties:{matched_terms:{items:{type:"string"},type:"array"},route:{type:"string"},score_micros:{format:"uint64",minimum:0,type:"integer"},spelling_variants:{items:{$ref:"#/$defs/SearchSpellingVariantV1"},type:"array"}},required:["route","score_micros","matched_terms"],type:"object"},SearchSpellingVariantV1:{additionalProperties:!1,properties:{alternative:{type:"string"},query:{type:"string"}},required:["query","alternative"],type:"object"},SearchUnavailableV1:{additionalProperties:!1,properties:{code_generation:{type:["string","null"]},coverage:{$ref:"#/$defs/SearchCoverageV1"},detail:{anyOf:[{$ref:"#/$defs/ApplicationProblemDetailV1"},{type:"null"}],description:"Present when indexing is parked: its cause, remedy, and wake retry."},freshness:{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},query_fallback_digest:{description:"Always null: no fallback subpayload was produced.",type:["string","null"]},reason:{type:"string"},results:{description:"Always empty: no generation answered.",items:{$ref:"#/$defs/SearchResultRowV1"},type:"array"},status:{$ref:"#/$defs/PrimitiveUnavailableStatusV1"},verified_graph_evidence:{anyOf:[{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"},{type:"null"}]}},required:["freshness","results","status","reason","coverage"],type:"object"},SessionOrThreadId:v7,SourceFreshness:by,SourceInstanceKey:bg,SourceNamespace:bv,SourceOccurrenceId:bb,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/SearchCompleteV1"},{$ref:"#/$defs/SearchUnavailableV1"}],description:"What a search served: a ranked page, or the typed reason no generation\ncould answer.",title:"SearchResultV1"},{$defs:{PageRequest:_U,ResultProjection:vP,RetrievalOrder:vx,RetrievalRequestMeta:vj,SessionId:v8,TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{meta:{$ref:"#/$defs/RetrievalRequestMeta"},session_id:{$ref:"#/$defs/SessionId"}},required:["session_id","meta"],title:"SessionLookupRequest",type:"object"},{$defs:{RetrievalAnchorId:vI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"}},required:["anchors"],title:"SessionLookupResult",type:"object"},{$defs:{SessionRefreshFrontierV1:{additionalProperties:!1,properties:{committed_through:{format:"uint64",minimum:0,type:"integer"},observed_through:{format:"uint64",minimum:0,type:"integer"}},required:["observed_through","committed_through"],type:"object"},SessionRefreshGrainV1:{enum:["occurrence","logical_message","turn","session","thread","agent","summary"],type:"string"},SessionRefreshScopeV1:{description:"Session-store owner one refresh is bound to.\n\nThe caller selects the already-mounted project or profile authority. Exact\nprofile, project, repository, worktree, branch, store, and root identities\nstay daemon-owned and are resolved from that authority during admission.",oneOf:[{additionalProperties:!1,properties:{kind:{const:"project",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"profile",type:"string"}},required:["kind"],type:"object"}]},SessionRefreshSessionV1:{additionalProperties:!1,properties:{id:{type:"string"}},required:["id"],type:"object"},SessionRefreshSourceV1:{additionalProperties:!1,properties:{scope:{type:"string"}},required:["scope"],type:"object"},SessionRefreshTargetV1:{additionalProperties:!1,properties:{frontier:{$ref:"#/$defs/SessionRefreshFrontierV1"},grain:{$ref:"#/$defs/SessionRefreshGrainV1"},temporal_mode:{$ref:"#/$defs/TemporalModeV1"}},required:["temporal_mode","grain","frontier"],type:"object"},TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact route-selected session-refresh request body.\n\nEach current route selects the action itself; `scope` selects the mounted\nsession-store owner. Project-scoped requests are served under project-open\nadmission, profile-scoped requests by the authenticated profile authority.",properties:{handle:{type:["string","null"]},scope:{$ref:"#/$defs/SessionRefreshScopeV1"},session:{$ref:"#/$defs/SessionRefreshSessionV1"},source:{$ref:"#/$defs/SessionRefreshSourceV1"},target:{$ref:"#/$defs/SessionRefreshTargetV1"}},required:["scope","session","source","target"],title:"SessionRefreshActionRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionRefreshFrontierResultV1:be,SessionRefreshProgressV1:bt,SessionRefreshReceiptV1:br,SessionRefreshTerminalStateResultV1:bi,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalModeV1:bW,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{accepted_at:{format:"int64",type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},handle:{type:["string","null"]},operation_id:{type:["string","null"]},outcome:{$ref:"#/$defs/RetainedOutcomeStatusV1"},progress:{anyOf:[{$ref:"#/$defs/SessionRefreshProgressV1"},{type:"null"}]},receipt:{anyOf:[{$ref:"#/$defs/SessionRefreshReceiptV1"},{type:"null"}]},scope:{type:"string"},tool:{type:"string"}},required:["outcome","scope","tool"],title:"SessionRefreshBeginResultV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionRefreshFrontierResultV1:be,SessionRefreshProgressV1:bt,SessionRefreshReceiptV1:br,SessionRefreshTerminalStateResultV1:bi,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalModeV1:bW,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{accepted_at:{format:"int64",type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},handle:{type:["string","null"]},operation_id:{type:["string","null"]},outcome:{$ref:"#/$defs/RetainedOutcomeStatusV1"},progress:{anyOf:[{$ref:"#/$defs/SessionRefreshProgressV1"},{type:"null"}]},receipt:{anyOf:[{$ref:"#/$defs/SessionRefreshReceiptV1"},{type:"null"}]},scope:{type:"string"},tool:{type:"string"}},required:["outcome","scope","tool"],title:"SessionRefreshCancelResultV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionRefreshFrontierResultV1:be,SessionRefreshProgressV1:bt,SessionRefreshReceiptV1:br,SessionRefreshTerminalStateResultV1:bi,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalModeV1:bW,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},outcome:{$ref:"#/$defs/RetainedOutcomeStatusV1"},progress:{anyOf:[{$ref:"#/$defs/SessionRefreshProgressV1"},{type:"null"}]},receipt:{anyOf:[{$ref:"#/$defs/SessionRefreshReceiptV1"},{type:"null"}]},scope:{type:"string"},tool:{type:"string"}},required:["outcome","scope","tool"],title:"SessionRefreshStatusResultV1",type:"object"},{$defs:{RetainedTimeFilterV1:vq,SessionGitRefV1:{enum:["branch","worktree","commit"],type:"string"},SessionGitRelationV1:{enum:["produced","observed","all"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{git_ref:{$ref:"#/$defs/SessionGitRefV1"},limit:{format:"uint64",minimum:0,type:["integer","null"]},relation:{anyOf:[{$ref:"#/$defs/SessionGitRelationV1"},{type:"null"}]},since:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},until:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},value:{type:"string"}},required:["git_ref","value"],title:"SessionsForRequestV1",type:"object"},{$defs:{CorrelationIndexCountModeV1:{enum:["presence_only"],type:"string"},CorrelationIndexV1:{additionalProperties:!1,properties:{backfill_watermark:{format:"int64",type:["integer","null"]},commit_count:{format:"uint64",minimum:0,type:["integer","null"]},commits_present:{type:"boolean"},count_mode:{$ref:"#/$defs/CorrelationIndexCountModeV1"},generation:{type:["string","null"]},projection_available:{type:"boolean"},source_watermark:{type:["string","null"]},span_count:{format:"uint64",minimum:0,type:["integer","null"]},spans_present:{type:"boolean"}},required:["projection_available","spans_present","commits_present","count_mode"],type:"object"},RetainedOutcomeStatusV1:vR,SessionCorrelationHitV1:{additionalProperties:!1,properties:{branch:{type:["string","null"]},commit_sha:{type:["string","null"]},committed_at:{format:"int64",type:["integer","null"]},confidence:{format:"int64",type:["integer","null"]},event_count:{format:"int64",type:"integer"},evidence:{type:["string","null"]},evidence_message_id:{type:["string","null"]},first_ts:{format:"int64",type:["integer","null"]},last_ts:{format:"int64",type:["integer","null"]},provider:{type:"string"},relation:{type:["string","null"]},session_id:{type:"string"},sources:{items:{type:"string"},type:"array"},span_count:{format:"int64",type:"integer"},span_overlap_kind:{type:["string","null"]},worktree:{type:["string","null"]}},required:["provider","session_id","event_count","span_count","sources"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:"integer"},git_ref:{type:["string","null"]},index:{anyOf:[{$ref:"#/$defs/CorrelationIndexV1"},{type:"null"}]},index_empty:{type:["boolean","null"]},message:{type:["string","null"]},observed_count:{format:"uint",minimum:0,type:["integer","null"]},observed_sessions:{items:{$ref:"#/$defs/SessionCorrelationHitV1"},type:["array","null"]},problem_code:{type:["string","null"]},relation:{type:["string","null"]},results:{items:{$ref:"#/$defs/SessionCorrelationHitV1"},type:"array"},since:{format:"int64",type:["integer","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},until:{format:"int64",type:["integer","null"]},value:{type:["string","null"]}},required:["count","results","status"],title:"SessionsForResultV1",type:"object"},{$defs:{NodeExpansionCostV1:_A,SymbolSignatureV1:{additionalProperties:!1,properties:{cost_to_expand:{$ref:"#/$defs/NodeExpansionCostV1"},docstring:{type:["string","null"]},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},is_async:{type:"boolean"},kind:{type:"string"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"},signature:{type:["string","null"]},start_line:{format:"uint32",minimum:0,type:"integer"},unavailable_fields:{items:{type:"string"},type:"array"},visibility:{type:"string"}},required:["node_id","name","qualified_name","kind","visibility","is_async","file","start_line","end_line","cost_to_expand","unavailable_fields"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",items:{$ref:"#/$defs/SymbolSignatureV1"},title:"Array_of_SymbolSignatureV1",type:"array"},{$defs:{ProjectId:_4,RepositoryId:vb,SimilarMatchClassV1:bc,SimilarTargetV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"symbol_occurrence",type:"string"},symbol_occurrence_id:{$ref:"#/$defs/SymbolOccurrenceId"}},required:["kind","symbol_occurrence_id"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"source_range",type:"string"},path:{type:"string"},span:{$ref:"#/$defs/SourceSpan"}},required:["kind","path","span"],type:"object"}]},SourceSpan:b$,SymbolOccurrenceId:bq},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{type:["string","null"]},match_classes:{items:{$ref:"#/$defs/SimilarMatchClassV1"},type:"array"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},result_limit:{description:"Preferred result page size.",format:"uint32",minimum:0,type:"integer"},target:{$ref:"#/$defs/SimilarTargetV1"},work_limit:{format:"uint32",minimum:0,type:"integer"}},required:["project_id","repository_id","target","match_classes","result_limit","work_limit"],title:"SimilarSurfaceRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ManifestDigest:_l,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,ProjectId:_4,RepositoryId:vb,SimilarCoverageV1:{oneOf:[{additionalProperties:!1,properties:{status:{const:"complete",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{status:{const:"partial",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{minimum_tokens:{format:"uint32",minimum:0,type:"integer"},status:{const:"excluded_too_small",type:"string"}},required:["status","minimum_tokens"],type:"object"},{additionalProperties:!1,properties:{maximum_bytes:{format:"uint64",minimum:0,type:"integer"},maximum_tokens:{format:"uint32",minimum:0,type:"integer"},status:{const:"excluded_too_large",type:"string"}},required:["status","maximum_tokens","maximum_bytes"],type:"object"},{additionalProperties:!1,properties:{status:{const:"excluded_incomplete_tokenization",type:"string"}},required:["status"],type:"object"}]},SimilarFamilyV1:bd,SimilarMatchClassV1:bc,SimilarOccurrenceV1:bl,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/SimilarCoverageV1"},families:{items:{$ref:"#/$defs/SimilarFamilyV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},source:{$ref:"#/$defs/SimilarOccurrenceV1"},source_generation:{$ref:"#/$defs/CodeGenerationId"}},required:["source","families","source_generation","coverage"],title:"SimilarResultV1",type:"object"},{$defs:{ManagedSkillState:_c},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_body:{default:!1,description:"If true, include each skill's body_markdown in the list response\n(default: false).",type:"boolean"},state:{anyOf:[{$ref:"#/$defs/ManagedSkillState"},{type:"null"}],description:"Optional managed-skill lifecycle state filter."}},title:"SkillListSurfaceRequestV1",type:"object"},{$defs:{AutomationReadStatusV1:fH,ManagedSkillMaterializationScope:_n,ManagedSkillMetadata:_a,ManagedSkillProvenance:_s,ManagedSkillSource:_d,ManagedSkillState:_c,SkillImprovementRecommendation:bp,SkillInstallTarget:bu,SkillListEntryV1:{additionalProperties:!1,properties:{body_markdown:{description:"Present only when the request asked for bodies.",type:["string","null"]},improvement_recommendation:{anyOf:[{$ref:"#/$defs/SkillImprovementRecommendation"},{type:"null"}]},metadata:{$ref:"#/$defs/ManagedSkillMetadata"},stale_recommendation:{anyOf:[{$ref:"#/$defs/SkillStaleRecommendation"},{type:"null"}]},support_file_count:{format:"uint",minimum:0,type:"integer"},support_file_paths:{items:{type:"string"},type:"array"},usage_summary:{$ref:"#/$defs/SkillUsageRecord"}},required:["metadata","support_file_count","support_file_paths","usage_summary"],type:"object"},SkillStaleRecommendation:bm,SkillUsageRecord:bf},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:"integer"},profile_root:{type:"string"},skills:{items:{$ref:"#/$defs/SkillListEntryV1"},type:"array"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","profile_root","count","skills"],title:"SkillListResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{id:{description:"Managed skill id to read.",type:"string"},include_support_files:{default:!1,description:"Include support-file byte payloads. Default false; the response still\nlists each path and byte length.",type:"boolean"}},required:["id"],title:"SkillViewSurfaceRequestV1",type:"object"},{$defs:{AutomationReadStatusV1:fH,ManagedSkill:{properties:{body_markdown:{type:"string"},metadata:{$ref:"#/$defs/ManagedSkillMetadata"},support_files:{items:{$ref:"#/$defs/ManagedSupportFile"},type:"array"}},required:["metadata","body_markdown","support_files"],type:"object"},ManagedSkillMaterializationScope:_n,ManagedSkillMetadata:_a,ManagedSkillProvenance:_s,ManagedSkillSource:_d,ManagedSkillState:_c,ManagedSupportFile:{properties:{bytes:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},type:"array"},path:{type:"string"}},required:["path","bytes"],type:"object"},SkillImprovementRecommendation:bp,SkillInstallTarget:bu,SkillStaleRecommendation:bm,SkillSupportFileSummaryV1:{additionalProperties:!1,properties:{byte_len:{format:"uint",minimum:0,type:"integer"},path:{type:"string"}},required:["path","byte_len"],type:"object"},SkillUsageRecord:bf},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{improvement_recommendation:{anyOf:[{$ref:"#/$defs/SkillImprovementRecommendation"},{type:"null"}]},profile_root:{type:"string"},skill:{$ref:"#/$defs/ManagedSkill",description:"The skill package; `support_files` is empty unless the request\nincluded them."},stale_recommendation:{anyOf:[{$ref:"#/$defs/SkillStaleRecommendation"},{type:"null"}]},status:{$ref:"#/$defs/AutomationReadStatusV1"},support_file_summaries:{items:{$ref:"#/$defs/SkillSupportFileSummaryV1"},type:"array"},support_files_included:{type:"boolean"},usage_summary:{$ref:"#/$defs/SkillUsageRecord"}},required:["status","profile_root","skill","usage_summary","support_files_included","support_file_summaries"],title:"SkillViewResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{node_id:{type:"string"}},required:["node_id"],title:"SourceBodyPrimitiveRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{body:{type:"string"},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},node_id:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["node_id","file","start_line","end_line","body"],title:"SourceBodyPrimitiveResult",type:"object"},{$defs:{ManifestDigest:_l,UseCaseId:bK},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",oneOf:[{additionalProperties:!1,description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",properties:{attempt_idempotency_key:{type:"string"},confirm:{default:!1,type:"boolean"},disposition:{const:"inspect",type:"string"},effect_id:{type:"string"},idempotency_key:{type:"string"},input_digest:{type:"string"},original_operation:{$ref:"#/$defs/UseCaseId"}},required:["original_operation","effect_id","idempotency_key","attempt_idempotency_key","input_digest","disposition"],type:"object"},{additionalProperties:!1,description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",properties:{attempt_idempotency_key:{type:"string"},committed_state:{$ref:"#/$defs/ManifestDigest"},confirm:{default:!1,type:"boolean"},disposition:{const:"confirm_committed",type:"string"},effect_id:{type:"string"},idempotency_key:{type:"string"},input_digest:{type:"string"},original_operation:{$ref:"#/$defs/UseCaseId"}},required:["original_operation","effect_id","idempotency_key","attempt_idempotency_key","input_digest","disposition","committed_state"],type:"object"},{additionalProperties:!1,description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",properties:{attempt_idempotency_key:{type:"string"},confirm:{default:!1,type:"boolean"},disposition:{const:"confirm_unchanged",type:"string"},effect_id:{type:"string"},idempotency_key:{type:"string"},input_digest:{type:"string"},original_operation:{$ref:"#/$defs/UseCaseId"}},required:["original_operation","effect_id","idempotency_key","attempt_idempotency_key","input_digest","disposition"],type:"object"},{additionalProperties:!1,description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",properties:{attempt_idempotency_key:{type:"string"},confirm:{default:!1,type:"boolean"},disposition:{const:"acknowledge_partial",type:"string"},effect_id:{type:"string"},idempotency_key:{type:"string"},input_digest:{type:"string"},observed_state:{$ref:"#/$defs/ManifestDigest"},original_operation:{$ref:"#/$defs/UseCaseId"}},required:["original_operation","effect_id","idempotency_key","attempt_idempotency_key","input_digest","disposition","observed_state"],type:"object"}],title:"SourceEditReconcileSurfaceRequestV1",type:"object"},{$defs:{FileOccurrenceId:gs,GitOidV1:gq,PageRequest:_U,ResultProjection:vP,RetrievalOrder:vx,RetrievalRequestMeta:vj,SourceSpan:b$,TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{additionalProperties:!1,description:"Read an exact byte span from the current indexed file occurrence.",properties:{file:{$ref:"#/$defs/FileOccurrenceId",description:"Canonical file occurrence from `code_exact_occurrence` at\n`items[].occurrence.file`; a logical path is not a file occurrence identity."},meta:{$ref:"#/$defs/RetrievalRequestMeta"},span:{$ref:"#/$defs/SourceSpan"}},required:["file","span","meta"],type:"object"},{additionalProperties:!1,description:"Read a bounded range of whole lines from an immutable Git revision.",properties:{end_line:{description:"One-based last line, inclusive. Large ranges are clipped with `next_line`.",format:"uint32",minimum:0,type:"integer"},file:{description:"Canonical repository-relative path in that revision.",type:"string"},revision:{$ref:"#/$defs/GitOidV1",description:"Full lowercase commit OID; mutable names and abbreviations are refused."},start_line:{description:"One-based first line, inclusive.",format:"uint32",minimum:0,type:"integer"}},required:["revision","file","start_line","end_line"],type:"object"}],title:"SourceLinesRequest"},{$defs:{GitOidV1:gq,RetrievalAnchorId:vI,SourceReference:{additionalProperties:!1,properties:{anchor:{$ref:"#/$defs/RetrievalAnchorId"},span:{$ref:"#/$defs/SourceSpan"}},required:["anchor","span"],type:"object"},SourceSpan:b$},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{additionalProperties:!1,properties:{body:{type:["string","null"]},file:{type:["string","null"]},references:{items:{$ref:"#/$defs/SourceReference"},type:"array"}},required:["references"],type:"object"},{additionalProperties:!1,properties:{blob_oid:{$ref:"#/$defs/GitOidV1"},body:{type:"string"},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},next_line:{description:"First unread line within the requested range. Keep the original\nrevision, file, and requested end line when continuing.",format:"uint32",minimum:0,type:["integer","null"]},revision:{$ref:"#/$defs/GitOidV1"},span:{$ref:"#/$defs/SourceSpan"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["file","revision","blob_oid","start_line","end_line","span","body"],type:"object"}],title:"SourceLinesResult"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{file:{type:"string"}},required:["file"],title:"SourceOutlinePrimitiveRequest",type:"object"},{$defs:{SymbolPrimitiveRecord:bI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{file:{type:"string"},symbols:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"}},required:["file","symbols"],title:"SourceOutlinePrimitiveResult",type:"object"},{$defs:{BranchStackEdgeV1:f3,BranchStackId:f9,BranchStackNodeV1:f5,BranchStackRevisionId:f8,CommitId:hq,ManifestDigest:_l,NativeIntegrationDirectionV1:_R,NativeIntegrationSelectionDeclarationV1:{description:"Explicit caller declaration for one native-integration selection.\n\nDeclared stacks contain the visible nodes and edges, while the daemon\nderives canonical order and the revision digest through the domain\nconstructor. Callers cannot submit either derived field.",oneOf:[{additionalProperties:!1,properties:{binding:{additionalProperties:!1,properties:{destination_node_id:{$ref:"#/$defs/StackNodeId"},direction:{$ref:"#/$defs/NativeIntegrationDirectionV1"},edges:{items:{$ref:"#/$defs/BranchStackEdgeV1"},type:"array"},nodes:{items:{$ref:"#/$defs/BranchStackNodeV1"},type:"array"},revision_id:{$ref:"#/$defs/BranchStackRevisionId"},source_node_id:{$ref:"#/$defs/StackNodeId"},stack_id:{$ref:"#/$defs/BranchStackId"}},required:["stack_id","revision_id","nodes","edges","source_node_id","destination_node_id","direction"],type:"object"},kind:{const:"declared_stack_edge",type:"string"}},required:["kind","binding"],type:"object"},{additionalProperties:!1,properties:{binding:{additionalProperties:!1,properties:{destination_ref:{$ref:"#/$defs/RefId"},proposal_digest:{$ref:"#/$defs/ManifestDigest"},source_ref:{$ref:"#/$defs/RefId"}},required:["proposal_digest","source_ref","destination_ref"],type:"object"},kind:{const:"independent_branch",type:"string"}},required:["kind","binding"],type:"object"}]},ProjectId:_4,RefId:vm,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,StackNodeId:bw,WorktreeId:SB,WorktreeInventoryEpoch:SK,WorktreeInventorySnapshotId:SJ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact caller-supplied identity frozen by `stack_snapshot`.\n\nThis proof binds the exact authorized `ProjectId`, `RepositoryId`, source\nand destination worktree/ref identity, frozen inventory, scope/grant/policy\nrevisions, and one declared-edge or independent-branch selection. Paths,\nfree-form SHA values, branch display names, and provider topology remain\nunrepresentable.",properties:{authorized_scope_set_digest:{$ref:"#/$defs/ManifestDigest"},authorized_scope_set_id:{$ref:"#/$defs/ScopeSetId"},authorized_scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},destination:{$ref:"#/$defs/ResolvedScope"},grant_digest:{$ref:"#/$defs/ManifestDigest"},inventory_epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},inventory_snapshot_id:{$ref:"#/$defs/WorktreeInventorySnapshotId"},policy_digest:{$ref:"#/$defs/ManifestDigest"},selection:{$ref:"#/$defs/NativeIntegrationSelectionDeclarationV1"},source:{$ref:"#/$defs/ResolvedScope"}},required:["source","destination","authorized_scope_set_id","authorized_scope_set_revision","authorized_scope_set_digest","inventory_snapshot_id","inventory_epoch","selection","grant_digest","policy_digest"],title:"NativeIntegrationStackSnapshotSurfaceRequest",type:"object"},{$defs:{CodeIndexReadinessTargetV1:{description:"The readiness a status caller can wait for.",oneOf:[{const:"fresh",description:"A sealed complete generation serves exact and lexical reads for the\ncurrent source: `code_index_freshness.status` is `current`.",type:"string"},{const:"ready",description:"`fresh`, and the generation's native code graph also serves.",type:"string"},{const:"graph_ready",description:"A published generation's native code graph serves and no convergence\npark is set, whatever the source freshness. Waiting for it never\nsweeps the source, so it cannot arm the reconcile it would observe.",type:"string"}]},CodeIndexReadinessWaitV1:{additionalProperties:!1,description:"`tracedecay_status` `wait_for`: hold the status read until the worktree\nreaches `state`, for at most the caller's `timeout_ms`.",properties:{state:{$ref:"#/$defs/CodeIndexReadinessTargetV1"},timeout_ms:{format:"uint64",minimum:0,type:"integer"}},required:["state","timeout_ms"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{admission_only:{default:!1,description:"Report only that the project route is admitted, reading no graph,\nindex, or session state. Default false.",type:"boolean"},include_branch_diagnostics:{default:!1,description:"Full tracked-branch diagnostic list. Default false.",type:"boolean"},include_session_ingest:{default:!1,description:"Session-ingest health. Default false.",type:"boolean"},include_staleness:{default:!1,description:"Git staleness object. Default false.",type:"boolean"},include_storage_health:{default:!1,description:"Storage-health snapshot. Default false.",type:"boolean"},wait_for:{anyOf:[{$ref:"#/$defs/CodeIndexReadinessWaitV1"},{type:"null"}],description:"Hold the status read until the code index reaches `state` (`fresh`:\nstatus `current`; `ready`: also native graph serving; `graph_ready`: a\npublished generation's native graph serves, whatever the freshness),\nfor at most `timeout_ms`. The payload's `wait` reports `reached`,\n`timed_out` with `last_state`, or `unavailable` with `reason`."}},title:"StatusSurfaceRequestV1",type:"object"},{$defs:{CodeCloneIndexBudgetsV1:{description:"Fixed automatic clone-discovery limits.",properties:{minimum_body_tokens:{format:"uint64",minimum:0,type:"integer"}},required:["minimum_body_tokens"],type:"object"},CodeCloneIndexCoverageV1:{description:"Coverage retained by one clone-index artifact or in-progress successor.\n\nCounts are `None` until the clone artifact has observed the corresponding\ndenominator. A complete empty repository reports `Some(0)`, which keeps a\ndesigned zero distinct from unavailable coverage.",properties:{conservative_normalized_bodies:{description:"Eligible bodies with a conservative exact posting.",format:"uint64",minimum:0,type:["integer","null"]},eligible_source_bodies:{description:"Source bodies admitted for automatic clone discovery.",format:"uint64",minimum:0,type:["integer","null"]},exact_postings:{description:"Conservative and rename-normalized exact posting rows.",format:"uint64",minimum:0,type:["integer","null"]},excluded_incomplete_tokenization_bodies:{description:"Bodies excluded because conservative tokenization was incomplete.",format:"uint64",minimum:0,type:["integer","null"]},excluded_too_large_bodies:{description:"Bodies excluded because they exceed the automatic-discovery token maximum.",format:"uint64",minimum:0,type:["integer","null"]},excluded_too_small_bodies:{description:"Bodies excluded because they are below the automatic-discovery minimum.",format:"uint64",minimum:0,type:["integer","null"]},payloads_reused:{description:"Current payload occurrences reused from the preceding generation.",format:"uint64",minimum:0,type:["integer","null"]},rename_normalized_bodies:{description:"Eligible bodies with a complete rename-normalized exact posting.",format:"uint64",minimum:0,type:["integer","null"]},rename_partial_bodies:{description:"Eligible bodies whose rename normalization is partial.",format:"uint64",minimum:0,type:["integer","null"]},rename_unsupported_bodies:{description:"Eligible bodies whose language has no rename normalization.",format:"uint64",minimum:0,type:["integer","null"]},source_bodies:{description:"Clone body occurrences observed in the sealed lexical source.",format:"uint64",minimum:0,type:["integer","null"]},unique_payloads:{description:"Distinct content-addressed payloads retained by the artifact.",format:"uint64",minimum:0,type:["integer","null"]}},type:"object"},CodeCloneIndexObservationV1:{description:"Generation-pinned clone-index evidence shared by non-error readiness states.",properties:{artifact_format_revision:{format:"uint32",minimum:0,type:["integer","null"]},budgets:{$ref:"#/$defs/CodeCloneIndexBudgetsV1"},conservative_normalization_revision:{format:"uint16",maximum:65535,minimum:0,type:"integer"},coverage:{$ref:"#/$defs/CodeCloneIndexCoverageV1"},generation_id:{type:"string"},rename_normalization_revision:{format:"uint16",maximum:65535,minimum:0,type:"integer"},resources:{$ref:"#/$defs/CodeCloneIndexResourcesV1"},source_revision:{type:["string","null"]}},required:["generation_id","conservative_normalization_revision","rename_normalization_revision","coverage","budgets","resources"],type:"object"},CodeCloneIndexResourcesV1:{description:"Measured resources and update accounting for one clone-index generation.",properties:{bytes_on_disk:{description:"Durable artifact bytes.",format:"uint64",minimum:0,type:["integer","null"]},changed_symbol_update_micros:{description:"Latest observed source-edit arrival through clone-ready publication.",format:"uint64",minimum:0,type:["integer","null"]},peak_scratch_memory_bytes:{description:"Largest measured clone-row serialization scratch during the build.",format:"uint64",minimum:0,type:["integer","null"]},stale_invalidations:{description:"Prior clone payload bindings invalidated by the latest publication.",format:"uint64",minimum:0,type:["integer","null"]}},type:"object"},CodeCloneIndexStatusV1:{description:"Clone readiness, independent from lexical and graph serving.",oneOf:[{description:"The sealed lexical artifact or its clone rows cannot be read.",properties:{reason:{type:"string"},state:{const:"unavailable",type:"string"}},required:["state","reason"],type:"object"},{description:"Some clone evidence is readable, but required postings are missing.",properties:{observation:{$ref:"#/$defs/CodeCloneIndexObservationV1"},omission_reasons:{items:{type:"string"},type:"array"},state:{const:"partial",type:"string"}},required:["state","observation","omission_reasons"],type:"object"},{description:"Required exact postings cover every eligible body.",properties:{observation:{$ref:"#/$defs/CodeCloneIndexObservationV1"},state:{const:"ready",type:"string"}},required:["state","observation"],type:"object"},{description:"The artifact is readable but belongs to a superseded source generation.",properties:{observation:{$ref:"#/$defs/CodeCloneIndexObservationV1"},reason:{type:"string"},state:{const:"stale",type:"string"}},required:["state","observation","reason"],type:"object"}]},CodeGraphServingReadinessV1:{description:"Interactive graph-serving state for the latest sealed generation.\n\nA sealed generation can expose truthful census statistics before its graph\nprojection is ready to serve queries, so readiness is reported separately.",oneOf:[{description:"No graph-serving authority exists for this worktree or generation.",properties:{reason:{type:"string"},state:{const:"unavailable",type:"string"}},required:["state","reason"],type:"object"},{description:"The sealed generation exists, but graph activation has not completed.",properties:{state:{const:"pending",type:"string"}},required:["state"],type:"object"},{description:"Graph activation completed without a serving projection.",properties:{reason:{type:"string"},state:{const:"refused",type:"string"}},required:["state","reason"],type:"object"},{description:"The verified graph projection is installed, but the engine or catalog\nits reads need is not resident: it is still being built, or it was\nreleased for memory. Graph reads answer the retryable warming state\nand restore it.",properties:{reason:{type:"string"},state:{const:"warming",type:"string"}},required:["state","reason"],type:"object"},{description:"The verified graph projection is installed for interactive reads.",properties:{state:{const:"ready",type:"string"}},required:["state"],type:"object"}]},CodeIndexBuildBlockedReasonV1:h_,CodeIndexBuildPhaseV1:{description:"The durable build phase whose committed boundary the dashboard is reading.\n\nA phase is not inferred from scheduler state. The mounted registry publishes\nthe exact phase that owns the active generation.",oneOf:[{enum:["source_scan","relational_preparation","bulk_commit","index_build","verification","ready"],type:"string"},{const:"graph_publication",description:"Text serving is built and the pass that sealed the generation is\nstill publishing its native graph.",type:"string"}]},CodeIndexBuildProgressV1:{description:"The latest committed progress boundary for one active code-index generation.\n\nEvery count is scoped to `generation_id`. The snapshot never includes a\nstaged page: work is reported only after the batch that owns it commits.",properties:{blocked_reason:{anyOf:[{$ref:"#/$defs/CodeIndexBuildBlockedReasonV1"},{type:"null"}],description:"Reason the active generation cannot currently advance, when known."},committed_chunks:{description:"Search chunks committed to the artifact database.",format:"uint64",minimum:0,type:"integer"},committed_imports:{description:"Import evidence rows committed to the artifact database.",format:"uint64",minimum:0,type:"integer"},committed_pages:{description:"Source pages committed to the artifact database.",format:"uint64",minimum:0,type:"integer"},committed_payload_bytes:{description:"Payload bytes committed to the artifact database.",format:"uint64",minimum:0,type:"integer"},completed_files:{description:"Authenticated sealed-source file boundary completed by committed work.",format:"uint64",minimum:0,type:"integer"},completed_lexical_units:{description:"Authenticated lexical-span boundary completed by committed work, in the\nsealed source's own advance unit.\n\nThe unit is the source's, not this surface's: a sealed-layout source\nadvances over the files-array byte span, while a published or\npartitioned source advances over file ordinals because its file records\nare not a contiguous byte range at all. Both are monotone and share the\ndenominator below, so completion and the derived estimate are truthful;\nnaming them bytes was not, and a consumer that multiplied this by an\naverage file size was wrong by orders of magnitude (issue #1205).",format:"uint64",minimum:0,type:"integer"},current_batch_pages:{description:"Source pages in the batch currently being processed.",format:"uint64",minimum:0,type:"integer"},current_batch_payload_bytes:{description:"Sealed payload bytes in the batch currently being processed.",format:"uint64",minimum:0,type:"integer"},daemon_incarnation:{description:"Durable daemon-authority epoch that produced this snapshot.\n\nThis orders snapshots across daemon restarts without relying on wall\nclock time.",format:"uint64",minimum:0,type:"integer"},elapsed_micros:{description:"Monotonic elapsed time for this process's active generation build.",format:"uint64",minimum:0,type:"integer"},estimated_remaining_seconds:{description:"Estimated remaining build duration, absent without a truthful rate.",format:"uint64",minimum:0,type:["integer","null"]},files_per_second:{description:"Rolling committed-file throughput, absent until it is established.",format:"double",type:["number","null"]},generation_id:{description:"Exact generation receiving the committed build work.",type:"string"},last_commit_latency_micros:{description:"Duration of the last committed SQLite batch, when one exists.",format:"uint64",minimum:0,type:["integer","null"]},last_progress_micros:{description:"Unix-epoch timestamp of the last durable progress publication.",format:"int64",type:"integer"},lexical_units_per_second:{description:"Rolling committed lexical-span throughput in units per second, absent\nuntil it is established. Not a byte rate; see\n[`Self::completed_lexical_units`].",format:"double",type:["number","null"]},phase:{$ref:"#/$defs/CodeIndexBuildPhaseV1",description:"Durable pipeline phase that published this snapshot."},producer_incarnation:{description:"Registry-minted scheduler incarnation within one daemon.\n\nA worktree retirement/remount creates a new value. `progress_epoch` is\ncomparable only when both incarnation fields match.",format:"uint64",minimum:0,type:"integer"},progress_epoch:{description:"Monotonic publication epoch for replacing delayed progress reads.",format:"uint64",minimum:0,type:"integer"},sealed_source_digest:{description:"Identity of the sealed source whose authenticated bounds define progress.",type:"string"},total_files:{description:"Authenticated sealed-source file bound for this generation.",format:"uint64",minimum:0,type:"integer"},total_lexical_units:{description:"Authenticated lexical-span bound for this generation, in the same unit\nas [`Self::completed_lexical_units`].",format:"uint64",minimum:0,type:"integer"}},required:["generation_id","daemon_incarnation","producer_incarnation","progress_epoch","sealed_source_digest","phase","committed_pages","committed_chunks","committed_imports","committed_payload_bytes","completed_files","total_files","completed_lexical_units","total_lexical_units","current_batch_pages","current_batch_payload_bytes","elapsed_micros","last_progress_micros"],type:"object"},CodeIndexConvergenceParkedV1:hv,CodeIndexFreshnessCoverageV1:{description:"Coverage of one freshness read. Distinct from [`CodeIndexStalenessStateV1`]:\na generation can be fresh and still omit hook-hint counts, or unverified\nwhile the ladder would otherwise say ready.\n\n`Unobserved` is only the constructed default. A projected read never emits\nit, so an absent observation cannot be mistaken for `complete`.",oneOf:[{enum:["unobserved","complete","partial_refresh_in_progress","partial_artifact_restore","partial_source_verification","partial_unverified_restore","partial_hook_hint_overflow"],type:"string"},{const:"partial_omitted_sources",description:"The sealed generation is fresh for every source it can index, and\n[`CodeIndexWorktreeFreshnessV1::omitted_sources`] names the sources it\ncannot. Waiting cannot change it.",type:"string"}]},CodeIndexGenerationRecoveryServingV1:{description:"Serving disposition of an incompatible generation during recovery.",enum:["preserved","refused"],type:"string"},CodeIndexGenerationRecoveryV1:{description:"Recovery state for a durable generation sealed under a different production\nowner configuration.",properties:{incompatibilities:{description:"Stable owner-input reason codes reported by the code-index authority.",items:{type:"string"},type:"array"},incompatible_generation_id:{description:"Generation retired from incremental reuse.",type:"string"},serving:{$ref:"#/$defs/CodeIndexGenerationRecoveryServingV1",description:"Whether the prior generation may continue serving while its replacement\nbuilds under the current configuration."}},required:["incompatible_generation_id","incompatibilities","serving"],type:"object"},CodeIndexOmittedSourceV1:hb,CodeIndexOmittedSourcesV1:h$,CodeIndexReadinessWaitOutcomeV1:{description:"How a `wait_for` status read ended. The status payload beside it is read\nafter the wait ends.",oneOf:[{properties:{outcome:{const:"reached",type:"string"}},required:["outcome"],type:"object"},{description:"The caller's budget elapsed; `last_state` is the last observed\n`code_index_freshness.status`.",properties:{last_state:{type:"string"},outcome:{const:"timed_out",type:"string"}},required:["outcome","last_state"],type:"object"},{description:"Waiting cannot reach the target: no scheduler is mounted, graph\nserving was refused, convergence is parked, or the request ended.",properties:{outcome:{const:"unavailable",type:"string"},reason:{type:"string"}},required:["outcome","reason"],type:"object"}]},CodeIndexRestoreProgressV1:{description:"Bounded authentication work required to restore one immutable lexical\nartifact as a serving reader.\n\nThe unit is a fixed restore check, not bytes or build work. Completed\nchecks are published only after they pass. `authenticated_remaining` is\nalways `authenticated_total - authenticated_completed`, so a caller can\ndistinguish bounded cold restore from an unbounded rebuild.",properties:{artifact_digest:{description:"Whole-file content address from the durable artifact descriptor.",type:"string"},authenticated_completed:{description:"Successfully completed authentication checks.",format:"uint64",minimum:0,type:"integer"},authenticated_remaining:{description:"Checks that have not completed yet.",format:"uint64",minimum:0,type:"integer"},authenticated_total:{description:"Fixed number of authentication checks for this restore.",format:"uint64",minimum:0,type:"integer"},generation_id:{description:"Generation whose lexical serving seat is being restored.",type:"string"}},required:["generation_id","artifact_digest","authenticated_completed","authenticated_total","authenticated_remaining"],type:"object"},CodeIndexSourceOmissionReasonV1:hS,CodeIndexStalenessStateV1:hk,CodeIndexWorktreeFreshnessV1:{description:"Freshness/generation state for one mounted worktree.\n\n`Deserialize` is part of the wire contract: the CLI status command decodes\nexactly this type back out of the daemon's `tracedecay_status` response,\nkeeping one authority for the freshness shape.",properties:{clone_index:{anyOf:[{$ref:"#/$defs/CodeCloneIndexStatusV1"},{type:"null"}],description:"Clone readiness from the same sealed lexical artifact."},code_graph_serving:{anyOf:[{$ref:"#/$defs/CodeGraphServingReadinessV1"},{type:"null"}],description:"Whether that generation's verified graph projection can serve reads."},coverage:{$ref:"#/$defs/CodeIndexFreshnessCoverageV1",description:"Whether this read covers the complete mounted scheduler state."},generation_recovery:{anyOf:[{$ref:"#/$defs/CodeIndexGenerationRecoveryV1"},{type:"null"}],description:"One-shot owner-configuration recovery currently replacing an\nincompatible durable generation."},hook_hint_count:{description:"Pending hook-hint count, when cheaply available.",format:"uint64",minimum:0,type:["integer","null"]},last_reconcile_micros:{description:"Last reconcile observation time (microseconds since the Unix epoch).",format:"int64",type:["integer","null"]},latest_generation_id:{description:"Latest sealed generation identity, when a complete generation exists.",type:["string","null"]},omitted_sources:{anyOf:[{$ref:"#/$defs/CodeIndexOmittedSourcesV1"},{type:"null"}],description:"Sources the serving snapshot captured but does not index, when any."},parked:{anyOf:[{$ref:"#/$defs/CodeIndexConvergenceParkedV1"},{type:"null"}],description:"Deterministic contract violation currently parking background\nconvergence, when one is observed. `staleness_state` reads `parked`\nwhile this is set and no generation serves."},progress:{anyOf:[{$ref:"#/$defs/CodeIndexBuildProgressV1"},{type:"null"}],description:"Latest committed progress for the active generation, if one is mounted."},rebuild_in_flight:{description:"Whether the exact scheduler route owns a reconcile pass or has a\npending wake. A stale seated generation with this false is stalled,\nnot in a routine rebuild window.",type:"boolean"},repository_id:{description:"Stable repository identity resolved by the scheduler.",type:["string","null"]},restore_progress:{anyOf:[{$ref:"#/$defs/CodeIndexRestoreProgressV1"},{type:"null"}],description:"Bounded immutable-artifact restore work currently in flight. This is\nseparate from build progress because restore commits no index data."},sealed_at_micros:{description:"Time the complete generation was durably sealed.",format:"int64",type:["integer","null"]},snapshot_content_identity:{description:"Content identity of the complete source snapshot.",type:["string","null"]},source_reference:{description:"Exact source reference captured by the sealed generation.",type:["string","null"]},source_revision:{description:"Exact source revision captured by the sealed generation.",type:["string","null"]},staleness_state:{anyOf:[{$ref:"#/$defs/CodeIndexStalenessStateV1"},{type:"null"}],description:"Staleness-ladder state from the last scheduler execution. `fresh` means\nthe scheduler most recently observed a fresh source; the status read\ndoes not probe the worktree to revalidate that observation."},worktree_id:{description:"Stable worktree identity resolved by the scheduler.",type:["string","null"]},worktree_root:{description:"Display path of the mounted worktree root.",type:"string"}},required:["worktree_root","rebuild_in_flight","coverage"],type:"object"},LcmConvergenceStateV1:gX,LcmConvergenceV1:gY,LcmDoctorProjectionStateV1:g1,LcmDoctorProjectionV1:g0,NativeHostIdentityV1:{enum:["claude_code","cursor_desktop","cursor_cloud","codex","hermes","kiro","cline","roo_code","kilo","kimi_code","open_code","pi","factory_droid"],type:"string"},ProjectStatusV1:{additionalProperties:!1,properties:{active_branch:{type:["string","null"]},branch_diagnostics:!0,branch_drifted:{type:["boolean","null"]},branch_mismatch:{anyOf:[{$ref:"#/$defs/StatusBranchMismatchV1"},{type:"null"}]},branch_resolution:{type:["string","null"]},branch_warnings:{items:{type:"string"},type:["array","null"]},code_index_freshness:{$ref:"#/$defs/StatusCodeIndexFreshnessV1"},code_index_freshness_warning:{type:["string","null"]},current_branch:{type:["string","null"]},git_staleness:{anyOf:[{$ref:"#/$defs/StatusGitStalenessV1"},{type:"null"}]},github_source:{description:"The checkout's GitHub source as its advisory owner observed it."},graph_statistics:{description:"The exact-scope sealed-generation census."},hook_replay:{$ref:"#/$defs/StatusHookReplayV1",description:"The daemon's drain of this project's hook spools, as its last sweep\nleft it."},live_branch:{type:["string","null"]},memory:{$ref:"#/$defs/StatusMemoryV1"},parent_branch:{type:["string","null"]},project_root:{type:"string"},reset_required_stores:{description:"Registered stores this binary serves only as a typed reset-required\nrefusal, each with the command that resets it.",items:{$ref:"#/$defs/StoreResetRequiredV1"},type:"array"},retrieval_serving:{anyOf:[{$ref:"#/$defs/StatusRetrievalServingV1"},{type:"null"}],description:"Whether exact-scope retrieval can serve, when the census authority is\nattached."},schema_convergence:{$ref:"#/$defs/StatusSchemaConvergenceV1"},scope_prefix:{type:["string","null"]},server:{description:"The serving MCP server's request counters."},serving_branch:{type:["string","null"]},session_git_evidence:{$ref:"#/$defs/StatusSessionGitEvidenceV1",description:"The session↔Git evidence `tracedecay_sessions_for` and the\nbranch/commit session filters read."},session_history_catch_up:!0,session_ingest:!0,session_projection:{$ref:"#/$defs/LcmDoctorProjectionV1",description:"The project session projection's serving state, the same reading\n`tracedecay_lcm_doctor` reports."},storage_health:!0,tracked_branch_count:{format:"uint",minimum:0,type:["integer","null"]},wait:{anyOf:[{$ref:"#/$defs/CodeIndexReadinessWaitOutcomeV1"},{type:"null"}]}},required:["project_root","graph_statistics","memory","schema_convergence","reset_required_stores","code_index_freshness","github_source","session_projection","session_git_evidence","hook_replay"],type:"object"},ResidentMemoryHolderReadV1:{description:"One worktree holding a retained owner's memory, and what it holds: a\ngeneration id, or an LSP session id.",properties:{holding:{type:"string"},worktree_id:{type:"string"}},required:["worktree_id","holding"],type:"object"},RetrievalWorkerStatusV1:vT,SchemaConvergenceFindingV1:vL,SchemaConvergenceStageV1:vU,SchemaConvergenceStateV1:vH,StatusAdmissionV1:{additionalProperties:!1,properties:{project_admitted:{type:"boolean"},project_root:{type:"string"},scope_prefix:{type:["string","null"]},server:{description:"The serving MCP server's request counters."}},required:["project_admitted","project_root"],type:"object"},StatusBranchMismatchV1:{additionalProperties:!1,properties:{git_branch:{type:["string","null"]},indexed_branch:{type:["string","null"]},serving_branch:{type:["string","null"]}},type:"object"},StatusCodeIndexFreshnessV1:{description:"The code-index freshness of the served worktree, labeled the way readiness\nwaits report their last state.",oneOf:[{additionalProperties:!1,properties:{status:{const:"current",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,properties:{status:{const:"stale",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,properties:{status:{const:"restoring",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,properties:{status:{const:"warming",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,properties:{status:{const:"parked",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,description:"The last code-index mount failed; explicit reconciliation can retry it.",properties:{message:{type:"string"},remediation:{type:"string"},status:{const:"mount_failed",type:"string"}},required:["status","message","remediation"],type:"object"},{additionalProperties:!1,properties:{reason:{type:"string"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},StatusGitStalenessUnavailableV1:{oneOf:[{const:"no_sealed_generation",description:"No complete generation has sealed for the worktree yet.",type:"string"},{const:"sealed_generation_has_no_commit",description:"The sealed generation captured no commit, as in an unborn repository.",type:"string"},{const:"git_head_unreadable",description:"The worktree's checked-out commit could not be read.",type:"string"}]},StatusGitStalenessV1:{description:"The sealed generation's Git watermark, the commit its source snapshot was\ncaptured from, against the worktree's checked-out commit.",oneOf:[{additionalProperties:!1,description:"HEAD is the commit the sealed generation was built from.",properties:{status:{const:"current",type:"string"},watermark:{type:"string"}},required:["status","watermark"],type:"object"},{additionalProperties:!1,description:"HEAD has moved off the commit the sealed generation was built from.",properties:{head:{type:"string"},status:{const:"stale",type:"string"},watermark:{type:"string"}},required:["status","watermark","head"],type:"object"},{additionalProperties:!1,description:"No watermark or no HEAD to compare it with.",properties:{reason:{$ref:"#/$defs/StatusGitStalenessUnavailableV1"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},StatusHookReplayFailureV1:{additionalProperties:!1,description:"One hook spool the last replay sweep could not drain.",properties:{cause:{type:"string"},host:{$ref:"#/$defs/NativeHostIdentityV1"},spool:{$ref:"#/$defs/StatusHookReplaySpoolV1"}},required:["host","spool","cause"],type:"object"},StatusHookReplaySpoolV1:{oneOf:[{const:"records",description:"The host's spooled hook events.",type:"string"},{const:"delivery_receipts",description:"The host's hook delivery receipts.",type:"string"},{const:"pending_work",description:"The producer work the host's admission ledger still owes.",type:"string"}]},StatusHookReplayV1:{description:"The daemon's hook spool drain for one project.",oneOf:[{additionalProperties:!1,description:"No replay consumer drains this project's hook spools in this daemon.",properties:{status:{const:"unowned",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,description:"The replay consumer has not finished its first sweep.",properties:{status:{const:"starting",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,description:"The last sweep drained every hook spool it found.",properties:{status:{const:"drained",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,description:"The spools drained, but producer work they admitted waits for the\nproject's hook orchestrator to mount. The work stays owed and runs\nonce it does; nothing has failed.",properties:{status:{const:"waiting",type:"string"},waiting:{items:{$ref:"#/$defs/StatusHookReplayFailureV1"},type:"array"}},required:["status","waiting"],type:"object"},{additionalProperties:!1,description:"The last sweep could not drain these spools. Their records stay\ndurable and the next sweep retries them.",properties:{failures:{items:{$ref:"#/$defs/StatusHookReplayFailureV1"},type:"array"},status:{const:"failed",type:"string"}},required:["status","failures"],type:"object"}]},StatusMemoryOwnerV1:{additionalProperties:!1,properties:{bytes:{format:"uint64",minimum:0,type:["integer","null"]},content_digest:{type:["string","null"]},holders:{items:{$ref:"#/$defs/ResidentMemoryHolderReadV1"},type:"array"},idle_seconds:{format:"uint64",minimum:0,type:"integer"},kind:{type:"string"},measured:{type:"boolean"},project_id:{type:"string"},protected:{type:"boolean"}},required:["project_id","kind","holders","measured","idle_seconds","protected"],type:"object"},StatusMemoryPressureV1:{enum:["unobserved","nominal","over_budget"],type:"string"},StatusMemoryReservationV1:{additionalProperties:!1,properties:{bytes:{format:"uint64",minimum:0,type:"integer"},component:{type:"string"}},required:["component","bytes"],type:"object"},StatusMemoryV1:{additionalProperties:!1,description:"The daemon's memory admission and resident accounting as one project sees it.",properties:{high_watermark_bytes:{format:"uint64",minimum:0,type:"integer"},idle_window_seconds:{format:"uint64",minimum:0,type:"integer"},limit_bytes:{format:"uint64",minimum:0,type:"integer"},low_watermark_bytes:{format:"uint64",minimum:0,type:"integer"},owners:{description:"This project's retained owners; other projects' belong to the\ndaemon-wide Doctor inventory.",items:{$ref:"#/$defs/StatusMemoryOwnerV1"},type:"array"},psi_some_avg10:{format:"double",type:["number","null"]},reservations:{description:"`reserved_bytes` per component, largest first.",items:{$ref:"#/$defs/StatusMemoryReservationV1"},type:"array"},reserved_bytes:{description:"Bytes admitted work has reserved daemon-wide: the admission model of\nin-flight builds and decodes, not a measurement.",format:"uint64",minimum:0,type:"integer"},resident_bytes:{description:"Observed admission occupancy: anonymous/shared process pages plus swap,\nconstrained by shared cgroup headroom. This is not raw process RSS.",format:"uint64",minimum:0,type:["integer","null"]},retained_bytes:{format:"uint64",minimum:0,type:"integer"},shed_order:{items:{type:"string"},type:"array"},status:{$ref:"#/$defs/StatusMemoryPressureV1"},unattributed_bytes:{description:"Raw process RSS from the last successful canonical sample minus the\ndaemon-wide measured `retained_bytes`, saturating at zero. Unlike\n`resident_bytes`, this excludes swap and shared cgroup pressure. Work in\nflight, runtime allocations, SQLite page caches, and allocator-held pages\ncan contribute. `None` until a resident sample has been published.",format:"uint64",minimum:0,type:["integer","null"]},unmeasured_owners:{format:"uint",minimum:0,type:"integer"}},required:["status","limit_bytes","high_watermark_bytes","low_watermark_bytes","idle_window_seconds","shed_order","retained_bytes","unmeasured_owners","reserved_bytes","reservations","owners"],type:"object"},StatusRetrievalServingV1:{oneOf:[{additionalProperties:!1,description:"A sealed complete generation serves the exact worktree. The ages tell a\nroutine rebuild window from a wedged route.",properties:{condition:{anyOf:[{$ref:"#/$defs/StatusServingConditionV1"},{type:"null"}]},freshness:{$ref:"#/$defs/StatusServingFreshnessV1"},last_reconcile_age_seconds:{format:"int64",type:["integer","null"]},seated_generation_age_seconds:{format:"int64",type:["integer","null"]},status:{const:"serving",type:"string"}},required:["status","freshness"],type:"object"},{additionalProperties:!1,description:"The census answered and nothing is servable yet.",properties:{reason:{type:"string"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},StatusSchemaConvergenceStateV1:{enum:["completed","in_progress","retrying","degraded"],type:"string"},StatusSchemaConvergenceV1:{additionalProperties:!1,properties:{findings:{items:{$ref:"#/$defs/SchemaConvergenceFindingV1"},type:"array"},status:{$ref:"#/$defs/StatusSchemaConvergenceStateV1"}},required:["status","findings"],type:"object"},StatusServingConditionV1:{enum:["artifact_restore","source_verification","rebuilding","stalled"],type:"string"},StatusServingFreshnessV1:{enum:["current","restoring","last_complete_stale","unknown"],type:"string"},StatusSessionGitEvidenceUnavailableV1:{oneOf:[{const:"session_store_denied",description:"This request holds no project session store.",type:"string"},{const:"read_failed",description:"The session store refused the evidence read.",type:"string"}]},StatusSessionGitEvidenceV1:{description:"The project's session↔Git evidence generation.",oneOf:[{additionalProperties:!1,description:"A convergence pass installed this generation.",properties:{backfill_watermark:{format:"int64",type:["integer","null"]},commit_count:{format:"uint64",minimum:0,type:"integer"},generation:{type:"string"},source_watermark:{type:"string"},span_count:{format:"uint64",minimum:0,type:"integer"},status:{const:"recorded",type:"string"}},required:["status","generation","source_watermark","span_count","commit_count"],type:"object"},{additionalProperties:!1,description:"No convergence pass has written evidence for this project yet.",properties:{backfill_watermark:{format:"int64",type:["integer","null"]},status:{const:"unrecorded",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,description:"The evidence could not be read.",properties:{message:{type:["string","null"]},reason:{$ref:"#/$defs/StatusSessionGitEvidenceUnavailableV1"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},StoreResetRequiredV1:{description:"A persisted store the daemon keeps mounted in a typed reset-required state\ninstead of refusing to serve: every read against it returns the typed\nrefusal, stores that admit keep serving, and `remedy` is the exact command\nthe operator runs to reset it.",properties:{authority:{type:"string"},found_version:{format:"int64",type:["integer","null"]},reason:{type:"string"},remedy:{type:"string"},required_version:{format:"int64",type:["integer","null"]},store:{type:"string"}},required:["store","authority","reason","remedy"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/StatusAdmissionV1"},{$ref:"#/$defs/ProjectStatusV1"}],description:"`tracedecay_status` for an `admission_only` read, or the project's status.",title:"StatusResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_details:{default:!1,type:"boolean"}},title:"StorageStatusPrimitiveRequest",type:"object"},{$defs:{StorageStatusHistoryPointV1:{additionalProperties:!1,properties:{database_bytes:{format:"uint64",minimum:0,type:"integer"},observed_at:{format:"int64",type:"integer"}},required:["observed_at","database_bytes"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{database_bytes:{format:"uint64",minimum:0,type:["integer","null"]},details:{items:{type:"string"},type:"array"},freelist_pages:{default:null,format:"uint64",minimum:0,type:["integer","null"]},history:{default:[],items:{$ref:"#/$defs/StorageStatusHistoryPointV1"},type:"array"},history_coverage:{default:null,type:["string","null"]},page_count:{default:null,format:"uint64",minimum:0,type:["integer","null"]},page_size_bytes:{default:null,format:"uint32",minimum:0,type:["integer","null"]},project_id:{default:null,type:["string","null"]},read_only:{type:"boolean"},status:{type:"string"},store_path:{default:null,type:["string","null"]}},required:["status","read_only","details"],title:"StorageStatusPrimitiveResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_str_replace`.",properties:{dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},new_str:{type:"string"},old_str:{type:"string"},path:{type:"string"},verify:{default:!1,type:"boolean"}},required:["path","old_str","new_str"],title:"StrReplaceSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{file:{description:"Source file path to find test coverage for.",type:["string","null"]},node_id:{description:"Specific node ID to find test coverage for (alternative to file).",type:["string","null"]}},title:"TestMapSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,TestMapSourceCoverageV1:{additionalProperties:!1,properties:{source_file:{type:"string"},source_id:{type:"string"},source_line:{format:"uint32",minimum:0,type:"integer"},source_name:{type:"string"},tests:{items:{$ref:"#/$defs/TestMapTestV1"},type:"array"}},required:["source_name","source_id","source_file","source_line","tests"],type:"object"},TestMapTestV1:{additionalProperties:!1,properties:{attribution_depth:{format:"uint32",minimum:0,type:"integer"},test_file:{type:"string"},test_line:{format:"uint32",minimum:0,type:"integer"},test_name:{type:"string"}},required:["test_name","test_file","test_line","attribution_depth"],type:"object"},TestMapUncoveredV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","file","line"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage:{items:{$ref:"#/$defs/TestMapSourceCoverageV1"},type:"array"},covered_symbols:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},test_files:{items:{type:"string"},type:"array"},uncovered:{items:{$ref:"#/$defs/TestMapUncoveredV1"},type:"array"},uncovered_symbols:{format:"uint64",minimum:0,type:"integer"}},required:["covered_symbols","uncovered_symbols","test_files","coverage","uncovered"],title:"TestMapResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The admitted project selects the retained managed test run, so this exact\nrequest intentionally carries no caller-selectable scope or identity.",title:"TestResultsSurfaceRequestV1",type:"object"},{$defs:{CancellationObservation:hn,CancellationStage:ha,CodeGenerationId:hy,CommitId:hq,Deadline:yv,OperationBudgetUsage:_D,OperationReceipt:_F,OperationTermination:_L,TestResultProjectionV1:{additionalProperties:!1,description:"One result emitted by the daemon-managed test-run authority.",properties:{passed:{type:"boolean"},test:{type:"string"}},required:["test","passed"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact retained managed-test-run projection returned by `test_results`.\n\nThe daemon resolves the admitted project, reads its newest durable managed\nrun, and verifies that the run's head and code generation are current\nbefore it serializes this payload. `result_offset` and `available_results`\nretain the authoritative page position. The outcome fields (`finished_at`,\n`exit_code`, the counts, `termination`, `receipt`) are present only after\nthe managed run terminates.",properties:{available_results:{format:"uint64",minimum:0,type:"integer"},code_generation_id:{anyOf:[{$ref:"#/$defs/CodeGenerationId"},{type:"null"}]},completed:{format:"uint64",minimum:0,type:"integer"},exit_code:{format:"int32",type:["integer","null"]},failed:{format:"uint64",minimum:0,type:["integer","null"]},finished_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},head_commit_id:{anyOf:[{$ref:"#/$defs/CommitId"},{type:"null"}]},ignored:{format:"uint64",minimum:0,type:["integer","null"]},operation_id:{type:"string"},passed:{format:"uint64",minimum:0,type:["integer","null"]},receipt:{anyOf:[{$ref:"#/$defs/OperationReceipt"},{type:"null"}]},result_offset:{format:"uint64",minimum:0,type:"integer"},results:{items:{$ref:"#/$defs/TestResultProjectionV1"},type:"array"},session_id:{description:"The session the run was requested by; null when the request named none.",type:["string","null"]},started_at:{$ref:"#/$defs/UtcMicros"},termination:{anyOf:[{$ref:"#/$defs/OperationTermination"},{type:"null"}]},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["operation_id","started_at","results","completed","result_offset","available_results"],title:"TestResultsResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_tested:{description:"Include already-tested functions in results (default: false).",type:["boolean","null"]},limit:{description:"Maximum number of results to return (default: 20, at most 200).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path.",type:["string","null"]}},title:"TestRiskSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComplexityAnalysisV1:hx,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,TestAttributionMethodV1:{description:"How a source symbol's static test evidence was attributed.",enum:["none","direct_unit","closure"],type:"string"},TestRiskAttributionSummaryV1:{additionalProperties:!1,properties:{cli_entry_attributed:{format:"uint64",minimum:0,type:"integer"},closure_attributed:{format:"uint64",minimum:0,type:"integer"},depth:{format:"uint64",minimum:0,type:"integer"},direct_unit_attributed:{format:"uint64",minimum:0,type:"integer"},public_api_attributed:{format:"uint64",minimum:0,type:"integer"},total_attributed:{format:"uint64",minimum:0,type:"integer"},trait_resolved_attributed:{format:"uint64",minimum:0,type:"integer"}},required:["depth","direct_unit_attributed","closure_attributed","trait_resolved_attributed","public_api_attributed","cli_entry_attributed","total_attributed"],type:"object"},TestRiskBucketSummaryV1:{additionalProperties:!1,properties:{attributed:{format:"uint64",minimum:0,type:"integer"},excluded:{format:"uint64",minimum:0,type:"integer"},orphan_entry:{format:"uint64",minimum:0,type:"integer"},reachable_unattributed:{format:"uint64",minimum:0,type:"integer"}},required:["attributed","reachable_unattributed","orphan_entry","excluded"],type:"object"},TestRiskConfidenceV1:{description:"What the reported coverage percentage bounds.",enum:["static_lower_bound"],type:"string"},TestRiskEntryV1:{additionalProperties:!1,properties:{attribution_depth:{format:"uint64",minimum:0,type:["integer","null"]},attribution_method:{$ref:"#/$defs/TestAttributionMethodV1"},churn:{format:"uint64",minimum:0,type:"integer"},complexity:{description:"`None` when `complexity_analysis` reports the bounded walk did not\ncover the body; `risk` then weighs the lower-bound counters.",format:"uint32",minimum:0,type:["integer","null"]},complexity_analysis:{$ref:"#/$defs/ComplexityAnalysisV1"},fan_in:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},has_test:{type:"boolean"},id:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},risk:{format:"double",type:"number"}},required:["id","name","file","line","complexity_analysis","fan_in","has_test","attribution_method","risk","churn"],type:"object"},TestRiskSummaryV1:{additionalProperties:!1,properties:{attribution:{$ref:"#/$defs/TestRiskAttributionSummaryV1"},buckets:{$ref:"#/$defs/TestRiskBucketSummaryV1"},confidence:{$ref:"#/$defs/TestRiskConfidenceV1"},confidence_note:{type:"string"},coverage_pct:{format:"double",type:"number"},skipped:{format:"uint64",minimum:0,type:"integer"},tested:{format:"uint64",minimum:0,type:"integer"},top_risk_unattributed:{type:"string"},top_risk_untested:{type:"string"},total_functions:{format:"uint64",minimum:0,type:"integer"}},required:["total_functions","tested","skipped","coverage_pct","top_risk_untested","top_risk_unattributed","attribution","buckets","confidence","confidence_note"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},risks:{items:{$ref:"#/$defs/TestRiskEntryV1"},type:"array"},summary:{$ref:"#/$defs/TestRiskSummaryV1"}},required:["risks","summary"],title:"TestRiskResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kinds:{items:{type:"string"},type:["array","null"]},limit:{format:"uint32",minimum:0,type:["integer","null"]},path:{type:["string","null"]}},title:"TodosSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,TodoMarkerV1:{additionalProperties:!1,properties:{enclosing:{type:["string","null"]},file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},text:{type:"string"}},required:["kind","file","line","text"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{by_kind:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},type:"object"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},markers:{items:{$ref:"#/$defs/TodoMarkerV1"},type:"array"},match_count:{format:"uint",minimum:0,type:"integer"}},required:["match_count","by_kind","markers"],title:"TodosResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{ecosystem:{description:"Filter findings to one ecosystem ('rust' or 'typescript'). Every\necosystem section is still reported, so the scope of the answer stays\nvisible.",type:["string","null"]},limit:{description:"Maximum unmounted files to return (default: 200, max: 2000). The\nresponse always states the true total and how many rows were omitted.",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter findings to files under this directory path (e.g. 'src/daemon').\nThe whole project is still walked, reachability is not a per-directory\nquestion.",type:["string","null"]}},title:"UnmountedFilesSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,UnmountedEcosystemStatusV1:{description:"Whether an ecosystem was audited, absent, or recognised but unmodelled.",enum:["audited","partial","not_present","unsupported"],type:"string"},UnmountedEcosystemV1:{additionalProperties:!1,properties:{blind_spots:{items:{type:"string"},type:"array"},ecosystem:{type:"string"},entry_point_count:{format:"uint64",minimum:0,type:"integer"},excluded_path_globs:{items:{type:"string"},type:"array"},mounted_file_count:{format:"uint64",minimum:0,type:"integer"},note:{type:["string","null"]},package_count:{format:"uint64",minimum:0,type:"integer"},scanned_file_count:{format:"uint64",minimum:0,type:"integer"},status:{$ref:"#/$defs/UnmountedEcosystemStatusV1"},unclaimed_file_count:{format:"uint64",minimum:0,type:"integer"},unmounted_file_count:{format:"uint64",minimum:0,type:"integer"},verdict:{type:"string"}},required:["ecosystem","status","package_count","entry_point_count","scanned_file_count","mounted_file_count","unclaimed_file_count","unmounted_file_count","verdict","blind_spots","excluded_path_globs"],type:"object"},UnmountedFileV1:{additionalProperties:!1,properties:{ecosystem:{type:"string"},file:{type:"string"},manifest:{type:"string"},nearest_mounted_parent:{type:["string","null"]},package:{type:"string"},suggested_declaration:{type:["string","null"]}},required:["file","ecosystem","package","manifest"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{complete:{type:"boolean"},ecosystem:{type:["string","null"]},ecosystems:{items:{$ref:"#/$defs/UnmountedEcosystemV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},limit:{format:"uint64",minimum:0,type:"integer"},omitted_count:{format:"uint64",minimum:0,type:"integer"},path:{type:["string","null"]},returned_count:{format:"uint64",minimum:0,type:"integer"},unmounted:{items:{$ref:"#/$defs/UnmountedFileV1"},type:"array"},unmounted_file_count:{format:"uint64",minimum:0,type:"integer"}},required:["unmounted_file_count","returned_count","omitted_count","complete","ecosystems","limit","unmounted"],title:"UnmountedFilesResultV1",type:"object"},{$defs:{UnsafePatternKindV1:bB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{exclude_tests:{description:"When true, skips files whose path looks like a test (default: false).",type:["boolean","null"]},kinds:{description:"Subset of patterns to search. Default (or an empty list): every kind.",items:{$ref:"#/$defs/UnsafePatternKindV1"},type:["array","null"]},limit:{description:"Maximum number of matches to return (default: 200, max: 2000).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory (relative to project root).",type:["string","null"]}},title:"UnsafePatternsSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,CoverageCompleteness:yu,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,UnsafePatternFileOmissionV1:{additionalProperties:!1,description:"One scanned file whose sites are not reported as verified matches.",properties:{cause:{$ref:"#/$defs/UnsafePatternOmissionCauseV1"},file:{type:"string"},reason:{$ref:"#/$defs/UnsafePatternOmissionReasonV1"},withheld_match_count:{description:"Sites of the requested kinds found in the file and withheld.",format:"uint64",minimum:0,type:"integer"}},required:["file","reason","cause","withheld_match_count"],type:"object"},UnsafePatternKindV1:bB,UnsafePatternMatchV1:{additionalProperties:!1,properties:{enclosing:{type:["string","null"]},file:{type:"string"},in_test:{type:"boolean"},kind:{$ref:"#/$defs/UnsafePatternKindV1"},line:{format:"uint32",minimum:0,type:"integer"},snippet:{type:"string"}},required:["kind","file","line","snippet","in_test"],type:"object"},UnsafePatternOmissionCauseV1:{description:"What prevented the file from being classified.",oneOf:[{const:"syntax_errors",description:"The Rust grammar parsed the file with error nodes. Valid Rust it only\npartly parses (heavy `macro_rules!`) lands here.",type:"string"}]},UnsafePatternOmissionReasonV1:{description:"Why a file's risky-pattern sites are withheld from the verified result.",oneOf:[{const:"test_scope_unclassified",description:"Whether a site is test-only cannot be decided for this file.",type:"string"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{by_kind:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},description:"Match count per pattern kind, keyed by its wire spelling.",type:"object"},coverage:{$ref:"#/$defs/CoverageCompleteness",description:"`partial` exactly when `omissions` names a file whose sites are withheld."},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{format:"uint64",minimum:0,type:"integer"},matches:{items:{$ref:"#/$defs/UnsafePatternMatchV1"},type:"array"},omissions:{items:{$ref:"#/$defs/UnsafePatternFileOmissionV1"},type:"array"}},required:["match_count","by_kind","matches","coverage","omissions"],title:"UnsafePatternsResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{agent_label:{type:["string","null"]},branch:{type:["string","null"]},commit:{type:["string","null"]},limit:{format:"uint64",minimum:0,type:["integer","null"]},run_id:{type:["string","null"]},session_id:{type:["string","null"]},worktree:{type:["string","null"]}},title:"WorkflowsRequestV1",type:"object"},{$defs:{GitScopeV1:gE,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,WorkflowAgentV1:{additionalProperties:!1,properties:{agent_id:{type:"string"},agent_label:{type:"string"},agent_session_id:{type:["string","null"]},ended_ts:{format:"int64",type:["integer","null"]},model:{type:["string","null"]},phase:{type:["string","null"]},run_id:{type:"string"},started_ts:{format:"int64",type:["integer","null"]},status:{$ref:"#/$defs/WorkflowStatusV1"},tokens:{format:"int64",type:"integer"},transcript_path:{type:["string","null"]}},required:["run_id","agent_label","agent_id","status"],type:"object"},WorkflowCoverageV1:{enum:["complete","conclusive","bounded_prefix"],type:"string"},WorkflowQueryModeV1:{enum:["session","git_scope","run","agent"],type:"string"},WorkflowRunV1:{additionalProperties:!1,properties:{agent_count:{format:"int64",type:"integer"},description:{type:["string","null"]},ended_ts:{format:"int64",type:["integer","null"]},name:{type:["string","null"]},parent_session_id:{type:"string"},phase_json:{type:["string","null"]},result_summary:{type:["string","null"]},run_id:{type:"string"},started_ts:{format:"int64",type:["integer","null"]},status:{$ref:"#/$defs/WorkflowStatusV1"}},required:["run_id","parent_session_id","status"],type:"object"},WorkflowStatusV1:{enum:["running","completed","failed","unknown"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{agent:{anyOf:[{$ref:"#/$defs/WorkflowAgentV1"},{type:"null"}]},agent_count:{format:"int64",type:["integer","null"]},agent_label:{type:["string","null"]},agents:{items:{$ref:"#/$defs/WorkflowAgentV1"},type:["array","null"]},agents_complete:{type:["boolean","null"]},agents_coverage:{anyOf:[{$ref:"#/$defs/WorkflowCoverageV1"},{type:"null"}]},agents_returned:{format:"uint",minimum:0,type:["integer","null"]},count:{format:"uint",minimum:0,type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},found:{type:["boolean","null"]},git_filter:{anyOf:[{$ref:"#/$defs/GitScopeV1"},{type:"null"}]},lookup_complete:{type:["boolean","null"]},lookup_coverage:{anyOf:[{$ref:"#/$defs/WorkflowCoverageV1"},{type:"null"}]},message:{type:["string","null"]},mode:{anyOf:[{$ref:"#/$defs/WorkflowQueryModeV1"},{type:"null"}]},run:{anyOf:[{$ref:"#/$defs/WorkflowRunV1"},{type:"null"}]},run_id:{type:["string","null"]},runs:{items:{$ref:"#/$defs/WorkflowRunV1"},type:["array","null"]},session_id:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"}},required:["status"],title:"WorkflowsResultV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Confirmation names the exact inspection digest, not a worktree id alone.",properties:{inspection_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target","inspection_digest"],title:"WorktreeCleanupConfirmRequestV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target"],title:"WorktreeCleanupInspectRequestV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target","confirmation_digest"],title:"WorktreeCleanupReconcileRequestV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Removal carries both proofs so a stale confirmation cannot be replayed\nagainst another inspection of the same opaque worktree identity.",properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},confirmed_at:{$ref:"#/$defs/UtcMicros"},inspection_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target","inspection_digest","confirmed_at","confirmation_digest"],title:"WorktreeCleanupRemoveRequestV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target"],title:"WorktreeInventoryRequestV1",type:"object"},{$defs:{ActorId:fb,TaskId:bT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Issues a short-lived, version-bound task-opening token.\n\nIdentity, scope, authority revisions, issuance time, and expiry are all\nsupplied by the admitted daemon request. The caller supplies only the\nbearer, destination session, exact task version, and enrolled recipient\nprincipal it intends to authorize.",properties:{recipient_actor_id:{$ref:"#/$defs/ActorId"},session_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"},token:{type:"string"},version:{format:"uint64",minimum:0,type:"integer"}},required:["token","session_id","task_id","version","recipient_actor_id"],title:"IssueTaskHandoffRequestV1",type:"object"},{$defs:{ManifestDigest:_l,TaskId:bT,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Flat public receipt for a committed task-handoff issue.\n\nThe complete binding remains inside the daemon authority. Publishing only\nthese exact identifiers avoids turning mutable grant and policy internals\ninto a second public wire authority.",properties:{expires_at:{$ref:"#/$defs/UtcMicros"},issued_at:{$ref:"#/$defs/UtcMicros"},issued_request_id:{type:"string"},session_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"},token_digest:{$ref:"#/$defs/ManifestDigest"},version:{format:"uint64",minimum:0,type:"integer"}},required:["token_digest","issued_request_id","session_id","task_id","version","issued_at","expires_at"],title:"IssueTaskHandoffResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:'Enumerates the handoff tokens this caller could redeem in one session.\n\nThe two `open_*` operations redeem a bearer the caller already holds; they\ncannot answer "what has been handed to me and not yet taken up". This one\ncan, and it does so without any bearer: the request carries no token, and\nthe result carries only digests.',properties:{session_id:{type:"string"}},required:["session_id"],title:"ListTaskHandoffsRequestV1",type:"object"},{$defs:{FeedbackFindingId:y8,HandoffOpenKindV1:{enum:["investigation","task"],type:"string"},HandoffOpenTargetV1:{oneOf:[{properties:{finding_id:{$ref:"#/$defs/FeedbackFindingId"},kind:{const:"investigation",type:"string"},owner_version_digest:{$ref:"#/$defs/ManifestDigest"}},required:["kind","finding_id","owner_version_digest"],type:"object"},{properties:{kind:{const:"task",type:"string"},owner_version_digest:{$ref:"#/$defs/ManifestDigest"},task_id:{$ref:"#/$defs/TaskId"},version:{format:"uint64",minimum:0,type:"integer"}},required:["kind","task_id","version","owner_version_digest"],type:"object"}]},ListedTaskHandoffV1:{additionalProperties:!1,description:"One handoff token, projected for public reading.\n\nMirrors [`IssueTaskHandoffResultV1`]'s doctrine: the complete binding stays\ninside the daemon authority, and only these identifiers cross the wire. No\nbearer secret exists to leak here. The authority never stored one, and the\nissuer's grant identity and policy digests stay concealed.",properties:{consumed_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}],description:"Set only when `state` is `consumed`."},expires_at:{$ref:"#/$defs/UtcMicros"},issued_at:{$ref:"#/$defs/UtcMicros"},issued_request_id:{type:"string"},kind:{$ref:"#/$defs/HandoffOpenKindV1"},session_id:{type:"string"},state:{$ref:"#/$defs/TaskHandoffTokenStateV1"},target:{$ref:"#/$defs/HandoffOpenTargetV1"},token_digest:{$ref:"#/$defs/ManifestDigest"}},required:["token_digest","issued_request_id","session_id","kind","target","issued_at","expires_at","state"],type:"object"},ManifestDigest:_l,TaskHandoffTokenStateV1:{description:"Where one enumerated token stands at the observed instant.",oneOf:[{const:"open",description:"Not yet redeemed, and not yet expired: the live frontier.",type:"string"},{const:"consumed",description:"Redeemed. Single-use, so it can never be redeemed again.",type:"string"},{const:"expired",description:"Its window closed with no redemption. A dropped handoff, which is\nexactly the fact a frontier exists to surface.",type:"string"}]},TaskId:bT,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The handoff-token frontier for one session.",properties:{consumed_count:{format:"uint32",minimum:0,type:"integer"},expired_count:{format:"uint32",minimum:0,type:"integer"},handoffs:{items:{$ref:"#/$defs/ListedTaskHandoffV1"},type:"array"},observed_at:{$ref:"#/$defs/UtcMicros",description:"The instant the states below were decided at. Without it, `open` and\n`expired` are claims with no clock behind them."},open_count:{format:"uint32",minimum:0,type:"integer"},truncated:{description:"True when the enumeration ceiling was reached, so the counts describe a\nprefix of the frontier rather than all of it.",type:"boolean"}},required:["observed_at","handoffs","open_count","consumed_count","expired_count","truncated"],title:"ListTaskHandoffsResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{session_id:{type:"string"},token:{type:"string"}},required:["token","session_id"],title:"OpenInvestigationHandoffRequestV1",type:"object"},{$defs:{FeedbackFindingId:y8,HandoffOpenReceiptV1:gD,InvestigationHandoffSurfaceV1:{additionalProperties:!1,properties:{finding_id:{$ref:"#/$defs/FeedbackFindingId"},owner_version_digest:{$ref:"#/$defs/ManifestDigest"}},required:["finding_id","owner_version_digest"],type:"object"},ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{receipt:{$ref:"#/$defs/HandoffOpenReceiptV1"},surface:{$ref:"#/$defs/InvestigationHandoffSurfaceV1"}},required:["surface","receipt"],title:"OpenInvestigationHandoffResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{session_id:{type:"string"},token:{type:"string"}},required:["token","session_id"],title:"OpenTaskHandoffRequestV1",type:"object"},{$defs:{HandoffOpenReceiptV1:gD,ManifestDigest:_l,TaskHandoffSurfaceV1:{additionalProperties:!1,properties:{task_id:{$ref:"#/$defs/TaskId"},version:{format:"uint64",minimum:0,type:"integer"}},required:["task_id","version"],type:"object"},TaskId:bT,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{receipt:{$ref:"#/$defs/HandoffOpenReceiptV1"},surface:{$ref:"#/$defs/TaskHandoffSurfaceV1"}},required:["surface","receipt"],title:"OpenTaskHandoffResultV1",type:"object"},{$defs:{ManifestDigest:_l,MultiRootContinuationV1:_P,MultiRootOperationV1:{description:"Closed federated read families. The family is typed while its existing\noperation-specific request remains the canonical JSON payload owned by that\napplication surface.",oneOf:[{properties:{kind:{const:"work",type:"string"},request:!0},required:["kind","request"],type:"object"},{properties:{kind:{const:"git",type:"string"},request:!0},required:["kind","request"],type:"object"},{properties:{kind:{const:"feedback",type:"string"},request:!0},required:["kind","request"],type:"object"},{properties:{kind:{const:"impact",type:"string"},request:!0},required:["kind","request"],type:"object"},{properties:{kind:{const:"query",type:"string"},request:!0},required:["kind","request"],type:"object"}]},RootGenerationV1:vM,RootScopeOutcomeV1_for_Nullable_RootGenerationV1:vN,RootScopeOutcomeV1_for_Nullable_string:vz,ScopeOutcome_for_Nullable_RootGenerationV1:vJ,ScopeOutcome_for_Nullable_string:vZ,ScopePartialReasonV1:vQ,ScopeSetId:vX,ScopeSetRevision:vY,ScopeUnavailableReasonV1:v0},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"External federated request bound to one persisted scope-set revision and\ndigest. Query/order digests and root generations are server-derived.",properties:{continuation:{anyOf:[{$ref:"#/$defs/MultiRootContinuationV1"},{type:"null"}]},operation:{$ref:"#/$defs/MultiRootOperationV1"},page:{format:"uint64",minimum:0,type:"integer"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"}},required:["scope_set_id","scope_set_revision","scope_set_digest","operation","page"],title:"MultiRootExecuteRequestV1",type:"object"},{$defs:{ManifestDigest:_l,MultiRootContinuationV1:_P,RootGenerationV1:vM,RootScopeOutcomeV1_for_Array_of_AnyValue:{additionalProperties:!1,description:"One typed outcome pinned to the digest of an exact resolved root.",properties:{outcome:{$ref:"#/$defs/ScopeOutcome_for_Array_of_AnyValue"},scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest","outcome"],type:"object"},RootScopeOutcomeV1_for_Nullable_RootGenerationV1:vN,RootScopeOutcomeV1_for_Nullable_string:vz,ScopeOutcome_for_Array_of_AnyValue:{description:"Truthful outcome for one authorized root or an aggregate over roots.\n\n`Denied` and `Unavailable` carry no value and therefore cannot be confused\nwith a successful empty result.",oneOf:[{properties:{outcome:{const:"exact",type:"string"},value:{items:!0,type:"array"}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"partial",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopePartialReasonV1"},value:{items:!0,type:"array"}},required:["value","reason"],type:"object"}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"denied",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopeUnavailableReasonV1"}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"}]},ScopeOutcome_for_Nullable_RootGenerationV1:vJ,ScopeOutcome_for_Nullable_string:vZ,ScopePartialReasonV1:vQ,ScopeSetId:vX,ScopeSetRevision:vY,ScopeUnavailableReasonV1:v0},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Federated page preserving each root outcome and aggregate partial truth.",properties:{aggregate:{$ref:"#/$defs/ScopeOutcome_for_Array_of_AnyValue"},continuation:{anyOf:[{$ref:"#/$defs/MultiRootContinuationV1"},{type:"null"}]},roots:{items:{$ref:"#/$defs/RootScopeOutcomeV1_for_Array_of_AnyValue"},type:"array"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"}},required:["scope_set_id","scope_set_revision","scope_set_digest","roots","aggregate"],title:"MultiRootQueryPageV1_for_AnyValue",type:"object"},{$defs:{ProjectId:_4,RegisteredRootSelectorV1:{additionalProperties:!1,description:"Exact registered-root selector accepted by scope-set CAS.",properties:{project_id:{$ref:"#/$defs/ProjectId"},root:{type:"string"}},required:["project_id","root"],type:"object"},ScopeSetId:vX,ScopeSetRevision:vY},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Canonical external selector for creating or updating an authorized scope\nset. Every member names one exact registered root; project-only selection\ncannot silently widen to an active or first-mounted graph.",properties:{expected_revision:{anyOf:[{$ref:"#/$defs/ScopeSetRevision"},{type:"null"}]},roots:{items:{$ref:"#/$defs/RegisteredRootSelectorV1"},type:"array"},scope_set_id:{$ref:"#/$defs/ScopeSetId"}},required:["scope_set_id","roots"],title:"MultiRootScopeSetCasRequestV1",type:"object"},{$defs:{ActorId:fb,AuthorizedRoot:fN,AuthorizedScopeSet:fz,BrainId:f1,ManifestDigest:_l,MultiRootScopeSetCasStatusV1:{enum:["applied","conflict"],type:"string"},ProjectId:_4,RefId:vm,RegisteredRootLocatorV1:vf,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,SharedProfileStoreLocatorV1:bs,UserProfileId:bJ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope_set:{anyOf:[{$ref:"#/$defs/AuthorizedScopeSet"},{type:"null"}]},status:{$ref:"#/$defs/MultiRootScopeSetCasStatusV1"}},required:["status"],title:"MultiRootScopeSetCasResultV1",type:"object"},{$defs:{ScopeSetId:vX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope_set_id:{$ref:"#/$defs/ScopeSetId"}},required:["scope_set_id"],title:"MultiRootScopeSetReadRequestV1",type:"object"},{$defs:{ActorId:fb,AuthorizedRoot:fN,AuthorizedScopeSet:fz,BrainId:f1,ManifestDigest:_l,ProjectId:_4,RefId:vm,RegisteredRootLocatorV1:vf,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,SharedProfileStoreLocatorV1:bs,UserProfileId:bJ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/AuthorizedScopeSet"},{type:"null"}],title:"Nullable_AuthorizedScopeSet"},{$defs:{AcceptWorkProposalDispositionV1:{description:"The accept-proposal operation can commit acceptance only.",enum:["accepted"],type:"string"},CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkCommandId:$p,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/AcceptWorkProposalDispositionV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal","disposition","mutation"],title:"AcceptWorkProposalRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,BrainId:f1,CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,SourceStoreId:bS,TaskEvidenceLinkV1:bj,TaskId:bT,UserProfileId:bJ,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkGraphChangeV1:$j,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductEventPayloadV1:$1,WorkProductEventV1:$0,WorkProductGraphV1:$4,WorkProductProfileScopeV1:$9,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{event:{$ref:"#/$defs/WorkProductEventV1"},replayed:{type:"boolean"},verified_graph_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["event","verified_graph_version","replayed"],title:"WorkProductMutationReceiptV1",type:"object"},{$defs:{AttemptId:fW,CoverageStateV1:yf,DuplicateEffectOutcomeV1:yP,DuplicateEffortKindV1:yV,ProjectionGenerationId:_5,QuantityEvidenceClassV1:vs,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkDuplicateAdjudicationEvidenceV1:$m,WorkDuplicateAdjudicationQuantitiesV1:$f,WorkTopologyGenerationRefV1:SE},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},evidence:{$ref:"#/$defs/WorkDuplicateAdjudicationEvidenceV1"},expected_revision:{format:"uint64",minimum:0,type:["integer","null"]},first_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},occurred_at:{$ref:"#/$defs/UtcMicros"},quantities:{$ref:"#/$defs/WorkDuplicateAdjudicationQuantitiesV1"},reason:{type:"string"},second_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},verdict:{$ref:"#/$defs/DuplicateEffortKindV1"}},required:["first_attempt","second_attempt","evidence","verdict","quantities","reason","command_id","occurred_at"],title:"WorkDuplicateAdjudicationCommandV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,CoverageStateV1:yf,DuplicateEffectOutcomeV1:yP,DuplicateEffortKindV1:yV,ManifestDigest:_l,ProjectionGenerationId:_5,QuantityEvidenceClassV1:vs,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkDuplicateAdjudicationCommandV1:{additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},evidence:{$ref:"#/$defs/WorkDuplicateAdjudicationEvidenceV1"},expected_revision:{format:"uint64",minimum:0,type:["integer","null"]},first_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},occurred_at:{$ref:"#/$defs/UtcMicros"},quantities:{$ref:"#/$defs/WorkDuplicateAdjudicationQuantitiesV1"},reason:{type:"string"},second_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},verdict:{$ref:"#/$defs/DuplicateEffortKindV1"}},required:["first_attempt","second_attempt","evidence","verdict","quantities","reason","command_id","occurred_at"],type:"object"},WorkDuplicateAdjudicationEvidenceV1:$m,WorkDuplicateAdjudicationQuantitiesV1:$f,WorkDuplicateAdjudicationReceiptV1:{additionalProperties:!1,properties:{actor_id:{$ref:"#/$defs/ActorId"},adjudication_ref:{$ref:"#/$defs/ManifestDigest"},canonical_input_digest:{$ref:"#/$defs/ManifestDigest"},command:{$ref:"#/$defs/WorkDuplicateAdjudicationCommandV1"},revision:{format:"uint64",minimum:0,type:"integer"}},required:["command","revision","actor_id","canonical_input_digest","adjudication_ref"],type:"object"},WorkTopologyGenerationRefV1:SE},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{outcome:{const:"appended",type:"string"},receipt:{$ref:"#/$defs/WorkDuplicateAdjudicationReceiptV1"}},required:["outcome","receipt"],type:"object"},{properties:{outcome:{const:"replayed",type:"string"},receipt:{$ref:"#/$defs/WorkDuplicateAdjudicationReceiptV1"}},required:["outcome","receipt"],type:"object"}],title:"WorkDuplicateAdjudicationAppendOutcomeV1"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,WorkAttemptIdentityV1:b6,WorkCommandId:$p},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{adjudication_id:{type:"string"},attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},command_id:{$ref:"#/$defs/WorkCommandId"},detection_horizon_micros:{format:"uint64",minimum:0,type:"integer"},expected_revision:{format:"uint64",minimum:0,type:["integer","null"]}},required:["adjudication_id","attempt","detection_horizon_micros","command_id"],title:"AdjudicateWorkLeakCommandV1",type:"object"},{$defs:{AdjudicateWorkLeakCommandV1:{additionalProperties:!1,properties:{adjudication_id:{type:"string"},attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},command_id:{$ref:"#/$defs/WorkCommandId"},detection_horizon_micros:{format:"uint64",minimum:0,type:"integer"},expected_revision:{format:"uint64",minimum:0,type:["integer","null"]}},required:["adjudication_id","attempt","detection_horizon_micros","command_id"],title:"AdjudicateWorkLeakCommandV1",type:"object"},AttemptId:fW,CoverageStateV1:yf,LeakOwnerClassV1:{enum:["work","workflow","git","delivery","unknown"],type:"string"},ManifestDigest:_l,RunId:vF,TaskId:bT,UtcMicros:bZ,VerifiedWorkLeakEvidenceV1:{additionalProperties:!1,description:"Exact result of one scan by the canonical lease/process/effect/placement/\ndelivery evidence owner. Evidence references are opaque local anchors;\ntheir owning records remain behind normal authorization.",properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},coverage:{$ref:"#/$defs/CoverageStateV1"},detection_horizon_micros:{format:"uint64",minimum:0,type:"integer"},evidence_refs:{items:{type:"string"},type:"array"},kind:{$ref:"#/$defs/WorkExecutionLeakKindV1"},owner_class:{$ref:"#/$defs/LeakOwnerClassV1"},recovery:{$ref:"#/$defs/WorkExecutionLeakRecoveryV1"},scan_completed_at:{$ref:"#/$defs/UtcMicros"},scan_started_at:{$ref:"#/$defs/UtcMicros"}},required:["attempt","kind","recovery","owner_class","coverage","detection_horizon_micros","scan_started_at","scan_completed_at","evidence_refs"],type:"object"},WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkExecutionLeakKindV1:{enum:["lease_after_terminal","attempt_without_live_owner","effect_unknown_past_deadline","missing_worktree_binding","unbounded_delivery","none","unknown"],type:"string"},WorkExecutionLeakRecoveryV1:{enum:["not_required","pending","recovered","failed","unknown"],type:"string"},WorkLeakAdjudicationReceiptV1:{additionalProperties:!1,properties:{canonical_input_digest:{$ref:"#/$defs/ManifestDigest"},command:{$ref:"#/$defs/AdjudicateWorkLeakCommandV1"},evidence:{$ref:"#/$defs/VerifiedWorkLeakEvidenceV1"},revision:{format:"uint64",minimum:0,type:"integer"},scan_deadline:{$ref:"#/$defs/UtcMicros",description:"Daemon/request-owned deadline that bounded the source scan."}},required:["command","revision","evidence","scan_deadline","canonical_input_digest"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{outcome:{const:"appended",type:"string"},receipt:{$ref:"#/$defs/WorkLeakAdjudicationReceiptV1"}},required:["outcome","receipt"],type:"object"},{properties:{outcome:{const:"replayed",type:"string"},receipt:{$ref:"#/$defs/WorkLeakAdjudicationReceiptV1"}},required:["outcome","receipt"],type:"object"}],title:"WorkLeakAdjudicationOutcomeV1"},{$defs:{CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RetrievalAnchorId:vI,SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkCommandId:$p,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","based_on_version","mutation"],title:"AdmitWorkExecutionRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,AutomaticWorktreeGcV1:fF,BrainId:f1,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CatalogGenerationId:hp,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,RetrievalAnchorId:vI,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,SourceStoreId:bS,TaskEvidenceLinkV1:bj,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkApprovalPolicy:b1,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkGraphChangeV1:$j,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductEventPayloadV1:$1,WorkProductEventV1:$0,WorkProductGraphV1:$4,WorkProductMutationReceiptV1:$3,WorkProductProfileScopeV1:$9,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkSandboxPolicy:Sw,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Execution admission together with the immutable provider snapshot licensed\nby the accepted proposal and current configuration authority.",properties:{execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},mutation:{$ref:"#/$defs/WorkProductMutationReceiptV1"}},required:["mutation","execution_snapshot"],title:"AdmittedWorkExecutionV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementKindV1:$B,WorkPlacementTargetV1:$J},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{occurred_at:{$ref:"#/$defs/UtcMicros"},retention_eligible_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}],default:null,description:"When retention makes this placement eligible for a fresh cleanup\npreflight. Eligibility is not delete authority."},run_id:{$ref:"#/$defs/RunId"},target:{$ref:"#/$defs/WorkPlacementTargetV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","target","occurred_at"],title:"AdmitWorkPlacementCommand",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementStateV1:$K,WorkPlacementTargetV1:$J},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One run's durable placement relation.",properties:{authority_version:{format:"uint64",minimum:0,type:"integer"},blockers:{items:{$ref:"#/$defs/WorkPlacementBlockerV1"},type:"array",uniqueItems:!0},identity:{$ref:"#/$defs/WorkPlacementIdentityV1"},retention_eligible_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}],description:"When retention makes this placement *eligible* for a fresh cleanup\npreflight. Eligibility is not delete authority."},state:{$ref:"#/$defs/WorkPlacementStateV1"},target:{$ref:"#/$defs/WorkPlacementTargetV1"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["identity","target","state","authority_version","transitioned_at","blockers"],title:"WorkPlacementV1",type:"object"},{$defs:{CommitId:hq,RefId:vm,WorkEffectStateV1:$h,WorkJobBaseV1:{additionalProperties:!1,description:"The source revision every attempt in the job starts from.",properties:{commit:{$ref:"#/$defs/CommitId"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]}},required:["commit"],type:"object"},WorkJobKeyV1:$z,WorkJobNameV1:{description:"A job name: `[a-z0-9-]`, 1 to 48 bytes. Identities derive from it.",type:"string"},WorkJobSynthesisV1:{additionalProperties:!1,properties:{instructions:{type:"string"},output_name:{$ref:"#/$defs/WorkflowOutputName"},task:{$ref:"#/$defs/WorkJobKeyV1",description:"The synthesis attempt runs under this task's run and execution snapshot."}},required:["task","output_name","instructions"],type:"object"},WorkJobTaskV1:{additionalProperties:!1,properties:{instructions:{type:"string"},key:{$ref:"#/$defs/WorkJobKeyV1"},placement:{$ref:"#/$defs/WorkPlacementTargetV1"},title:{type:"string"}},required:["key","title","instructions","placement"],type:"object"},WorkPlacementKindV1:$B,WorkPlacementTargetV1:$J,WorkflowOutputName:SD},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One guided job: the tasks to run in parallel, where each runs, and the\nsynthesis that reviews them.",properties:{base:{$ref:"#/$defs/WorkJobBaseV1"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},job:{$ref:"#/$defs/WorkJobNameV1"},synthesis:{$ref:"#/$defs/WorkJobSynthesisV1"},tasks:{items:{$ref:"#/$defs/WorkJobTaskV1"},type:"array"},title:{type:"string"}},required:["job","title","base","effect_state","tasks","synthesis"],title:"AdvanceWorkJobRequestV1",type:"object"},{$defs:{ActorId:fb,AdmittedWorkExecutionV1:{additionalProperties:!1,description:"Execution admission together with the immutable provider snapshot licensed\nby the accepted proposal and current configuration authority.",properties:{execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},mutation:{$ref:"#/$defs/WorkProductMutationReceiptV1"}},required:["mutation","execution_snapshot"],type:"object"},ApplicationExecutionFailureClassV1:{description:"Stable non-retryable class for an admitted execution failure.",enum:["denied","malformed_output","permanent"],type:"string"},ApplicationProblemDetailV1:fA,ApplicationProblemKind:{description:"Stable problem-code taxonomy for request failures and admitted terminals.",enum:["invalid_request","not_found_or_not_authorized","conflict","partial_effect","stale","unsupported","unavailable","execution_failed","reset_required","saturated","cancelled","timed_out"],type:"string"},ApplicationProblemRecord:{additionalProperties:!1,description:"Stable application problem record shared verbatim by every adapter.",properties:{cancellation_stage:{$ref:"#/$defs/RequiredNullable3"},code:{type:"string"},committed_receipt:{$ref:"#/$defs/RequiredNullable2",description:"A committed effect is present only for an admitted partial effect.\nThe nullable field is always serialized: omitting it would create a\ncompatibility/default path that could hide a missing receipt."},coverage:{anyOf:[{$ref:"#/$defs/EvidenceCoverage"},{type:"null"}]},detail:{$ref:"#/$defs/RequiredNullable",description:"The structured facts `message` is rendered from, when the problem has\nany. Always serialized so a client never mistakes an omitted detail\nfor a problem without one."},details:{items:{$ref:"#/$defs/SafeDiagnostic"},type:"array"},diagnostic:{anyOf:[{$ref:"#/$defs/SafeDiagnostic"},{type:"null"}]},execution_failure_classification:{$ref:"#/$defs/RequiredNullable5"},kind:{$ref:"#/$defs/ApplicationProblemKind"},legal_actions:{items:{$ref:"#/$defs/LegalAction"},type:"array"},message:{type:"string"},owning_layer:{$ref:"#/$defs/ProblemOwningLayer"},request_id:{type:"string"},retry:{$ref:"#/$defs/RetryDirective"},retry_after_millis:{format:"uint64",minimum:0,type:["integer","null"]},retry_scope:{anyOf:[{$ref:"#/$defs/RetryScope"},{type:"null"}]},retryable:{type:"boolean"},revision:{format:"uint32",minimum:0,type:"integer"},terminality:{$ref:"#/$defs/ProblemTerminality"},trace_id:{type:"string"},unavailable_classification:{$ref:"#/$defs/RequiredNullable4"}},required:["revision","kind","code","message","detail","committed_receipt","owning_layer","terminality","retryable","retry","cancellation_stage","unavailable_classification","execution_failure_classification","request_id","trace_id","details","legal_actions"],type:"object"},ApplicationUnavailableClassV1:{description:"Stable reason an application authority is unavailable.",enum:["authority","backend_unavailable","backend_disconnected","backend_retryable"],type:"string"},AttemptId:fW,AutomaticWorktreeGcV1:fF,BrainId:f1,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CancellationStage:ha,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CatalogGenerationId:hp,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CoverageCompleteness:yu,CoverageDomainState:ym,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,DaemonServiceUnitObservationV1:y_,DiagnosticsSearchedTsconfigV1:yS,EffectClass:yR,EffectReceipt:yq,EffectTermination:yI,EvidenceCoverage:yx,EvidenceDomain:yj,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LegalAction:{description:"Bounded action an adapter may offer without inferring executable authority.",enum:["correct_request","reauthorize","refresh","retry","reconcile","reset","restart_without_cursor","contact_administrator"],type:"string"},LocatorDigest:_r,ManifestDigest:_l,ProblemOwningLayer:{description:"Layer that owns resolving the problem rather than merely presenting it.",enum:["adapter","application","runtime","port"],type:"string"},ProblemTerminality:{description:"Whether the problem occurred before admission or is an admitted terminal.",enum:["pre_admission","admitted_terminal"],type:"string"},ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,RequiredNullable:{anyOf:[{$ref:"#/$defs/ApplicationProblemDetailV1"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},RequiredNullable2:{anyOf:[{$ref:"#/$defs/EffectReceipt"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},RequiredNullable3:{anyOf:[{$ref:"#/$defs/CancellationStage"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},RequiredNullable4:{anyOf:[{$ref:"#/$defs/ApplicationUnavailableClassV1"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},RequiredNullable5:{anyOf:[{$ref:"#/$defs/ApplicationExecutionFailureClassV1"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},ResolvedScope:vw,RetrievalAnchorId:vI,RetryDirective:{description:"Safe adapter-independent retry instruction. Adapters preserve it verbatim.",enum:["never","same_request","after_delay","after_revalidate","after_reconcile"],type:"string"},RetryScope:{description:"Request identity boundary within which a retry remains valid.",enum:["same_request","same_operation","fresh_request"],type:"string"},ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SafeDiagnostic:{additionalProperties:!1,description:"Sanitized detail that may cross the application boundary.",properties:{code:{type:"string"},message:{type:"string"}},required:["code","message"],type:"object"},SensitiveFilesystemLocatorV1:v4,SourceStoreId:bS,TaskEvidenceLinkV1:bj,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UseCaseId:bK,UserProfileId:bJ,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkCommandId:$p,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkGraphChangeV1:$j,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkJobIdentitiesV1:{additionalProperties:!1,properties:{operation:{$ref:"#/$defs/WorkflowOperationRef"},synthesis:{$ref:"#/$defs/WorkAttemptIdentityV1"},tasks:{items:{$ref:"#/$defs/WorkJobTaskIdentitiesV1"},type:"array"}},required:["operation","tasks","synthesis"],type:"object"},WorkJobKeyV1:$z,WorkJobStateV1:{oneOf:[{additionalProperties:!1,description:"The call's deadline floor arrived with work left; call again now.",properties:{state:{const:"advancing",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"Nothing can move until providers, routing, or capacity progress.",properties:{on:{items:{$ref:"#/$defs/WorkJobWaitV1"},type:"array"},state:{const:"waiting",type:"string"}},required:["state","on"],type:"object"},{additionalProperties:!1,description:"The chain stopped at `step`. `problem` is the record the step's own\noperation produced, or a guided refusal naming the job-level cause.",properties:{problem:{$ref:"#/$defs/ApplicationProblemRecord"},state:{const:"refused",type:"string"},step:{$ref:"#/$defs/WorkJobStepV1"}},required:["state","step","problem"],type:"object"},{additionalProperties:!1,properties:{sources:{items:{$ref:"#/$defs/WorkAttemptV1"},type:"array"},state:{const:"completed",type:"string"},synthesis:{$ref:"#/$defs/WorkAttemptV1"}},required:["state","sources","synthesis"],type:"object"}]},WorkJobStepRecordV1:{additionalProperties:!1,description:"A step this call executed, with its operation's own effect receipt.",properties:{receipt:{$ref:"#/$defs/EffectReceipt"},request_id:{type:"string"},result:{$ref:"#/$defs/WorkJobStepResultV1"},step:{$ref:"#/$defs/WorkJobStepV1"}},required:["step","request_id","receipt","result"],type:"object"},WorkJobStepResultV1:{description:"Every arm is an existing Work operation's own output.",oneOf:[{properties:{result:{const:"graph",type:"string"},value:{$ref:"#/$defs/WorkProductMutationReceiptV1"}},required:["result","value"],type:"object"},{properties:{result:{const:"execution",type:"string"},value:{$ref:"#/$defs/AdmittedWorkExecutionV1"}},required:["result","value"],type:"object"},{properties:{result:{const:"placement",type:"string"},value:{$ref:"#/$defs/WorkPlacementV1"}},required:["result","value"],type:"object"},{properties:{result:{const:"attempt",type:"string"},value:{$ref:"#/$defs/WorkAttemptV1"}},required:["result","value"],type:"object"},{properties:{result:{const:"synthesis",type:"string"},value:{$ref:"#/$defs/WorkSynthesisAttemptV1"}},required:["result","value"],type:"object"}]},WorkJobStepV1:{description:"One existing Work operation the guided job runs. There is deliberately no\narm that advances a job, so a step can never recurse into the guided path.",oneOf:[{additionalProperties:!1,properties:{step:{const:"create_task",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"accept_proposal",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"admit_execution",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"admit_placement",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"start_source",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"await_sources",type:"string"}},required:["step"],type:"object"},{additionalProperties:!1,properties:{step:{const:"synthesize",type:"string"}},required:["step"],type:"object"},{additionalProperties:!1,properties:{step:{const:"await_synthesis",type:"string"}},required:["step"],type:"object"},{additionalProperties:!1,properties:{step:{const:"release_placement",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"}]},WorkJobTaskIdentitiesV1:{additionalProperties:!1,properties:{key:{$ref:"#/$defs/WorkJobKeyV1"},proposal_id:{$ref:"#/$defs/ProposalId"},source:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["key","proposal_id","source"],type:"object"},WorkJobWaitV1:{oneOf:[{additionalProperties:!1,description:"The proposal route abstained, as it does while routing warms.",properties:{reason:{type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"},wait:{const:"proposal_route",type:"string"}},required:["wait","task","reason"],type:"object"},{additionalProperties:!1,properties:{identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"},wait:{const:"attempt",type:"string"}},required:["wait","identity","state"],type:"object"},{additionalProperties:!1,description:"The registered topology has no free attempt slot for this task.",properties:{problem:{$ref:"#/$defs/ApplicationProblemRecord"},task:{$ref:"#/$defs/WorkJobKeyV1"},wait:{const:"capacity",type:"string"}},required:["wait","task","problem"],type:"object"}]},WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkMilestoneV1:$L,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementStateV1:$K,WorkPlacementTargetV1:$J,WorkPlacementV1:$Z,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductEventPayloadV1:$1,WorkProductEventV1:$0,WorkProductGraphV1:$4,WorkProductMutationReceiptV1:$3,WorkProductProfileScopeV1:$9,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRestartReasonV1:Sm,WorkRouteDecisionV1:S_,WorkSandboxPolicy:Sw,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkSynthesisAttemptV1:{description:"The typed outcome of a synthesis request: an admitted attempt, or the\nsealed unsynthesized set when synthesis could not truthfully begin.",oneOf:[{additionalProperties:!1,description:"The admitted synthesis attempt and everything it is accountable to.",properties:{attempt:{$ref:"#/$defs/WorkAttemptV1",description:"The leased (or idempotently replayed) synthesis attempt."},draft:{$ref:"#/$defs/WorkflowSynthesisDraft",description:"The citation obligation, complete by construction: the draft cites\nevery citable source digest and is verified downstream by\n[`crate::workflow_synthesis::verify_workflow_synthesis_draft`]."},groups:{description:"Disagreement structure over the succeeded sources.",items:{$ref:"#/$defs/WorkSynthesisEvidenceGroupV1"},type:"array"},source_set:{$ref:"#/$defs/WorkSynthesisSourceSetV1",description:"The sealed source envelopes the attempt was admitted against."},synthesis:{const:"admitted",type:"string"},uncited:{description:"Sources preserved without citations: failures, unknowns, and\nartifact-less successes, in the caller's requested order.",items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"}},required:["synthesis","attempt","source_set","groups","draft","uncited"],type:"object"},{properties:{refusal:{$ref:"#/$defs/WorkSynthesisRefusalV1"},sources:{$ref:"#/$defs/WorkSynthesisSourceSetV1"},synthesis:{const:"unsynthesized",type:"string"}},required:["synthesis","sources","refusal"],type:"object"}]},WorkSynthesisEvidenceGroupV1:Sq,WorkSynthesisRefusalV1:SI,WorkSynthesisSourceEnvelopeV1:Sx,WorkSynthesisSourceOutcomeV1:Sj,WorkSynthesisSourceSetV1:SC,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowSynthesisDraft:SH,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"What one call did and where the job now stands.",properties:{job:{$ref:"#/$defs/WorkJobIdentitiesV1",description:"The derived identities, so the advanced operations can target them."},performed:{description:"Only the steps this call executed, in order.",items:{$ref:"#/$defs/WorkJobStepRecordV1"},type:"array"},state:{$ref:"#/$defs/WorkJobStateV1"}},required:["job","performed","state"],title:"AdvanceWorkJobResultV1",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{attempt_id:{$ref:"#/$defs/AttemptId"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","attempt_id"],title:"WorkAttemptStatusRequestV1",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkSandboxPolicy:Sw,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",properties:{actual_route:{anyOf:[{$ref:"#/$defs/WorkProviderRouteV1"},{type:"null"}]},artifacts:{items:{$ref:"#/$defs/WorkArtifactRefV1"},type:"array"},cancellation:{$ref:"#/$defs/WorkCancellationStateV1"},execution:{$ref:"#/$defs/WorkExecutionEnvelopeV1"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},lease:{$ref:"#/$defs/WorkLeaseFenceV1"},progress:{anyOf:[{$ref:"#/$defs/WorkAttemptProgressV1"},{type:"null"}]},projection_binding:{$ref:"#/$defs/WorkAttemptProjectionBindingV1"},recovery:{$ref:"#/$defs/WorkRecoveryStateV1"},requested_route:{$ref:"#/$defs/WorkProviderRouteV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"},terminal:{anyOf:[{$ref:"#/$defs/WorkTerminalEvidenceV1"},{type:"null"}]}},required:["identity","projection_binding","execution","lease","state","artifacts","cancellation","recovery","requested_route"],title:"WorkAttemptV1",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkCancellationRequestId:$d},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{attempt_id:{$ref:"#/$defs/AttemptId"},occurred_at:{$ref:"#/$defs/UtcMicros"},request_id:{$ref:"#/$defs/WorkCancellationRequestId"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","attempt_id","request_id","occurred_at"],title:"CancelWorkAttemptCommand",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{new_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"},observed_at:{$ref:"#/$defs/UtcMicros"},old_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","old_version","new_version","observed_at"],title:"WorkProposalComparisonRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProposalId:_8,ProviderId:vo,RetrievalAnchorId:vI,RunId:vF,TaskEvidenceLinkV1:bj,TaskId:bT,UtcMicros:bZ,VerifiedWorkEvidenceRootV1:{additionalProperties:!1,properties:{item:{$ref:"#/$defs/WorkItemV1"},links:{items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},proposal_decisions:{items:{$ref:"#/$defs/WorkProposalDecisionV1"},type:"array"},relation_replan_decisions:{items:{$ref:"#/$defs/WorkRelationReplanDecisionV1"},type:"array"},relations:{items:{$ref:"#/$defs/WorkProductRelationV1"},type:"array"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["verified_version","item","relations","proposal_decisions","relation_replan_decisions","links"],type:"object"},VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkItemInputV1:$M,WorkItemV1:$N,WorkProductRelationV1:$5,WorkProposalComparisonEffectV1:{oneOf:[{const:"advisory_only",description:"Comparison is evidence only. There is no apply edge from this result.",type:"string"}]},WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{added_evidence:{items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},added_relations:{items:{$ref:"#/$defs/WorkProductRelationV1"},type:"array"},effect:{$ref:"#/$defs/WorkProposalComparisonEffectV1"},item_changed:{type:"boolean"},new:{$ref:"#/$defs/VerifiedWorkEvidenceRootV1"},old:{$ref:"#/$defs/VerifiedWorkEvidenceRootV1"},removed_evidence:{items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},removed_relations:{items:{$ref:"#/$defs/WorkProductRelationV1"},type:"array"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","old","new","added_relations","removed_relations","added_evidence","removed_evidence","item_changed","effect"],title:"WorkProposalComparisonV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{initiative:{$ref:"#/$defs/WorkInitiativeV1"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},plan:{$ref:"#/$defs/WorkPlanV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","initiative","plan","milestone","item","mutation"],title:"CreateWorkTaskRequestV1",type:"object"},{$defs:{WorkAttemptListCursorV1:b9},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{anyOf:[{$ref:"#/$defs/WorkAttemptListCursorV1"},{type:"null"}],default:null},page_size:{format:"uint32",minimum:0,type:"integer"}},required:["page_size"],title:"WorkAttemptListRequestV1",type:"object"},{$defs:{AttemptId:fW,ManifestDigest:_l,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkAttemptListCoverageV1:b3,WorkAttemptListCursorV1:b9,WorkAttemptStateV1:$t,WorkEffectStateV1:$h,WorkExecutionSpanV1:{additionalProperties:!1,properties:{admitted_projection_sequence:{description:"Durable Work projection sequence under which execution was admitted.",format:"uint64",minimum:0,type:"integer"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},ended_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},started_at:{$ref:"#/$defs/UtcMicros"},state:{$ref:"#/$defs/WorkAttemptStateV1"},terminal_evidence_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},wall_micros:{description:"Present only when both owner instants form a valid non-negative span.",format:"uint64",minimum:0,type:["integer","null"]}},required:["identity","admitted_projection_sequence","state","effect_state","started_at"],type:"object"},WorkExecutionTimingCoverageV1:{oneOf:[{additionalProperties:!1,properties:{coverage:{const:"complete",type:"string"}},required:["coverage"],type:"object"},{additionalProperties:!1,properties:{coverage:{const:"partial",type:"string"},invalid_terminal_span:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},missing_dispatch:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"}},required:["coverage","missing_dispatch","invalid_terminal_span"],type:"object"}]},WorkObservedExecutionOrderBasisV1:{enum:["terminal_observed_at_then_admitted_projection_sequence_then_attempt_identity"],type:"string"},WorkObservedExecutionV1:{additionalProperties:!1,properties:{admitted_projection_sequence:{format:"uint64",minimum:0,type:"integer"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},observed_at:{$ref:"#/$defs/UtcMicros"},ordinal:{description:"One-based order assigned after sorting the durable terminal instants.",format:"uint32",minimum:0,type:"integer"},state:{$ref:"#/$defs/WorkAttemptStateV1"}},required:["ordinal","identity","admitted_projection_sequence","observed_at","state","evidence_digest"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,properties:{attempt_coverage:{$ref:"#/$defs/WorkAttemptListCoverageV1"},observed_order:{items:{$ref:"#/$defs/WorkObservedExecutionV1"},type:"array"},order_basis:{$ref:"#/$defs/WorkObservedExecutionOrderBasisV1"},spans:{items:{$ref:"#/$defs/WorkExecutionSpanV1"},type:"array"},state:{const:"listed",type:"string"},timing_coverage:{$ref:"#/$defs/WorkExecutionTimingCoverageV1"}},required:["state","spans","observed_order","order_basis","attempt_coverage","timing_coverage"],type:"object"}],title:"WorkExecutionHistoryV1"},{$defs:{ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkExpertiseCategoryV1:$V,WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{evidence_not_before:{$ref:"#/$defs/UtcMicros",description:"Evidence before this owner-supplied horizon is excluded as stale."},expertise_categories:{description:"Categories for which the returned context will be used ephemerally.",items:{$ref:"#/$defs/WorkExpertiseCategoryV1"},type:"array",uniqueItems:!0},limit:{format:"uint32",minimum:0,type:"integer"},observed_at:{$ref:"#/$defs/UtcMicros"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["selection","task_id","verified_version","evidence_not_before","expertise_categories","limit","observed_at"],title:"WorkExperienceRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProposalId:_8,ProviderId:vo,RetrievalAnchorId:vI,RunId:vF,SessionId:v8,TaskEvidenceLinkV1:bj,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptEvidenceRecordV1:b4,WorkAttemptIdentityV1:b6,WorkAttemptProviderOutcomeV1:b7,WorkAttemptReceiptV1:$e,WorkAttemptStreamChannelV1:$r,WorkAttemptStreamSummaryV1:$i,WorkExperienceApplicabilityV1:{enum:["same_accepted_route","same_milestone"],type:"string"},WorkExperienceCandidateV1:{additionalProperties:!1,properties:{applicability:{description:"Separate declared applicability facts. This is intentionally not a\nscore and candidates remain in canonical TaskId order.",items:{$ref:"#/$defs/WorkExperienceApplicabilityV1"},type:"array",uniqueItems:!0},attempt_receipts:{description:"Exact receipts for accepted successful attempts whose sealed provider\nevidence and declared artifacts establish reusable observed work. The\nidentity is also the canonical `work_retrieve_evidence` drill target.",items:{$ref:"#/$defs/WorkAttemptReceiptV1"},type:"array"},evidence:{description:"Exact anchored evidence establishing that this is observed experience.",items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},item:{$ref:"#/$defs/WorkItemV1"}},required:["item","evidence","attempt_receipts","applicability"],type:"object"},WorkExperienceCoverageV1:{oneOf:[{additionalProperties:!1,properties:{coverage:{const:"unavailable",type:"string"}},required:["coverage"],type:"object"},{additionalProperties:!1,properties:{applicable:{format:"uint32",minimum:0,type:"integer"},coverage:{const:"complete",type:"string"},returned:{format:"uint32",minimum:0,type:"integer"},stale_excluded:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned","applicable","stale_excluded"],type:"object"},{additionalProperties:!1,properties:{applicable:{format:"uint32",minimum:0,type:"integer"},coverage:{const:"partial",type:"string"},omitted_by_limit:{format:"uint32",minimum:0,type:"integer"},returned:{format:"uint32",minimum:0,type:"integer"},stale_excluded:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned","applicable","stale_excluded","omitted_by_limit"],type:"object"}]},WorkExpertiseAuthorizationV1:{oneOf:[{additionalProperties:!1,properties:{availability:{const:"available",type:"string"},categories:{items:{$ref:"#/$defs/WorkExpertiseCategoryV1"},type:"array",uniqueItems:!0},durability:{$ref:"#/$defs/WorkExpertiseContextDurabilityV1"},expires_at:{$ref:"#/$defs/UtcMicros"},pin:{$ref:"#/$defs/WorkExpertiseConsentPinV1"}},required:["availability","categories","expires_at","pin","durability"],type:"object"},{additionalProperties:!1,properties:{availability:{const:"unavailable",type:"string"},legal_actions:{items:{$ref:"#/$defs/WorkExpertiseLegalActionV1"},type:"array",uniqueItems:!0},pin:{$ref:"#/$defs/WorkExpertiseConsentPinV1"},reasons:{items:{$ref:"#/$defs/WorkExpertiseUnavailableReasonV1"},type:"array",uniqueItems:!0}},required:["availability","reasons","legal_actions","pin"],type:"object"}]},WorkExpertiseCategoryV1:$V,WorkExpertiseConsentPinV1:{additionalProperties:!1,properties:{configuration_digest:{$ref:"#/$defs/ManifestDigest"},configuration_revision:{$ref:"#/$defs/ConfigurationRevisionId"},configuration_snapshot:{$ref:"#/$defs/ConfigurationSnapshotId"},provenance_digest:{$ref:"#/$defs/ManifestDigest"}},required:["configuration_revision","configuration_snapshot","configuration_digest","provenance_digest"],type:"object"},WorkExpertiseContextDurabilityV1:{oneOf:[{const:"ephemeral_only",description:"Context is returned for this read only and cannot establish evidence,\nrouting, proposal acceptance, execution admission, or completion.",type:"string"}]},WorkExpertiseLegalActionV1:{enum:["grant_user_consent","grant_project_consent","renew_user_consent","renew_project_consent","allow_requested_categories"],type:"string"},WorkExpertiseUnavailableReasonV1:{enum:["user_consent_disabled","project_consent_disabled","user_consent_not_yet_effective","project_consent_not_yet_effective","user_consent_expired","project_consent_expired","requested_category_not_allowed"],type:"string"},WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkItemInputV1:$M,WorkItemV1:$N,WorkProviderAvailabilityV1:So,WorkProviderBackendV1:Sn,WorkProviderFallbackRecordV1:Sa,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{candidates:{items:{$ref:"#/$defs/WorkExperienceCandidateV1"},type:"array"},coverage:{$ref:"#/$defs/WorkExperienceCoverageV1"},evidence_not_before:{$ref:"#/$defs/UtcMicros"},expertise:{$ref:"#/$defs/WorkExpertiseAuthorizationV1"},observed_at:{$ref:"#/$defs/UtcMicros"},task_id:{$ref:"#/$defs/TaskId"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["task_id","verified_version","evidence_not_before","observed_at","expertise","candidates","coverage"],title:"WorkExperienceV1",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,ProposalId:_8,RepositoryId:vb,TaskId:bT,UtcMicros:bZ,WorkEvidenceFrontierV1:$v,WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Read-only proposal generation over one exact current product graph.",properties:{live_git_evidence:{anyOf:[{$ref:"#/$defs/WorkEvidenceFrontierV1"},{type:"null"}],default:null},occurred_at:{$ref:"#/$defs/UtcMicros"},proposal_id:{$ref:"#/$defs/ProposalId"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","proposal_id","occurred_at"],title:"GenerateProposalRequest",type:"object"},{$defs:{ConfigurationRevisionId:hM,ManifestDigest:_l,PolicyIdentifierV1:{description:"A bounded, canonical identifier owned by the policy input schema.\n\nIt represents immutable references only; it is never a path, display\nlabel, provider account, branch name, or native object identifier.",type:"string"},ProposalId:_8,ProviderId:vo,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkCalibratedSizingV1:{additionalProperties:!1,description:"Calibrated sizing. Emitted ONLY when support >= floor. Every field is\nnamed separately (Plan 06); `support_floor` carries the governing floor\ninto the record.",properties:{band:{$ref:"#/$defs/WorkOrdinalBandV1",description:"The sizing band itself: the stronger of the route's declared effort and\nthe derived shape magnitude, widened when the cohort error is high."},cohort:{description:"Identity of the cohort the sizing was calibrated over: the top-ranked\nroute id. Sizing from one cohort is never reused for another.",type:"string"},drift_valid:{description:"False when the cohort contains incomparable or stale observations, so a\nconsumer can refuse a sizing that drifted rather than silently trust it.",type:"boolean"},error:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Observed adverse-outcome band over the cohort. An ordinal band, never a\nrate and never a probability."},horizon:{$ref:"#/$defs/UtcMicros",description:"Latest comparable observation in the cohort. Nothing after\n`evaluated_at` contributes, so the horizon never runs ahead of the input."},support:{description:"Count of comparable in-cohort outcomes backing this sizing.",format:"uint32",minimum:0,type:"integer"},support_floor:{description:"The floor that governed this emission, carried so replay shows which\nfloor applied rather than assuming the current constant.",format:"uint32",minimum:0,type:"integer"}},required:["cohort","horizon","support","support_floor","error","drift_valid","band"],type:"object"},WorkCalibrationEvidenceV1:{additionalProperties:!1,description:"Raw calibration values and their exact decision provenance.\n\nNo rate, probability, or composite score is derived here. Consumers see\nthe authority-supplied outcome rows, categorical uncertainty, and exact\ndenominator counts that produced the proposal's existing calibrated sizing.",properties:{cohort_route:{type:["string","null"]},comparable_outcomes:{format:"uint32",minimum:0,type:"integer"},eligible_route_count:{format:"uint32",minimum:0,type:"integer"},incomparable_outcomes:{format:"uint32",minimum:0,type:"integer"},provenance:{$ref:"#/$defs/WorkCalibrationProvenanceV1"},raw_outcomes:{items:{$ref:"#/$defs/WorkPriorOutcomeV1"},type:"array"},routes_with_outcomes:{format:"uint32",minimum:0,type:"integer"},uncertainty:{$ref:"#/$defs/WorkCalibrationUncertaintyV1"}},required:["raw_outcomes","eligible_route_count","routes_with_outcomes","comparable_outcomes","incomparable_outcomes","uncertainty","provenance"],type:"object"},WorkCalibrationProvenanceV1:{additionalProperties:!1,properties:{configuration_digest:{$ref:"#/$defs/ManifestDigest"},configuration_revision:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},evaluated_at:{$ref:"#/$defs/UtcMicros"},evaluator_id:{type:"string"},evaluator_revision:{format:"uint64",minimum:0,type:"integer"},input_digest:{$ref:"#/$defs/ManifestDigest"},local_evidence:{anyOf:[{$ref:"#/$defs/WorkEvidenceFrontierV1"},{type:"null"}]}},required:["evaluator_id","evaluator_revision","input_digest","configuration_digest","evaluated_at"],type:"object"},WorkCalibrationUncertaintyV1:{enum:["supported","sparse","stale","incomparable"],type:"string"},WorkDecompositionProposalV1:{additionalProperties:!1,description:"A one-level decomposition proposal. Never recursive: a deeper split is a\nseparate sequenced capability, not something this evaluator may invent.",properties:{candidates:{description:"The proposed sketches, ordinal ascending from 0.",items:{$ref:"#/$defs/WorkSubtaskSketchV1"},type:"array"},rationale:{description:"Why the proposal was emitted, in the same ordered reason vocabulary the\ndecision uses.",items:{$ref:"#/$defs/WorkProposalReasonV1"},type:"array"}},required:["candidates","rationale"],type:"object"},WorkEvidenceFrontierV1:$v,WorkFrontierComparisonV1:{description:"Recorded relation between the two supplied frontiers. `Incomparable` means\nat least one side was absent; it is not collapsed into agreement.",enum:["agree","disagree","incomparable"],type:"string"},WorkOrdinalBandV1:$U,WorkPriorOutcomeV1:{additionalProperties:!1,description:"Cohort denominator. APPLICATION-supplied, never worker-supplied.\n\nA worker cannot widen its own calibration cohort, so a route cannot earn\ncalibrated sizing by reporting its own successes.",properties:{accepted:{description:"Whether the produced work was accepted.",type:"boolean"},escaped_defect:{description:"Whether a defect escaped review.",type:"boolean"},observed_at:{$ref:"#/$defs/UtcMicros",description:"When the outcome was observed. Outcomes later than `evaluated_at` are\nINCOMPARABLE and are excluded from support rather than trusted."},rework:{description:"Whether the accepted work required rework.",type:"boolean"},route_id:{description:"The route this outcome belongs to. May name a retired route; only\noutcomes matching the top-ranked route form the sizing cohort.",type:"string"},terminal:{$ref:"#/$defs/WorkPriorTerminalV1",description:"How the attempt terminated."}},required:["route_id","accepted","rework","escaped_defect","terminal","observed_at"],type:"object"},WorkPriorTerminalV1:{description:"How a prior attempt on a route ended. Recorded, never inferred.",enum:["succeeded","failed","timed_out","cancelled"],type:"string"},WorkProposalActionV1:{description:"The explicit command the decision recommends next. A recommendation never\nexecutes; each action names a separate version-checked application command.",enum:["proceed_to_acceptance","hold_for_dependencies","admit_execution","replan"],type:"string"},WorkProposalDecisionV1:{additionalProperties:!1,description:"One explained, replayable work-loop decision.",properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},configuration_revision:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},decomposition:{anyOf:[{$ref:"#/$defs/WorkDecompositionProposalV1"},{type:"null"}],description:"One-level decomposition sketch, present only when more than one\ndependency is unresolved."},deterministic_fallback:{description:"True when the recommendation is the declared deterministic baseline\nselected because the evidence cannot support a stronger claim.",type:"boolean"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},evaluator_id:{$ref:"#/$defs/PolicyIdentifierV1"},evaluator_revision:{format:"uint64",minimum:0,type:"integer"},frontier_comparison:{$ref:"#/$defs/WorkFrontierComparisonV1"},input_digest:{$ref:"#/$defs/ManifestDigest"},live_git_evidence:{anyOf:[{$ref:"#/$defs/WorkEvidenceFrontierV1"},{type:"null"}],description:"The live Git frontier, returned exactly as supplied."},local_evidence:{anyOf:[{$ref:"#/$defs/WorkEvidenceFrontierV1"},{type:"null"}],description:"The local code/session frontier, returned exactly as supplied."},ordered_reason_codes:{items:{$ref:"#/$defs/WorkProposalReasonV1"},type:"array"},policy_digest:{$ref:"#/$defs/ManifestDigest"},policy_revision:{format:"uint64",minimum:0,type:"integer"},recommended_action:{anyOf:[{$ref:"#/$defs/WorkProposalActionV1"},{type:"null"}]},route_plan:{anyOf:[{$ref:"#/$defs/WorkRoutePlanV1"},{type:"null"}],description:"The explained route plan. Present on every evaluation that reached the\ngates, including the one that found no eligible route."},shape:{anyOf:[{$ref:"#/$defs/WorkTaskShapeV1"},{type:"null"}],description:"Derived task shape. Absent on the invalid, cancelled, and deadline\nshort-circuits, where no planner claim is licensed."},sizing:{anyOf:[{$ref:"#/$defs/WorkCalibratedSizingV1"},{type:"null"}],description:"Calibrated sizing, present only when in-cohort support reached the\ngoverning floor. Absence is a recorded fact, never a fabricated estimate."},task_id:{$ref:"#/$defs/TaskId"}},required:["evaluator_id","evaluator_revision","input_digest","task_id","based_on_version","policy_revision","policy_digest","configuration_digest","disposition","deterministic_fallback","ordered_reason_codes","frontier_comparison"],type:"object"},WorkProposalDispositionV1:{description:"Exactly one disposition per decision.",enum:["allow","deny","abstain","indeterminate"],type:"string"},WorkProposalReasonV1:{enum:["invalid_request","request_cancelled","deadline_exceeded","frontier_agreement","frontier_disagreement","frontier_incomparable","task_accepted","runtime_coverage_partial","runtime_coverage_unavailable","terminal_evidence_observed","execution_in_flight","proposal_accepted","dependencies_unresolved","ready","insufficient_calibration_support","route_budget_exceeded","route_content_location_refused","route_evidence_sparse","route_evidence_stale","human_override_applied","no_eligible_routes","deterministic_baseline_selected"],type:"string"},WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRankedRouteV1:{additionalProperties:!1,description:"Ranked route. Dimensions stay SEPARATE. No scalar score field is permitted here.",properties:{autonomy:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Autonomy fitness, echoed unmerged."},correctness:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Correctness fitness, echoed so the ranking can be audited without the input."},cost:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Cost fitness, oriented so `Highest` is best-fitting."},evidence_quality:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Evidence-quality fitness, echoed unmerged."},latency:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Latency fitness, oriented so `Highest` is best-fitting."},rank:{description:"Position in the ranking, ascending from 1.",format:"uint32",minimum:0,type:"integer"},route_id:{description:"The ranked route's identity.",type:"string"},sensitive_data_fitness:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Sensitive-data fitness, echoed unmerged."}},required:["rank","route_id","correctness","sensitive_data_fitness","latency","cost","autonomy","evidence_quality"],type:"object"},WorkRouteDecisionV1:S_,WorkRouteExclusionV1:{additionalProperties:!1,description:"One refused route and the single reason that refused it. Exclusion is\nrecorded rather than silent so a missing route is always explained.",properties:{reason:{$ref:"#/$defs/WorkProposalReasonV1",description:"The first limit the route failed, in the declared exclusion order."},route_id:{description:"The refused route's identity.",type:"string"}},required:["route_id","reason"],type:"object"},WorkRoutePlanV1:{additionalProperties:!1,description:"The explained route plan for one decision. Recommends; never dispatches.",properties:{coverage:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Fraction-free ordinal coverage of the cohort evidence over the ranked set."},deterministic_baseline:{description:"The declared deterministic baseline, selected when evidence cannot support a\nstronger claim. Always names a route that survived exclusion, or None when none did.",type:["string","null"]},exclusions:{description:"Every refused route with its reason, in supplied order.",items:{$ref:"#/$defs/WorkRouteExclusionV1"},type:"array"},human_override_applied:{description:"True only when a recorded human override named a route that survived\nexclusion. An excluded or unknown override leaves ranking untouched.",type:"boolean"},ranked:{description:"Surviving routes in total, deterministic order, rank ascending from 1.",items:{$ref:"#/$defs/WorkRankedRouteV1"},type:"array"},uncertainty:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Widens on sparse / stale / incomparable evidence."}},required:["ranked","exclusions","coverage","uncertainty","human_override_applied"],type:"object"},WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkSubtaskSketchV1:{additionalProperties:!1,description:"One level only (Q3). Read-only sketch; accepting it stays a separate version-checked command.",properties:{ordinal:{description:"Position in the proposal, ascending from 0. Stable across replays of the\nsame input.",format:"uint32",minimum:0,type:"integer"},shape:{$ref:"#/$defs/WorkTaskShapeKindV1",description:"Kind the sketch would carry if it were accepted as its own task."},summary:{description:"What the sketch covers, phrased from the declared counts alone.",type:"string"}},required:["ordinal","summary","shape"],type:"object"},WorkTaskShapeKindV1:{description:"Kind of work the snapshot facts describe. Derived only from facts already in\nthe input; `Unclassified` when those facts do not distinguish a kind.",enum:["investigation","change","synthesis","unclassified"],type:"string"},WorkTaskShapeV1:{additionalProperties:!1,description:"The derived shape of the task: what kind of work it is and how large the\ndeclared dependency and evidence counts make it.",properties:{band:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Magnitude band derived from the declared dependency and evidence counts."},kind:{$ref:"#/$defs/WorkTaskShapeKindV1",description:"Kind derived from the gate booleans and counts. No new discovery."}},required:["kind","band"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"A canonical product proposal and the exact verified graph that licensed it.\n\n`proposal` can be moved directly into a `DecideWorkProposalRequestV1`;\ncallers use `verified_graph_version` to construct that mutation's CAS pin.",properties:{calibration:{$ref:"#/$defs/WorkCalibrationEvidenceV1"},decision:{$ref:"#/$defs/WorkProposalDecisionV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},verified_graph_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["proposal","verified_graph_version","decision","calibration"],title:"GeneratedWorkProposal",type:"object"},{$defs:{WorkAttemptListCursorV1:b9},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One authority-scoped artifact hydration request, paged like the attempt\nlist and pinned to the same verified topology generation.",properties:{cursor:{anyOf:[{$ref:"#/$defs/WorkAttemptListCursorV1"},{type:"null"}],default:null},page_size:{format:"uint32",minimum:0,type:"integer"}},required:["page_size"],title:"WorkArtifactHydrationRequestV1",type:"object"},{$defs:{AttemptId:fW,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProviderId:vo,RunId:vF,SessionId:v8,TaskId:bT,UtcMicros:bZ,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptArtifactsV1:{additionalProperties:!1,description:"The artifacts and evidence one attempt declared.",properties:{artifacts:{description:"Every artifact reference the attempt declared, in its canonical\nstored order. References carry digest and byte length; bytes are\nnever part of this read.",items:{$ref:"#/$defs/WorkArtifactRefV1"},type:"array"},evidence:{$ref:"#/$defs/WorkAttemptEvidenceStateV1"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["identity","artifacts","evidence"],type:"object"},WorkAttemptEvidenceRecordV1:b4,WorkAttemptEvidenceStateV1:{description:"Whether an attempt's terminal evidence has been sealed. An attempt that\nhas not reported an outcome yet is a typed state, not a missing record.",oneOf:[{additionalProperties:!1,description:"The attempt has not sealed terminal evidence yet.",properties:{state:{const:"pending",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The sealed terminal evidence record, exactly as it was written.",properties:{record:{$ref:"#/$defs/WorkAttemptEvidenceRecordV1"},state:{const:"sealed",type:"string"}},required:["state","record"],type:"object"}]},WorkAttemptIdentityV1:b6,WorkAttemptListCoverageV1:b3,WorkAttemptListCursorV1:b9,WorkAttemptProviderOutcomeV1:b7,WorkAttemptStreamChannelV1:$r,WorkAttemptStreamSummaryV1:$i,WorkAttemptTopologyBindingV1:$o,WorkProviderAvailabilityV1:So,WorkProviderBackendV1:Sn,WorkProviderFallbackRecordV1:Sa,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One authority-scoped artifact hydration read. Absence of any Work in\nscope is a typed state, distinct from an authorized-but-empty page.",oneOf:[{additionalProperties:!1,description:"No Work exists in this authority scope, so there is no attempt set to\nhydrate. Concealed scopes never reach this state: they are refused as\nnot-found-or-not-authorized before any read.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"One page of attempt artifact sets under the verified topology\nsnapshot.",properties:{attempts:{items:{$ref:"#/$defs/WorkAttemptArtifactsV1"},type:"array"},coverage:{$ref:"#/$defs/WorkAttemptListCoverageV1"},state:{const:"hydrated",type:"string"},topology:{$ref:"#/$defs/WorkAttemptTopologyBindingV1"}},required:["state","topology","attempts","coverage"],type:"object"}],title:"WorkArtifactHydrationV1"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptListCoverageV1:b3,WorkAttemptListCursorV1:b9,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptTopologyBindingV1:$o,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkSandboxPolicy:Sw,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One authority-scoped attempt-list read. Absence of any Work in scope is a\ntyped state, distinct from an authorized-but-empty page.",oneOf:[{additionalProperties:!1,description:"No Work exists in this authority scope, so there is no attempt set to\npage. Concealed scopes never reach this state: they are refused as\nnot-found-or-not-authorized before any read.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"One page of durable attempts under the verified topology snapshot.",properties:{attempts:{items:{$ref:"#/$defs/WorkAttemptV1"},type:"array"},coverage:{$ref:"#/$defs/WorkAttemptListCoverageV1"},state:{const:"listed",type:"string"},topology:{$ref:"#/$defs/WorkAttemptTopologyBindingV1"}},required:["state","topology","attempts","coverage"],type:"object"}],title:"WorkAttemptListV1"},{$defs:{AcceptWorkTaskRequestV1:{additionalProperties:!1,properties:{evidence_by_criterion:{additionalProperties:{type:"string"},type:"object"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","evidence_by_criterion","mutation"],type:"object"},ActorId:fb,AddWorkTaskRequestV1:{additionalProperties:!1,properties:{item:{$ref:"#/$defs/WorkItemV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","item","mutation"],type:"object"},AdmitWorkExecutionRequestV1:{additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","based_on_version","mutation"],type:"object"},ApplyWorkRelationReplanRequestV1:{additionalProperties:!1,properties:{mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal_id:{$ref:"#/$defs/ProposalId"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal_id","mutation"],type:"object"},AttemptId:fW,CatalogGenerationId:hp,ConfigurationRevisionId:hM,CreateWorkProductRequestV1:{additionalProperties:!1,properties:{initial_graph:{$ref:"#/$defs/WorkProductGraphV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","initial_graph","mutation"],type:"object"},CreateWorkTaskRequestV1:{additionalProperties:!1,properties:{initiative:{$ref:"#/$defs/WorkInitiativeV1"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},plan:{$ref:"#/$defs/WorkPlanV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","initiative","plan","milestone","item","mutation"],type:"object"},DecideWorkProposalRequestV1:{additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal","disposition","mutation"],type:"object"},DecideWorkRelationReplanRequestV1:{additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal:{$ref:"#/$defs/WorkRelationReplanProposalV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal","disposition","mutation"],type:"object"},LinkAcceptedWorkAttemptRequestV1:{additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","based_on_version","identity","mutation"],type:"object"},ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RecordWorkHandoffRequestV1:{additionalProperties:!1,properties:{handoff:{$ref:"#/$defs/WorkHandoffV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","handoff","mutation"],type:"object"},RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,SourceStoreId:bS,TaskEvidenceLinkV1:bj,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductGraphV1:$4,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Closed public mutation surface for the Work-product graph authority.",oneOf:[{properties:{mutation:{const:"create",type:"string"},request:{$ref:"#/$defs/CreateWorkProductRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"add_task",type:"string"},request:{$ref:"#/$defs/AddWorkTaskRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"create_task",type:"string"},request:{$ref:"#/$defs/CreateWorkTaskRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"decide_proposal",type:"string"},request:{$ref:"#/$defs/DecideWorkProposalRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"decide_relation_replan",type:"string"},request:{$ref:"#/$defs/DecideWorkRelationReplanRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"apply_relation_replan",type:"string"},request:{$ref:"#/$defs/ApplyWorkRelationReplanRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"accept_task",type:"string"},request:{$ref:"#/$defs/AcceptWorkTaskRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"admit_execution",type:"string"},request:{$ref:"#/$defs/AdmitWorkExecutionRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"link_accepted_attempt",type:"string"},request:{$ref:"#/$defs/LinkAcceptedWorkAttemptRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"record_handoff",type:"string"},request:{$ref:"#/$defs/RecordWorkHandoffRequestV1"}},required:["mutation","request"],type:"object"}],title:"WorkProductMutationRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkRunControlReasonV1:S$},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_authority_version:{default:null,description:'The authority version the caller read. Absent means "no control row was\npublished yet"; a mismatch is a conflict, never an overwrite.',format:"uint64",minimum:0,type:["integer","null"]},occurred_at:{$ref:"#/$defs/UtcMicros"},reason:{$ref:"#/$defs/WorkRunControlReasonV1"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","reason","occurred_at"],title:"PauseWorkRunCommand",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkRunControlAuthorityV1:Sb,WorkRunControlReasonV1:S$,WorkRunControlStateV1:SS,WorkRunDeadlineCheckpointV1:Sk},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One run's durable control aggregate.",properties:{authority:{$ref:"#/$defs/WorkRunControlAuthorityV1"},deadline:{$ref:"#/$defs/WorkRunDeadlineCheckpointV1"},fenced_attempts:{description:'The exact attempts that were live when the current state published.\nEmpty means "none were live", never "we did not look".',items:{$ref:"#/$defs/AttemptId"},type:"array"},reason:{anyOf:[{$ref:"#/$defs/WorkRunControlReasonV1"},{type:"null"}]},run_id:{$ref:"#/$defs/RunId"},state:{$ref:"#/$defs/WorkRunControlStateV1"},task_id:{$ref:"#/$defs/TaskId"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["task_id","run_id","state","authority","deadline","transitioned_at","fenced_attempts"],title:"WorkRunControlV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementKindV1:$B,WorkPlacementTargetV1:$J},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{occurred_at:{$ref:"#/$defs/UtcMicros"},run_id:{$ref:"#/$defs/RunId"},target:{$ref:"#/$defs/WorkPlacementTargetV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","target","occurred_at"],title:"WorkPlacementPreflightRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementObservationV1:{additionalProperties:!1,description:'What was actually observed at the target, in counts rather than prose.\n\nCounts are measurements: a zero is "we looked and found none", and\n`readable: false` is the separate state for "we could not look". Collapsing\nthem would let an unreadable target read as a clean one.',properties:{active_holder:{description:"Whether another admitted placement already holds this target.",type:"boolean"},dirty_tracked_paths:{description:"Tracked paths that differ from the index or HEAD.",format:"uint32",minimum:0,type:"integer"},network_required:{description:"Whether the declared network-free placement would require network.",type:"boolean"},observed_at:{$ref:"#/$defs/UtcMicros"},readable:{description:"Whether the target could be read at all.",type:"boolean"},unique_commits:{description:'Commits in the target reachable from nowhere else.\n\n`None` means reachability was not measured, and it blocks removal\nexactly as a positive count does: an unmeasured target is "unknown"\nand is retained rather than assumed worthless. Only removal consults\nthis; admission does not.',format:"uint32",minimum:0,type:["integer","null"]},untracked_paths:{description:"Untracked paths present in the target.",format:"uint32",minimum:0,type:"integer"}},required:["dirty_tracked_paths","untracked_paths","readable","active_holder","network_required","observed_at"],title:"WorkPlacementObservationV1",type:"object"},WorkPlacementTargetV1:$J},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One placement preflight reading: what was asked for, what was seen, and\nexactly what blocks it.",properties:{blockers:{items:{$ref:"#/$defs/WorkPlacementBlockerV1"},type:"array",uniqueItems:!0},identity:{$ref:"#/$defs/WorkPlacementIdentityV1"},observation:{$ref:"#/$defs/WorkPlacementObservationV1"},target:{$ref:"#/$defs/WorkPlacementTargetV1"}},required:["identity","target","observation","blockers"],title:"WorkPlacementPreflightV1",type:"object"},{$defs:{RunId:vF,TaskId:bT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id"],title:"WorkPlacementStatusRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementStateV1:$K,WorkPlacementTargetV1:$J,WorkPlacementV1:$Z},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One placement reading. Absence is a state, not an empty placement.",oneOf:[{additionalProperties:!1,description:"No placement was ever admitted for this run.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The durable placement relation.",properties:{placement:{$ref:"#/$defs/WorkPlacementV1"},state:{const:"placed",type:"string"}},required:["state","placement"],type:"object"}],title:"WorkPlacementReadingV1"},{$defs:{AttemptId:fW,CoverageStateV1:yf,DuplicateEffectOutcomeV1:yP,DuplicateEffortKindV1:yV,QuantityEvidenceClassV1:vs,RunId:vF,TaskId:bT,WorkAttemptIdentityV1:b6,WorkDuplicateAdjudicationQuantitiesV1:$f},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Operator judgment before the owning Work authority binds exact current\ngenerations, relation revision, command identity, and observation time.",properties:{first_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},quantities:{$ref:"#/$defs/WorkDuplicateAdjudicationQuantitiesV1"},reason:{type:"string"},second_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},verdict:{$ref:"#/$defs/DuplicateEffortKindV1"}},required:["first_attempt","second_attempt","verdict","quantities","reason"],title:"PrepareWorkDuplicateAdjudicationRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductChangeDraftV1:{description:"Operator-selected graph change before the owning Work authority binds the\ncurrent verified head and revision authorities.",oneOf:[{properties:{change:{const:"add_task",type:"string"},item:{$ref:"#/$defs/WorkItemV1"}},required:["change","item"],type:"object"},{properties:{change:{const:"create_task",type:"string"},initiative:{$ref:"#/$defs/WorkInitiativeV1"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},plan:{$ref:"#/$defs/WorkPlanV1"}},required:["change","initiative","plan","milestone","item"],type:"object"},{properties:{change:{const:"decide_proposal",type:"string"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["change","proposal","disposition"],type:"object"},{properties:{change:{const:"decide_relation_replan",type:"string"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},proposal:{$ref:"#/$defs/WorkRelationReplanProposalV1"}},required:["change","proposal","disposition"],type:"object"},{properties:{change:{const:"apply_relation_replan",type:"string"},proposal_id:{$ref:"#/$defs/ProposalId"}},required:["change","proposal_id"],type:"object"},{properties:{change:{const:"accept_task",type:"string"},evidence_by_criterion:{additionalProperties:{type:"string"},type:"object"},task_id:{$ref:"#/$defs/TaskId"}},required:["change","task_id","evidence_by_criterion"],type:"object"},{properties:{change:{const:"admit_execution",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["change","task_id"],type:"object"},{properties:{change:{const:"link_accepted_attempt",type:"string"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["change","task_id","identity"],type:"object"},{properties:{change:{const:"record_handoff",type:"string"},handoff:{$ref:"#/$defs/WorkHandoffV1"}},required:["change","handoff"],type:"object"}]},WorkProductEventEvidenceV1:$Y,WorkProductSelectionScopeV1:$7,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Read-only preparation input. Authority identities, clocks, and revision\npins are deliberately absent because the backend owns them.",properties:{causation_event_id:{type:["string","null"]},change:{$ref:"#/$defs/WorkProductChangeDraftV1"},evidence:{items:{$ref:"#/$defs/WorkProductEventEvidenceV1"},type:"array"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","change","evidence"],title:"PrepareWorkProductMutationRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_authority_version:{format:"uint64",minimum:0,type:"integer"},occurred_at:{$ref:"#/$defs/UtcMicros"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","expected_authority_version","occurred_at"],title:"ReleaseWorkPlacementCommand",type:"object"},{$defs:{UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{occurred_at:{$ref:"#/$defs/UtcMicros"}},required:["occurred_at"],title:"ResumeWorkAttemptsCommand",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkSandboxPolicy:Sw,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"What restart recovery did to each open attempt.\n\nThis report never claims that a provider resumed. An attempt in\n`recovery_required` remains fenced under its original identity. This report\ndoes not authorize another launch; an explicit `retry_attempt` must verify\nthe exact recovery fence and effect safety before it can atomically admit a\nnew identity.",properties:{cancelled:{description:"Attempts whose in-flight cancellation was completed during recovery.",items:{$ref:"#/$defs/WorkAttemptV1"},type:"array"},recovery_required:{description:"Attempts fenced onto a new epoch and awaiting an explicit recovery\ndecision.",items:{$ref:"#/$defs/WorkAttemptV1"},type:"array"}},required:["recovery_required","cancelled"],title:"WorkAttemptRecoveryReportV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkRunControlReasonV1:S$},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_authority_version:{format:"uint64",minimum:0,type:"integer"},occurred_at:{$ref:"#/$defs/UtcMicros"},reason:{$ref:"#/$defs/WorkRunControlReasonV1"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","reason","expected_authority_version","occurred_at"],title:"ResumeWorkRunCommand",type:"object"},{$defs:{AttemptId:fW,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProjectId:_4,ProviderId:vo,RepositoryId:vb,RunId:vF,SessionId:v8,TaskId:bT,TemporalModeV1:bW,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAttemptIdentityV1:b6,WorkEvidenceContinuationV1:$_,WorkEvidenceExpansionSelectorV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"anchor",type:"string"},link_id:{type:"string"}},required:["kind","link_id"],type:"object"},{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},kind:{const:"task_session",type:"string"}},required:["kind","attempt"],type:"object"}]},WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7,WorkTaskSessionContinuationV1:ST},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One TaskId-rooted read. The exact Work graph identity remains mandatory on\ncontinuation and expansion requests, so neither an anchor nor a cursor is\nauthority by possession.",properties:{continuation:{anyOf:[{$ref:"#/$defs/WorkEvidenceContinuationV1"},{type:"null"}],default:null},expansion:{anyOf:[{$ref:"#/$defs/WorkEvidenceExpansionSelectorV1"},{type:"null"}],default:null},observed_at:{$ref:"#/$defs/UtcMicros"},page_size:{format:"uint32",minimum:0,type:"integer"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"},temporal:{$ref:"#/$defs/TemporalModeV1"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["selection","task_id","verified_version","temporal","page_size","observed_at"],title:"WorkEvidenceRetrieveRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProposalId:_8,ProviderId:vo,RetrievalAnchorId:vI,RunId:vF,SessionId:v8,SessionRetrievalBudgetAccountingV1:{additionalProperties:!1,description:"The ceiling and count behind a budget refusal.\n\n`stage` names which budget refused; this is what tells an oversized request\napart from a read whose cost was mis-sized for it. The ceiling value also\ndistinguishes the resources inside one stage: a record read that stopped at\n1024 hit the item count, one that stopped at 16 MiB hit the byte total, so\nthe kernel's resource spelling stays in the kernel instead of becoming a\nsecond wire vocabulary to keep in step.",properties:{limit:{format:"uint64",minimum:0,type:"integer"},observed:{$ref:"#/$defs/SessionRetrievalBudgetObservationV1"}},required:["limit","observed"],type:"object"},SessionRetrievalBudgetObservationV1:{description:"What a refusing budget boundary had counted.\n\nBoth variants are exact. A bounded read never counts the rows it declined to\nread, so an exhausted read reports what it consumed and that storage held\nmore, never a total it would have to run the refused scan to learn.",oneOf:[{additionalProperties:!1,description:"The request asked for more units than the admitted maximum.",properties:{observation:{const:"requested",type:"string"},units:{format:"uint64",minimum:0,type:"integer"}},required:["observation","units"],type:"object"},{additionalProperties:!1,description:"The read consumed its whole budget and storage still held more.",properties:{observation:{const:"consumed_with_more_available",type:"string"},units:{format:"uint64",minimum:0,type:"integer"}},required:["observation","units"],type:"object"}]},SessionRetrievalBudgetStageV1:bo,SessionRetrievalStructuralRefusalV1:{oneOf:[{additionalProperties:!1,properties:{kind:{type:"string"},maximum:{format:"uint",minimum:0,type:"integer"},observed:{format:"uint",minimum:0,type:"integer"},refusal:{const:"cursor_manifest_limit_exceeded",type:"string"}},required:["refusal","kind","observed","maximum"],type:"object"},{additionalProperties:!1,properties:{accounting:{anyOf:[{$ref:"#/$defs/SessionRetrievalBudgetAccountingV1"},{type:"null"}],description:"Present when the refusing boundary keeps a counter. A request-shape\ncheck has none and reports `None` rather than inventing numbers."},refusal:{const:"budget_exhausted",type:"string"},stage:{$ref:"#/$defs/SessionRetrievalBudgetStageV1"}},required:["refusal","stage"],type:"object"}]},TaskEvidenceLinkV1:bj,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAnchorHydrationV1:{additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},content:{items:{type:"string"},type:"array"},continuation:{type:["string","null"]},coverage:{$ref:"#/$defs/WorkEvidenceCoverageStateV1"},exact_anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},freshness:{$ref:"#/$defs/WorkEvidenceFreshnessV1"},redacted:{type:"boolean"}},required:["anchor_id","exact_anchors","content","coverage","freshness","redacted"],type:"object"},WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptEvidenceRecordV1:b4,WorkAttemptIdentityV1:b6,WorkAttemptProviderOutcomeV1:b7,WorkAttemptReceiptV1:$e,WorkAttemptStreamChannelV1:$r,WorkAttemptStreamSummaryV1:$i,WorkEvidenceContinuationV1:$_,WorkEvidenceCoverageStateV1:{enum:["complete","partial","unknown"],type:"string"},WorkEvidenceCoverageV1:{additionalProperties:!1,properties:{hydrated:{format:"uint32",minimum:0,type:"integer"},omitted:{format:"uint32",minimum:0,type:"integer"},selected:{format:"uint32",minimum:0,type:"integer"},state:{$ref:"#/$defs/WorkEvidenceCoverageStateV1"}},required:["state","selected","hydrated","omitted"],type:"object"},WorkEvidenceFreshnessV1:{enum:["current","stale","unknown"],type:"string"},WorkEvidenceOmissionReasonV1:{oneOf:[{enum:["limit_reached","pending","not_found_or_not_authorized","unavailable","reset_required","stale","cancelled","timed_out","redacted"],type:"string"},{additionalProperties:!1,properties:{structural_refusal:{$ref:"#/$defs/SessionRetrievalStructuralRefusalV1"}},required:["structural_refusal"],type:"object"}]},WorkEvidenceOmissionV1:{additionalProperties:!1,properties:{reason:{$ref:"#/$defs/WorkEvidenceOmissionReasonV1"},relation:{type:"string"}},required:["relation","reason"],type:"object"},WorkEvidenceSourceV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"attempt_receipt",type:"string"},receipt:{$ref:"#/$defs/WorkAttemptReceiptV1"}},required:["kind","receipt"],type:"object"},{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},evidence:{$ref:"#/$defs/WorkTaskSessionEvidenceV1"},kind:{const:"task_session",type:"string"}},required:["kind","attempt","evidence"],type:"object"},{additionalProperties:!1,properties:{hydration:{$ref:"#/$defs/WorkAnchorHydrationV1"},kind:{const:"anchor",type:"string"},link:{$ref:"#/$defs/TaskEvidenceLinkV1"}},required:["kind","link","hydration"],type:"object"}]},WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkItemInputV1:$M,WorkItemV1:$N,WorkProductRelationV1:$5,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderAvailabilityV1:So,WorkProviderBackendV1:Sn,WorkProviderFallbackRecordV1:Sa,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTaskSessionContinuationV1:ST,WorkTaskSessionCoverageV1:{additionalProperties:!1,properties:{hidden:{format:"uint64",minimum:0,type:"integer"},redacted:{format:"uint64",minimum:0,type:"integer"},unknown:{format:"uint64",minimum:0,type:"integer"},visible:{format:"uint64",minimum:0,type:"integer"}},required:["visible","hidden","unknown","redacted"],type:"object"},WorkTaskSessionEvidenceV1:{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},continuation:{anyOf:[{$ref:"#/$defs/WorkTaskSessionContinuationV1"},{type:"null"}]},coverage:{$ref:"#/$defs/WorkEvidenceCoverageStateV1"},coverage_counts:{$ref:"#/$defs/WorkTaskSessionCoverageV1"},freshness:{$ref:"#/$defs/WorkEvidenceFreshnessV1"},hydrated:{items:{$ref:"#/$defs/WorkTaskSessionHydrationV1"},type:"array"},participant_epoch:{$ref:"#/$defs/ManifestDigest"},ranked_anchors:{items:{$ref:"#/$defs/WorkTaskSessionRankedAnchorV1"},type:"array"},redacted:{type:"boolean"},source:{$ref:"#/$defs/ObservationSourceIdentityV1"},task_id:{$ref:"#/$defs/TaskId"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["task_id","verified_version","attempt","source","participant_epoch","ranked_anchors","hydrated","coverage","coverage_counts","freshness","redacted"],type:"object"},WorkTaskSessionHydrationStateV1:{enum:["available","retained_but_unavailable","redacted","deleted","retention_expired","unauthorized","locked","unverifiable"],type:"string"},WorkTaskSessionHydrationV1:{additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},content:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},type:["array","null"]},rank:{format:"uint32",minimum:0,type:"integer"},state:{$ref:"#/$defs/WorkTaskSessionHydrationStateV1"}},required:["rank","anchor_id","state"],type:"object"},WorkTaskSessionRankContributionV1:{additionalProperties:!1,properties:{calibrated_feature_micros:{format:"uint32",minimum:0,type:"integer"},calibration_profile:{type:"string"},ordinal_rank:{format:"uint32",minimum:0,type:"integer"},raw_score_micros:{format:"int64",type:"integer"},retriever:{type:"string"},retriever_revision:{type:"string"},score_domain:{type:"string"},source_occurrence:{type:"string"},weight_micros:{format:"uint32",minimum:0,type:"integer"},weighted_contribution_micros:{format:"uint64",minimum:0,type:"integer"}},required:["retriever","retriever_revision","source_occurrence","ordinal_rank","raw_score_micros","score_domain","calibration_profile","calibrated_feature_micros","weight_micros","weighted_contribution_micros"],type:"object"},WorkTaskSessionRankedAnchorV1:{additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},contributions:{items:{$ref:"#/$defs/WorkTaskSessionRankContributionV1"},type:"array"},final_ordinal:{format:"uint32",minimum:0,type:"integer"},utility_micros:{format:"uint64",minimum:0,type:"integer"}},required:["anchor_id","final_ordinal","utility_micros","contributions"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{continuations:{items:{$ref:"#/$defs/WorkEvidenceContinuationV1"},type:"array"},coverage:{$ref:"#/$defs/WorkEvidenceCoverageV1"},freshness:{$ref:"#/$defs/WorkEvidenceFreshnessV1"},item:{$ref:"#/$defs/WorkItemV1"},omissions:{items:{$ref:"#/$defs/WorkEvidenceOmissionV1"},type:"array"},proposal_decisions:{items:{$ref:"#/$defs/WorkProposalDecisionV1"},type:"array"},redacted:{type:"boolean"},relation_replan_decisions:{items:{$ref:"#/$defs/WorkRelationReplanDecisionV1"},type:"array"},relations:{items:{$ref:"#/$defs/WorkProductRelationV1"},type:"array"},sources:{items:{$ref:"#/$defs/WorkEvidenceSourceV1"},type:"array"},task_id:{$ref:"#/$defs/TaskId"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["task_id","verified_version","item","relations","proposal_decisions","relation_replan_decisions","sources","coverage","omissions","freshness","redacted","continuations"],title:"WorkEvidenceRetrievalV1",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkRetryCauseV1:Sf,WorkRetryFailureSelectorV1:Sh,WorkRetrySourceV1:Sy},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},failure:{$ref:"#/$defs/WorkRetryFailureSelectorV1"},new_attempt_id:{$ref:"#/$defs/AttemptId"},original_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["original_attempt","new_attempt_id","failure","command_id"],title:"RetryWorkAttemptCommandV1",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,RetryWorkAttemptCommandV1:{additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},failure:{$ref:"#/$defs/WorkRetryFailureSelectorV1"},new_attempt_id:{$ref:"#/$defs/AttemptId"},original_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["original_attempt","new_attempt_id","failure","command_id"],title:"RetryWorkAttemptCommandV1",type:"object"},ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,VerifiedWorkRetryFailureV1:{additionalProperties:!1,description:"Failure fact returned by a canonical evidence authority.",properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},selector:{$ref:"#/$defs/WorkRetryFailureSelectorV1"}},required:["selector","evidence_digest","observed_at"],type:"object"},WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkCommandId:$p,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkRetryCauseV1:Sf,WorkRetryFailureSelectorV1:Sh,WorkRetryReceiptV1:{additionalProperties:!1,properties:{canonical_input_digest:{$ref:"#/$defs/ManifestDigest"},command:{$ref:"#/$defs/RetryWorkAttemptCommandV1"},failure:{$ref:"#/$defs/VerifiedWorkRetryFailureV1"},new_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},owner_receipt_digest:{$ref:"#/$defs/ManifestDigest"},restarted_at:{$ref:"#/$defs/UtcMicros",description:"Daemon-owned admission time at which the new attempt was created."},retry_required_at:{$ref:"#/$defs/UtcMicros",description:"Exact source-owned time at which the failure made a retry necessary."}},required:["command","failure","new_attempt","retry_required_at","restarted_at","canonical_input_digest","owner_receipt_digest"],type:"object"},WorkRetrySourceV1:Sy,WorkSandboxPolicy:Sw,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptV1"},outcome:{const:"created",type:"string"},receipt:{$ref:"#/$defs/WorkRetryReceiptV1"}},required:["outcome","receipt","attempt"],type:"object"},{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptV1"},outcome:{const:"replayed",type:"string"},receipt:{$ref:"#/$defs/WorkRetryReceiptV1"}},required:["outcome","receipt","attempt"],type:"object"}],title:"WorkRetryAttemptOutcomeV1"},{$defs:{CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,ReviewWorkProposalDispositionV1:{description:"The only non-accepting dispositions the proposal-review operation can\ncommit. The broader decision request remains available to the graph\nmutation operation, which owns all decision forms.",enum:["rejected","superseded"],type:"string"},SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkCommandId:$p,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/ReviewWorkProposalDispositionV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal","disposition","mutation"],title:"ReviewWorkProposalRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id"],title:"WorkRunControlRequestV1",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkRunControlAuthorityV1:Sb,WorkRunControlReasonV1:S$,WorkRunControlStateV1:SS,WorkRunControlV1:{additionalProperties:!1,description:"One run's durable control aggregate.",properties:{authority:{$ref:"#/$defs/WorkRunControlAuthorityV1"},deadline:{$ref:"#/$defs/WorkRunDeadlineCheckpointV1"},fenced_attempts:{description:'The exact attempts that were live when the current state published.\nEmpty means "none were live", never "we did not look".',items:{$ref:"#/$defs/AttemptId"},type:"array"},reason:{anyOf:[{$ref:"#/$defs/WorkRunControlReasonV1"},{type:"null"}]},run_id:{$ref:"#/$defs/RunId"},state:{$ref:"#/$defs/WorkRunControlStateV1"},task_id:{$ref:"#/$defs/TaskId"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["task_id","run_id","state","authority","deadline","transitioned_at","fenced_attempts"],title:"WorkRunControlV1",type:"object"},WorkRunDeadlineCheckpointV1:Sk},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One run's control reading.\n\n`Uncontrolled` is a distinct answer from `Controlled`: it says the run is\nadmitted and running under its admitted deadline with no control transition\never published, which is not the same as a control row that happens to say\n`Running`.",oneOf:[{additionalProperties:!1,description:"The run holds durable attempts but no control transition has ever been\npublished for it.",properties:{deadline:{$ref:"#/$defs/UtcMicros",description:"The admitted deadline the run is running against."},live_attempts:{description:"Attempts that have not reached a terminal state.",items:{$ref:"#/$defs/AttemptId"},type:"array"},state:{const:"uncontrolled",type:"string"},total_attempts:{format:"uint32",minimum:0,type:"integer"}},required:["state","deadline","live_attempts","total_attempts"],type:"object"},{additionalProperties:!1,description:"The published control aggregate, plus the live frontier as of this\nread (which may differ from the frontier the transition fenced).",properties:{control:{$ref:"#/$defs/WorkRunControlV1"},live_attempts:{items:{$ref:"#/$defs/AttemptId"},type:"array"},state:{const:"controlled",type:"string"},total_attempts:{format:"uint32",minimum:0,type:"integer"}},required:["state","control","live_attempts","total_attempts"],type:"object"}],title:"WorkRunControlReadingV1"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Starts one admitted provider attempt. Every field is a typed fact; there\nis no argv, environment entry, executable path, or shell string here. The\nprojection binding and admission facts are re-read from the canonical Work\nauthority, never trusted from the caller.",properties:{attempt_id:{$ref:"#/$defs/AttemptId"},commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},instructions:{type:"string"},occurred_at:{$ref:"#/$defs/UtcMicros"},operation:{$ref:"#/$defs/WorkflowOperationRef"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"},worktree_root:{type:"string"}},required:["task_id","run_id","attempt_id","operation","execution_snapshot","worktree_root","commit","instructions","effect_state","occurred_at"],title:"StartWorkAttemptCommand",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,StartWorkAttemptCommand:{additionalProperties:!1,description:"Starts one admitted provider attempt. Every field is a typed fact; there\nis no argv, environment entry, executable path, or shell string here. The\nprojection binding and admission facts are re-read from the canonical Work\nauthority, never trusted from the caller.",properties:{attempt_id:{$ref:"#/$defs/AttemptId"},commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},instructions:{type:"string"},occurred_at:{$ref:"#/$defs/UtcMicros"},operation:{$ref:"#/$defs/WorkflowOperationRef"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"},worktree_root:{type:"string"}},required:["task_id","run_id","attempt_id","operation","execution_snapshot","worktree_root","commit","instructions","effect_state","occurred_at"],type:"object"},TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkAttemptIdentityV1:b6,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Admits one synthesis attempt over an ordered set of sibling sources.",properties:{output_name:{$ref:"#/$defs/WorkflowOutputName",description:"The fan-out output the synthesis belongs to, carried into the draft\nthe workflow completion path verifies."},sources:{description:"The ordered sibling sources the synthesis consumes.",items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},start:{$ref:"#/$defs/StartWorkAttemptCommand",description:"The synthesis attempt's own admission facts; it is started through\nthe same admission machinery as any other attempt."}},required:["start","output_name","sources"],title:"AdmitWorkSynthesisCommand",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkSandboxPolicy:Sw,WorkSynthesisEvidenceGroupV1:Sq,WorkSynthesisRefusalV1:SI,WorkSynthesisSourceEnvelopeV1:Sx,WorkSynthesisSourceOutcomeV1:Sj,WorkSynthesisSourceSetV1:SC,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowSynthesisDraft:SH,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",description:"The typed outcome of a synthesis request: an admitted attempt, or the\nsealed unsynthesized set when synthesis could not truthfully begin.",oneOf:[{additionalProperties:!1,description:"The admitted synthesis attempt and everything it is accountable to.",properties:{attempt:{$ref:"#/$defs/WorkAttemptV1",description:"The leased (or idempotently replayed) synthesis attempt."},draft:{$ref:"#/$defs/WorkflowSynthesisDraft",description:"The citation obligation, complete by construction: the draft cites\nevery citable source digest and is verified downstream by\n[`crate::workflow_synthesis::verify_workflow_synthesis_draft`]."},groups:{description:"Disagreement structure over the succeeded sources.",items:{$ref:"#/$defs/WorkSynthesisEvidenceGroupV1"},type:"array"},source_set:{$ref:"#/$defs/WorkSynthesisSourceSetV1",description:"The sealed source envelopes the attempt was admitted against."},synthesis:{const:"admitted",type:"string"},uncited:{description:"Sources preserved without citations: failures, unknowns, and\nartifact-less successes, in the caller's requested order.",items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"}},required:["synthesis","attempt","source_set","groups","draft","uncited"],type:"object"},{properties:{refusal:{$ref:"#/$defs/WorkSynthesisRefusalV1"},sources:{$ref:"#/$defs/WorkSynthesisSourceSetV1"},synthesis:{const:"unsynthesized",type:"string"}},required:["synthesis","sources","refusal"],type:"object"}],title:"WorkSynthesisAttemptV1"},{$defs:{WorkAttemptListCursorV1:b9},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One page-bounded topology view read. The cursor vocabulary is the attempt\nlist's: a cursor minted under a superseded topology generation is a typed\nstaleness refusal, never a silently different page.",properties:{cursor:{anyOf:[{$ref:"#/$defs/WorkAttemptListCursorV1"},{type:"null"}],default:null},page_size:{format:"uint32",minimum:0,type:"integer"}},required:["page_size"],title:"WorkTopologyViewRequestV1",type:"object"},{$defs:{BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,TaskId:bT,TopologyGatePolicyV1:bH,UtcMicros:bZ,WorkAttemptListCoverageV1:b3,WorkAttemptListCursorV1:b9,WorkAttemptTopologyBindingV1:$o,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementReadingV1:{description:"One placement reading. Absence is a state, not an empty placement.",oneOf:[{additionalProperties:!1,description:"No placement was ever admitted for this run.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The durable placement relation.",properties:{placement:{$ref:"#/$defs/WorkPlacementV1"},state:{const:"placed",type:"string"}},required:["state","placement"],type:"object"}],title:"WorkPlacementReadingV1"},WorkPlacementStateV1:$K,WorkPlacementTargetV1:$J,WorkPlacementV1:$Z,WorkTopologyExecutionPlacementV1:{additionalProperties:!1,description:"The execution-placement dimension: the policy's placement mode plus one\nlane per distinct `(task, run)` pair in page order.",properties:{lanes:{items:{$ref:"#/$defs/WorkTopologyPlacementLaneV1"},type:"array"},mode:{$ref:"#/$defs/WorktreePlacementModeV1"}},required:["mode","lanes"],title:"WorkTopologyExecutionPlacementV1",type:"object"},WorkTopologyIntegrationStrategyV1:{additionalProperties:!1,description:"The integration-strategy dimension, read verbatim from the resolved work\ntopology policy the runs in scope are admitted against.",properties:{cross_merge:{$ref:"#/$defs/CrossMergePolicyV1"},gates:{$ref:"#/$defs/TopologyGatePolicyV1"},protected_refs:{items:{$ref:"#/$defs/ProtectedRefRuleV1"},type:"array"}},required:["cross_merge","gates","protected_refs"],title:"WorkTopologyIntegrationStrategyV1",type:"object"},WorkTopologyPlacementLaneV1:{additionalProperties:!1,description:"One execution-placement lane: a distinct `(task, run)` pair from the\nattempt page joined to its durable placement reading. Placement absence is\na state on the lane, not a dropped lane.",properties:{attempt_count:{description:"Attempts this lane carried within the requested page.",format:"uint32",minimum:0,type:"integer"},placement:{$ref:"#/$defs/WorkPlacementReadingV1"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","attempt_count","placement"],title:"WorkTopologyPlacementLaneV1",type:"object"},WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ},$schema:"https://json-schema.org/draft/2020-12/schema",description:"The application-owned execution-topology view. Absence of any Work in\nscope is a typed state, distinct from an authorized-but-empty page.",oneOf:[{additionalProperties:!1,description:"No Work exists in this authority scope, so there is no topology to\ndraw. Concealed scopes are refused before any read.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The four dimensions, pinned to one verified topology generation.",properties:{branch_topology:{$ref:"#/$defs/BranchTopologyPolicyV1"},coverage:{$ref:"#/$defs/WorkAttemptListCoverageV1"},execution_placement:{$ref:"#/$defs/WorkTopologyExecutionPlacementV1"},integration_strategy:{$ref:"#/$defs/WorkTopologyIntegrationStrategyV1"},review_topology:{$ref:"#/$defs/ReviewTopologyPolicyV1"},state:{const:"view",type:"string"},topology:{$ref:"#/$defs/WorkAttemptTopologyBindingV1"}},required:["state","topology","coverage","execution_placement","branch_topology","review_topology","integration_strategy"],type:"object"}],title:"ExecutionTopologyViewV1"},{$defs:{ObservabilityHorizonV1:_W},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One horizon-bounded execution-topology metrics read. The authorized scope\nis taken from the request context, not from the request, so a caller can\nnever widen the population it reads.",properties:{horizon:{$ref:"#/$defs/ObservabilityHorizonV1"},max_events:{description:"Event budget for this read, at most\n[`MAX_EXECUTION_TOPOLOGY_EVENTS_V1`].",format:"uint32",minimum:0,type:"integer"}},required:["horizon","max_events"],title:"ExecutionTopologyMetricsRequestV1",type:"object"},{$defs:{CoverageStateV1:yf,ExecutionBlockedCauseV1:{description:"Cause a work item was blocked for.",enum:["dependency","needs_input","capability","policy","scope","conflict","lease","backpressure","test","ci","review","effect_unknown","other","unknown"],type:"string"},ExecutionConcurrencyPhaseV1:{description:"Concurrency-width phase. `Useful` counts only distinct admitted\nattempts that advanced a committed progress frontier; heartbeats,\nqueued work, child processes, and transport fanout never reach it.",enum:["requested","accepted","admitted","active","useful"],type:"string"},ExecutionConflictKindV1:{description:"Conflict prediction kind. Mechanical and semantic keep separate\ndenominators because their adjudicators are not interchangeable.",enum:["mechanical","semantic","combined"],type:"string"},ExecutionConflictOutcomeV1:{description:"Independently observed conflict outcome. `Censored` and `Unknown`\nnever enter a confusion-matrix denominator.",enum:["conflict","no_conflict","censored","unknown"],type:"string"},ExecutionDeliveryOutcomeV1:{description:"Per-surface delivery outcome. A multi-surface delivery is never a\nduplicate of product work; only `Deduplicated` is.",enum:["delivered","deduplicated","dropped","unknown"],type:"string"},ExecutionDuplicateKindV1:{description:"Adjudicated duplicate-work relation. Similarity, proximity, shared\npaths, and concurrency never produce one of these.",enum:["exact_duplicate","superseded_overlap","repeated_investigation","duplicate_effect","not_duplicate","censored","unknown"],type:"string"},ExecutionDuplicateOutcomeV1:{description:"Whether a duplicate effect was prevented or actually committed. The\ntwo never collapse into one count.",enum:["prevented","committed","unknown","not_applicable"],type:"string"},ExecutionDurationBucketV1:{description:"Fixed duration buckets shared by stale stack age, blocked time, and\nrerun latency. Raw timestamps and exact durations stay authorized\nlocal detail.",enum:["under1m","from1m_to5m","from5m_to15m","from15m_to1h","from1h_to4h","from4h_to24h","from1d_to7d","over7d"],type:"string"},ExecutionFanoutPhaseV1:{description:"Fan-out width phase. `PeakActive` is the sampled active width; the\nfan-out distribution is unweighted so serialized and blocked samples,\nwhich carry no interval, are preserved rather than dropped.",enum:["requested","accepted","admitted","peak_active","useful"],type:"string"},ExecutionGitHubStackCapabilityReadingV1:{additionalProperties:!1,description:"Latest trustworthy GitHub stacked-PR capability observation in the\nhorizon. It is a typed operational state, not a metric or success claim.",properties:{capability:{anyOf:[{$ref:"#/$defs/ExecutionGitHubStackCapabilityV1"},{type:"null"}]},coverage:{$ref:"#/$defs/MetricCoverageV1"},other_forge_fallback_available:{type:["boolean","null"]},standard_git_fallback_available:{type:["boolean","null"]},unavailable:{anyOf:[{$ref:"#/$defs/ExecutionMetricUnavailableV1"},{type:"null"}]}},required:["coverage"],title:"ExecutionGitHubStackCapabilityReadingV1",type:"object"},ExecutionGitHubStackCapabilityV1:{description:"Last bounded GitHub stacked-PR capability state observed in the\nhorizon. This remains orthogonal to GitHub ingress and item lifecycle.",enum:["unavailable","private_preview_disabled","enabled","degraded"],type:"string"},ExecutionIntegrationKindV1:{description:"Integration operation kind. Rebase remains external observation only.",enum:["fast_forward","merge_commit","rebase","cherry_pick","stack_retarget","graph_only","external_observed","unknown"],type:"string"},ExecutionIntegrationOutcomeV1:{description:"Terminal result of an observed native integration.",enum:["succeeded","conflicted","rejected","denied","stale","locked","cancelled","timed_out","failed","partial","effect_unknown","unsupported","unknown"],type:"string"},ExecutionIntervalStateV1:{description:"Whether the owning drift interval is still open or exactly closed.",enum:["open","closed"],type:"string"},ExecutionLeakKindV1:{description:"Independently proved execution-leak class.",enum:["lease_after_terminal","attempt_without_live_owner","effect_unknown_past_deadline","missing_worktree_binding","unbounded_delivery","none","unknown"],type:"string"},ExecutionLeakOutcomeV1:{description:"Recovery state a proved leak reached.",enum:["not_required","pending","recovered","failed","unknown"],type:"string"},ExecutionMetricUnavailableV1:{description:"Why a measurement carries no value. Absence is always one of these typed\nreasons; it is never an empty string, a zero, or a silently dropped row.",oneOf:[{const:"store_unavailable",description:"The observation store could not be read at all for this horizon.",type:"string"},{const:"event_budget_exceeded",description:"The horizon holds more events than one read may draw, so every\ndenominator here would be a partial count presented as a total.",type:"string"},{const:"cell_budget_exceeded",description:"The bounded projection would exceed the Plan 26 result-cell ceiling.\nThe whole read refuses rather than returning a misleading subset.",type:"string"},{const:"no_eligible_evidence",description:"No recorded event in the family supplies this metric's numerator or\ndenominator.",type:"string"},{const:"support_floor_unmet",description:"Eligible cases exist but fall below the metric's support floor.",type:"string"},{const:"coverage_floor_unmet",description:"Observed cases cover less of the eligible population than the metric's\ncoverage floor allows.",type:"string"},{const:"censoring_ceiling_exceeded",description:"More of the eligible population is censored than the metric admits.",type:"string"},{const:"unbounded_interval",description:"The interval this metric integrates over has no proved upper bound, so\nits duration cannot be measured without inventing a terminal.",type:"string"}]},ExecutionQuantityUnitV1:{description:"Quantity unit for duplicate-effort accounting. Each unit is reported\nseparately: wall time, tokens, cost, tests, and effects are never\nsummed into one number.",enum:["wall_micros","tokens","cost_micros","tests","effects"],type:"string"},ExecutionRerunCauseV1:{description:"Typed rerun cause. Repeated logs and transport redelivery are not\nreruns and never carry one of these.",enum:["runtime_retry","runtime_fallback","test_rerun","ci_rerun","recovery","human_requested","unknown"],type:"string"},ExecutionRerunSourceV1:{description:"Which independent system observed the rerun.",enum:["runtime","test","ci"],type:"string"},ExecutionStackDriftKindV1:{description:"Exact reason a stack became stale. The enum is bounded and never\ncarries a branch, ref, worktree, repository, or provider identity.",enum:["head_advanced","base_advanced","merge_base_changed","retargeted","superseded"],type:"string"},ExecutionSurfaceFamilyV1:{description:"Delivery surface family. Addresses, payloads, principals, and\nrecipients are never observed, so the family is the whole label.",enum:["hook","mcp","lsp","dashboard","cli","other"],type:"string"},ExecutionTopologyDimensionV1:{description:"One allowed local grouping dimension. The set is closed by construction:\nevery value is produced by an exhaustive match over a bounded domain class,\nso no person, agent, task, project, repository, worktree, branch, ref,\ncommit, model version, or route can ever appear as a label.",oneOf:[{properties:{dimension:{const:"concurrency_phase",type:"string"},value:{$ref:"#/$defs/ExecutionConcurrencyPhaseV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"fanout_phase",type:"string"},value:{$ref:"#/$defs/ExecutionFanoutPhaseV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"width_bucket",type:"string"},value:{$ref:"#/$defs/ExecutionWidthBucketV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"duration_bucket",type:"string"},value:{$ref:"#/$defs/ExecutionDurationBucketV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"duplicate_kind",type:"string"},value:{$ref:"#/$defs/ExecutionDuplicateKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"unit",type:"string"},value:{$ref:"#/$defs/ExecutionQuantityUnitV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"duplicate_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionDuplicateOutcomeV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"conflict_kind",type:"string"},value:{$ref:"#/$defs/ExecutionConflictKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"conflict_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionConflictOutcomeV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"integration_kind",type:"string"},value:{$ref:"#/$defs/ExecutionIntegrationKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"integration_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionIntegrationOutcomeV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"stack_drift_kind",type:"string"},value:{$ref:"#/$defs/ExecutionStackDriftKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"interval_state",type:"string"},value:{$ref:"#/$defs/ExecutionIntervalStateV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"blocked_cause",type:"string"},value:{$ref:"#/$defs/ExecutionBlockedCauseV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"rerun_source",type:"string"},value:{$ref:"#/$defs/ExecutionRerunSourceV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"rerun_cause",type:"string"},value:{$ref:"#/$defs/ExecutionRerunCauseV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"leak_kind",type:"string"},value:{$ref:"#/$defs/ExecutionLeakKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"leak_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionLeakOutcomeV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"surface",type:"string"},value:{$ref:"#/$defs/ExecutionSurfaceFamilyV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"delivery_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionDeliveryOutcomeV1"}},required:["dimension","value"],type:"object"}]},ExecutionTopologyDrillAnchorV1:{additionalProperties:!1,description:"An opaque cursor minted by the registered observation authority. It can be\nresolved only through that same authorized local query boundary and is not\na metric dimension or exportable identity.",properties:{cursor:{type:"string"}},required:["cursor"],title:"ExecutionTopologyDrillAnchorV1",type:"object"},ExecutionTopologyEmissionCoverageV1:{additionalProperties:!1,description:"Envelope-level delivery evidence for this read. `None` means the store did\nnot answer, so no zero may be inferred. `dropped` is the proved lower bound\nfrom the bound producer scope, deduplicated across explicit loss receipts\nand their next-envelope carriers; it is not attributed to a topology\nfamily. Sampling stays a count of sampled topology envelopes and is never\nexpanded into a fabricated population estimate.",properties:{delayed:{format:"uint64",minimum:0,type:["integer","null"]},dropped:{format:"uint64",minimum:0,type:["integer","null"]},emitted:{format:"uint64",minimum:0,type:["integer","null"]},sampled_events:{format:"uint64",minimum:0,type:["integer","null"]}},title:"ExecutionTopologyEmissionCoverageV1",type:"object"},ExecutionTopologyMeasurementV1:{additionalProperties:!1,description:"One descriptor cell: the Plan 26 descriptor name, its grouping dimensions,\nand the landed metric envelope carrying value, denominator, coverage, and\nprovenance.",properties:{dimensions:{description:"Allowed local grouping dimensions, at most\n[`MAX_METRIC_DIMENSIONS_V1`], in a fixed order per descriptor.",items:{$ref:"#/$defs/ExecutionTopologyDimensionV1"},type:"array"},unavailable:{anyOf:[{$ref:"#/$defs/ExecutionMetricUnavailableV1"},{type:"null"}],description:"Typed absence reason. It is `Some` exactly when `value.value` is\n`None`, so a reader can never mistake a refused metric for a zero."},value:{$ref:"#/$defs/MetricValueV1"}},required:["dimensions","value"],title:"ExecutionTopologyMeasurementV1",type:"object"},ExecutionWidthBucketV1:{description:"Fixed width buckets. Raw widths stay authorized local detail; only\nbucket counts leave the projection.",enum:["zero","one","two","from3_to4","from5_to8","from9_to16","from17_to32","from33_to64","over64"],type:"string"},MetricCalibrationV1:_h,MetricCohortV1:_y,MetricCoverageV1:_g,MetricEvidenceClassV1:__,MetricProvenanceV1:_v,MetricSourceV1:_b,MetricTemporalV1:_$,MetricUncertaintyV1:_S,MetricValueV1:_k,ObservabilityHorizonV1:_W},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The canonical execution-topology read model. Observatory and Costs render\nthis without local formulas; CLI, MCP, and HTTP return the same bytes.",properties:{authorized_scope_ref:{description:"Local authorization anchor the read was admitted under. It is derived\nfrom the resolved scope, never from a caller-supplied string.",type:"string"},coverage:{$ref:"#/$defs/MetricCoverageV1",description:"Family-level coverage over the event population, independent of any\nsingle descriptor's denominator."},current:{description:"True only when the whole family was read with `Known` coverage. A\nfalse value means at least one descriptor below is a typed absence.",type:"boolean"},drill_anchors:{description:"Bounded registered source cursors for authorized local drill-down.\nPayload anchors, traces, and scope identifiers never enter this list.",items:{$ref:"#/$defs/ExecutionTopologyDrillAnchorV1"},type:"array"},emission_coverage:{$ref:"#/$defs/ExecutionTopologyEmissionCoverageV1"},github_stack_capability:{$ref:"#/$defs/ExecutionGitHubStackCapabilityReadingV1"},horizon:{$ref:"#/$defs/ObservabilityHorizonV1"},measurements:{items:{$ref:"#/$defs/ExecutionTopologyMeasurementV1"},type:"array"},observed_at_micros:{format:"int64",type:"integer"},watermark:{description:"Watermark of the last event this projection consumed. A rebuild at the\nsame watermark yields the same values.",type:"string"}},required:["authorized_scope_ref","horizon","watermark","observed_at_micros","current","coverage","emission_coverage","github_stack_capability","drill_anchors","measurements"],title:"ExecutionTopologyMetricsV1",type:"object"},{$defs:{ProjectId:_4,RepositoryId:vb,UtcMicros:bZ,WorkGraphReadModeV1:{oneOf:[{properties:{mode:{const:"current",type:"string"}},required:["mode"],type:"object"},{properties:{mode:{const:"as_of",type:"string"},valid_at:{$ref:"#/$defs/UtcMicros"}},required:["mode","valid_at"],type:"object"},{properties:{from_valid_at:{$ref:"#/$defs/UtcMicros"},mode:{const:"evolution",type:"string"},through_valid_at:{$ref:"#/$defs/UtcMicros"}},required:["mode","from_valid_at","through_valid_at"],type:"object"},{properties:{from_observed_at:{$ref:"#/$defs/UtcMicros"},mode:{const:"forensic",type:"string"},through_observed_at:{$ref:"#/$defs/UtcMicros"}},required:["mode","from_observed_at","through_observed_at"],type:"object"}]},WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{continuation:{type:["string","null"]},mode:{$ref:"#/$defs/WorkGraphReadModeV1"},observed_at:{$ref:"#/$defs/UtcMicros"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","mode","observed_at"],title:"WorkGraphReadRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,AuthorizedWorkProductScopeV1:{additionalProperties:!1,description:"Owner identity resolved by the registered profile authority. It is never\naccepted from a Work request.",properties:{owner_brain_id:{$ref:"#/$defs/BrainId"},owner_profile_id:{$ref:"#/$defs/UserProfileId"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["owner_brain_id","owner_profile_id","selection"],type:"object"},BrainId:f1,ManifestDigest:_l,ProjectId:_4,ProjectionGenerationId:_5,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,TaskEvidenceLinkV1:bj,TaskId:bT,UserProfileId:bJ,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkAttemptStateV1:$t,WorkCausalProjectionV1:{additionalProperties:!1,properties:{candidate_edges:{items:{$ref:"#/$defs/WorkDagEdgeV1"},type:"array"},graph_version:{format:"uint64",minimum:0,type:"integer"}},required:["graph_version","candidate_edges"],type:"object"},WorkCriticalPathProjectionV1:{additionalProperties:!1,properties:{graph_version:{format:"uint64",minimum:0,type:"integer"},task_ids:{items:{$ref:"#/$defs/TaskId"},type:"array"},total_effort:{format:"uint32",minimum:0,type:"integer"}},required:["graph_version","task_ids","total_effort"],type:"object"},WorkDagEdgeV1:{additionalProperties:!1,properties:{dependency:{$ref:"#/$defs/TaskId"},dependent:{$ref:"#/$defs/TaskId"}},required:["dependency","dependent"],type:"object"},WorkDagProjectionV1:{additionalProperties:!1,properties:{gating_edges:{items:{$ref:"#/$defs/WorkDagEdgeV1"},type:"array"},graph_version:{format:"uint64",minimum:0,type:"integer"},task_ids:{items:{$ref:"#/$defs/TaskId"},type:"array"}},required:["graph_version","task_ids","gating_edges"],type:"object"},WorkGraphSelectionCoverageV1:{description:"How much of the owner's journal the read's selection actually covers.\n\nA selection names a slice of the owner's work, not the whole journal: an\nevent records the relation scopes it was admitted under, and a selection\nthat does not name them puts that event *outside* the slice. The events\noutside a selection do not poison the ones inside it, but they must never be\nconcealed either, a caller who is shown the covered slice with no way to\nlearn that more exists is reading a silently incomplete graph.\n\nSo the read answers over the covered slice and says so, in the same\n`Complete`/`Partial` vocabulary [`WorkGraphTimelineCoverageV1`] and\n[`WorkHistoryCoverageV1`](crate::WorkHistoryCoverageV1) already use.\n\nThe covered slice is always a *prefix* of the journal, and that is a\nproperty of folding rather than a simplification. A graph version is folded\nfrom every event up to its own sequence, so the first event a selection does\nnot cover ends the readable slice: every later version, whatever scopes its\nown event named, would have to be folded across that event to exist at all.\n`excluded_events` therefore counts every event from the first uncovered one\nonward.",oneOf:[{description:"The selection covers the owner's whole journal. Nothing was withheld.",properties:{coverage:{const:"complete",type:"string"},covered_events:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","covered_events"],type:"object"},{description:"The selection covers `covered_events` events and `excluded_events`\nevents lie outside it, starting at `first_excluded_sequence`. Every\nentry this read returned was folded from covered events alone.",properties:{coverage:{const:"partial",type:"string"},covered_events:{format:"uint32",minimum:0,type:"integer"},excluded_events:{format:"uint32",minimum:0,type:"integer"},first_excluded_sequence:{format:"uint64",minimum:0,type:"integer"}},required:["coverage","covered_events","excluded_events","first_excluded_sequence"],type:"object"}]},WorkGraphTimelineCoverageV1:{oneOf:[{properties:{coverage:{const:"complete",type:"string"},returned:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned"],type:"object"},{properties:{continuation:{type:"string"},coverage:{const:"partial",type:"string"},returned:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned","continuation"],type:"object"}]},WorkGraphTimelineV1:{additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/WorkGraphTimelineCoverageV1"},entries:{items:{$ref:"#/$defs/WorkGraphVersionEntryV1"},type:"array"}},required:["entries","coverage"],type:"object"},WorkGraphVersionEntryV1:{additionalProperties:!1,description:"One immutable graph version and every Work projection derived from that\nsame version at the caller's explicit observation time.",properties:{graph:{$ref:"#/$defs/WorkProductGraphV1"},observed_at:{$ref:"#/$defs/UtcMicros"},projected_at:{$ref:"#/$defs/UtcMicros"},projections:{$ref:"#/$defs/WorkProductProjectionBundleV1"},runtime:{$ref:"#/$defs/WorkRuntimeProjectionV1"},valid_at:{$ref:"#/$defs/UtcMicros"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["valid_at","observed_at","projected_at","verified_version","graph","runtime","projections"],type:"object"},WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkKanbanCardV1:{additionalProperties:!1,properties:{effort:{format:"uint32",minimum:0,type:"integer"},lane:{$ref:"#/$defs/WorkTimelineLaneV1"},legal_actions:{items:{$ref:"#/$defs/WorkLegalActionV1"},type:"array",uniqueItems:!0},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","lane","effort","legal_actions"],type:"object"},WorkKanbanProjectionV1:{additionalProperties:!1,properties:{cards:{items:{$ref:"#/$defs/WorkKanbanCardV1"},type:"array"},graph_version:{format:"uint64",minimum:0,type:"integer"}},required:["graph_version","cards"],type:"object"},WorkLegalActionV1:{enum:["view_evidence","generate_proposal","accept_proposal","link_accepted_attempt","accept_task","handoff","archive"],type:"string"},WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductGraphV1:$4,WorkProductProjectionBundleV1:{additionalProperties:!1,properties:{causal:{$ref:"#/$defs/WorkCausalProjectionV1"},critical_path:{$ref:"#/$defs/WorkCriticalPathProjectionV1"},dag:{$ref:"#/$defs/WorkDagProjectionV1"},graph_version:{format:"uint64",minimum:0,type:"integer"},kanban:{$ref:"#/$defs/WorkKanbanProjectionV1"},runtime:{$ref:"#/$defs/WorkRuntimeProjectionV1"},timeline:{$ref:"#/$defs/WorkTimelineProjectionV1"},workload:{$ref:"#/$defs/WorkWorkloadProjectionV1"}},required:["graph_version","runtime","kanban","dag","timeline","causal","critical_path","workload"],type:"object"},WorkProductSelectionScopeV1:$7,WorkProjectionSequenceV1:{format:"uint64",minimum:0,title:"WorkProjectionSequenceV1",type:"integer"},WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkRuntimeAttemptProjectionV1:{additionalProperties:!1,properties:{identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"}},required:["identity","state"],type:"object"},WorkRuntimeProjectionCoverageV1:{oneOf:[{additionalProperties:!1,properties:{coverage:{const:"complete",type:"string"}},required:["coverage"],type:"object"},{additionalProperties:!1,properties:{coverage:{const:"partial",type:"string"},unavailable_attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array",uniqueItems:!0}},required:["coverage","unavailable_attempts"],type:"object"},{additionalProperties:!1,properties:{coverage:{const:"unavailable",type:"string"}},required:["coverage"],type:"object"}]},WorkRuntimeProjectionV1:{additionalProperties:!1,properties:{attempts:{items:{$ref:"#/$defs/WorkRuntimeAttemptProjectionV1"},type:"array"},coverage:{$ref:"#/$defs/WorkRuntimeProjectionCoverageV1"},generation_id:{$ref:"#/$defs/ProjectionGenerationId"},graph_version:{format:"uint64",minimum:0,type:"integer"},observed_at:{$ref:"#/$defs/UtcMicros"},sequence:{$ref:"#/$defs/WorkProjectionSequenceV1"}},required:["graph_version","generation_id","sequence","observed_at","attempts","coverage"],type:"object"},WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTimelineEntryV1:{additionalProperties:!1,properties:{created_at:{$ref:"#/$defs/UtcMicros"},deadline:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},scheduled_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},task_id:{$ref:"#/$defs/TaskId"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["task_id","created_at","updated_at"],type:"object"},WorkTimelineLaneV1:{enum:["triage","todo","scheduled","ready","running","blocked","review","done","archived","cancelled","unavailable"],type:"string"},WorkTimelineProjectionV1:{additionalProperties:!1,properties:{entries:{items:{$ref:"#/$defs/WorkTimelineEntryV1"},type:"array"},graph_version:{format:"uint64",minimum:0,type:"integer"}},required:["graph_version","entries"],type:"object"},WorkWorkloadProjectionV1:{additionalProperties:!1,properties:{actual_concurrency:{format:"uint32",minimum:0,type:["integer","null"]},blocked_effort:{format:"uint32",minimum:0,type:["integer","null"]},graph_version:{format:"uint64",minimum:0,type:"integer"},ready_effort:{format:"uint32",minimum:0,type:["integer","null"]},requested_concurrency:{format:"uint32",minimum:0,type:["integer","null"]},running_effort:{format:"uint32",minimum:0,type:["integer","null"]},total_effort:{format:"uint32",minimum:0,type:"integer"}},required:["graph_version","total_effort"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"current",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"},snapshot:{$ref:"#/$defs/WorkGraphVersionEntryV1"}},required:["mode","authorized_scope","selection_coverage","snapshot"],type:"object"},{properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"as_of",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"},snapshot:{$ref:"#/$defs/WorkGraphVersionEntryV1"}},required:["mode","authorized_scope","selection_coverage","snapshot"],type:"object"},{properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"evolution",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"},timeline:{$ref:"#/$defs/WorkGraphTimelineV1"}},required:["mode","authorized_scope","selection_coverage","timeline"],type:"object"},{properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"forensic",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"},timeline:{$ref:"#/$defs/WorkGraphTimelineV1"}},required:["mode","authorized_scope","selection_coverage","timeline"],type:"object"},{description:"A `Current` or `AsOf` point read under an authorized selection that has\nno published graph version at that point: no task has been created yet.\nThe caller was authorized; the legal next action is creating a task.",properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"absent",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"}},required:["mode","authorized_scope","selection_coverage"],type:"object"}],title:"WorkGraphReadV1"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::activate`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},expected_revision:{description:"Current candidate disposition revision. A newly registered candidate\nstarts at revision 1; activation reports expected and observed values\nwhen this compare-and-swap precondition is stale.",format:"uint64",minimum:1,type:"integer"}},required:["definition_id","definition_version","expected_revision"],title:"WorkflowDefinitionActivateRequest",type:"object"},{$defs:{UtcMicros:bZ,WorkflowDefinitionId:SM,WorkflowDefinitionLifecycleState:{description:'Durable lifecycle disposition of one immutable workflow definition version.\n\nPlan 32 ("Typed workflow definitions"): "Lifecycle retains candidate,\nvalidate, activate, retire, reject, list, get, diff, and history operations\nthrough the same application surfaces." The definition payload itself stays\nimmutable, "Editing creates a new version; admitted runs remain pinned",\nso the disposition is a separate revisioned aggregate keyed by the same\ndefinition identity.',enum:["candidate","validated","active","retired","rejected"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Revisioned lifecycle disposition of one definition version.",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},revision:{format:"uint64",minimum:1,type:"integer"},state:{$ref:"#/$defs/WorkflowDefinitionLifecycleState"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["definition_id","definition_version","state","revision","transitioned_at"],title:"WorkflowDefinitionDisposition",type:"object"},{$defs:{RunId:vF,WorkCommandId:$p},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Requests cooperative cancellation as a durable typed transition; the run\nsettles to `Cancelled` when the runtime reconciles in-flight steps.",properties:{command_id:{$ref:"#/$defs/WorkCommandId"},expected_sequence:{format:"uint64",minimum:0,type:"integer"},run_id:{$ref:"#/$defs/RunId"}},required:["run_id","expected_sequence","command_id"],title:"WorkflowRunCancelRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkAcceptanceCriterionV1:bY,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAuthority:{additionalProperties:!1,properties:{actor_id:{$ref:"#/$defs/ActorId"},policy_digest:{$ref:"#/$defs/ManifestDigest"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["project_id","repository_id","worktree_id","actor_id","policy_digest"],type:"object"},WorkCommandId:$p,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_,WorkSandboxPolicy:Sw,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTopologyPolicyV1:SA,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowFanOutChildPlanV1:{additionalProperties:!1,properties:{admit_command_id:{$ref:"#/$defs/WorkCommandId"},attempt_identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},create_command_id:{$ref:"#/$defs/WorkCommandId"},initiative:{$ref:"#/$defs/WorkInitiativeV1"},instructions:{type:"string"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},plan:{$ref:"#/$defs/WorkPlanV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},proposal_command_id:{$ref:"#/$defs/WorkCommandId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","attempt_identity","create_command_id","proposal_command_id","admit_command_id","initiative","plan","milestone","item","proposal","instructions"],type:"object"},WorkflowFanOutFailurePolicyV1:{oneOf:[{properties:{policy:{const:"fail_fast",type:"string"}},required:["policy"],type:"object"},{properties:{policy:{const:"collect",type:"string"}},required:["policy"],type:"object"},{properties:{policy:{const:"require_at_least",type:"string"},successes:{format:"uint16",maximum:65535,minimum:1,type:"integer"}},required:["policy","successes"],type:"object"}]},WorkflowFanOutPlanV1:{additionalProperties:!1,properties:{admitted_at:{$ref:"#/$defs/UtcMicros"},authority:{$ref:"#/$defs/WorkAuthority",description:"Exact Work authority that admitted this plan. Recovery may execute the\nplan only from a runtime with this byte-identical authority."},children:{items:{$ref:"#/$defs/WorkflowFanOutChildPlanV1"},type:"array"},commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},failure_policy:{$ref:"#/$defs/WorkflowFanOutFailurePolicyV1"},maximum_parallel:{format:"uint16",maximum:65535,minimum:1,type:"integer"},operation:{$ref:"#/$defs/WorkflowOperationRef"},plan_digest:{$ref:"#/$defs/ManifestDigest"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},step_id:{$ref:"#/$defs/WorkflowStepId"}},required:["authority","step_id","operation","plan_digest","admitted_at","maximum_parallel","failure_policy","execution_snapshot","commit","effect_state","children"],type:"object"},WorkflowOperationRef:Sz,WorkflowOutputArtifact:{additionalProperties:!1,properties:{artifact:{$ref:"#/$defs/WorkArtifactRefV1"},attempt_identity:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["attempt_identity","artifact"],type:"object"},WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowPlacementReceipt:{additionalProperties:!1,properties:{backend:{$ref:"#/$defs/WorkProviderBackendV1"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},model:{type:"string"},placement_digest:{$ref:"#/$defs/ManifestDigest"},provider_registry_digest:{$ref:"#/$defs/ManifestDigest"},route:{$ref:"#/$defs/WorkProviderRouteV1"},run_id:{$ref:"#/$defs/RunId"},step_id:{$ref:"#/$defs/WorkflowStepId"},topology_digest:{$ref:"#/$defs/ManifestDigest"},worktree_placement:{$ref:"#/$defs/WorktreePlacementModeV1"}},required:["run_id","step_id","route","backend","model","configuration_digest","topology_digest","provider_registry_digest","worktree_placement","placement_digest"],type:"object"},WorkflowRunEvent:{additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},event:{$ref:"#/$defs/WorkflowRunEventKind"},input_digest:{$ref:"#/$defs/ManifestDigest"},occurred_at:{$ref:"#/$defs/UtcMicros"},run_id:{$ref:"#/$defs/RunId"},sequence:{format:"uint64",minimum:0,type:"integer"}},required:["run_id","sequence","command_id","input_digest","occurred_at","event"],type:"object"},WorkflowRunEventKind:{oneOf:[{properties:{definition:{$ref:"#/$defs/WorkflowDefinition"},fan_out_plans:{default:[],items:{$ref:"#/$defs/WorkflowFanOutPlanV1"},type:"array"},pinned_provider_registry_digest:{$ref:"#/$defs/ManifestDigest"},pinned_topology_digest:{$ref:"#/$defs/ManifestDigest"},type:{const:"admitted",type:"string"}},required:["type","definition","pinned_topology_digest","pinned_provider_registry_digest"],type:"object"},{properties:{attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"fan_out_children_released",type:"string"}},required:["type","step_id","attempts"],type:"object"},{properties:{attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"fan_out_children_settled",type:"string"}},required:["type","step_id","attempts"],type:"object"},{properties:{planned_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},prior_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},replacement_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},retry_receipt_digest:{$ref:"#/$defs/ManifestDigest"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"fan_out_child_retry_rebound",type:"string"}},required:["type","step_id","planned_attempt","prior_attempt","replacement_attempt","retry_receipt_digest"],type:"object"},{properties:{placement:{$ref:"#/$defs/WorkflowPlacementReceipt"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"step_started",type:"string"}},required:["type","step_id","placement"],type:"object"},{properties:{effect_receipt:{$ref:"#/$defs/WorkflowStepEffectReceipt"},outputs:{items:{$ref:"#/$defs/WorkflowStepOutput"},type:"array"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"step_completed",type:"string"}},required:["type","step_id","outputs","effect_receipt"],type:"object"},{properties:{effect_receipt:{$ref:"#/$defs/WorkflowStepEffectReceipt"},outputs:{items:{$ref:"#/$defs/WorkflowStepOutput"},type:"array"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"step_failed",type:"string"}},required:["type","step_id","outputs","effect_receipt"],type:"object"},{properties:{type:{const:"paused",type:"string"}},required:["type"],type:"object"},{properties:{type:{const:"resumed",type:"string"}},required:["type"],type:"object"},{properties:{type:{const:"cancellation_requested",type:"string"}},required:["type"],type:"object"},{properties:{type:{const:"cancelled",type:"string"}},required:["type"],type:"object"}]},WorkflowRunStatus:{enum:["running","paused","cancelling","completed","failed","cancelled"],type:"string"},WorkflowStep:SL,WorkflowStepEffectOutcome:{enum:["completed","failed","cancelled","timed_out","unknown"],type:"string"},WorkflowStepEffectReceipt:{additionalProperties:!1,properties:{effect_digest:{$ref:"#/$defs/ManifestDigest"},outcome:{$ref:"#/$defs/WorkflowStepEffectOutcome"},output_set_digest:{$ref:"#/$defs/ManifestDigest"},placement_digest:{$ref:"#/$defs/ManifestDigest"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},run_id:{$ref:"#/$defs/RunId"},step_id:{$ref:"#/$defs/WorkflowStepId"}},required:["run_id","step_id","placement_digest","outcome","effect_digest","output_set_digest","receipt_digest"],type:"object"},WorkflowStepId:SU,WorkflowStepOutput:{additionalProperties:!1,properties:{artifacts:{items:{$ref:"#/$defs/WorkflowOutputArtifact"},type:"array"},output_name:{$ref:"#/$defs/WorkflowOutputName"}},required:["output_name","artifacts"],type:"object"},WorkflowStepRunProjection:{additionalProperties:!1,properties:{effect_receipt:{anyOf:[{$ref:"#/$defs/WorkflowStepEffectReceipt"},{type:"null"}]},outputs:{additionalProperties:{$ref:"#/$defs/WorkflowStepOutput"},type:"object"},placement_receipt:{anyOf:[{$ref:"#/$defs/WorkflowPlacementReceipt"},{type:"null"}]},status:{$ref:"#/$defs/WorkflowStepStatus"}},required:["status","outputs"],type:"object"},WorkflowStepStatus:{enum:["blocked","ready","running","succeeded","failed","cancelled"],type:"string"},WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{definition:{$ref:"#/$defs/WorkflowDefinition"},fan_out_plans:{additionalProperties:{$ref:"#/$defs/WorkflowFanOutPlanV1"},type:"object"},history:{items:{$ref:"#/$defs/WorkflowRunEvent"},type:"array"},pinned_provider_registry_digest:{$ref:"#/$defs/ManifestDigest"},pinned_topology_digest:{$ref:"#/$defs/ManifestDigest"},released_fan_out_attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array",uniqueItems:!0},run_id:{$ref:"#/$defs/RunId"},sequence:{format:"uint64",minimum:0,type:"integer"},settled_fan_out_attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array",uniqueItems:!0},status:{$ref:"#/$defs/WorkflowRunStatus"},steps:{additionalProperties:{$ref:"#/$defs/WorkflowStepRunProjection"},type:"object"}},required:["run_id","definition","pinned_topology_digest","pinned_provider_registry_digest","status","sequence","steps","fan_out_plans","released_fan_out_attempts","settled_fan_out_attempts","history"],title:"WorkflowRunProjection",type:"object"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::history`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"}},required:["definition_id"],title:"WorkflowDefinitionHistoryRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",items:{$ref:"#/$defs/WorkflowDefinition"},title:"Array_of_WorkflowDefinition",type:"array"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::diff`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},from_version:{format:"uint64",minimum:1,type:"integer"},to_version:{format:"uint64",minimum:1,type:"integer"}},required:["definition_id","from_version","to_version"],title:"WorkflowDefinitionDiffRequest",type:"object"},{$defs:{WorkflowDefinitionId:SM,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{catalog_changed:{type:"boolean"},changed_steps:{items:{$ref:"#/$defs/WorkflowStepId"},type:"array",uniqueItems:!0},configuration_changed:{type:"boolean"},definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},from_version:{format:"uint64",minimum:0,type:"integer"},policy_changed:{type:"boolean"},to_version:{format:"uint64",minimum:0,type:"integer"}},required:["definition_id","from_version","to_version","changed_steps","policy_changed","configuration_changed","catalog_changed"],title:"WorkflowDefinitionDiff",type:"object"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::get`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"}},required:["definition_id","definition_version"],title:"WorkflowDefinitionGetRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:0,type:"integer"},pinned_catalog_digest:{$ref:"#/$defs/ManifestDigest",description:"Must equal the live Work executable catalog digest. Validation and\nactivation report the current digest when this pin is stale."},pinned_configuration_digest:{$ref:"#/$defs/ManifestDigest"},pinned_policy_digest:{$ref:"#/$defs/ManifestDigest"},project_id:{$ref:"#/$defs/ProjectId"},steps:{items:{$ref:"#/$defs/WorkflowStep"},type:"array"}},required:["definition_id","definition_version","project_id","steps","pinned_policy_digest","pinned_configuration_digest","pinned_catalog_digest"],title:"WorkflowDefinition",type:"object"},{$defs:{RunId:vF},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run_id:{$ref:"#/$defs/RunId"}},required:["run_id"],title:"WorkflowRunGetRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RunId:vF,TaskHandoffScope:bC,TaskId:bT,ThreadId:bz,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkAttemptStateV1:$t,WorkHandoffAttemptFrontierV1:$C,WorkHandoffFrontierV1:$T,WorkHandoffLineageV1:$O,WorkflowDefinitionId:SM,WorkflowStepId:SU,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`TaskHandoffService::issue`].\n\n`secret` is the caller-supplied bearer token; the authority persists only\nits digest, never the secret itself. The scope must name a step the\nActive definition version declares and a run admitted from that version;\nany other scope is refused as not found and journals no grant.",properties:{frontier:{$ref:"#/$defs/WorkHandoffFrontierV1",description:"The exact work/evidence frontier this handoff records (Plan 24)."},scope:{$ref:"#/$defs/TaskHandoffScope"},secret:{type:"string"}},required:["scope","secret","frontier"],title:"TaskHandoffIssueRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RunId:vF,TaskHandoffScope:bC,TaskId:bT,ThreadId:bz,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkAttemptStateV1:$t,WorkHandoffAttemptFrontierV1:$C,WorkHandoffFrontierV1:$T,WorkHandoffLineageV1:$O,WorkflowDefinitionId:SM,WorkflowStepId:SU,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expires_at:{$ref:"#/$defs/UtcMicros"},frontier:{$ref:"#/$defs/WorkHandoffFrontierV1",description:"The exact work/evidence frontier this handoff records (Plan 24)."},frontier_digest:{$ref:"#/$defs/ManifestDigest",description:"The canonical digest of `frontier`; lineage chains hold this value."},issued_at:{$ref:"#/$defs/UtcMicros"},scope:{$ref:"#/$defs/TaskHandoffScope"},token_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope","token_digest","issued_at","expires_at","frontier","frontier_digest"],title:"TaskHandoffGrant",type:"object"},{$defs:{ActorId:fb,ProjectId:_4,RepositoryId:vb,RunId:vF,TaskHandoffScope:bC,TaskId:bT,ThreadId:bz,WorkflowDefinitionId:SM,WorkflowStepId:SU,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`TaskHandoffService::redeem`].",properties:{expected_scope:{$ref:"#/$defs/TaskHandoffScope"},secret:{type:"string"}},required:["secret","expected_scope"],title:"TaskHandoffRedeemRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RunId:vF,TaskHandoffScope:bC,TaskId:bT,ThreadId:bz,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkAttemptStateV1:$t,WorkHandoffAttemptFrontierV1:$C,WorkHandoffFrontierV1:$T,WorkHandoffLineageV1:$O,WorkflowDefinitionId:SM,WorkflowStepId:SU,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire response for [`TaskHandoffService::redeem`]: the redemption receipt,\nonce and only once, for the caller that actually consumed the grant.\n\nThe receipt is checkpoint evidence only. It deliberately carries no\nlease, fence, or acceptance authority: redeeming a handoff cannot renew\na lease, establish task acceptance, or mutate graph or runtime state\n(Plan 24). The redeemer must earn runtime authority through the normal\nadmission and lease paths.",properties:{frontier:{$ref:"#/$defs/WorkHandoffFrontierV1",description:"The frontier exactly as the issuer recorded it."},frontier_digest:{$ref:"#/$defs/ManifestDigest",description:"The canonical digest of `frontier`, for lineage chaining."},redeemed_at:{$ref:"#/$defs/UtcMicros"},scope:{$ref:"#/$defs/TaskHandoffScope"}},required:["scope","frontier","frontier_digest","redeemed_at"],title:"TaskHandoffRedeemed",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::list`].",title:"WorkflowDefinitionListRequest",type:"object"},{$defs:{RunId:vF,WorkCommandId:$p},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},expected_sequence:{format:"uint64",minimum:0,type:"integer"},run_id:{$ref:"#/$defs/RunId"}},required:["run_id","expected_sequence","command_id"],title:"WorkflowRunPauseRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::register`].",properties:{definition:{$ref:"#/$defs/WorkflowDefinition"}},required:["definition"],title:"WorkflowDefinitionRegisterRequest",type:"object"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::reject`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},expected_revision:{format:"uint64",minimum:1,type:"integer"}},required:["definition_id","definition_version","expected_revision"],title:"WorkflowDefinitionRejectRequest",type:"object"},{$defs:{RunId:vF,WorkCommandId:$p},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},expected_sequence:{format:"uint64",minimum:0,type:"integer"},run_id:{$ref:"#/$defs/RunId"}},required:["run_id","expected_sequence","command_id"],title:"WorkflowRunResumeRequest",type:"object"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::retire`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},expected_revision:{format:"uint64",minimum:1,type:"integer"}},required:["definition_id","definition_version","expected_revision"],title:"WorkflowDefinitionRetireRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkAcceptanceCriterionV1:bY,WorkApprovalPolicy:b1,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_,WorkSandboxPolicy:Sw,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTopologyPolicyV1:SA,WorkflowDefinitionId:SM,WorkflowExecutionFence:{additionalProperties:!1,properties:{attempt_id:{$ref:"#/$defs/AttemptId"},lease:{$ref:"#/$defs/WorkLeaseFenceV1"}},required:["attempt_id","lease"],type:"object"},WorkflowFailurePolicy:{oneOf:[{properties:{policy:{const:"fail_fast",type:"string"}},required:["policy"],type:"object"},{properties:{policy:{const:"collect",type:"string"}},required:["policy"],type:"object"},{properties:{policy:{const:"require_at_least",type:"string"},successes:{format:"uint32",minimum:1,type:"integer"}},required:["policy","successes"],type:"object"}]},WorkflowFanOutInput:{additionalProperties:!1,properties:{initiative:{$ref:"#/$defs/WorkInitiativeV1"},input_digest:{$ref:"#/$defs/ManifestDigest"},instructions:{type:"string"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},plan:{$ref:"#/$defs/WorkPlanV1"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["instructions","input_digest","initiative","plan","milestone","item","proposal"],type:"object"},WorkflowFanOutStartV1:{additionalProperties:!1,description:"Caller input required to durably plan the entry fan-out of a workflow run.\nDaemon-owned registration and topology digests are resolved at admission.",properties:{commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},failure_policy:{$ref:"#/$defs/WorkflowFailurePolicy"},fence:{$ref:"#/$defs/WorkflowExecutionFence"},inputs:{items:{$ref:"#/$defs/WorkflowFanOutInput"},type:"array"},max_parallel:{format:"uint32",minimum:1,type:"integer"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]}},required:["fence","max_parallel","failure_policy","execution_snapshot","commit","effect_state","inputs"],type:"object"},WorkflowProviderRegistration:{additionalProperties:!1,properties:{backend:{$ref:"#/$defs/WorkProviderBackendV1"},model:{type:"string"},priority:{format:"uint32",minimum:0,type:"integer"},route:{$ref:"#/$defs/WorkProviderRouteV1"}},required:["route","backend","model","priority"],type:"object"},WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Starts (admits) a journaled workflow run from an active definition.\n\nThe daemon derives every admission digest itself: the definition's own\npinned policy/configuration/catalog digests are checked against the live\nenvironment, the topology digest comes from the evaluated topology policy,\nand the provider registry digest is computed from this registration. The\ncaller never supplies a digest the runtime must trust.",properties:{command_id:{$ref:"#/$defs/WorkCommandId"},definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},fan_out:{anyOf:[{$ref:"#/$defs/WorkflowFanOutStartV1"},{type:"null"}]},provider:{$ref:"#/$defs/WorkflowProviderRegistration"},run_id:{$ref:"#/$defs/RunId"}},required:["run_id","definition_id","definition_version","provider","command_id"],title:"WorkflowRunStartRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::validate`].",properties:{definition:{$ref:"#/$defs/WorkflowDefinition"}},required:["definition"],title:"WorkflowDefinitionValidateRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{definition:{$ref:"#/$defs/WorkflowDefinition"}},required:["definition"],title:"WorkflowDefinitionValidation",type:"object"}].map(e=>t=>(!function e(t,r,i,o,n){var a;if("boolean"==typeof r){if(!r)throw TypeError(`${o} is rejected by the canonical schema`);return}let s=ft(r,o);if("string"==typeof s.$ref){if(n.has(s.$ref))throw TypeError(`cyclic canonical schema reference: ${s.$ref}`);n.add(s.$ref),e(t,function(e,t){if(!t.startsWith("#/"))throw TypeError(`unsupported canonical schema reference: ${t}`);let r=e;for(let e of t.slice(2).split("/")){let i=e.replaceAll("~1","/").replaceAll("~0","~");r=ft(r,t)[i]}return ft(r,t)}(i,s.$ref),i,o,n),n.delete(s.$ref);return}if("const"in s&&(a=s.const,fe(t)!==fe(a)))throw TypeError(`${o} does not match the canonical constant`);if(Array.isArray(s.enum)&&!s.enum.some(e=>fe(t)===fe(e)))throw TypeError(`${o} is not a canonical enum value`);if(Array.isArray(s.allOf))for(let r of s.allOf)e(t,r,i,o,new Set(n));if(Array.isArray(s.anyOf)&&!s.anyOf.some(r=>{try{return e(t,r,i,o,new Set(n)),!0}catch{return!1}}))throw TypeError(`${o} does not match any canonical variant`);if(Array.isArray(s.oneOf)&&1!==s.oneOf.filter(r=>{try{return e(t,r,i,o,new Set(n)),!0}catch{return!1}}).length)throw TypeError(`${o} must match exactly one canonical variant`);let d=s.type;if("string"==typeof d&&!fr(t,d))throw TypeError(`${o} must be ${d}`);if(Array.isArray(d)&&!d.some(e=>"string"==typeof e&&fr(t,e)))throw TypeError(`${o} has no canonical type`);if("string"==typeof t){if("number"==typeof s.minLength&&t.length<s.minLength)throw TypeError(`${o} is shorter than minLength`);if("number"==typeof s.maxLength&&t.length>s.maxLength)throw TypeError(`${o} exceeds maxLength`);if("string"==typeof s.pattern&&!RegExp(s.pattern,"u").test(t))throw TypeError(`${o} does not match the canonical pattern`)}if("number"==typeof t){if("integer"===s.type){if("uint32"===s.format&&(t<0||t>0xffffffff))throw TypeError(`${o} is outside uint32`);if("uint64"===s.format&&(t<0||t>Number.MAX_SAFE_INTEGER))throw TypeError(`${o} is outside safely representable uint64`);if("int64"===s.format&&(t<Number.MIN_SAFE_INTEGER||t>Number.MAX_SAFE_INTEGER))throw TypeError(`${o} is outside safely representable int64`)}if("number"==typeof s.minimum&&t<s.minimum)throw TypeError(`${o} is below minimum`);if("number"==typeof s.maximum&&t>s.maximum)throw TypeError(`${o} exceeds maximum`)}if(Array.isArray(t)){if("number"==typeof s.minItems&&t.length<s.minItems)throw TypeError(`${o} has too few items`);if("number"==typeof s.maxItems&&t.length>s.maxItems)throw TypeError(`${o} has too many items`);if(!0===s.uniqueItems){let e=new Set;for(let r of t){let t=fe(r);if(e.has(t))throw TypeError(`${o} contains duplicate items`);e.add(t)}}Array.isArray(s.prefixItems)&&s.prefixItems.forEach((r,n)=>{n<t.length&&e(t[n],r,i,`${o}[${n}]`,new Set)}),void 0===s.items||Array.isArray(s.prefixItems)||t.forEach((t,r)=>e(t,s.items,i,`${o}[${r}]`,new Set))}if("object"==typeof t&&null!==t&&!Array.isArray(t)){let r=void 0===s.properties?{}:ft(s.properties,`${o}.properties`);if(Array.isArray(s.required)){for(let e of s.required)if("string"==typeof e&&!(e in t))throw TypeError(`${o}.${e} is required`)}for(let[n,a]of Object.entries(t))if(n in r)e(a,r[n],i,`${o}.${n}`,new Set);else if(!1===s.additionalProperties)throw TypeError(`${o}.${n} is not allowed`);else"object"==typeof s.additionalProperties&&e(a,s.additionalProperties,i,`${o}.${n}`,new Set)}}(t,e,e,"value",new Set),t));function S1(e){let t=SY[e];if(void 0===t)throw TypeError(`generated canonical schema ${e} is missing`);return t}let S0=[{operation:"active_project",operationId:"operation.application.active_project",transport:{kind:"mcp_tool",toolName:"tracedecay_active_project"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.active_project.v1",requestSchema:{schemaId:"schema.application.primitive.active-project.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.active-project.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(0),decodeResult:S1(1)},{operation:"admin_cli",operationId:"operation.application.admin_cli",transport:{kind:"mcp_tool",toolName:"tracedecay_admin_cli"},effect:"maintains_profile_state",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.admin_cli.v1",requestSchema:{schemaId:"schema.application.primitive.admin-cli.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.admin-cli.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","effect_in_flight"]},deadline:{behavior:"return_operation_receipt",maximum_millis:6e5},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(2),decodeResult:S1(3)},{operation:"admin_project",operationId:"operation.application.admin_project",transport:{kind:"mcp_tool",toolName:"tracedecay_admin_project"},effect:"maintains_owner_state",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.admin_project.v1",requestSchema:{schemaId:"schema.application.primitive.admin-project.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.admin-project.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:6e5},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","unavailable","partial"],decodeRequest:S1(4),decodeResult:S1(5)},{operation:"admin_sync",operationId:"operation.application.admin_sync",transport:{kind:"mcp_tool",toolName:"tracedecay_admin_sync"},effect:"schedules_work",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.admin_sync.v1",requestSchema:{schemaId:"schema.application.primitive.admin-sync.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.admin-sync.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:6e5},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","unavailable","partial"],decodeRequest:S1(6),decodeResult:S1(7)},{operation:"affected",operationId:"operation.application.affected",transport:{kind:"mcp_tool",toolName:"tracedecay_affected"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.affected.v1",requestSchema:{schemaId:"schema.application.primitive.affected.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.affected.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(8),decodeResult:S1(9)},{operation:"application_affected_tests",operationId:"operation.application.affected_tests",transport:{kind:"http",route:"/application/tests/affected",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.affected_tests.v1",requestSchema:{schemaId:"schema.application.feedback.affected-tests.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.affected-tests.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(11),decodeSuccess:e=>fp(e,"binding.http.affected_tests.v1","schema.application.feedback.affected-tests.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(11))},{operation:"analytics",operationId:"operation.application.analytics",transport:{kind:"mcp_tool",toolName:"tracedecay_analytics"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.analytics.v1",requestSchema:{schemaId:"schema.application.primitive.analytics.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.analytics.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(12),decodeResult:S1(13)},{operation:"apply_native_integration",operationId:"operation.application.apply_native_integration",transport:{kind:"mcp_tool",toolName:"tracedecay_apply_native_integration"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.apply_native_integration.v1",requestSchema:{schemaId:"schema.application.native-integration.apply.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.apply.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(14),decodeResult:S1(15)},{operation:"approve_native_integration",operationId:"operation.application.approve_native_integration",transport:{kind:"mcp_tool",toolName:"tracedecay_approve_native_integration"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.approve_native_integration.v1",requestSchema:{schemaId:"schema.application.native-integration.approve.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.approve.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(16),decodeResult:S1(15)},{operation:"ast_grep_rewrite",operationId:"operation.application.ast_grep_rewrite",transport:{kind:"mcp_tool",toolName:"tracedecay_ast_grep_rewrite"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.ast_grep_rewrite.v1",requestSchema:{schemaId:"schema.application.source-edit.ast-grep-rewrite.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.ast-grep-rewrite.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(17),decodeResult:S1(18)},{operation:"ast_grep_search",operationId:"operation.application.ast_grep_search",transport:{kind:"mcp_tool",toolName:"tracedecay_ast_grep_search"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.ast_grep_search.v1",requestSchema:{schemaId:"schema.application.primitive.ast-grep-search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.ast-grep-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(19),decodeResult:S1(20)},{operation:"automation_run_artifact_view",operationId:"operation.application.automation_run_artifact_view",transport:{kind:"mcp_tool",toolName:"tracedecay_automation_run_artifact_view"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.automation_run_artifact_view.v1",requestSchema:{schemaId:"schema.application.primitive.automation-run-artifact-view.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.automation-run-artifact-view.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(21),decodeResult:S1(22)},{operation:"automation_run_list",operationId:"operation.application.automation_run_list",transport:{kind:"mcp_tool",toolName:"tracedecay_automation_run_list"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.automation_run_list.v1",requestSchema:{schemaId:"schema.application.primitive.automation-run-list.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.automation-run-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(23),decodeResult:S1(24)},{operation:"automation_run_view",operationId:"operation.application.automation_run_view",transport:{kind:"mcp_tool",toolName:"tracedecay_automation_run_view"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.automation_run_view.v1",requestSchema:{schemaId:"schema.application.primitive.automation-run-view.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.automation-run-view.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(25),decodeResult:S1(26)},{operation:"branch_diff",operationId:"operation.application.branch_diff",transport:{kind:"mcp_tool",toolName:"tracedecay_branch_diff"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.branch_diff.v1",requestSchema:{schemaId:"schema.application.primitive.branch-diff.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.branch-diff.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(27),decodeResult:S1(28)},{operation:"branch_list",operationId:"operation.application.branch_list",transport:{kind:"mcp_tool",toolName:"tracedecay_branch_list"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.branch_list.v1",requestSchema:{schemaId:"schema.application.primitive.branch-list.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.branch-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(29),decodeResult:S1(30)},{operation:"branch_search",operationId:"operation.application.branch_search",transport:{kind:"mcp_tool",toolName:"tracedecay_branch_search"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.branch_search.v1",requestSchema:{schemaId:"schema.application.primitive.branch-search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.branch-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(31),decodeResult:S1(32)},{operation:"by_qualified_name",operationId:"operation.application.by_qualified_name",transport:{kind:"mcp_tool",toolName:"tracedecay_by_qualified_name"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.by_qualified_name.v1",requestSchema:{schemaId:"schema.application.primitive.by-qualified-name.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.by-qualified-name.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(33),decodeResult:S1(34)},{operation:"application_call_chain",operationId:"operation.application.call_chain",transport:{kind:"http",route:"/application/primitives/call_chain",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.call_chain.v1",requestSchema:{schemaId:"schema.application.primitive.call-chain.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.call-chain.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(35),decodeResult:S1(36),decodeSuccess:e=>fp(e,"binding.http.call_chain.v1","schema.application.primitive.call-chain.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(36))},{operation:"cancel_native_integration",operationId:"operation.application.cancel_native_integration",transport:{kind:"mcp_tool",toolName:"tracedecay_cancel_native_integration"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.cancel_native_integration.v1",requestSchema:{schemaId:"schema.application.native-integration.cancel.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.cancel.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(37),decodeResult:S1(15)},{operation:"changelog",operationId:"operation.application.changelog",transport:{kind:"mcp_tool",toolName:"tracedecay_changelog"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.changelog.v1",requestSchema:{schemaId:"schema.application.primitive.changelog.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.changelog.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(38),decodeResult:S1(39)},{operation:"circular",operationId:"operation.application.circular",transport:{kind:"mcp_tool",toolName:"tracedecay_circular"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.circular.v1",requestSchema:{schemaId:"schema.application.primitive.circular.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.circular.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(40),decodeResult:S1(41)},{operation:"code_callees",operationId:"operation.application.code_callees",transport:{kind:"http",route:"/application/code/code_callees",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_callees.v1",requestSchema:{schemaId:"schema.application.code-query.callees.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.callees.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(42),decodeResult:S1(43),decodeSuccess:e=>fp(e,"binding.http.code_callees.v1","schema.application.code-query.callees.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(43))},{operation:"code_callers",operationId:"operation.application.code_callers",transport:{kind:"http",route:"/application/code/code_callers",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_callers.v1",requestSchema:{schemaId:"schema.application.primitive.code-callers.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.code-callers.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(44),decodeResult:S1(45),decodeSuccess:e=>fp(e,"binding.http.code_callers.v1","schema.application.primitive.code-callers.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(45))},{operation:"code_declaration",operationId:"operation.application.code_declaration",transport:{kind:"http",route:"/application/code/code_declaration",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_declaration.v1",requestSchema:{schemaId:"schema.application.code-query.declaration.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.declaration.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(46),decodeResult:S1(47),decodeSuccess:e=>fp(e,"binding.http.code_declaration.v1","schema.application.code-query.declaration.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(47))},{operation:"code_exact_occurrence",operationId:"operation.application.code_exact_occurrence",transport:{kind:"http",route:"/application/code/code_exact_occurrence",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_exact_occurrence.v1",requestSchema:{schemaId:"schema.application.code-query.exact-occurrence.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.exact-occurrence.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(48),decodeResult:S1(49),decodeSuccess:e=>fp(e,"binding.http.code_exact_occurrence.v1","schema.application.code-query.exact-occurrence.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(49))},{operation:"code_facets",operationId:"operation.application.code_facets",transport:{kind:"http",route:"/application/code/code_facets",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_facets.v1",requestSchema:{schemaId:"schema.application.code-query.facets.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.facets.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(50),decodeResult:S1(51),decodeSuccess:e=>fp(e,"binding.http.code_facets.v1","schema.application.code-query.facets.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(51))},{operation:"code_implementations",operationId:"operation.application.code_implementations",transport:{kind:"http",route:"/application/code/code_implementations",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_implementations.v1",requestSchema:{schemaId:"schema.application.primitive.code-implementations.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.code-implementations.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(52),decodeResult:S1(53),decodeSuccess:e=>fp(e,"binding.http.code_implementations.v1","schema.application.primitive.code-implementations.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(53))},{operation:"code_phrase_search",operationId:"operation.application.code_phrase_search",transport:{kind:"http",route:"/application/code/code_phrase_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_phrase_search.v1",requestSchema:{schemaId:"schema.application.code-query.phrase-search.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.phrase-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(54),decodeResult:S1(55),decodeSuccess:e=>fp(e,"binding.http.code_phrase_search.v1","schema.application.code-query.phrase-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(55))},{operation:"code_references",operationId:"operation.application.code_references",transport:{kind:"http",route:"/application/code/code_references",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_references.v1",requestSchema:{schemaId:"schema.application.code-query.references.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.references.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(46),decodeResult:S1(43),decodeSuccess:e=>fp(e,"binding.http.code_references.v1","schema.application.code-query.references.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(43))},{operation:"code_signature_search",operationId:"operation.application.code_signature_search",transport:{kind:"http",route:"/application/code/code_signature_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_signature_search.v1",requestSchema:{schemaId:"schema.application.primitive.code-signature-search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.code-signature-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(56),decodeResult:S1(57),decodeSuccess:e=>fp(e,"binding.http.code_signature_search.v1","schema.application.primitive.code-signature-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(57))},{operation:"code_symbol_search",operationId:"operation.application.code_symbol_search",transport:{kind:"http",route:"/application/code/code_symbol_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_symbol_search.v1",requestSchema:{schemaId:"schema.application.symbol-search.request",revision:1},resultSchema:{schemaId:"schema.application.symbol-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(58),decodeResult:S1(57),decodeSuccess:e=>fp(e,"binding.http.code_symbol_search.v1","schema.application.symbol-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(57))},{operation:"code_timeline",operationId:"operation.application.code_timeline",transport:{kind:"http",route:"/application/code/code_timeline",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_timeline.v1",requestSchema:{schemaId:"schema.application.code-query.timeline.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.timeline.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(59),decodeResult:S1(60),decodeSuccess:e=>fp(e,"binding.http.code_timeline.v1","schema.application.code-query.timeline.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(60))},{operation:"code_type_definition",operationId:"operation.application.code_type_definition",transport:{kind:"http",route:"/application/code/code_type_definition",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_type_definition.v1",requestSchema:{schemaId:"schema.application.code-query.type-definition.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.type-definition.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(46),decodeResult:S1(47),decodeSuccess:e=>fp(e,"binding.http.code_type_definition.v1","schema.application.code-query.type-definition.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(47))},{operation:"code_type_hierarchy",operationId:"operation.application.code_type_hierarchy",transport:{kind:"http",route:"/application/code/code_type_hierarchy",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_type_hierarchy.v1",requestSchema:{schemaId:"schema.application.primitive.code-type-hierarchy.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.code-type-hierarchy.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(61),decodeResult:S1(62),decodeSuccess:e=>fp(e,"binding.http.code_type_hierarchy.v1","schema.application.primitive.code-type-hierarchy.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(62))},{operation:"commit_context",operationId:"operation.application.commit_context",transport:{kind:"mcp_tool",toolName:"tracedecay_commit_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.commit_context.v1",requestSchema:{schemaId:"schema.application.primitive.commit-context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.commit-context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(63),decodeResult:S1(64)},{operation:"complexity",operationId:"operation.application.complexity",transport:{kind:"mcp_tool",toolName:"tracedecay_complexity"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.complexity.v1",requestSchema:{schemaId:"schema.application.primitive.complexity.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.complexity.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(65),decodeResult:S1(66)},{operation:"config",operationId:"operation.application.config",transport:{kind:"mcp_tool",toolName:"tracedecay_config"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.config.v1",requestSchema:{schemaId:"schema.application.primitive.config.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.config.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(67),decodeResult:S1(68)},{operation:"application_configuration_audit",operationId:"operation.application.configuration_audit",transport:{kind:"http",route:"/application/configuration/configuration_audit",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_audit.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_audit.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_audit.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(69),decodeResult:S1(70),decodeSuccess:e=>fp(e,"binding.http.configuration_audit.v1","schema.application.configuration.configuration_audit.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(70))},{operation:"application_configuration_batch",operationId:"operation.application.configuration_batch",transport:{kind:"http",route:"/application/configuration/configuration_batch",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_batch.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_batch.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_batch.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(71),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_batch.v1","schema.application.configuration.configuration_batch.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_configuration_get",operationId:"operation.application.configuration_get",transport:{kind:"http",route:"/application/configuration/configuration_get",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_get.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_get.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_get.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(73),decodeResult:S1(74),decodeSuccess:e=>fp(e,"binding.http.configuration_get.v1","schema.application.configuration.configuration_get.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(74))},{operation:"application_configuration_list",operationId:"operation.application.configuration_list",transport:{kind:"http",route:"/application/configuration/configuration_list",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_list.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_list.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(75),decodeResult:S1(76),decodeSuccess:e=>fp(e,"binding.http.configuration_list.v1","schema.application.configuration.configuration_list.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(76))},{operation:"application_configuration_observed_state",operationId:"operation.application.configuration_observed_state",transport:{kind:"http",route:"/application/configuration/configuration_observed_state",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_observed_state.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_observed_state.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_observed_state.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(77),decodeResult:S1(78),decodeSuccess:e=>fp(e,"binding.http.configuration_observed_state.v1","schema.application.configuration.configuration_observed_state.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(78))},{operation:"application_configuration_protected_apply",operationId:"operation.application.configuration_protected_apply",transport:{kind:"http",route:"/application/configuration/configuration_protected_apply",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_protected_apply.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_protected_apply.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_protected_apply.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(79),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_protected_apply.v1","schema.application.configuration.configuration_protected_apply.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_configuration_protected_preview",operationId:"operation.application.configuration_protected_preview",transport:{kind:"http",route:"/application/configuration/configuration_protected_preview",method:"POST"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_protected_preview.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_protected_preview.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_protected_preview.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(80),decodeResult:S1(81),decodeSuccess:e=>fp(e,"binding.http.configuration_protected_preview.v1","schema.application.configuration.configuration_protected_preview.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(81))},{operation:"application_configuration_rollback_apply",operationId:"operation.application.configuration_rollback_apply",transport:{kind:"http",route:"/application/configuration/configuration_rollback_apply",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_rollback_apply.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_rollback_apply.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_rollback_apply.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(79),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_rollback_apply.v1","schema.application.configuration.configuration_rollback_apply.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_configuration_rollback_preview",operationId:"operation.application.configuration_rollback_preview",transport:{kind:"http",route:"/application/configuration/configuration_rollback_preview",method:"POST"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_rollback_preview.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_rollback_preview.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_rollback_preview.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(82),decodeResult:S1(81),decodeSuccess:e=>fp(e,"binding.http.configuration_rollback_preview.v1","schema.application.configuration.configuration_rollback_preview.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(81))},{operation:"application_configuration_set",operationId:"operation.application.configuration_set",transport:{kind:"http",route:"/application/configuration/configuration_set",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_set.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_set.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_set.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(83),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_set.v1","schema.application.configuration.configuration_set.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_configuration_unset",operationId:"operation.application.configuration_unset",transport:{kind:"http",route:"/application/configuration/configuration_unset",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_unset.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_unset.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_unset.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(84),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_unset.v1","schema.application.configuration.configuration_unset.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"constructors",operationId:"operation.application.constructors",transport:{kind:"mcp_tool",toolName:"tracedecay_constructors"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.constructors.v1",requestSchema:{schemaId:"schema.application.primitive.constructors.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.constructors.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(85),decodeResult:S1(86)},{operation:"context",operationId:"operation.application.context",transport:{kind:"mcp_tool",toolName:"tracedecay_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.context.v1",requestSchema:{schemaId:"schema.application.primitive.context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(87),decodeResult:S1(88)},{operation:"application_context_scout_budget",operationId:"operation.application.context_scout_budget",transport:{kind:"http",route:"/application/context-scout/context_scout_budget",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_budget.v1",requestSchema:{schemaId:"schema.application.context-scout-budget.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-budget.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(89),decodeResult:S1(90),decodeSuccess:e=>fp(e,"binding.http.context_scout_budget.v1","schema.application.context-scout-budget.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(90))},{operation:"application_context_scout_cancel",operationId:"operation.application.context_scout_cancel",transport:{kind:"http",route:"/application/context-scout/context_scout_cancel",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_cancel.v1",requestSchema:{schemaId:"schema.application.context-scout-cancel.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-cancel.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(91),decodeResult:S1(92),decodeSuccess:e=>fp(e,"binding.http.context_scout_cancel.v1","schema.application.context-scout-cancel.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(92))},{operation:"application_context_scout_capability",operationId:"operation.application.context_scout_capability",transport:{kind:"http",route:"/application/context-scout/context_scout_capability",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_capability.v1",requestSchema:{schemaId:"schema.application.context-scout-capability.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-capability.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(89),decodeResult:S1(93),decodeSuccess:e=>fp(e,"binding.http.context_scout_capability.v1","schema.application.context-scout-capability.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(93))},{operation:"application_context_scout_claim",operationId:"operation.application.context_scout_claim",transport:{kind:"http",route:"/application/context-scout/context_scout_claim",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_claim.v1",requestSchema:{schemaId:"schema.application.context-scout-claim.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-claim.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(94),decodeResult:S1(95),decodeSuccess:e=>fp(e,"binding.http.context_scout_claim.v1","schema.application.context-scout-claim.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(95))},{operation:"application_context_scout_delivery",operationId:"operation.application.context_scout_delivery",transport:{kind:"http",route:"/application/context-scout/context_scout_delivery",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_delivery.v1",requestSchema:{schemaId:"schema.application.context-scout-delivery.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-delivery.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(96),decodeResult:S1(97),decodeSuccess:e=>fp(e,"binding.http.context_scout_delivery.v1","schema.application.context-scout-delivery.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(97))},{operation:"application_context_scout_explain",operationId:"operation.application.context_scout_explain",transport:{kind:"http",route:"/application/context-scout/context_scout_explain",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_explain.v1",requestSchema:{schemaId:"schema.application.context-scout-explain.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-explain.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(98),decodeResult:S1(99),decodeSuccess:e=>fp(e,"binding.http.context_scout_explain.v1","schema.application.context-scout-explain.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(99))},{operation:"application_context_scout_feedback",operationId:"operation.application.context_scout_feedback",transport:{kind:"http",route:"/application/context-scout/context_scout_feedback",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_feedback.v1",requestSchema:{schemaId:"schema.application.context-scout-feedback.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-feedback.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(100),decodeResult:S1(92),decodeSuccess:e=>fp(e,"binding.http.context_scout_feedback.v1","schema.application.context-scout-feedback.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(92))},{operation:"application_context_scout_pause",operationId:"operation.application.context_scout_pause",transport:{kind:"http",route:"/application/context-scout/context_scout_pause",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_pause.v1",requestSchema:{schemaId:"schema.application.context-scout-pause.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-pause.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(101),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.context_scout_pause.v1","schema.application.context-scout-pause.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_context_scout_recent",operationId:"operation.application.context_scout_recent",transport:{kind:"http",route:"/application/context-scout/context_scout_recent",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_recent.v1",requestSchema:{schemaId:"schema.application.context-scout-recent.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-recent.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(98),decodeResult:S1(102),decodeSuccess:e=>fp(e,"binding.http.context_scout_recent.v1","schema.application.context-scout-recent.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(102))},{operation:"application_context_scout_resume",operationId:"operation.application.context_scout_resume",transport:{kind:"http",route:"/application/context-scout/context_scout_resume",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_resume.v1",requestSchema:{schemaId:"schema.application.context-scout-resume.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-resume.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(101),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.context_scout_resume.v1","schema.application.context-scout-resume.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_context_scout_status",operationId:"operation.application.context_scout_status",transport:{kind:"http",route:"/application/context-scout/context_scout_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_status.v1",requestSchema:{schemaId:"schema.application.context-scout-status.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(89),decodeResult:S1(103),decodeSuccess:e=>fp(e,"binding.http.context_scout_status.v1","schema.application.context-scout-status.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(103))},{operation:"coupling",operationId:"operation.application.coupling",transport:{kind:"mcp_tool",toolName:"tracedecay_coupling"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.coupling.v1",requestSchema:{schemaId:"schema.application.primitive.coupling.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.coupling.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(104),decodeResult:S1(105)},{operation:"dashboard",operationId:"operation.application.dashboard",transport:{kind:"mcp_tool",toolName:"tracedecay_dashboard"},effect:"binds_server",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.dashboard.v1",requestSchema:{schemaId:"schema.application.primitive.dashboard.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.dashboard.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","unavailable","partial"],decodeRequest:S1(106),decodeResult:S1(107)},{operation:"dead_code",operationId:"operation.application.dead_code",transport:{kind:"mcp_tool",toolName:"tracedecay_dead_code"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.dead_code.v1",requestSchema:{schemaId:"schema.application.primitive.dead-code.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.dead-code.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(108),decodeResult:S1(109)},{operation:"dependency_depth",operationId:"operation.application.dependency_depth",transport:{kind:"mcp_tool",toolName:"tracedecay_dependency_depth"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.dependency_depth.v1",requestSchema:{schemaId:"schema.application.primitive.dependency-depth.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.dependency-depth.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(110),decodeResult:S1(111)},{operation:"derives",operationId:"operation.application.derives",transport:{kind:"mcp_tool",toolName:"tracedecay_derives"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.derives.v1",requestSchema:{schemaId:"schema.application.primitive.derives.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.derives.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(112),decodeResult:S1(113)},{operation:"diagnose",operationId:"operation.application.diagnose",transport:{kind:"mcp_tool",toolName:"tracedecay_diagnose"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.diagnose.v1",requestSchema:{schemaId:"schema.application.primitive.diagnose.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.diagnose.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(114),decodeResult:S1(115)},{operation:"application_diagnostics_read",operationId:"operation.application.diagnostics_read",transport:{kind:"http",route:"/application/primitives/diagnostics_read",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.diagnostics_read.v1",requestSchema:{schemaId:"schema.application.primitive.diagnostics-read.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.diagnostics-read.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(116),decodeResult:S1(117),decodeSuccess:e=>fp(e,"binding.http.diagnostics_read.v1","schema.application.primitive.diagnostics-read.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(117))},{operation:"diff_context",operationId:"operation.application.diff_context",transport:{kind:"mcp_tool",toolName:"tracedecay_diff_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.diff_context.v1",requestSchema:{schemaId:"schema.application.primitive.diff-context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.diff-context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(118),decodeResult:S1(119)},{operation:"distribution",operationId:"operation.application.distribution",transport:{kind:"mcp_tool",toolName:"tracedecay_distribution"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.distribution.v1",requestSchema:{schemaId:"schema.application.primitive.distribution.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.distribution.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(120),decodeResult:S1(121)},{operation:"doc_coverage",operationId:"operation.application.doc_coverage",transport:{kind:"mcp_tool",toolName:"tracedecay_doc_coverage"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.doc_coverage.v1",requestSchema:{schemaId:"schema.application.primitive.doc-coverage.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.doc-coverage.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(122),decodeResult:S1(123)},{operation:"dsm",operationId:"operation.application.dsm",transport:{kind:"mcp_tool",toolName:"tracedecay_dsm"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.dsm.v1",requestSchema:{schemaId:"schema.application.primitive.dsm.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.dsm.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(124),decodeResult:S1(125)},{operation:"application_fact_feedback",operationId:"operation.application.fact_feedback",transport:{kind:"http",route:"/application/retained/fact_feedback",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_feedback.v1",requestSchema:{schemaId:"schema.application.retained.fact-feedback.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-feedback.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(126),decodeResult:S1(127),decodeSuccess:e=>fp(e,"binding.http.fact_feedback.v1","schema.application.retained.fact-feedback.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(127))},{operation:"application_fact_store_add",operationId:"operation.application.fact_store_add",transport:{kind:"http",route:"/application/retained/fact_store_add",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_add.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-add.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-add.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(128),decodeResult:S1(129),decodeSuccess:e=>fp(e,"binding.http.fact_store_add.v1","schema.application.retained.fact-store-add.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(129))},{operation:"application_fact_store_contradict",operationId:"operation.application.fact_store_contradict",transport:{kind:"http",route:"/application/retained/fact_store_contradict",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_contradict.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-contradict.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-contradict.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(130),decodeResult:S1(131),decodeSuccess:e=>fp(e,"binding.http.fact_store_contradict.v1","schema.application.retained.fact-store-contradict.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(131))},{operation:"application_fact_store_curate",operationId:"operation.application.fact_store_curate",transport:{kind:"http",route:"/application/retained/fact_store_curate",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"required",resultSemantics:"fact_store_curate_receipt",bindingId:"binding.http.fact_store_curate.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-curate.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-curate.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:9e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(132),decodeResult:S1(133),decodeSuccess:e=>fp(e,"binding.http.fact_store_curate.v1","schema.application.retained.fact-store-curate.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(133))},{operation:"application_fact_store_get",operationId:"operation.application.fact_store_get",transport:{kind:"http",route:"/application/retained/fact_store_get",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_get.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-get.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-get.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(134),decodeResult:S1(135),decodeSuccess:e=>fp(e,"binding.http.fact_store_get.v1","schema.application.retained.fact-store-get.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(135))},{operation:"application_fact_store_list",operationId:"operation.application.fact_store_list",transport:{kind:"http",route:"/application/retained/fact_store_list",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_list.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-list.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(136),decodeResult:S1(137),decodeSuccess:e=>fp(e,"binding.http.fact_store_list.v1","schema.application.retained.fact-store-list.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(137))},{operation:"application_fact_store_probe",operationId:"operation.application.fact_store_probe",transport:{kind:"http",route:"/application/retained/fact_store_probe",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_probe.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-probe.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-probe.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(138),decodeResult:S1(139),decodeSuccess:e=>fp(e,"binding.http.fact_store_probe.v1","schema.application.retained.fact-store-probe.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(139))},{operation:"application_fact_store_reason",operationId:"operation.application.fact_store_reason",transport:{kind:"http",route:"/application/retained/fact_store_reason",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_reason.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-reason.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-reason.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(140),decodeResult:S1(141),decodeSuccess:e=>fp(e,"binding.http.fact_store_reason.v1","schema.application.retained.fact-store-reason.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(141))},{operation:"application_fact_store_related",operationId:"operation.application.fact_store_related",transport:{kind:"http",route:"/application/retained/fact_store_related",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_related.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-related.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-related.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(142),decodeResult:S1(143),decodeSuccess:e=>fp(e,"binding.http.fact_store_related.v1","schema.application.retained.fact-store-related.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(143))},{operation:"application_fact_store_remove",operationId:"operation.application.fact_store_remove",transport:{kind:"http",route:"/application/retained/fact_store_remove",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_remove.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-remove.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-remove.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(144),decodeResult:S1(145),decodeSuccess:e=>fp(e,"binding.http.fact_store_remove.v1","schema.application.retained.fact-store-remove.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(145))},{operation:"application_fact_store_search",operationId:"operation.application.fact_store_search",transport:{kind:"http",route:"/application/retained/fact_store_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_search.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-search.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(146),decodeResult:S1(147),decodeSuccess:e=>fp(e,"binding.http.fact_store_search.v1","schema.application.retained.fact-store-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(147))},{operation:"application_fact_store_supersede",operationId:"operation.application.fact_store_supersede",transport:{kind:"http",route:"/application/retained/fact_store_supersede",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_supersede.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-supersede.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-supersede.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(148),decodeResult:S1(149),decodeSuccess:e=>fp(e,"binding.http.fact_store_supersede.v1","schema.application.retained.fact-store-supersede.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(149))},{operation:"application_fact_store_update",operationId:"operation.application.fact_store_update",transport:{kind:"http",route:"/application/retained/fact_store_update",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_update.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-update.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-update.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(150),decodeResult:S1(151),decodeSuccess:e=>fp(e,"binding.http.fact_store_update.v1","schema.application.retained.fact-store-update.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(151))},{operation:"application_feedback_advisory_cycle",operationId:"operation.application.feedback_advisory_cycle",transport:{kind:"http",route:"/application/feedback/advisory_cycle",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_advisory_cycle.v1",requestSchema:{schemaId:"schema.application.feedback.advisory-cycle.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.advisory-cycle.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(152),decodeResult:S1(153),decodeSuccess:e=>fp(e,"binding.http.feedback_advisory_cycle.v1","schema.application.feedback.advisory-cycle.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(153))},{operation:"application_feedback_diagnostics",operationId:"operation.application.feedback_diagnostics",transport:{kind:"http",route:"/application/feedback/diagnostics",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_diagnostics.v1",requestSchema:{schemaId:"schema.application.feedback.diagnostics.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.diagnostics.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(154),decodeSuccess:e=>fp(e,"binding.http.feedback_diagnostics.v1","schema.application.feedback.diagnostics.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(154))},{operation:"application_feedback_expand",operationId:"operation.application.feedback_expand",transport:{kind:"http",route:"/application/feedback/expand",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_expand.v1",requestSchema:{schemaId:"schema.application.feedback.expand.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.expand.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(155),decodeSuccess:e=>fp(e,"binding.http.feedback_expand.v1","schema.application.feedback.expand.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(155))},{operation:"application_feedback_get",operationId:"operation.application.feedback_get",transport:{kind:"http",route:"/application/feedback/get",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_get.v1",requestSchema:{schemaId:"schema.application.feedback.get.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.get.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(156),decodeSuccess:e=>fp(e,"binding.http.feedback_get.v1","schema.application.feedback.get.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(156))},{operation:"application_feedback_impact",operationId:"operation.application.feedback_impact",transport:{kind:"http",route:"/application/feedback/impact",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_impact.v1",requestSchema:{schemaId:"schema.application.feedback.impact.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.impact.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(157),decodeSuccess:e=>fp(e,"binding.http.feedback_impact.v1","schema.application.feedback.impact.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(157))},{operation:"application_feedback_list",operationId:"operation.application.feedback_list",transport:{kind:"http",route:"/application/feedback/list",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_list.v1",requestSchema:{schemaId:"schema.application.feedback.list.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(158),decodeSuccess:e=>fp(e,"binding.http.feedback_list.v1","schema.application.feedback.list.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(158))},{operation:"application_feedback_proximity",operationId:"operation.application.feedback_proximity",transport:{kind:"http",route:"/application/feedback/proximity",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_proximity.v1",requestSchema:{schemaId:"schema.application.feedback.proximity.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.proximity.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(159),decodeResult:S1(160),decodeSuccess:e=>fp(e,"binding.http.feedback_proximity.v1","schema.application.feedback.proximity.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(160))},{operation:"field_sites",operationId:"operation.application.field_sites",transport:{kind:"mcp_tool",toolName:"tracedecay_field_sites"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.field_sites.v1",requestSchema:{schemaId:"schema.application.primitive.field-sites.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.field-sites.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(161),decodeResult:S1(162)},{operation:"application_file_dependents",operationId:"operation.application.file_dependents",transport:{kind:"http",route:"/application/primitives/file_dependents",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.file_dependents.v1",requestSchema:{schemaId:"schema.application.primitive.file-dependents.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.file-dependents.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(163),decodeResult:S1(164),decodeSuccess:e=>fp(e,"binding.http.file_dependents.v1","schema.application.primitive.file-dependents.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(164))},{operation:"files",operationId:"operation.application.files",transport:{kind:"mcp_tool",toolName:"tracedecay_files"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.files.v1",requestSchema:{schemaId:"schema.application.primitive.files.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.files.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(165),decodeResult:S1(166)},{operation:"find_exact_symbol",operationId:"operation.application.find_exact_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_find_exact_symbol"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.find_exact_symbol.v1",requestSchema:{schemaId:"schema.application.primitive.find-exact-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.find-exact-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(167),decodeResult:S1(168)},{operation:"gini",operationId:"operation.application.gini",transport:{kind:"mcp_tool",toolName:"tracedecay_gini"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.gini.v1",requestSchema:{schemaId:"schema.application.primitive.gini.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.gini.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(169),decodeResult:S1(170)},{operation:"git_apply",operationId:"operation.application.git_apply",transport:{kind:"mcp_tool",toolName:"tracedecay_git_apply"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.git_apply.v1",requestSchema:{schemaId:"schema.application.git.apply.request",revision:1},resultSchema:{schemaId:"schema.application.git.apply.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(171),decodeResult:S1(172)},{operation:"application_git_blame",operationId:"operation.application.git_blame",transport:{kind:"http",route:"/application/git/blame",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_blame.v1",requestSchema:{schemaId:"schema.application.git.blame.request",revision:1},resultSchema:{schemaId:"schema.application.git.blame.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(173),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_blame.v1","schema.application.git.blame.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"application_git_diff",operationId:"operation.application.git_diff",transport:{kind:"http",route:"/application/git/diff",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_diff.v1",requestSchema:{schemaId:"schema.application.git.diff.request",revision:1},resultSchema:{schemaId:"schema.application.git.diff.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(175),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_diff.v1","schema.application.git.diff.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"application_git_history",operationId:"operation.application.git_history",transport:{kind:"http",route:"/application/git/history",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_history.v1",requestSchema:{schemaId:"schema.application.git.history.request",revision:1},resultSchema:{schemaId:"schema.application.git.history.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(176),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_history.v1","schema.application.git.history.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"application_git_hunks",operationId:"operation.application.git_hunks",transport:{kind:"http",route:"/application/git/hunks",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_hunks.v1",requestSchema:{schemaId:"schema.application.git.hunks.request",revision:1},resultSchema:{schemaId:"schema.application.git.hunks.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(177),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_hunks.v1","schema.application.git.hunks.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"git_preview",operationId:"operation.application.git_preview",transport:{kind:"mcp_tool",toolName:"tracedecay_git_preview"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.git_preview.v1",requestSchema:{schemaId:"schema.application.git.preview.request",revision:1},resultSchema:{schemaId:"schema.application.git.preview.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(178),decodeResult:S1(179)},{operation:"application_git_status",operationId:"operation.application.git_status",transport:{kind:"http",route:"/application/git/status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_status.v1",requestSchema:{schemaId:"schema.application.git.status.request",revision:1},resultSchema:{schemaId:"schema.application.git.status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(180),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_status.v1","schema.application.git.status.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"application_github_stack_signal_expand",operationId:"operation.application.github_stack_signal_expand",transport:{kind:"http",route:"/application/github-stack/signal-expand",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.github_stack_signal_expand.v1",requestSchema:{schemaId:"schema.application.github-stack.signal-expand.request",revision:1},resultSchema:{schemaId:"schema.application.github-stack.signal-expand.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(181),decodeResult:S1(182),decodeSuccess:e=>fp(e,"binding.http.github_stack_signal_expand.v1","schema.application.github-stack.signal-expand.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(182))},{operation:"god_class",operationId:"operation.application.god_class",transport:{kind:"mcp_tool",toolName:"tracedecay_god_class"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.god_class.v1",requestSchema:{schemaId:"schema.application.primitive.god-class.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.god-class.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(183),decodeResult:S1(184)},{operation:"grep",operationId:"operation.application.grep",transport:{kind:"mcp_tool",toolName:"tracedecay_grep"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.grep.v1",requestSchema:{schemaId:"schema.application.primitive.grep.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.grep.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(185),decodeResult:S1(186)},{operation:"health",operationId:"operation.application.health",transport:{kind:"mcp_tool",toolName:"tracedecay_health"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.health.v1",requestSchema:{schemaId:"schema.application.primitive.health.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.health.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(187),decodeResult:S1(188)},{operation:"application_health_delta",operationId:"operation.application.health_delta",transport:{kind:"http",route:"/application/primitives/health_delta",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.health_delta.v1",requestSchema:{schemaId:"schema.application.primitive.health-delta.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.health-delta.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(189),decodeResult:S1(190),decodeSuccess:e=>fp(e,"binding.http.health_delta.v1","schema.application.primitive.health-delta.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(190))},{operation:"application_health_read",operationId:"operation.application.health_read",transport:{kind:"http",route:"/application/primitives/health_read",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.health_read.v1",requestSchema:{schemaId:"schema.application.primitive.health-read.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.health-read.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(191),decodeResult:S1(192),decodeSuccess:e=>fp(e,"binding.http.health_read.v1","schema.application.primitive.health-read.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(192))},{operation:"hermes_skill_bridge",operationId:"operation.application.hermes_skill_bridge",transport:{kind:"mcp_tool",toolName:"tracedecay_hermes_skill_bridge"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.hermes_skill_bridge.v1",requestSchema:{schemaId:"schema.application.primitive.hermes-skill-bridge.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.hermes-skill-bridge.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(193),decodeResult:S1(194)},{operation:"hook_runtime",operationId:"operation.application.hook_runtime",transport:{kind:"mcp_tool",toolName:"tracedecay_hook_runtime"},effect:"records_host_evidence",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.hook_runtime.v1",requestSchema:{schemaId:"schema.application.primitive.hook-runtime.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.hook-runtime.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","unavailable","partial"],decodeRequest:S1(195),decodeResult:S1(196)},{operation:"hotspots",operationId:"operation.application.hotspots",transport:{kind:"mcp_tool",toolName:"tracedecay_hotspots"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.hotspots.v1",requestSchema:{schemaId:"schema.application.primitive.hotspots.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.hotspots.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(197),decodeResult:S1(198)},{operation:"impact",operationId:"operation.application.impact",transport:{kind:"mcp_tool",toolName:"tracedecay_impact"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.impact.v1",requestSchema:{schemaId:"schema.application.primitive.impact.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.impact.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(199),decodeResult:S1(200)},{operation:"inheritance_depth",operationId:"operation.application.inheritance_depth",transport:{kind:"mcp_tool",toolName:"tracedecay_inheritance_depth"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.inheritance_depth.v1",requestSchema:{schemaId:"schema.application.primitive.inheritance-depth.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.inheritance-depth.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(201),decodeResult:S1(202)},{operation:"insert_at",operationId:"operation.application.insert_at",transport:{kind:"mcp_tool",toolName:"tracedecay_insert_at"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.insert_at.v1",requestSchema:{schemaId:"schema.application.source-edit.insert-at.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.insert-at.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(203),decodeResult:S1(18)},{operation:"insert_at_symbol",operationId:"operation.application.insert_at_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_insert_at_symbol"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.insert_at_symbol.v1",requestSchema:{schemaId:"schema.application.source-edit.insert-at-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.insert-at-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(204),decodeResult:S1(18)},{operation:"largest",operationId:"operation.application.largest",transport:{kind:"mcp_tool",toolName:"tracedecay_largest"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.largest.v1",requestSchema:{schemaId:"schema.application.primitive.largest.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.largest.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(205),decodeResult:S1(206)},{operation:"application_lcm_describe",operationId:"operation.application.lcm_describe",transport:{kind:"http",route:"/application/retained/lcm_describe",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_describe.v1",requestSchema:{schemaId:"schema.application.retained.lcm-describe.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-describe.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(207),decodeResult:S1(208),decodeSuccess:e=>fp(e,"binding.http.lcm_describe.v1","schema.application.retained.lcm-describe.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(208))},{operation:"application_lcm_doctor",operationId:"operation.application.lcm_doctor",transport:{kind:"http",route:"/application/retained/lcm_doctor",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_doctor.v1",requestSchema:{schemaId:"schema.application.retained.lcm-doctor.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-doctor.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(209),decodeResult:S1(210),decodeSuccess:e=>fp(e,"binding.http.lcm_doctor.v1","schema.application.retained.lcm-doctor.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(210))},{operation:"application_lcm_expand",operationId:"operation.application.lcm_expand",transport:{kind:"http",route:"/application/retained/lcm_expand",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_expand.v1",requestSchema:{schemaId:"schema.application.retained.lcm-expand.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-expand.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(211),decodeResult:S1(212),decodeSuccess:e=>fp(e,"binding.http.lcm_expand.v1","schema.application.retained.lcm-expand.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(212))},{operation:"application_lcm_expand_query",operationId:"operation.application.lcm_expand_query",transport:{kind:"http",route:"/application/retained/lcm_expand_query",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_expand_query.v1",requestSchema:{schemaId:"schema.application.retained.lcm-expand-query.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-expand-query.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(213),decodeResult:S1(214),decodeSuccess:e=>fp(e,"binding.http.lcm_expand_query.v1","schema.application.retained.lcm-expand-query.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(214))},{operation:"application_lcm_grep",operationId:"operation.application.lcm_grep",transport:{kind:"http",route:"/application/retained/lcm_grep",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_grep.v1",requestSchema:{schemaId:"schema.application.retained.lcm-grep.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-grep.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(215),decodeResult:S1(216),decodeSuccess:e=>fp(e,"binding.http.lcm_grep.v1","schema.application.retained.lcm-grep.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(216))},{operation:"application_lcm_load_session",operationId:"operation.application.lcm_load_session",transport:{kind:"http",route:"/application/retained/lcm_load_session",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_load_session.v1",requestSchema:{schemaId:"schema.application.retained.lcm-load-session.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-load-session.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(217),decodeResult:S1(218),decodeSuccess:e=>fp(e,"binding.http.lcm_load_session.v1","schema.application.retained.lcm-load-session.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(218))},{operation:"application_lcm_status",operationId:"operation.application.lcm_status",transport:{kind:"http",route:"/application/retained/lcm_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_status.v1",requestSchema:{schemaId:"schema.application.retained.lcm-status.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(219),decodeResult:S1(220),decodeSuccess:e=>fp(e,"binding.http.lcm_status.v1","schema.application.retained.lcm-status.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(220))},{operation:"application_memory_status",operationId:"operation.application.memory_status",transport:{kind:"http",route:"/application/retained/memory_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.memory_status.v1",requestSchema:{schemaId:"schema.application.retained.memory-status.request",revision:1},resultSchema:{schemaId:"schema.application.retained.memory-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(221),decodeResult:S1(222),decodeSuccess:e=>fp(e,"binding.http.memory_status.v1","schema.application.retained.memory-status.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(222))},{operation:"application_message_search",operationId:"operation.application.message_search",transport:{kind:"http",route:"/application/retained/message_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.message_search.v1",requestSchema:{schemaId:"schema.application.retained.message-search.request",revision:1},resultSchema:{schemaId:"schema.application.retained.message-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(223),decodeResult:S1(224),decodeSuccess:e=>fp(e,"binding.http.message_search.v1","schema.application.retained.message-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(224))},{operation:"application_module_api",operationId:"operation.application.module_api",transport:{kind:"http",route:"/application/primitives/module_api",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.module_api.v1",requestSchema:{schemaId:"schema.application.primitive.module-api.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.module-api.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(225),decodeResult:S1(226),decodeSuccess:e=>fp(e,"binding.http.module_api.v1","schema.application.primitive.module-api.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(226))},{operation:"move_symbol",operationId:"operation.application.move_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_move_symbol"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.move_symbol.v1",requestSchema:{schemaId:"schema.application.source-edit.move-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.move-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(227),decodeResult:S1(18)},{operation:"multi_str_replace",operationId:"operation.application.multi_str_replace",transport:{kind:"mcp_tool",toolName:"tracedecay_multi_str_replace"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.multi_str_replace.v1",requestSchema:{schemaId:"schema.application.source-edit.multi-str-replace.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.multi-str-replace.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(228),decodeResult:S1(18)},{operation:"native_integration_status",operationId:"operation.application.native_integration_status",transport:{kind:"mcp_tool",toolName:"tracedecay_native_integration_status"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.native_integration_status.v1",requestSchema:{schemaId:"schema.application.native-integration.status.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(229),decodeResult:S1(15)},{operation:"node",operationId:"operation.application.node",transport:{kind:"mcp_tool",toolName:"tracedecay_node"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.node.v1",requestSchema:{schemaId:"schema.application.primitive.node.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.node.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(230),decodeResult:S1(231)},{operation:"observatory_read",operationId:"operation.application.observatory_read",transport:{kind:"mcp_tool",toolName:"tracedecay_observatory_read"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.observatory_read.v1",requestSchema:{schemaId:"schema.application.observatory-read.request",revision:1},resultSchema:{schemaId:"schema.application.observatory-read.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(232),decodeResult:S1(233)},{operation:"port_order",operationId:"operation.application.port_order",transport:{kind:"mcp_tool",toolName:"tracedecay_port_order"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.port_order.v1",requestSchema:{schemaId:"schema.application.primitive.port-order.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.port-order.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(234),decodeResult:S1(235)},{operation:"port_status",operationId:"operation.application.port_status",transport:{kind:"mcp_tool",toolName:"tracedecay_port_status"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.port_status.v1",requestSchema:{schemaId:"schema.application.primitive.port-status.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.port-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(236),decodeResult:S1(237)},{operation:"pr_context",operationId:"operation.application.pr_context",transport:{kind:"mcp_tool",toolName:"tracedecay_pr_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.pr_context.v1",requestSchema:{schemaId:"schema.application.primitive.pr-context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.pr-context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(238),decodeResult:S1(239)},{operation:"preflight_native_integration",operationId:"operation.application.preflight_native_integration",transport:{kind:"mcp_tool",toolName:"tracedecay_preflight_native_integration"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.preflight_native_integration.v1",requestSchema:{schemaId:"schema.application.native-integration.preflight.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.preflight.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(240),decodeResult:S1(15)},{operation:"project_context",operationId:"operation.application.project_context",transport:{kind:"mcp_tool",toolName:"tracedecay_project_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.project_context.v1",requestSchema:{schemaId:"schema.application.primitive.project-context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.project-context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(241),decodeResult:S1(242)},{operation:"project_list",operationId:"operation.application.project_list",transport:{kind:"mcp_tool",toolName:"tracedecay_project_list"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.project_list.v1",requestSchema:{schemaId:"schema.application.primitive.project-list.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.project-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(243),decodeResult:S1(244)},{operation:"project_search",operationId:"operation.application.project_search",transport:{kind:"mcp_tool",toolName:"tracedecay_project_search"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.project_search.v1",requestSchema:{schemaId:"schema.application.primitive.project-search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.project-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(245),decodeResult:S1(244)},{operation:"application_qualified_name",operationId:"operation.application.qualified_name",transport:{kind:"http",route:"/application/primitives/qualified_name",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.qualified_name.v1",requestSchema:{schemaId:"schema.application.primitive.qualified-name.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.qualified-name.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(246),decodeResult:S1(247),decodeSuccess:e=>fp(e,"binding.http.qualified_name.v1","schema.application.primitive.qualified-name.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(247))},{operation:"rank",operationId:"operation.application.rank",transport:{kind:"mcp_tool",toolName:"tracedecay_rank"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.rank.v1",requestSchema:{schemaId:"schema.application.primitive.rank.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.rank.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(248),decodeResult:S1(249)},{operation:"recursion",operationId:"operation.application.recursion",transport:{kind:"mcp_tool",toolName:"tracedecay_recursion"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.recursion.v1",requestSchema:{schemaId:"schema.application.primitive.recursion.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.recursion.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(250),decodeResult:S1(251)},{operation:"redundancy",operationId:"operation.application.redundancy",transport:{kind:"mcp_tool",toolName:"tracedecay_redundancy"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.redundancy.v1",requestSchema:{schemaId:"schema.application.primitive.redundancy.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.redundancy.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(252),decodeResult:S1(253)},{operation:"remote_status",operationId:"operation.application.remote_status",transport:{kind:"mcp_tool",toolName:"tracedecay_remote_status"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.remote_status.v1",requestSchema:{schemaId:"schema.application.primitive.remote-status.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.remote-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(254),decodeResult:S1(255)},{operation:"rename_preview",operationId:"operation.application.rename_preview",transport:{kind:"mcp_tool",toolName:"tracedecay_rename_preview"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.rename_preview.v1",requestSchema:{schemaId:"schema.application.primitive.rename-preview.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.rename-preview.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(256),decodeResult:S1(257)},{operation:"rename_symbol",operationId:"operation.application.rename_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_rename_symbol"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.rename_symbol.v1",requestSchema:{schemaId:"schema.application.source-edit.rename-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.rename-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(258),decodeResult:S1(18)},{operation:"replace_symbol",operationId:"operation.application.replace_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_replace_symbol"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.replace_symbol.v1",requestSchema:{schemaId:"schema.application.source-edit.replace-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.replace-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(259),decodeResult:S1(18)},{operation:"retrieve",operationId:"operation.application.retrieve",transport:{kind:"mcp_tool",toolName:"tracedecay_retrieve"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.retrieve.v1",requestSchema:{schemaId:"schema.application.primitive.retrieve.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.retrieve.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(260),decodeResult:S1(261)},{operation:"run_affected_tests",operationId:"operation.application.run_affected_tests",transport:{kind:"mcp_tool",toolName:"tracedecay_run_affected_tests"},effect:"spawns_process",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.run_affected_tests.v1",requestSchema:{schemaId:"schema.application.primitive.run-affected-tests.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.run-affected-tests.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","effect_in_flight"]},deadline:{behavior:"return_operation_receipt",maximum_millis:6e5},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(262),decodeResult:S1(263)},{operation:"runtime",operationId:"operation.application.runtime",transport:{kind:"mcp_tool",toolName:"tracedecay_runtime"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.runtime.v1",requestSchema:{schemaId:"schema.application.primitive.runtime.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.runtime.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(264),decodeResult:S1(265)},{operation:"search",operationId:"operation.application.search",transport:{kind:"mcp_tool",toolName:"tracedecay_search"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.search.v1",requestSchema:{schemaId:"schema.application.primitive.search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(266),decodeResult:S1(267)},{operation:"session_lookup",operationId:"operation.application.session_lookup",transport:{kind:"mcp_tool",toolName:"tracedecay_session_lookup"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.session_lookup.v1",requestSchema:{schemaId:"schema.application.primitive.session-lookup.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.session-lookup.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(268),decodeResult:S1(269)},{operation:"application_session_refresh_begin",operationId:"operation.application.session_refresh_begin",transport:{kind:"http",route:"/application/retained/session_refresh_begin",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.session_refresh_begin.v1",requestSchema:{schemaId:"schema.application.retained.session-refresh-begin.request",revision:1},resultSchema:{schemaId:"schema.application.retained.session-refresh-begin.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(270),decodeResult:S1(271),decodeSuccess:e=>fp(e,"binding.http.session_refresh_begin.v1","schema.application.retained.session-refresh-begin.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(271))},{operation:"application_session_refresh_cancel",operationId:"operation.application.session_refresh_cancel",transport:{kind:"http",route:"/application/retained/session_refresh_cancel",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.session_refresh_cancel.v1",requestSchema:{schemaId:"schema.application.retained.session-refresh-cancel.request",revision:1},resultSchema:{schemaId:"schema.application.retained.session-refresh-cancel.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(270),decodeResult:S1(272),decodeSuccess:e=>fp(e,"binding.http.session_refresh_cancel.v1","schema.application.retained.session-refresh-cancel.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(272))},{operation:"application_session_refresh_status",operationId:"operation.application.session_refresh_status",transport:{kind:"http",route:"/application/retained/session_refresh_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.session_refresh_status.v1",requestSchema:{schemaId:"schema.application.retained.session-refresh-status.request",revision:1},resultSchema:{schemaId:"schema.application.retained.session-refresh-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(270),decodeResult:S1(273),decodeSuccess:e=>fp(e,"binding.http.session_refresh_status.v1","schema.application.retained.session-refresh-status.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(273))},{operation:"application_sessions_for",operationId:"operation.application.sessions_for",transport:{kind:"http",route:"/application/retained/sessions_for",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.sessions_for.v1",requestSchema:{schemaId:"schema.application.retained.sessions-for.request",revision:1},resultSchema:{schemaId:"schema.application.retained.sessions-for.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(274),decodeResult:S1(275),decodeSuccess:e=>fp(e,"binding.http.sessions_for.v1","schema.application.retained.sessions-for.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(275))},{operation:"signature",operationId:"operation.application.signature",transport:{kind:"mcp_tool",toolName:"tracedecay_signature"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.signature.v1",requestSchema:{schemaId:"schema.application.primitive.signature.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.signature.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(112),decodeResult:S1(276)},{operation:"similar",operationId:"operation.application.similar",transport:{kind:"mcp_tool",toolName:"tracedecay_similar"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.similar.v1",requestSchema:{schemaId:"schema.application.primitive.similar.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.similar.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(277),decodeResult:S1(278)},{operation:"skill_list",operationId:"operation.application.skill_list",transport:{kind:"mcp_tool",toolName:"tracedecay_skill_list"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.skill_list.v1",requestSchema:{schemaId:"schema.application.primitive.skill-list.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.skill-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(279),decodeResult:S1(280)},{operation:"skill_view",operationId:"operation.application.skill_view",transport:{kind:"mcp_tool",toolName:"tracedecay_skill_view"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.skill_view.v1",requestSchema:{schemaId:"schema.application.primitive.skill-view.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.skill-view.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(281),decodeResult:S1(282)},{operation:"application_source_body",operationId:"operation.application.source_body",transport:{kind:"http",route:"/application/primitives/source_body",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.source_body.v1",requestSchema:{schemaId:"schema.application.primitive.source-body.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.source-body.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(283),decodeResult:S1(284),decodeSuccess:e=>fp(e,"binding.http.source_body.v1","schema.application.primitive.source-body.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(284))},{operation:"source_edit_reconcile",operationId:"operation.application.source_edit_reconcile",transport:{kind:"mcp_tool",toolName:"tracedecay_source_edit_reconcile"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.source_edit_reconcile.v1",requestSchema:{schemaId:"schema.application.source-edit.reconcile.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.reconcile.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(285),decodeResult:S1(18)},{operation:"application_source_lines",operationId:"operation.application.source_lines",transport:{kind:"http",route:"/application/primitives/source_lines",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.source_lines.v1",requestSchema:{schemaId:"schema.application.primitive.source-lines.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.source-lines.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(286),decodeResult:S1(287),decodeSuccess:e=>fp(e,"binding.http.source_lines.v1","schema.application.primitive.source-lines.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(287))},{operation:"application_source_outline",operationId:"operation.application.source_outline",transport:{kind:"http",route:"/application/primitives/source_outline",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.source_outline.v1",requestSchema:{schemaId:"schema.application.primitive.source-outline.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.source-outline.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(288),decodeResult:S1(289),decodeSuccess:e=>fp(e,"binding.http.source_outline.v1","schema.application.primitive.source-outline.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(289))},{operation:"stack_snapshot",operationId:"operation.application.stack_snapshot",transport:{kind:"mcp_tool",toolName:"tracedecay_stack_snapshot"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.stack_snapshot.v1",requestSchema:{schemaId:"schema.application.native-integration.stack-snapshot.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.stack-snapshot.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(290),decodeResult:S1(15)},{operation:"status",operationId:"operation.application.status",transport:{kind:"mcp_tool",toolName:"tracedecay_status"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.status.v1",requestSchema:{schemaId:"schema.application.primitive.status.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(291),decodeResult:S1(292)},{operation:"application_storage_status",operationId:"operation.application.storage_status",transport:{kind:"http",route:"/application/primitives/storage_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.storage_status.v1",requestSchema:{schemaId:"schema.application.primitive.storage-status.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.storage-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(293),decodeResult:S1(294),decodeSuccess:e=>fp(e,"binding.http.storage_status.v1","schema.application.primitive.storage-status.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(294))},{operation:"str_replace",operationId:"operation.application.str_replace",transport:{kind:"mcp_tool",toolName:"tracedecay_str_replace"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.str_replace.v1",requestSchema:{schemaId:"schema.application.source-edit.str-replace.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.str-replace.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(295),decodeResult:S1(18)},{operation:"test_map",operationId:"operation.application.test_map",transport:{kind:"mcp_tool",toolName:"tracedecay_test_map"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.test_map.v1",requestSchema:{schemaId:"schema.application.primitive.test-map.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.test-map.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(296),decodeResult:S1(297)},{operation:"application_test_results",operationId:"operation.application.test_results",transport:{kind:"http",route:"/application/tests/results",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.test_results.v1",requestSchema:{schemaId:"schema.application.feedback.test-results.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.test-results.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(298),decodeResult:S1(299),decodeSuccess:e=>fp(e,"binding.http.test_results.v1","schema.application.feedback.test-results.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(299))},{operation:"test_risk",operationId:"operation.application.test_risk",transport:{kind:"mcp_tool",toolName:"tracedecay_test_risk"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.test_risk.v1",requestSchema:{schemaId:"schema.application.primitive.test-risk.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.test-risk.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(300),decodeResult:S1(301)},{operation:"todos",operationId:"operation.application.todos",transport:{kind:"mcp_tool",toolName:"tracedecay_todos"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.todos.v1",requestSchema:{schemaId:"schema.application.primitive.todos.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.todos.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(302),decodeResult:S1(303)},{operation:"unmounted_files",operationId:"operation.application.unmounted_files",transport:{kind:"mcp_tool",toolName:"tracedecay_unmounted_files"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.unmounted_files.v1",requestSchema:{schemaId:"schema.application.primitive.unmounted-files.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.unmounted-files.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(304),decodeResult:S1(305)},{operation:"unsafe_patterns",operationId:"operation.application.unsafe_patterns",transport:{kind:"mcp_tool",toolName:"tracedecay_unsafe_patterns"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.unsafe_patterns.v1",requestSchema:{schemaId:"schema.application.primitive.unsafe-patterns.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.unsafe-patterns.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(306),decodeResult:S1(307)},{operation:"application_workflows",operationId:"operation.application.workflows",transport:{kind:"http",route:"/application/retained/workflows",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflows.v1",requestSchema:{schemaId:"schema.application.retained.workflows.request",revision:1},resultSchema:{schemaId:"schema.application.retained.workflows.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(308),decodeResult:S1(309),decodeSuccess:e=>fp(e,"binding.http.workflows.v1","schema.application.retained.workflows.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(309))},{operation:"application_worktree_cleanup_confirm",operationId:"operation.application.worktree_cleanup_confirm",transport:{kind:"http",route:"/application/native-integration/worktree_cleanup_confirm",method:"POST"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_cleanup_confirm.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-confirm.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-confirm.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(310),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_cleanup_confirm.v1","schema.application.native-integration.worktree-cleanup-confirm.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(15))},{operation:"application_worktree_cleanup_inspect",operationId:"operation.application.worktree_cleanup_inspect",transport:{kind:"http",route:"/application/native-integration/worktree_cleanup_inspect",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_cleanup_inspect.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-inspect.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-inspect.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(311),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_cleanup_inspect.v1","schema.application.native-integration.worktree-cleanup-inspect.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(15))},{operation:"application_worktree_cleanup_reconcile",operationId:"operation.application.worktree_cleanup_reconcile",transport:{kind:"http",route:"/application/native-integration/worktree_cleanup_reconcile",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_cleanup_reconcile.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-reconcile.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-reconcile.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(312),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_cleanup_reconcile.v1","schema.application.native-integration.worktree-cleanup-reconcile.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(15))},{operation:"application_worktree_cleanup_remove",operationId:"operation.application.worktree_cleanup_remove",transport:{kind:"http",route:"/application/native-integration/worktree_cleanup_remove",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_cleanup_remove.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-remove.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-remove.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(313),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_cleanup_remove.v1","schema.application.native-integration.worktree-cleanup-remove.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(15))},{operation:"application_worktree_inventory",operationId:"operation.application.worktree_inventory",transport:{kind:"http",route:"/application/native-integration/worktree_inventory",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_inventory.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-inventory.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-inventory.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(314),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_inventory.v1","schema.application.native-integration.worktree-inventory.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(15))},{operation:"handoff_issue_task_handoff",operationId:"operation.handoff.issue_task_handoff",transport:{kind:"http",route:"/application/handoff/issue-task",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.handoff.issue_task_handoff",requestSchema:{schemaId:"schema.handoff.issue_task_handoff.request",revision:1},resultSchema:{schemaId:"schema.handoff.issue_task_handoff.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(315),decodeResult:S1(316),decodeSuccess:e=>fp(e,"binding.http.handoff.issue_task_handoff","schema.handoff.issue_task_handoff.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(316))},{operation:"handoff_list_task_handoffs",operationId:"operation.handoff.list_task_handoffs",transport:{kind:"http",route:"/application/handoff/list-task",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.handoff.list_task_handoffs",requestSchema:{schemaId:"schema.handoff.list_task_handoffs.request",revision:1},resultSchema:{schemaId:"schema.handoff.list_task_handoffs.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","partial"],decodeRequest:S1(317),decodeResult:S1(318),decodeSuccess:e=>fp(e,"binding.http.handoff.list_task_handoffs","schema.handoff.list_task_handoffs.result",1,["completed","timed_out","failed","partial"],{mode:"not_cancellable"},"operation","not_required",S1(318))},{operation:"handoff_open_investigation_handoff",operationId:"operation.handoff.open_investigation_handoff",transport:{kind:"http",route:"/application/handoff/open-investigation",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.handoff.open_investigation_handoff",requestSchema:{schemaId:"schema.handoff.open_investigation_handoff.request",revision:1},resultSchema:{schemaId:"schema.handoff.open_investigation_handoff.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(319),decodeResult:S1(320),decodeSuccess:e=>fp(e,"binding.http.handoff.open_investigation_handoff","schema.handoff.open_investigation_handoff.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(320))},{operation:"handoff_open_task_handoff",operationId:"operation.handoff.open_task_handoff",transport:{kind:"http",route:"/application/handoff/open-task",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.handoff.open_task_handoff",requestSchema:{schemaId:"schema.handoff.open_task_handoff.request",revision:1},resultSchema:{schemaId:"schema.handoff.open_task_handoff.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(321),decodeResult:S1(322),decodeSuccess:e=>fp(e,"binding.http.handoff.open_task_handoff","schema.handoff.open_task_handoff.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(322))},{operation:"multi_root_execute",operationId:"operation.multi_root.execute",transport:{kind:"http",route:"/application/multi-root/execute",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.multi_root.execute.v1",requestSchema:{schemaId:"schema.tracedecay.multi-root.execute-request.v1",revision:1},resultSchema:{schemaId:"schema.tracedecay.multi-root.execute-result.v1",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(323),decodeResult:S1(324),decodeSuccess:e=>fp(e,"binding.http.multi_root.execute.v1","schema.tracedecay.multi-root.execute-result.v1",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(324))},{operation:"multi_root_scope_set_compare_and_swap",operationId:"operation.multi_root.scope_set_compare_and_swap",transport:{kind:"http",route:"/application/multi-root/scope-set/compare-and-swap",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.multi_root.scope_set_compare_and_swap.v1",requestSchema:{schemaId:"schema.tracedecay.multi-root.scope-set-compare-and-swap-request.v1",revision:1},resultSchema:{schemaId:"schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(325),decodeResult:S1(326),decodeSuccess:e=>fp(e,"binding.http.multi_root.scope_set_compare_and_swap.v1","schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(326))},{operation:"multi_root_scope_set_read",operationId:"operation.multi_root.scope_set_read",transport:{kind:"http",route:"/application/multi-root/scope-set/read",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.multi_root.scope_set_read.v1",requestSchema:{schemaId:"schema.tracedecay.multi-root.scope-set-read-request.v1",revision:1},resultSchema:{schemaId:"schema.tracedecay.multi-root.scope-set-read-result.v1",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(327),decodeResult:S1(328),decodeSuccess:e=>fp(e,"binding.http.multi_root.scope_set_read.v1","schema.tracedecay.multi-root.scope-set-read-result.v1",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(328))},{operation:"work_accept_proposal",operationId:"operation.work.accept_proposal",transport:{kind:"http",route:"/application/work/accept-proposal",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.accept_proposal",requestSchema:{schemaId:"schema.work.accept_proposal.request",revision:1},resultSchema:{schemaId:"schema.work.accept_proposal.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(329),decodeResult:S1(330),decodeSuccess:e=>fp(e,"binding.http.work.accept_proposal","schema.work.accept_proposal.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(330))},{operation:"work_adjudicate_duplicate",operationId:"operation.work.adjudicate_duplicate",transport:{kind:"http",route:"/application/work/adjudicate-duplicate",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.adjudicate_duplicate",requestSchema:{schemaId:"schema.work.adjudicate_duplicate.request",revision:1},resultSchema:{schemaId:"schema.work.adjudicate_duplicate.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(331),decodeResult:S1(332),decodeSuccess:e=>fp(e,"binding.http.work.adjudicate_duplicate","schema.work.adjudicate_duplicate.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(332))},{operation:"work_adjudicate_leak",operationId:"operation.work.adjudicate_leak",transport:{kind:"http",route:"/application/work/adjudicate-leak",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.adjudicate_leak",requestSchema:{schemaId:"schema.work.adjudicate_leak.request",revision:1},resultSchema:{schemaId:"schema.work.adjudicate_leak.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(333),decodeResult:S1(334),decodeSuccess:e=>fp(e,"binding.http.work.adjudicate_leak","schema.work.adjudicate_leak.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(334))},{operation:"work_admit_execution",operationId:"operation.work.admit_execution",transport:{kind:"http",route:"/application/work/admit-execution",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.admit_execution",requestSchema:{schemaId:"schema.work.admit_execution.request",revision:1},resultSchema:{schemaId:"schema.work.admit_execution.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(335),decodeResult:S1(336),decodeSuccess:e=>fp(e,"binding.http.work.admit_execution","schema.work.admit_execution.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(336))},{operation:"work_admit_placement",operationId:"operation.work.admit_placement",transport:{kind:"http",route:"/application/work/admit-placement",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.admit_placement",requestSchema:{schemaId:"schema.work.admit_placement.request",revision:1},resultSchema:{schemaId:"schema.work.admit_placement.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(337),decodeResult:S1(338),decodeSuccess:e=>fp(e,"binding.http.work.admit_placement","schema.work.admit_placement.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(338))},{operation:"work_advance_job",operationId:"operation.work.advance_job",transport:{kind:"http",route:"/application/work/advance-job",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.advance_job",requestSchema:{schemaId:"schema.work.advance_job.request",revision:1},resultSchema:{schemaId:"schema.work.advance_job.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(339),decodeResult:S1(340),decodeSuccess:e=>fp(e,"binding.http.work.advance_job","schema.work.advance_job.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(340))},{operation:"work_attempt_status",operationId:"operation.work.attempt_status",transport:{kind:"http",route:"/application/work/attempt-status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.attempt_status",requestSchema:{schemaId:"schema.work.attempt_status.request",revision:1},resultSchema:{schemaId:"schema.work.attempt_status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(341),decodeResult:S1(342),decodeSuccess:e=>fp(e,"binding.http.work.attempt_status","schema.work.attempt_status.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(342))},{operation:"work_cancel_attempt",operationId:"operation.work.cancel_attempt",transport:{kind:"http",route:"/application/work/cancel-attempt",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.cancel_attempt",requestSchema:{schemaId:"schema.work.cancel_attempt.request",revision:1},resultSchema:{schemaId:"schema.work.cancel_attempt.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(343),decodeResult:S1(342),decodeSuccess:e=>fp(e,"binding.http.work.cancel_attempt","schema.work.cancel_attempt.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(342))},{operation:"work_compare_proposal",operationId:"operation.work.compare_proposal",transport:{kind:"http",route:"/application/work/compare-proposal",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.compare_proposal",requestSchema:{schemaId:"schema.work.compare_proposal.request",revision:1},resultSchema:{schemaId:"schema.work.compare_proposal.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(344),decodeResult:S1(345),decodeSuccess:e=>fp(e,"binding.http.work.compare_proposal","schema.work.compare_proposal.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(345))},{operation:"work_create",operationId:"operation.work.create",transport:{kind:"http",route:"/application/work/create",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.create",requestSchema:{schemaId:"schema.work.create.request",revision:1},resultSchema:{schemaId:"schema.work.create.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(346),decodeResult:S1(330),decodeSuccess:e=>fp(e,"binding.http.work.create","schema.work.create.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(330))},{operation:"work_execution_history",operationId:"operation.work.execution_history",transport:{kind:"http",route:"/application/work/execution-history",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.execution_history",requestSchema:{schemaId:"schema.work.execution_history.request",revision:1},resultSchema:{schemaId:"schema.work.execution_history.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(347),decodeResult:S1(348),decodeSuccess:e=>fp(e,"binding.http.work.execution_history","schema.work.execution_history.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(348))},{operation:"work_experience",operationId:"operation.work.experience",transport:{kind:"http",route:"/application/work/experience",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.experience",requestSchema:{schemaId:"schema.work.experience.request",revision:1},resultSchema:{schemaId:"schema.work.experience.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(349),decodeResult:S1(350),decodeSuccess:e=>fp(e,"binding.http.work.experience","schema.work.experience.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(350))},{operation:"work_generate_proposal",operationId:"operation.work.generate_proposal",transport:{kind:"http",route:"/application/work/generate-proposal",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.generate_proposal",requestSchema:{schemaId:"schema.work.generate_proposal.request",revision:1},resultSchema:{schemaId:"schema.work.generate_proposal.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(351),decodeResult:S1(352),decodeSuccess:e=>fp(e,"binding.http.work.generate_proposal","schema.work.generate_proposal.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(352))},{operation:"work_hydrate_artifacts",operationId:"operation.work.hydrate_artifacts",transport:{kind:"http",route:"/application/work/hydrate-artifacts",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.hydrate_artifacts",requestSchema:{schemaId:"schema.work.hydrate_artifacts.request",revision:1},resultSchema:{schemaId:"schema.work.hydrate_artifacts.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(353),decodeResult:S1(354),decodeSuccess:e=>fp(e,"binding.http.work.hydrate_artifacts","schema.work.hydrate_artifacts.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(354))},{operation:"work_list_attempts",operationId:"operation.work.list_attempts",transport:{kind:"http",route:"/application/work/list-attempts",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.list_attempts",requestSchema:{schemaId:"schema.work.list_attempts.request",revision:1},resultSchema:{schemaId:"schema.work.list_attempts.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(347),decodeResult:S1(355),decodeSuccess:e=>fp(e,"binding.http.work.list_attempts","schema.work.list_attempts.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(355))},{operation:"work_mutate_graph",operationId:"operation.work.mutate_graph",transport:{kind:"http",route:"/application/work/mutate-graph",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.mutate_graph",requestSchema:{schemaId:"schema.work.mutate_graph.request",revision:1},resultSchema:{schemaId:"schema.work.mutate_graph.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(356),decodeResult:S1(330),decodeSuccess:e=>fp(e,"binding.http.work.mutate_graph","schema.work.mutate_graph.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(330))},{operation:"work_pause_run",operationId:"operation.work.pause_run",transport:{kind:"http",route:"/application/work/pause-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.pause_run",requestSchema:{schemaId:"schema.work.pause_run.request",revision:1},resultSchema:{schemaId:"schema.work.pause_run.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(357),decodeResult:S1(358),decodeSuccess:e=>fp(e,"binding.http.work.pause_run","schema.work.pause_run.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(358))},{operation:"work_placement_preflight",operationId:"operation.work.placement_preflight",transport:{kind:"http",route:"/application/work/placement-preflight",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.placement_preflight",requestSchema:{schemaId:"schema.work.placement_preflight.request",revision:1},resultSchema:{schemaId:"schema.work.placement_preflight.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(359),decodeResult:S1(360),decodeSuccess:e=>fp(e,"binding.http.work.placement_preflight","schema.work.placement_preflight.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(360))},{operation:"work_placement_status",operationId:"operation.work.placement_status",transport:{kind:"http",route:"/application/work/placement-status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.placement_status",requestSchema:{schemaId:"schema.work.placement_status.request",revision:1},resultSchema:{schemaId:"schema.work.placement_status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(361),decodeResult:S1(362),decodeSuccess:e=>fp(e,"binding.http.work.placement_status","schema.work.placement_status.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(362))},{operation:"work_prepare_duplicate_adjudication",operationId:"operation.work.prepare_duplicate_adjudication",transport:{kind:"http",route:"/application/work/prepare-duplicate-adjudication",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.prepare_duplicate_adjudication",requestSchema:{schemaId:"schema.work.prepare_duplicate_adjudication.request",revision:1},resultSchema:{schemaId:"schema.work.prepare_duplicate_adjudication.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(363),decodeResult:S1(331),decodeSuccess:e=>fp(e,"binding.http.work.prepare_duplicate_adjudication","schema.work.prepare_duplicate_adjudication.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(331))},{operation:"work_prepare_graph_mutation",operationId:"operation.work.prepare_graph_mutation",transport:{kind:"http",route:"/application/work/prepare-graph-mutation",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.prepare_graph_mutation",requestSchema:{schemaId:"schema.work.prepare_graph_mutation.request",revision:1},resultSchema:{schemaId:"schema.work.prepare_graph_mutation.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(364),decodeResult:S1(356),decodeSuccess:e=>fp(e,"binding.http.work.prepare_graph_mutation","schema.work.prepare_graph_mutation.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(356))},{operation:"work_release_placement",operationId:"operation.work.release_placement",transport:{kind:"http",route:"/application/work/release-placement",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.release_placement",requestSchema:{schemaId:"schema.work.release_placement.request",revision:1},resultSchema:{schemaId:"schema.work.release_placement.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(365),decodeResult:S1(338),decodeSuccess:e=>fp(e,"binding.http.work.release_placement","schema.work.release_placement.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(338))},{operation:"work_resume_attempts",operationId:"operation.work.resume_attempts",transport:{kind:"http",route:"/application/work/resume-attempts",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.resume_attempts",requestSchema:{schemaId:"schema.work.resume_attempts.request",revision:1},resultSchema:{schemaId:"schema.work.resume_attempts.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(366),decodeResult:S1(367),decodeSuccess:e=>fp(e,"binding.http.work.resume_attempts","schema.work.resume_attempts.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(367))},{operation:"work_resume_run",operationId:"operation.work.resume_run",transport:{kind:"http",route:"/application/work/resume-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.resume_run",requestSchema:{schemaId:"schema.work.resume_run.request",revision:1},resultSchema:{schemaId:"schema.work.resume_run.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(368),decodeResult:S1(358),decodeSuccess:e=>fp(e,"binding.http.work.resume_run","schema.work.resume_run.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(358))},{operation:"work_retrieve_evidence",operationId:"operation.work.retrieve_evidence",transport:{kind:"http",route:"/application/work/retrieve-evidence",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.retrieve_evidence",requestSchema:{schemaId:"schema.work.retrieve_evidence.request",revision:1},resultSchema:{schemaId:"schema.work.retrieve_evidence.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(369),decodeResult:S1(370),decodeSuccess:e=>fp(e,"binding.http.work.retrieve_evidence","schema.work.retrieve_evidence.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(370))},{operation:"work_retry_attempt",operationId:"operation.work.retry_attempt",transport:{kind:"http",route:"/application/work/retry-attempt",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.retry_attempt",requestSchema:{schemaId:"schema.work.retry_attempt.request",revision:1},resultSchema:{schemaId:"schema.work.retry_attempt.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(371),decodeResult:S1(372),decodeSuccess:e=>fp(e,"binding.http.work.retry_attempt","schema.work.retry_attempt.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(372))},{operation:"work_review_proposal",operationId:"operation.work.review_proposal",transport:{kind:"http",route:"/application/work/review-proposal",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.review_proposal",requestSchema:{schemaId:"schema.work.review_proposal.request",revision:1},resultSchema:{schemaId:"schema.work.review_proposal.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(373),decodeResult:S1(330),decodeSuccess:e=>fp(e,"binding.http.work.review_proposal","schema.work.review_proposal.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(330))},{operation:"work_run_control",operationId:"operation.work.run_control",transport:{kind:"http",route:"/application/work/run-control",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.run_control",requestSchema:{schemaId:"schema.work.run_control.request",revision:1},resultSchema:{schemaId:"schema.work.run_control.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(374),decodeResult:S1(375),decodeSuccess:e=>fp(e,"binding.http.work.run_control","schema.work.run_control.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(375))},{operation:"work_start_attempt",operationId:"operation.work.start_attempt",transport:{kind:"http",route:"/application/work/start-attempt",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.start_attempt",requestSchema:{schemaId:"schema.work.start_attempt.request",revision:1},resultSchema:{schemaId:"schema.work.start_attempt.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(376),decodeResult:S1(342),decodeSuccess:e=>fp(e,"binding.http.work.start_attempt","schema.work.start_attempt.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(342))},{operation:"work_synthesize",operationId:"operation.work.synthesize",transport:{kind:"http",route:"/application/work/synthesize",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.synthesize",requestSchema:{schemaId:"schema.work.synthesize.request",revision:1},resultSchema:{schemaId:"schema.work.synthesize.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(377),decodeResult:S1(378),decodeSuccess:e=>fp(e,"binding.http.work.synthesize","schema.work.synthesize.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(378))},{operation:"work_topology",operationId:"operation.work.topology",transport:{kind:"http",route:"/application/work/topology",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.topology",requestSchema:{schemaId:"schema.work.topology.request",revision:1},resultSchema:{schemaId:"schema.work.topology.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(379),decodeResult:S1(380),decodeSuccess:e=>fp(e,"binding.http.work.topology","schema.work.topology.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(380))},{operation:"work_topology_metrics",operationId:"operation.work.topology_metrics",transport:{kind:"http",route:"/application/work/topology-metrics",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.topology_metrics",requestSchema:{schemaId:"schema.work.topology_metrics.request",revision:1},resultSchema:{schemaId:"schema.work.topology_metrics.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(381),decodeResult:S1(382),decodeSuccess:e=>fp(e,"binding.http.work.topology_metrics","schema.work.topology_metrics.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(382))},{operation:"work_views",operationId:"operation.work.views",transport:{kind:"http",route:"/application/work/views",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.views",requestSchema:{schemaId:"schema.work.views.request",revision:1},resultSchema:{schemaId:"schema.work.views.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(383),decodeResult:S1(384),decodeSuccess:e=>fp(e,"binding.http.work.views","schema.work.views.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(384))},{operation:"workflow_activate_definition",operationId:"operation.workflow.activate_definition",transport:{kind:"http",route:"/application/workflow/activate-definition",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.activate_definition",requestSchema:{schemaId:"schema.workflow.activate_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.activate_definition.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(385),decodeResult:S1(386),decodeSuccess:e=>fp(e,"binding.http.workflow.activate_definition","schema.workflow.activate_definition.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(386))},{operation:"workflow_cancel_run",operationId:"operation.workflow.cancel_run",transport:{kind:"http",route:"/application/workflow/cancel-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.cancel_run",requestSchema:{schemaId:"schema.workflow.cancel_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.cancel_run.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(387),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.cancel_run","schema.workflow.cancel_run.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(388))},{operation:"workflow_definition_history",operationId:"operation.workflow.definition_history",transport:{kind:"http",route:"/application/workflow/definition-history",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.definition_history",requestSchema:{schemaId:"schema.workflow.definition_history.request",revision:1},resultSchema:{schemaId:"schema.workflow.definition_history.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(389),decodeResult:S1(390),decodeSuccess:e=>fp(e,"binding.http.workflow.definition_history","schema.workflow.definition_history.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(390))},{operation:"workflow_diff_definition",operationId:"operation.workflow.diff_definition",transport:{kind:"http",route:"/application/workflow/diff-definition",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.diff_definition",requestSchema:{schemaId:"schema.workflow.diff_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.diff_definition.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(391),decodeResult:S1(392),decodeSuccess:e=>fp(e,"binding.http.workflow.diff_definition","schema.workflow.diff_definition.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(392))},{operation:"workflow_get_definition",operationId:"operation.workflow.get_definition",transport:{kind:"http",route:"/application/workflow/get-definition",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.get_definition",requestSchema:{schemaId:"schema.workflow.get_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.get_definition.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(393),decodeResult:S1(394),decodeSuccess:e=>fp(e,"binding.http.workflow.get_definition","schema.workflow.get_definition.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(394))},{operation:"workflow_get_run",operationId:"operation.workflow.get_run",transport:{kind:"http",route:"/application/workflow/get-run",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.get_run",requestSchema:{schemaId:"schema.workflow.get_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.get_run.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(395),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.get_run","schema.workflow.get_run.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(388))},{operation:"workflow_handoff_issue",operationId:"operation.workflow.handoff_issue",transport:{kind:"http",route:"/application/workflow/handoff-issue",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.handoff_issue",requestSchema:{schemaId:"schema.workflow.handoff_issue.request",revision:1},resultSchema:{schemaId:"schema.workflow.handoff_issue.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(396),decodeResult:S1(397),decodeSuccess:e=>fp(e,"binding.http.workflow.handoff_issue","schema.workflow.handoff_issue.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(397))},{operation:"workflow_handoff_redeem",operationId:"operation.workflow.handoff_redeem",transport:{kind:"http",route:"/application/workflow/handoff-redeem",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.handoff_redeem",requestSchema:{schemaId:"schema.workflow.handoff_redeem.request",revision:1},resultSchema:{schemaId:"schema.workflow.handoff_redeem.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(398),decodeResult:S1(399),decodeSuccess:e=>fp(e,"binding.http.workflow.handoff_redeem","schema.workflow.handoff_redeem.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(399))},{operation:"workflow_list_definitions",operationId:"operation.workflow.list_definitions",transport:{kind:"http",route:"/application/workflow/list-definitions",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.list_definitions",requestSchema:{schemaId:"schema.workflow.list_definitions.request",revision:1},resultSchema:{schemaId:"schema.workflow.list_definitions.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(400),decodeResult:S1(390),decodeSuccess:e=>fp(e,"binding.http.workflow.list_definitions","schema.workflow.list_definitions.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(390))},{operation:"workflow_pause_run",operationId:"operation.workflow.pause_run",transport:{kind:"http",route:"/application/workflow/pause-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.pause_run",requestSchema:{schemaId:"schema.workflow.pause_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.pause_run.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(401),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.pause_run","schema.workflow.pause_run.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(388))},{operation:"workflow_register_definition",operationId:"operation.workflow.register_definition",transport:{kind:"http",route:"/application/workflow/register-definition",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.register_definition",requestSchema:{schemaId:"schema.workflow.register_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.register_definition.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(402),decodeResult:S1(394),decodeSuccess:e=>fp(e,"binding.http.workflow.register_definition","schema.workflow.register_definition.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(394))},{operation:"workflow_reject_definition",operationId:"operation.workflow.reject_definition",transport:{kind:"http",route:"/application/workflow/reject-definition",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.reject_definition",requestSchema:{schemaId:"schema.workflow.reject_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.reject_definition.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(403),decodeResult:S1(386),decodeSuccess:e=>fp(e,"binding.http.workflow.reject_definition","schema.workflow.reject_definition.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(386))},{operation:"workflow_resume_run",operationId:"operation.workflow.resume_run",transport:{kind:"http",route:"/application/workflow/resume-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.resume_run",requestSchema:{schemaId:"schema.workflow.resume_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.resume_run.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(404),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.resume_run","schema.workflow.resume_run.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(388))},{operation:"workflow_retire_definition",operationId:"operation.workflow.retire_definition",transport:{kind:"http",route:"/application/workflow/retire-definition",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.retire_definition",requestSchema:{schemaId:"schema.workflow.retire_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.retire_definition.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(405),decodeResult:S1(386),decodeSuccess:e=>fp(e,"binding.http.workflow.retire_definition","schema.workflow.retire_definition.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(386))},{operation:"workflow_start_run",operationId:"operation.workflow.start_run",transport:{kind:"http",route:"/application/workflow/start-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.start_run",requestSchema:{schemaId:"schema.workflow.start_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.start_run.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(406),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.start_run","schema.workflow.start_run.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(388))},{operation:"workflow_validate_definition",operationId:"operation.workflow.validate_definition",transport:{kind:"http",route:"/application/workflow/validate-definition",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.validate_definition",requestSchema:{schemaId:"schema.workflow.validate_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.validate_definition.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(407),decodeResult:S1(408),decodeSuccess:e=>fp(e,"binding.http.workflow.validate_definition","schema.workflow.validate_definition.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(408))}],S2=new TextEncoder;class S4 extends Error{cause;constructor(e,t){super(e),this.name=new.target.name,this.cause=t}}class S6 extends S4{constructor(e){super("the caller aborted the request",e)}}class S3 extends S4{}class S9 extends S4{status;constructor(e){super(401===e?"the daemon rejected HTTP authentication":"the daemon rejected the HTTP origin"),this.status=e}}class S5 extends Error{status;payload;constructor(e,t={}){super(e),this.name=new.target.name,this.status=t.status,this.payload=t.payload}}class S8 extends S5{}class S7 extends Error{status;envelope;problem;constructor(e,t){super(`${t.problem.kind}/${t.problem.code}: ${t.problem.message}`),this.name=new.target.name,this.status=e,this.envelope=t,this.problem=t.problem}}class ke extends S7{}class kt extends S7{}class kr extends S7{}class ki extends S7{}class ko extends S7{}class kn extends S7{}class ka extends S7{}class ks extends S7{}class kd extends S7{}class kc extends S7{}class kl extends S7{}let kp=new Set(["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"]),ku=new TextEncoder;function km(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function kf(e){return"number"==typeof e&&Number.isSafeInteger(e)&&e>=0}function kh(e){return"number"==typeof e&&Number.isSafeInteger(e)}function ky(e,t){return"string"==typeof e&&e.length>0&&e.trim()===e&&ku.encode(e).byteLength<=t&&!/\p{Cc}/u.test(e)}function kg(e,t){let r=e.headers.get("content-type");return null!==r&&r.split(";",1)[0]?.trim().toLowerCase()===t}function k_(e){return!!km(e)&&!!kh(e.started_at)&&!!kh(e.ended_at)&&!(e.ended_at<e.started_at)&&"effective_deadline"in e&&(null===e.cancellation||!!km(e.cancellation))&&!!km(e.budget)&&!!kf(e.budget.units_consumed)&&!!kf(e.budget.bytes_consumed)&&!!kf(e.budget.elapsed_micros)&&"string"==typeof e.termination&&("cancelled"!==e.termination&&"timed_out"!==e.termination||km(e.cancellation))}function kv(e,t){try{return JSON.parse(e)}catch(r){throw new S8("the daemon returned non-JSON data",{status:t,payload:{text:e,cause:r}})}}async function kb(e,t){if(t?.aborted)throw new S6(t.reason);await new Promise((r,i)=>{let o=setTimeout(()=>{t?.removeEventListener("abort",n),r()},e),n=()=>{clearTimeout(o),i(new S6(t?.reason))};t?.addEventListener("abort",n,{once:!0})})}async function*k$(e,t){let r,i=e.getReader(),o=new TextDecoder("utf-8",{fatal:!0}),n=new Uint8Array(65536),a=0,s=0,d=!1,c="",l=0,p=t??"",u=ku.encode(p).byteLength,m=[],f=0,h=!1,y=()=>new S8("the daemon returned an SSE line or frame exceeding 65536 bytes",{payload:{limitBytes:65536}}),g=(e,t)=>{try{return o.decode(e,{stream:t})}catch(e){throw new S8("the daemon returned malformed UTF-8 event-stream data",{payload:e})}},_=e=>{if(""===e){if(h=!1,l=0,0===m.length)return c="",null;let e={event:""===c?"message":c,id:""===p?null:p,data:m.join("\n"),...void 0===r?{}:{retryDelayMs:r}};return c="",m=[],f=0,e}if(e.startsWith(":"))return null;h=!0;let t=e.indexOf(":"),i=t<0?e:e.slice(0,t),o=t<0?"":e.slice(t+1);o.startsWith(" ")&&(o=o.slice(1));let n=ku.encode(o).byteLength;if(("event"===i||"id"===i||"data"===i)&&l+u+f+n+1>65536)throw y();switch(i){case"event":c=o,l=n;break;case"id":o.includes("\0")||(p=o,u=n);break;case"data":f+=n+ +(0!==m.length),m.push(o);break;case"retry":if(/^[0-9]+$/.test(o)){let e=BigInt(o);r=e>2147483647n?0x7fffffff:Number(e)}}return null};try{for(;;){let e=await i.read();if(e.done){g(n.subarray(0,a),!1);break}for(let t=0;t<e.value.length;t+=1){let r=e.value[t];if(d&&(d=!1,10===r)){if(65536===s)throw y();continue}if(65536===a)throw y();if(n[a++]=r,10!==r&&13!==r)continue;let i=g(n.subarray(0,a),!0).slice(0,-1);s=a,a=0,d=13===r;let o=_(i);null!==o&&(yield o)}}if(a>0||h||m.length>0)throw new S3("operation stream ended with an incomplete SSE event")}catch(e){if(e instanceof S5||e instanceof S4)throw e;throw new S3("operation stream transport was interrupted",e)}finally{i.releaseLock()}}class kS{operations;projectRoot;applicationRoot;token;origin;doFetch;mcp;constructor(e){let t=new URL(e.baseUrl);if("http:"!==t.protocol&&"https:"!==t.protocol||""!==t.username||""!==t.password||""!==t.search||""!==t.hash)throw new S5("baseUrl must be an absolute HTTP URL without credentials, query, or fragment");let r=t.toString().replace(/\/+$/u,"");this.projectRoot=`${r}/projects/${encodeURIComponent(e.projectId)}`,this.applicationRoot=`${this.projectRoot}/application`,this.token=e.token,this.origin=e.origin??t.origin,this.doFetch=e.fetch??globalThis.fetch.bind(globalThis),this.mcp=e.mcp;let i={};for(let e of S0)i[e.operation]=(t,r)=>this.#p(e,t,r);this.operations=Object.freeze(i)}headers(e){return new Headers({accept:e,authorization:`Bearer ${this.token}`,origin:this.origin})}operationUrl(e,t){if(t?.size!==void 0&&(!Number.isSafeInteger(t.size)||t.size<1||t.size>1e3))throw new S5("page size must be an integer between 1 and 1000");if(t?.cursor!==void 0&&!ky(t.cursor,4096))throw new S5("page cursor is not a canonical opaque cursor");let r=new URL(`${this.projectRoot}${e}`);return t?.size!==void 0&&r.searchParams.set("page_size",String(t.size)),t?.cursor!==void 0&&r.searchParams.set("cursor",t.cursor),r}lifecycleUrl(e,t){if(!ky(e,512))throw new S5("operationId is not a canonical request handle");return new URL(`${this.applicationRoot}/operations/${encodeURIComponent(e)}/${t}`)}async fetchResponse(e,t,r){try{return await this.doFetch(e,t)}catch(t){if(r?.aborted)throw new S6(r.reason);throw new S3(`transport failure requesting ${e.pathname}`,t)}}async readJson(e,t,r,i){let o,n,a=!1,s=()=>n??=o?.cancel(i?.reason)??e.body?.cancel(i?.reason)??Promise.resolve(),d=()=>{s().catch(()=>void 0)};try{if(i?.aborted)throw new S6(i.reason);if(401===e.status||403===e.status)throw new S9(e.status);if(!kg(e,"application/json"))throw new S8("the daemon returned JSON with an invalid media type",{status:e.status});let n="";try{if(o=e.body?.getReader(),i?.addEventListener("abort",d,{once:!0}),i?.aborted)throw new S6(i.reason);if(void 0!==o){let e=new TextDecoder;for(;;){let{done:t,value:r}=await o.read();if(i?.aborted)throw new S6(i.reason);if(t)break;n+=e.decode(r,{stream:!0})}n+=e.decode()}a=!0}catch(e){if(i?.aborted)throw new S6(i.reason);throw new S3("transport failure reading the daemon response body",e)}let s=kv(n,e.status);if(km(s)&&"problem"===s.kind){var c;let i=s.value;if(!function(e){var t,r,i;if(!fu(e)||void 0!==e.binding_id&&"string"!=typeof e.binding_id||!(fu(t=e.contract)&&fh(t.schema_id,512)&&fm(t.schema_revision)&&t.schema_revision>0)||!fh(e.request_id,512)||!fu(e.problem))return!1;let o=e.problem,n=Array.isArray(o.legal_actions)?o.legal_actions:null,a="never"===o.retry?null:"same_request"===o.retry||"after_delay"===o.retry?"same_request":"after_revalidate"===o.retry?"fresh_request":"after_reconcile"===o.retry?"same_operation":void 0;if(!(1===o.revision&&"string"==typeof o.kind&&["invalid_request","not_found_or_not_authorized","conflict","partial_effect","stale","unsupported","unavailable","execution_failed","reset_required","saturated","cancelled","timed_out"].includes(o.kind)&&"string"==typeof o.code&&"string"==typeof o.message&&(null===o.diagnostic||fg(o.diagnostic))&&"detail"in o&&(null===o.detail||function(e){if(!fu(e))return!1;switch(e.kind){case"parked":return"string"==typeof e.cause&&"string"==typeof e.remedy&&"boolean"==typeof e.retries_on_wake;case"stale_refresh_frontier":return fm(e.requested)&&fm(e.committed)&&fm(e.active);case"stale_precondition":return"string"==typeof e.field&&fm(e.requested)&&fm(e.current);case"lock_deadline":return"string"==typeof e.resource&&fm(e.deadline_ms);case"diagnostics_unsupported":return(null===e.file||"string"==typeof e.file)&&Array.isArray(e.searched)&&e.searched.every(e=>fu(e)&&"string"==typeof e.path&&"boolean"==typeof e.present);case"diagnostics_pending":return"string"==typeof e.producer&&(null===e.generation||"string"==typeof e.generation);case"code_graph_rewarming":return fm(e.retry_after_millis);case"reset_required":return"string"==typeof e.authority&&(null===e.found_version||ff(e.found_version))&&(null===e.required_version||ff(e.required_version))&&"string"==typeof e.reason&&"string"==typeof e.remedy;default:return!1}}(o.detail))&&"committed_receipt"in o&&"string"==typeof o.owning_layer&&"string"==typeof o.terminality&&"boolean"==typeof o.retryable&&"string"==typeof o.retry&&(null===o.retry_scope||"string"==typeof o.retry_scope)&&(null===o.retry_after_millis||fm(o.retry_after_millis))&&"cancellation_stage"in o&&(null===o.cancellation_stage||"string"==typeof o.cancellation_stage&&["before_admission","before_read","during_read","before_effect","effect_in_flight"].includes(o.cancellation_stage))&&"unavailable_classification"in o&&(null===o.unavailable_classification||"string"==typeof o.unavailable_classification&&["authority","backend_unavailable","backend_disconnected","backend_retryable"].includes(o.unavailable_classification))&&"execution_failure_classification"in o&&(null===o.execution_failure_classification||"string"==typeof o.execution_failure_classification&&["denied","malformed_output","permanent"].includes(o.execution_failure_classification))&&o.request_id===e.request_id&&fh(o.trace_id,512)&&Array.isArray(o.details)&&o.details.every(fg)&&null!==n&&n.every(e=>"string"==typeof e)&&"coverage"in o)||null===n)return!1;let s=null!==o.cancellation_stage&&"before_admission"!==o.cancellation_stage,d=null!==o.unavailable_classification&&"authority"!==o.unavailable_classification,c="partial_effect"===o.kind||"reset_required"===o.kind||"execution_failed"===o.kind||s||d;return o.terminality===(c?"admitted_terminal":"pre_admission")&&"unavailable"===o.kind==(null!==o.unavailable_classification)&&"execution_failed"===o.kind==(null!==o.execution_failure_classification)&&("cancelled"===o.kind||"timed_out"===o.kind)==(null!==o.cancellation_stage)&&null!==o.diagnostic===("string"==typeof o.kind&&["invalid_request","conflict","partial_effect","stale","unsupported","unavailable","execution_failed","reset_required","saturated"].includes(o.kind))&&(null===o.detail||!!("string"==typeof o.kind&&["stale","unsupported","unavailable","reset_required","saturated"].includes(o.kind)))&&o.retryable===("never"!==o.retry)&&void 0!==a&&o.retry_scope===a&&"after_delay"===o.retry==(null!==o.retry_after_millis)&&("partial_effect"===o.kind?"admitted_terminal"===o.terminality&&!1===o.retryable&&"never"===o.retry&&(r=o.committed_receipt,i=e.request_id,fu(r)&&r.request_id===i&&"partial"===r.outcome&&"string"==typeof r.operation&&"string"==typeof r.effect_class&&"string"==typeof r.idempotency_key&&"string"==typeof r.input_digest&&("string"==typeof r.committed_state||"string"==typeof r.external_proof))&&1===n.length&&"reconcile"===n[0]:"reset_required"===o.kind?"admitted_terminal"===o.terminality&&!1===o.retryable&&"never"===o.retry&&null===o.committed_receipt&&1===n.length&&"reset"===n[0]:"unavailable"===o.kind&&"authority"!==o.unavailable_classification?"admitted_terminal"===o.terminality&&!0===o.retryable&&"after_revalidate"===o.retry&&null===o.committed_receipt&&1===n.length&&"retry"===n[0]:"execution_failed"===o.kind?"admitted_terminal"===o.terminality&&!1===o.retryable&&"never"===o.retry&&null===o.committed_receipt&&1===n.length&&"contact_administrator"===n[0]:null===o.committed_receipt)}(i))throw new S8("the daemon returned a malformed problem envelope",{status:e.status,payload:i});let o=void 0===t||(c=[t],"not_found_or_not_authorized"===i.problem.kind?void 0===i.binding_id:c.some(e=>e===i.binding_id));if(e.ok||!o||void 0!==r&&i.request_id!==r||!function(e,t){switch(t){case"invalid_request":return 400===e;case"not_found_or_not_authorized":return 404===e;case"conflict":case"partial_effect":case"stale":return 409===e;case"unsupported":return 422===e;case"unavailable":case"reset_required":return 503===e;case"execution_failed":return 500===e;case"saturated":return 429===e;case"cancelled":return 408===e;case"timed_out":return 504===e;default:return!1}}(e.status,i.problem.kind))throw new S8("the daemon returned a malformed problem envelope",{status:e.status,payload:i});throw function(e,t){switch(t.problem.kind){case"not_found_or_not_authorized":return new ke(e,t);case"unavailable":return new kt(e,t);case"unsupported":return new kr(e,t);case"stale":return new ki(e,t);case"conflict":return new ko(e,t);case"partial_effect":return new kn(e,t);case"reset_required":return new ka(e,t);case"saturated":return new ks(e,t);case"cancelled":return new kd(e,t);case"timed_out":return new kc(e,t);case"invalid_request":return new kl(e,t);default:return new S7(e,t)}}(e.status,i)}return s}finally{i?.removeEventListener("abort",d);try{a||await s()}catch{}finally{o?.releaseLock()}}}async #p(e,t,r={}){var i,o,n,a;let s=e.decodeRequest(t);if("http"!==e.transport.kind){let t;if(void 0!==r.page||void 0!==r.deadlineMicros||void 0!==r.requestId)throw new S5(`${e.operation} does not accept HTTP transport options`);if(void 0===this.mcp)throw new S4(`${e.operation} requires an MCP tool adapter`);try{t=await this.mcp.callTool(e.transport.toolName,s,{signal:r.signal})}catch(t){if(r.signal?.aborted)throw new S6(r.signal.reason??t);throw new S4(`MCP tool ${e.transport.toolName} failed`,t)}try{return e.decodeResult(t)}catch(r){throw new S8(`MCP tool ${e.transport.toolName} returned an invalid ${e.operation} result`,{payload:{response:t,cause:r}})}}let d=this.operationUrl(e.transport.route,r.page),c=JSON.stringify(s);if(void 0===c)throw new S5(`${e.operation} request decoder returned a non-JSON value`);let l=this.headers("application/json");l.set("content-type","application/json");let p=(i=l,o=e,void 0!==(n=r).deadlineMicros&&(!Number.isSafeInteger(n.deadlineMicros)||n.deadlineMicros<=0)?"deadlineMicros must be a positive safe integer":"required"===o.requestIdControl&&void 0===n.requestId?`${o.operation} requires a stable requestId replay handle`:"server_minted"===o.requestIdControl&&void 0!==n.requestId?`${o.operation} uses a server-minted request ID`:void 0===n.requestId||(a=n.requestId).length>0&&a.trim()===a&&S2.encode(a).byteLength<=512&&!/\p{Cc}/u.test(a)?void(void 0!==n.deadlineMicros&&i.set("x-tracedecay-deadline-micros",String(n.deadlineMicros)),void 0!==n.requestId&&i.set("x-tracedecay-request-id",n.requestId)):"requestId is not a canonical request identity");if(void 0!==p)throw new S5(p);let u=await this.fetchResponse(d,{method:e.transport.method,headers:l,body:c,signal:r.signal},r.signal),m=await this.readJson(u,e.bindingId,r.requestId,r.signal);if(!km(m)||"success"!==m.kind)throw new S8("the daemon returned an unknown HTTP envelope",{status:u.status,payload:m});if(!u.ok)throw new S8("the daemon returned success with a failing HTTP status",{status:u.status,payload:m});try{let t=e.decodeSuccess(m.value);if(!(km(t)&&km(t.outcome)&&km(t.outcome.value)&&"payload"in t.outcome.value&&k_(t.outcome.value.execution))||("evidence"===t.outcome.outcome?"completed"===t.outcome.value.execution.termination&&null===t.outcome.value.payload:"preview"!==t.outcome.outcome&&"effect"!==t.outcome.outcome))throw TypeError("decoded application success invariants are invalid");if(void 0!==r.requestId&&t.request_id!==r.requestId)throw TypeError("daemon returned a different application request ID");if("fact_store_curate_receipt"===e.resultSemantics&&!await async function(e,t){if(!fu(e)||!fu(t)||!fu(t.outcome))return!1;let r=t.outcome,i=fu(r.value)?r.value.payload:void 0;if("effect"!==r.outcome||!fu(i)||!fh(t.request_id,512)||"request_digest,run_id,state,task"!==Object.keys(i).sort().join(",")||i.run_id!==t.request_id||"memory_curator"!==i.task||"started"!==i.state)return!1;let o=e.fact_review_limit??24,n=e.min_confidence_millionths??72e4;return!!fm(o)&&!(o<1)&&!(o>1e3)&&!!fm(n)&&!(n>1e6)&&!!await async function(e){return!!fu(e)&&"project_id,reference,repository_id,scope_digest,worktree_id"===Object.keys(e).sort().join(",")&&!!fh(e.project_id,512)&&!!fh(e.repository_id,512)&&!!fh(e.worktree_id,512)&&(null===e.reference||!!fh(e.reference,512))&&e.scope_digest===await fy(["tracedecay.application.scope.v1",e.project_id,e.repository_id,e.worktree_id,e.reference])}(t.scope)&&i.request_digest===await fy(["tracedecay.automation-run.request-identity.v1",{kind:"memory_curator",options:{fact_review_limit:o,min_confidence_millionths:n}}])}(s,t))throw TypeError("automatic curation receipt invariants are invalid");return t}catch(t){throw new S8(`the daemon returned an invalid ${e.operation} success envelope`,{status:u.status,payload:{envelope:m.value,cause:t}})}}async *streamOperation(e,t={}){let r=t.resume?.resumeToken,i=t.resume?.nextSequence===void 0?void 0:function(e,t){let r;if("number"==typeof e){if(!kf(e))throw new S5(`${t} must be an unsigned safe integer`);r=BigInt(e)}else if("bigint"==typeof e)r=e;else if(/^[0-9]+$/.test(e))r=BigInt(e);else throw new S5(`${t} must be unsigned decimal`);if(r<0n||r>0xffffffffffffffffn)throw new S5(`${t} exceeds the canonical u64 range`);return r.toString()}(t.resume.nextSequence,"resume nextSequence");if(void 0!==r&&!ky(r,4096))throw new S5("resumeToken is not a canonical stream resume token");let o=t.maxReconnects??0;if(!Number.isSafeInteger(o)||o<0)throw new S5("maxReconnects must be a non-negative integer");let n=0,a=0;for(;;){let d;if(t.signal?.aborted)throw new S6(t.signal.reason);let c=this.lifecycleUrl(e,"events");void 0!==i&&c.searchParams.set("next_sequence",i),void 0!==r&&c.searchParams.set("resume_token",r);try{d=await this.fetchResponse(c,{method:"GET",headers:this.headers("text/event-stream"),signal:t.signal},t.signal)}catch(e){if(0===n||n>=o||!(e instanceof S3))throw e;n+=1,await kb(a,t.signal);continue}let l=!1;try{if(!d.ok||null===d.body)throw await this.readJson(d,void 0,void 0,t.signal),new S8("the daemon did not open an SSE stream",{status:d.status});if(!kg(d,"text/event-stream"))throw new S8("the daemon opened an operation stream with an invalid media type",{status:d.status});try{for await(let t of k$(d.body)){void 0!==t.retryDelayMs&&(a=t.retryDelayMs);let o=function(e,t,r){let i=kv(e.data,t);if(!km(i)||"string"!=typeof i.event||i.event!==e.event||!km(i.data))throw new S8("the daemon returned a malformed SSE event",{status:t,payload:i});let o=i.event,n=i.data;if("open"===o){let e=n.frontier;if(n.correlation_id!==r||!km(e)||!kf(e.next_sequence)||!kf(e.retained_from_sequence)||e.retained_from_sequence>e.next_sequence||null!==e.resume_token&&"string"!=typeof e.resume_token)throw new S8("the daemon returned a malformed SSE open frontier",{status:t,payload:i});return{event:{...i,event:o,data:n},frontier:{..."string"==typeof e.resume_token?{resumeToken:e.resume_token}:{}}}}if(!kf(n.sequence)||null===e.id)throw new S8("the daemon returned an SSE event without a valid sequence",{status:t,payload:i});let a=String(n.sequence);if(e.id!==a)throw new S8("the SSE event ID does not match its canonical sequence",{status:t,payload:i});if("item"===o&&!("item"in n))throw new S8("the SSE item payload is missing",{status:t,payload:i});if("progress"===o&&(!kf(n.completed)||null!==n.total&&!kf(n.total)))throw new S8("the SSE progress payload is malformed",{status:t,payload:i});if("resume_gap"===o){let e=n.gap;if(!km(e)||!kf(e.first_missing_sequence)||!kf(e.last_missing_sequence)||e.first_missing_sequence!==n.sequence||e.first_missing_sequence>e.last_missing_sequence||!km(e.frontier)||!kf(e.frontier.next_sequence)||!kf(e.frontier.retained_from_sequence)||e.frontier.retained_from_sequence>e.frontier.next_sequence||e.last_missing_sequence>=e.frontier.next_sequence||null!==e.frontier.resume_token&&"string"!=typeof e.frontier.resume_token)throw new S8("the SSE resume gap is malformed",{status:t,payload:i})}if(kp.has(o)){let e=n.terminal;if(!km(e)||!k_(e.receipt))throw new S8("the SSE terminal event is malformed",{status:t,payload:i});if(e.termination!==o||e.receipt.termination!==o)throw new S8("the SSE terminal event is inconsistent",{status:t,payload:i})}let s={...i,event:o,data:n};if("resume_gap"===o){let e=n.gap,t=e.frontier;return{event:s,sequence:a,lastSequence:String(e.last_missing_sequence),frontier:{..."string"==typeof t.resume_token?{resumeToken:t.resume_token}:{}}}}return{event:s,sequence:a}}(t,d.status,e);if(void 0!==o.sequence){var s;let e=i??"0",r=(s=o.lastSequence??o.sequence,(BigInt(s)+1n).toString()),n=kp.has(t.event);if(!n&&BigInt(o.sequence)<BigInt(e))continue;if(o.sequence!==e&&!(n&&r===e))throw new S8("the daemon returned a non-contiguous SSE sequence",{status:d.status,payload:o.event});i=r}else i??="0";if(void 0!==o.frontier&&(r=o.frontier.resumeToken),yield{event:t.event,id:o.sequence??null,data:o.event},kp.has(t.event))return}}catch(e){if(l=!0,e instanceof S5)throw e;if(t.signal?.aborted)throw new S6(t.signal.reason??e);if(n>=o){if(e instanceof S3)throw e;throw new S3(`operation stream disconnected after ${n} reconnects`,e)}}}catch(e){throw l=!0,e}finally{try{await d.body?.cancel()}catch(e){if(!l)throw new S3("failed to close operation stream transport",e)}}if(n>=o)throw new S3(`operation stream ended before a terminal event after ${n} reconnects`);if(void 0===i||void 0===r)throw new S3("operation stream ended before exposing a resumable frontier");n+=1,await kb(a,t.signal)}}async cancelOperation(e,t={}){let r=await this.fetchResponse(this.lifecycleUrl(e,"cancel"),{method:"POST",headers:this.headers("application/json"),signal:t.signal},t.signal),i=await this.readJson(r,void 0,void 0,t.signal);if(!km(i))throw new S8("the daemon returned a malformed cancellation response",{status:r.status,payload:i});let o=i.status,n="requested"===o&&202===r.status||("already_requested"===o||"already_terminal"===o)&&200===r.status;if(!r.ok||"requested"!==o&&"already_requested"!==o&&"already_terminal"!==o||!n)throw new S8("the daemon returned a malformed cancellation response",{status:r.status,payload:i});return{...i,status:o}}}function kk(e){let t=S0.find(t=>t.operation===e);if(void 0===t||"mcp_tool"!==t.transport.kind)throw TypeError(`${e} is not an MCP-backed operation in the canonical catalog`);return t}let kw=kk("project_list"),kP=kk("project_search"),kV=kk("project_context");class kR{#u;constructor(e){this.#u=e}projectList(e,t){return this.#m(kw,e,t)}projectContext(e,t){return this.#m(kV,e,t)}projectSearch(e,t){return this.#m(kP,e,t)}async #m(e,t,r){let i,o=e.transport.toolName,n=e.decodeRequest(t);try{if(r?.aborted||(i=await this.#u(o,n,r),r?.aborted))throw new S6(r.reason)}catch(e){if(r?.aborted)throw new S6(r.reason);throw new S4(`MCP tool ${o} failed`,e)}try{return e.decodeResult(i)}catch(t){throw new S8(`MCP tool ${o} returned an invalid ${e.operation} result`,{payload:{response:i,cause:t}})}}}var kq=Object.create,kI=Object.defineProperty,kx=Object.getOwnPropertyDescriptor,kj=Object.getOwnPropertyNames,kC=Object.getPrototypeOf,kT=Object.prototype.hasOwnProperty,kO=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);let kE=new Set(["https://json-schema.org/draft/2020-12/schema","http://json-schema.org/draft/2020-12/schema"]),kA=new Set(["https://json-schema.org/draft/2019-09/schema","http://json-schema.org/draft/2019-09/schema"]),kW=new Set(["https://json-schema.org/draft-07/schema","http://json-schema.org/draft-07/schema"]),kM=new Set(["https://json-schema.org/draft-06/schema","http://json-schema.org/draft-06/schema"]),kN=Symbol.for("mcp.sdk.errorBrands");function kz(e,t){let r=new Set,i=t;for(;"function"==typeof i;){let e=i.mcpBrand;Object.prototype.hasOwnProperty.call(i,"mcpBrand")&&"string"==typeof e&&r.add(e),i=Object.getPrototypeOf(i)}0!==r.size&&Object.defineProperty(e,kN,{value:r,enumerable:!1,configurable:!0})}function kD(e,t){try{if("object"==typeof t&&null!==t&&Object.prototype.hasOwnProperty.call(e,"mcpBrand")&&"string"==typeof e.mcpBrand&&Object.prototype.hasOwnProperty.call(t,kN)){let r=t[kN];if(r&&"function"==typeof r.has&&r.has(e.mcpBrand))return!0}}catch{}return Function.prototype[Symbol.hasInstance].call(e,t)}(class e extends Error{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.OAuthError"})}static[Symbol.hasInstance](e){return kD(this,e)}static isInstance(e){if("function"!=typeof this)throw TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");return kD(this,e)}constructor(e,t,r){super(t),this.code=e,this.errorUri=r,this.name="OAuthError",kz(this,new.target)}toResponseObject(){let e={error:this.code,error_description:this.message};return this.errorUri&&(e.error_uri=this.errorUri),e}static fromResponse(t){return new e(t.error,t.error_description??t.error,t.error_uri)}});let kF=((X={}).NotConnected="NOT_CONNECTED",X.AlreadyConnected="ALREADY_CONNECTED",X.NotInitialized="NOT_INITIALIZED",X.CapabilityNotSupported="CAPABILITY_NOT_SUPPORTED",X.RequestTimeout="REQUEST_TIMEOUT",X.ConnectionClosed="CONNECTION_CLOSED",X.SendFailed="SEND_FAILED",X.InvalidResult="INVALID_RESULT",X.UnsupportedResultType="UNSUPPORTED_RESULT_TYPE",X.InputRequiredRoundsExceeded="INPUT_REQUIRED_ROUNDS_EXCEEDED",X.ListPaginationExceeded="LIST_PAGINATION_EXCEEDED",X.MethodNotSupportedByProtocolVersion="METHOD_NOT_SUPPORTED_BY_PROTOCOL_VERSION",X.EraNegotiationFailed="ERA_NEGOTIATION_FAILED",X.ClientHttpNotImplemented="CLIENT_HTTP_NOT_IMPLEMENTED",X.ClientHttpAuthentication="CLIENT_HTTP_AUTHENTICATION",X.ClientHttpForbidden="CLIENT_HTTP_FORBIDDEN",X.ClientHttpUnexpectedContent="CLIENT_HTTP_UNEXPECTED_CONTENT",X.ClientHttpFailedToOpenStream="CLIENT_HTTP_FAILED_TO_OPEN_STREAM",X.ClientHttpFailedToTerminateSession="CLIENT_HTTP_FAILED_TO_TERMINATE_SESSION",X);var kL=class extends Error{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.SdkError"})}static[Symbol.hasInstance](e){return kD(this,e)}static isInstance(e){if("function"!=typeof this)throw TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");return kD(this,e)}constructor(e,t,r,i){super(t,i),this.code=e,this.data=r,this.name="SdkError",kz(this,new.target)}},kU=class extends kL{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.SdkHttpError"})}constructor(e,t,r,i){super(e,t,r,i),this.name="SdkHttpError"}get status(){return this.data.status}get statusText(){return this.data.statusText}};let kH="2026-07-28",kG=[kH];function kB(e){return e.filter(e=>!(e>=kH))}function kK(e){return e.filter(e=>e>=kH)}function kJ(e){let t=e.structuredContent;return void 0===t||!("object"!=typeof t||null===t||Array.isArray(t))||e.content?.some(e=>"text"===e.type)?e:{...e,content:[...e.content??[],{type:"text",text:JSON.stringify(t)}]}}let kZ=["task","inputRequests","requestState"];function kQ(e){return null===e||"object"!=typeof e||Array.isArray(e)||void 0!==e.content||kZ.some(t=>t in e)?e:{...e,content:[]}}function kX(){let e,t,r,i,o,n,a,s,c,l,p,u,m,f,h,y,g,_,v,b,$,S,k,w,P,V,R,q,I,x,j,C,T,O,E,A,W,M,N,z,D,F,L,U,H,G,B,K,J,Z,Q,X,Y,ee,et,er,ei,eo,en,ea,es,ed,ec,el,ep,eu,em,ef,eh,ey,eg,e_,ev,eb,e$,eS,ek,ew,eP,eV,eR,eq,eI,ex,ej,eC,eT,eO,eE,eA,eW,eM,eN,ez,eD,eF,eL,eU,eH,eG,eB,eK,eJ,eZ,eQ,eX,eY,e1,e0,e2,e4,e6,e3,e9,e5,e8,e7,te,tt,tr,ti,to,tn,ta,ts,td,tc,tl,tp,tu,tm,tf,th,ty,tg,t_,tv,tb,t$,tS;return d??=(e=ao(()=>nD([o5(),nk(),nR(),nI(),nB(o5(),e),nA(e)])),t=nB(o5(),e),r=nD([o5(),nk().int()]),i=o5(),o=nM({ttl:nk().optional()}),n=nM({taskId:o5()}),c=(s=nM({_meta:(a=nN({progressToken:r.optional(),"io.modelcontextprotocol/related-task":n.optional()})).optional()})).extend({task:o.optional()}),l=nM({method:o5(),params:s.loose().optional()}),p=nM({_meta:a.optional()}),u=nM({method:o5(),params:p.loose().optional()}),m=nN({_meta:a.optional()}),f=nD([o5(),nk().int()]),h=m.strict(),y=p.extend({requestId:f.optional(),reason:o5().optional()}),g=u.extend({method:nQ("notifications/cancelled"),params:y}),_=nM({src:o5(),mimeType:o5().optional(),sizes:nA(o5()).optional(),theme:nJ(["light","dark"]).optional()}),v=nM({icons:nA(_).optional()}),$=(b=nM({name:o5(),title:o5().optional()})).extend({...b.shape,...v.shape,version:o5(),websiteUrl:o5().optional(),description:o5().optional()}),S=nH(nM({applyDefaults:nR().optional()}),t),k=aa(e=>e&&"object"==typeof e&&!Array.isArray(e)&&0===Object.keys(e).length?{form:{}}:e,nH(nM({form:S.optional(),url:t.optional()}),t.optional())),w=nN({list:t.optional(),cancel:t.optional(),requests:nN({sampling:nN({createMessage:t.optional()}).optional(),elicitation:nN({create:t.optional()}).optional()}).optional()}),P=nN({list:t.optional(),cancel:t.optional(),requests:nN({tools:nN({call:t.optional()}).optional()}).optional()}),V=nM({experimental:nB(o5(),t).optional(),sampling:nM({context:t.optional(),tools:t.optional()}).optional(),elicitation:k.optional(),roots:nM({listChanged:nR().optional()}).optional(),tasks:w.optional(),extensions:nB(o5(),t).optional()}),R=s.extend({protocolVersion:o5(),capabilities:V,clientInfo:$}),q=l.extend({method:nQ("initialize"),params:R}),I=nM({experimental:nB(o5(),t).optional(),logging:t.optional(),completions:t.optional(),prompts:nM({listChanged:nR().optional()}).optional(),resources:nM({subscribe:nR().optional(),listChanged:nR().optional()}).optional(),tools:nM({listChanged:nR().optional()}).optional(),tasks:P.optional(),extensions:nB(o5(),t).optional()}),x=m.extend({protocolVersion:o5(),capabilities:I,serverInfo:$,instructions:o5().optional()}),j=u.extend({method:nQ("notifications/initialized"),params:p.optional()}),C=l.extend({method:nQ("ping"),params:s.optional()}),T=nM({progress:nk(),total:n0(nk()),message:n0(o5())}),O=nM({...p.shape,...T.shape,progressToken:r}),E=u.extend({method:nQ("notifications/progress"),params:O}),A=s.extend({cursor:i.optional()}),W=l.extend({params:A.optional()}),M=m.extend({nextCursor:i.optional()}),z=(N=nM({uri:o5(),mimeType:n0(o5()),_meta:nB(o5(),nT()).optional()})).extend({text:o5()}),D=o5().refine(e=>{try{return atob(e),!0}catch{return!1}},{message:"Invalid Base64 string"}),F=N.extend({blob:D}),U=nM({audience:nA(L=nJ(["user","assistant"])).optional(),priority:nk().min(0).max(1).optional(),lastModified:as({offset:!0}).optional()}),H=nM({...b.shape,...v.shape,uri:o5(),description:n0(o5()),mimeType:n0(o5()),size:n0(nk()),annotations:U.optional(),_meta:n0(nN({}))}),G=nM({...b.shape,...v.shape,uriTemplate:o5(),description:n0(o5()),mimeType:n0(o5()),annotations:U.optional(),_meta:n0(nN({}))}),B=W.extend({method:nQ("resources/list")}),K=M.extend({resources:nA(H)}),J=W.extend({method:nQ("resources/templates/list")}),Z=M.extend({resourceTemplates:nA(G)}),Q=s.extend({uri:o5()}),X=l.extend({method:nQ("resources/read"),params:Q}),Y=m.extend({contents:nA(nD([z,F]))}),ee=u.extend({method:nQ("notifications/resources/list_changed"),params:p.optional()}),et=l.extend({method:nQ("resources/subscribe"),params:Q}),er=l.extend({method:nQ("resources/unsubscribe"),params:Q}),ei=p.extend({uri:o5()}),eo=u.extend({method:nQ("notifications/resources/updated"),params:ei}),en=nM({name:o5(),description:n0(o5()),required:n0(nR())}),ea=nM({...b.shape,...v.shape,description:n0(o5()),arguments:n0(nA(en)),_meta:n0(nN({}))}),es=W.extend({method:nQ("prompts/list")}),ed=M.extend({prompts:nA(ea)}),ec=s.extend({name:o5(),arguments:nB(o5(),o5()).optional()}),el=l.extend({method:nQ("prompts/get"),params:ec}),ep=nM({type:nQ("text"),text:o5(),annotations:U.optional(),_meta:nB(o5(),nT()).optional()}),eu=nM({type:nQ("image"),data:D,mimeType:o5(),annotations:U.optional(),_meta:nB(o5(),nT()).optional()}),em=nM({type:nQ("audio"),data:D,mimeType:o5(),annotations:U.optional(),_meta:nB(o5(),nT()).optional()}),ef=nM({type:nQ("tool_use"),name:o5(),id:o5(),input:nB(o5(),nT()),_meta:nB(o5(),nT()).optional()}),eh=nM({type:nQ("resource"),resource:nD([z,F]),annotations:U.optional(),_meta:nB(o5(),nT()).optional()}),e_=nM({role:L,content:eg=nD([ep,eu,em,ey=H.extend({type:nQ("resource_link")}),eh])}),ev=m.extend({description:o5().optional(),messages:nA(e_)}),eb=u.extend({method:nQ("notifications/prompts/list_changed"),params:p.optional()}),e$=nM({title:o5().optional(),readOnlyHint:nR().optional(),destructiveHint:nR().optional(),idempotentHint:nR().optional(),openWorldHint:nR().optional()}),eS=nM({taskSupport:nJ(["required","optional","forbidden"]).optional()}),ek=nM({...b.shape,...v.shape,description:o5().optional(),inputSchema:nM({type:nQ("object"),properties:nB(o5(),e).optional(),required:nA(o5()).optional()}).catchall(nT()),outputSchema:nM({type:nQ("object"),properties:nB(o5(),e).optional(),required:nA(o5()).optional()}).catchall(nT()).optional(),annotations:e$.optional(),execution:eS.optional(),_meta:nB(o5(),nT()).optional()}),ew=W.extend({method:nQ("tools/list")}),eP=M.extend({tools:nA(ek)}),eV=m.extend({content:nA(eg),structuredContent:nB(o5(),nT()).optional(),isError:nR().optional()}),eR=c.extend({name:o5(),arguments:nB(o5(),nT()).optional()}),eq=l.extend({method:nQ("tools/call"),params:eR}),eI=u.extend({method:nQ("notifications/tools/list_changed"),params:p.optional()}),ex=nJ(["debug","info","notice","warning","error","critical","alert","emergency"]),ej=s.extend({level:ex}),eC=l.extend({method:nQ("logging/setLevel"),params:ej}),eT=p.extend({level:ex,logger:o5().optional(),data:nT()}),eO=u.extend({method:nQ("notifications/message"),params:eT}),eE=nM({name:o5().optional()}),eA=nM({hints:nA(eE).optional(),costPriority:nk().min(0).max(1).optional(),speedPriority:nk().min(0).max(1).optional(),intelligencePriority:nk().min(0).max(1).optional()}),eW=nM({mode:nJ(["auto","required","none"]).optional()}),eM=nM({type:nQ("tool_result"),toolUseId:o5().describe("The unique identifier for the corresponding tool call."),content:nA(eg),structuredContent:nM({}).loose().optional(),isError:nR().optional(),_meta:nB(o5(),nT()).optional()}),eN=nL("type",[ep,eu,em]),eD=nM({role:L,content:nD([ez=nL("type",[ep,eu,em,ef,eM]),nA(ez)]),_meta:nB(o5(),nT()).optional()}),eF=c.extend({messages:nA(eD),modelPreferences:eA.optional(),systemPrompt:o5().optional(),includeContext:nJ(["none","thisServer","allServers"]).optional(),temperature:nk().optional(),maxTokens:nk().int(),stopSequences:nA(o5()).optional(),metadata:t.optional(),tools:nA(ek).optional(),toolChoice:eW.optional()}),eL=l.extend({method:nQ("sampling/createMessage"),params:eF}),eU=m.extend({model:o5(),stopReason:n0(nJ(["endTurn","stopSequence","maxTokens"]).or(o5())),role:L,content:eN}),eH=m.extend({model:o5(),stopReason:n0(nJ(["endTurn","stopSequence","maxTokens","toolUse"]).or(o5())),role:L,content:nD([ez,nA(ez)])}),eG=nM({type:nQ("boolean"),title:o5().optional(),description:o5().optional(),default:nR().optional()}),eB=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),minLength:nk().optional(),maxLength:nk().optional(),format:nJ(["email","uri","date","date-time"]).optional(),default:o5().optional()}),eK=nM({type:nJ(["number","integer"]),title:o5().optional(),description:o5().optional(),minimum:nk().optional(),maximum:nk().optional(),default:nk().optional()}),eJ=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),enum:nA(o5()),default:o5().optional()}),eZ=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),oneOf:nA(nM({const:o5(),title:o5()})),default:o5().optional()}),eQ=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),enum:nA(o5()),enumNames:nA(o5()).optional(),default:o5().optional()}),eX=nD([eJ,eZ]),eY=nM({type:nQ("array"),title:o5().optional(),description:o5().optional(),minItems:nk().optional(),maxItems:nk().optional(),items:nM({type:nQ("string"),enum:nA(o5())}),default:nA(o5()).optional()}),e0=nD([eY,e1=nM({type:nQ("array"),title:o5().optional(),description:o5().optional(),minItems:nk().optional(),maxItems:nk().optional(),items:nM({anyOf:nA(nM({const:o5(),title:o5()}))}),default:nA(o5()).optional()})]),e2=nD([eQ,eX,e0]),e4=nD([e2,eG,eB,eK]),e6=c.extend({mode:nQ("form").optional(),message:o5(),requestedSchema:nM({type:nQ("object"),properties:nB(o5(),e4),required:nA(o5()).optional()}).catchall(nT())}),e9=nD([e6,e3=c.extend({mode:nQ("url"),message:o5(),elicitationId:o5(),url:o5().url()})]),e5=l.extend({method:nQ("elicitation/create"),params:e9}),e8=p.extend({elicitationId:o5()}),e7=u.extend({method:nQ("notifications/elicitation/complete"),params:e8}),te=m.extend({action:nJ(["accept","decline","cancel"]),content:aa(e=>null===e?void 0:e,nB(o5(),nD([o5(),nk(),nR(),nA(o5())])).optional())}),tt=nM({type:nQ("ref/resource"),uri:o5()}),tr=nM({type:nQ("ref/prompt"),name:o5()}),ti=s.extend({ref:nD([tr,tt]),argument:nM({name:o5(),value:o5()}),context:nM({arguments:nB(o5(),o5()).optional()}).optional()}),to=l.extend({method:nQ("completion/complete"),params:ti}),tn=m.extend({completion:nN({values:nA(o5()).max(100),total:n0(nk().int()),hasMore:n0(nR())})}),ta=nM({uri:o5().startsWith("file://"),name:o5().optional(),_meta:nB(o5(),nT()).optional()}),ts=l.extend({method:nQ("roots/list"),params:s.optional()}),td=m.extend({roots:nA(ta)}),tc=u.extend({method:nQ("notifications/roots/list_changed"),params:p.optional()}),tl=nN({ttl:nk().optional(),pollInterval:nk().optional()}),tp=nJ(["working","input_required","completed","failed","cancelled"]),tu=nM({taskId:o5(),status:tp,ttl:nD([nk(),nI()]),createdAt:o5(),lastUpdatedAt:o5(),pollInterval:n0(nk()),statusMessage:n0(o5())}),tm=m.extend({task:tu}),tf=p.merge(tu),th=u.extend({method:nQ("notifications/tasks/status"),params:tf}),ty=l.extend({method:nQ("tasks/get"),params:s.extend({taskId:o5()})}),tg=m.merge(tu),t_=l.extend({method:nQ("tasks/result"),params:s.extend({taskId:o5()})}),tv=m.loose(),tb=W.extend({method:nQ("tasks/list")}),t$=M.extend({tasks:nA(tu)}),tS=l.extend({method:nQ("tasks/cancel"),params:s.extend({taskId:o5()})}),{JSONValueSchema:e,JSONObjectSchema:t,ProgressTokenSchema:r,CursorSchema:i,TaskMetadataSchema:o,RelatedTaskMetadataSchema:n,RequestMetaSchema:a,BaseRequestParamsSchema:s,TaskAugmentedRequestParamsSchema:c,RequestSchema:l,NotificationsParamsSchema:p,NotificationSchema:u,ResultSchema:m,RequestIdSchema:f,EmptyResultSchema:h,CancelledNotificationParamsSchema:y,CancelledNotificationSchema:g,IconSchema:_,IconsSchema:v,BaseMetadataSchema:b,ImplementationSchema:$,ClientTasksCapabilitySchema:w,ServerTasksCapabilitySchema:P,ClientCapabilitiesSchema:V,InitializeRequestParamsSchema:R,InitializeRequestSchema:q,ServerCapabilitiesSchema:I,InitializeResultSchema:x,InitializedNotificationSchema:j,PingRequestSchema:C,ProgressSchema:T,ProgressNotificationParamsSchema:O,ProgressNotificationSchema:E,PaginatedRequestParamsSchema:A,PaginatedRequestSchema:W,PaginatedResultSchema:M,ResourceContentsSchema:N,TextResourceContentsSchema:z,BlobResourceContentsSchema:F,RoleSchema:L,AnnotationsSchema:U,ResourceSchema:H,ResourceTemplateSchema:G,ListResourcesRequestSchema:B,ListResourcesResultSchema:K,ListResourceTemplatesRequestSchema:J,ListResourceTemplatesResultSchema:Z,ResourceRequestParamsSchema:Q,ReadResourceRequestParamsSchema:Q,ReadResourceRequestSchema:X,ReadResourceResultSchema:Y,ResourceListChangedNotificationSchema:ee,SubscribeRequestParamsSchema:Q,SubscribeRequestSchema:et,UnsubscribeRequestParamsSchema:Q,UnsubscribeRequestSchema:er,ResourceUpdatedNotificationParamsSchema:ei,ResourceUpdatedNotificationSchema:eo,PromptArgumentSchema:en,PromptSchema:ea,ListPromptsRequestSchema:es,ListPromptsResultSchema:ed,GetPromptRequestParamsSchema:ec,GetPromptRequestSchema:el,TextContentSchema:ep,ImageContentSchema:eu,AudioContentSchema:em,ToolUseContentSchema:ef,EmbeddedResourceSchema:eh,ResourceLinkSchema:ey,ContentBlockSchema:eg,PromptMessageSchema:e_,GetPromptResultSchema:ev,PromptListChangedNotificationSchema:eb,ToolAnnotationsSchema:e$,ToolExecutionSchema:eS,ToolSchema:ek,ListToolsRequestSchema:ew,ListToolsResultSchema:eP,CallToolResultSchema:eV,CallToolRequestParamsSchema:eR,CallToolRequestSchema:eq,ToolListChangedNotificationSchema:eI,LoggingLevelSchema:ex,SetLevelRequestParamsSchema:ej,SetLevelRequestSchema:eC,LoggingMessageNotificationParamsSchema:eT,LoggingMessageNotificationSchema:eO,ModelHintSchema:eE,ModelPreferencesSchema:eA,ToolChoiceSchema:eW,ToolResultContentSchema:eM,SamplingContentSchema:eN,SamplingMessageContentBlockSchema:ez,SamplingMessageSchema:eD,CreateMessageRequestParamsSchema:eF,CreateMessageRequestSchema:eL,CreateMessageResultSchema:eU,CreateMessageResultWithToolsSchema:eH,BooleanSchemaSchema:eG,StringSchemaSchema:eB,NumberSchemaSchema:eK,UntitledSingleSelectEnumSchemaSchema:eJ,TitledSingleSelectEnumSchemaSchema:eZ,LegacyTitledEnumSchemaSchema:eQ,SingleSelectEnumSchemaSchema:eX,UntitledMultiSelectEnumSchemaSchema:eY,TitledMultiSelectEnumSchemaSchema:e1,MultiSelectEnumSchemaSchema:e0,EnumSchemaSchema:e2,PrimitiveSchemaDefinitionSchema:e4,ElicitRequestFormParamsSchema:e6,ElicitRequestURLParamsSchema:e3,ElicitRequestParamsSchema:e9,ElicitRequestSchema:e5,ElicitationCompleteNotificationParamsSchema:e8,ElicitationCompleteNotificationSchema:e7,ElicitResultSchema:te,ResourceTemplateReferenceSchema:tt,PromptReferenceSchema:tr,CompleteRequestParamsSchema:ti,CompleteRequestSchema:to,CompleteResultSchema:tn,RootSchema:ta,ListRootsRequestSchema:ts,ListRootsResultSchema:td,RootsListChangedNotificationSchema:tc,TaskCreationParamsSchema:tl,TaskStatusSchema:tp,TaskSchema:tu,CreateTaskResultSchema:tm,TaskStatusNotificationParamsSchema:tf,TaskStatusNotificationSchema:th,GetTaskRequestSchema:ty,GetTaskResultSchema:tg,GetTaskPayloadRequestSchema:t_,GetTaskPayloadResultSchema:tv,ListTasksRequestSchema:tb,ListTasksResultSchema:t$,CancelTaskRequestSchema:tS,CancelTaskResultSchema:m.merge(tu),ClientRequestSchema:nD([C,q,to,eC,el,es,B,J,X,et,er,eq,ew,ty,t_,tb,tS]),ClientNotificationSchema:nD([g,E,j,tc,th]),ClientResultSchema:nD([h,eU,eH,te,td,tg,t$,tm]),ServerRequestSchema:nD([C,eL,e5,ts,ty,t_,tb,tS]),ServerNotificationSchema:nD([g,E,eO,eo,ee,eI,eb,th,e7]),ServerResultSchema:nD([h,x,tn,ev,ed,K,Z,Y,eV,eP,tg,t$,tm]),CallToolResultWireSchema:nT().superRefine((e,t)=>{if(!("object"!=typeof e||null===e||Array.isArray(e))&&void 0===e.content){for(let r of kZ)if(r in e)return void t.addIssue({code:"custom",message:`content is required when the body carries '${r}' — another result family cannot default into an empty tools/call success`})}}).transform(kQ).pipe(eV)})}function kY(e){return"object"!==e.type}let k1=new Set(["const","enum","default","examples"]),k0=new Set(["properties","patternProperties","$defs","definitions","dependentSchemas","dependencies"]);function k2(e){return void 0!==e&&!("string"==typeof e&&e.startsWith("#"))}let k4={ping:null,initialize:null,"completion/complete":null,"logging/setLevel":null,"prompts/get":null,"prompts/list":null,"resources/list":null,"resources/templates/list":null,"resources/read":null,"resources/subscribe":null,"resources/unsubscribe":null,"tools/call":null,"tools/list":null,"tasks/get":null,"tasks/result":null,"tasks/list":null,"tasks/cancel":null,"sampling/createMessage":null,"elicitation/create":null,"roots/list":null},k6={"notifications/cancelled":null,"notifications/progress":null,"notifications/initialized":null,"notifications/roots/list_changed":null,"notifications/tasks/status":null,"notifications/message":null,"notifications/resources/updated":null,"notifications/resources/list_changed":null,"notifications/tools/list_changed":null,"notifications/prompts/list_changed":null,"notifications/elicitation/complete":null},k3={ping:null,initialize:null,"completion/complete":null,"logging/setLevel":null,"prompts/get":null,"prompts/list":null,"resources/list":null,"resources/templates/list":null,"resources/read":null,"resources/subscribe":null,"resources/unsubscribe":null,"tools/call":null,"tools/list":null,"sampling/createMessage":null,"elicitation/create":null,"roots/list":null};function k9(){if(c)return c;let e=kX();return c={requestSchemas:{ping:e.PingRequestSchema,initialize:e.InitializeRequestSchema,"completion/complete":e.CompleteRequestSchema,"logging/setLevel":e.SetLevelRequestSchema,"prompts/get":e.GetPromptRequestSchema,"prompts/list":e.ListPromptsRequestSchema,"resources/list":e.ListResourcesRequestSchema,"resources/templates/list":e.ListResourceTemplatesRequestSchema,"resources/read":e.ReadResourceRequestSchema,"resources/subscribe":e.SubscribeRequestSchema,"resources/unsubscribe":e.UnsubscribeRequestSchema,"tools/call":e.CallToolRequestSchema,"tools/list":e.ListToolsRequestSchema,"tasks/get":e.GetTaskRequestSchema,"tasks/result":e.GetTaskPayloadRequestSchema,"tasks/list":e.ListTasksRequestSchema,"tasks/cancel":e.CancelTaskRequestSchema,"sampling/createMessage":e.CreateMessageRequestSchema,"elicitation/create":e.ElicitRequestSchema,"roots/list":e.ListRootsRequestSchema},notificationSchemas:{"notifications/cancelled":e.CancelledNotificationSchema,"notifications/progress":e.ProgressNotificationSchema,"notifications/initialized":e.InitializedNotificationSchema,"notifications/roots/list_changed":e.RootsListChangedNotificationSchema,"notifications/tasks/status":e.TaskStatusNotificationSchema,"notifications/message":e.LoggingMessageNotificationSchema,"notifications/resources/updated":e.ResourceUpdatedNotificationSchema,"notifications/resources/list_changed":e.ResourceListChangedNotificationSchema,"notifications/tools/list_changed":e.ToolListChangedNotificationSchema,"notifications/prompts/list_changed":e.PromptListChangedNotificationSchema,"notifications/elicitation/complete":e.ElicitationCompleteNotificationSchema},resultSchemas:{ping:e.EmptyResultSchema,initialize:e.InitializeResultSchema,"completion/complete":e.CompleteResultSchema,"logging/setLevel":e.EmptyResultSchema,"prompts/get":e.GetPromptResultSchema,"prompts/list":e.ListPromptsResultSchema,"resources/list":e.ListResourcesResultSchema,"resources/templates/list":e.ListResourceTemplatesResultSchema,"resources/read":e.ReadResourceResultSchema,"resources/subscribe":e.EmptyResultSchema,"resources/unsubscribe":e.EmptyResultSchema,"tools/call":e.CallToolResultWireSchema,"tools/list":e.ListToolsResultSchema,"sampling/createMessage":e.CreateMessageResultWithToolsSchema,"elicitation/create":e.ElicitResultSchema,"roots/list":e.ListRootsResultSchema}}}function k5(e){return Object.prototype.hasOwnProperty.call(k4,e)}function k8(e){return Object.prototype.hasOwnProperty.call(k6,e)}function k7(e){return null!==e&&"object"==typeof e&&!Array.isArray(e)}function we(e,t){if(void 0===e)return{ok:!1,reason:"not-in-era"};let r=e.safeParse(t);return r.success?{ok:!0,value:r.data}:{ok:!1,reason:"invalid",message:String(r.error)}}Object.keys(k4),Object.keys(k6);let wt={ok:!1,reason:"not-in-era"};function wr(e){return k7(e)&&k7(e.outputSchema)&&kY(e.outputSchema)}let wi={era:"2025-11-25",hasRequestMethod:k5,hasNotificationMethod:k8,validateRequest:(e,t)=>we(k5(e)?k9().requestSchemas[e]:void 0,t),validateResult:(e,t)=>we(Object.prototype.hasOwnProperty.call(k3,e)?k9().resultSchemas[e]:void 0,t),validateNotification:(e,t)=>we(k8(e)?k9().notificationSchemas[e]:void 0,t),hasInputRequestMethod:()=>!1,validateInputRequest:()=>wt,validateInputResponse:()=>wt,samplingResultVariant:(e,t)=>{let r=kX();return we(e?r.CreateMessageResultWithToolsSchema:r.CreateMessageResultSchema,t)},outboundEnvelope:e=>void 0,validateEnvelopeMeta:e=>[],projectCallToolResult(e,t){let r=kJ(e),i=r.structuredContent;if(void 0===i)return r;let o="object"!=typeof i||null===i||Array.isArray(i),n=void 0!==t&&kY(t);return o||n?{...r,structuredContent:{result:i}}:r},decodeResult(e,t){if(k7(t)&&"resultType"in t){let e={...t};return delete e.resultType,{kind:"complete",result:e}}return{kind:"complete",result:t}},encodeResult(e,t){if("tools/list"!==e)return t;let r=t.tools;return Array.isArray(r)&&r.some(e=>wr(e))?{...t,tools:r.map(e=>wr(e)?{...e,outputSchema:function(e){var t;let r="string"==typeof e.$schema?e.$schema:void 0;if(k2(e.$id))return{...void 0!==r&&{$schema:r},type:"object",properties:{result:e},required:["result"]};let i="string"==typeof(t=e.$schema)&&kA.has(t.replace(/#$/,""))&&!0!==e.$recursiveAnchor,o=(e,t)=>{if(Array.isArray(e))return e.map(e=>o(e,!1));if(null===e||"object"!=typeof e||!t&&k2(e.$id))return e;let r={},n=!1;for(let[a,s]of Object.entries(e))t?r[a]=o(s,!1):("$ref"===a||"$dynamicRef"===a)&&"string"==typeof s?r[a]="#"===s?"#/properties/result":s.startsWith("#/")?`#/properties/result${s.slice(1)}`:s:"$recursiveRef"===a&&"#"===s&&i?n=!0:k1.has(a)?r[a]=s:k0.has(a)?r[a]=o(s,!0):r[a]=o(s,!1);return n&&("$ref"in r?r.allOf=[...Array.isArray(r.allOf)?r.allOf:[],{$ref:"#/properties/result"}]:r.$ref="#/properties/result"),r};return{...void 0!==r&&{$schema:r},type:"object",properties:{result:o(e,!1)},required:["result"]}}(e.outputSchema)}:e)}:t},encodeErrorCode:e=>-32002===e?-32602:e,checkInboundEnvelope:e=>void 0};function wo(){return l??=function(){let e=ao(()=>nD([o5(),nk(),nR(),nI(),nB(o5(),e),nA(e)])),t=nB(o5(),e),r=nD([o5(),nk().int()]),i=o5(),o=nD([o5(),nk().int()]),n=nJ(["user","assistant"]),a=nJ(["debug","info","notice","warning","error","critical","alert","emergency"]),s=o5().refine(e=>{try{return atob(e),!0}catch{return!1}},{message:"Invalid Base64 string"}),d=nM({ttl:nk().optional()}),c=nM({taskId:o5()}),l=nN({progressToken:r.optional(),"io.modelcontextprotocol/related-task":c.optional()}),p=nM({_meta:l.optional()}),u=p.extend({task:d.optional()}),m=nM({_meta:l.optional()}),f=nM({method:o5(),params:m.loose().optional()}),h=nM({src:o5(),mimeType:o5().optional(),sizes:nA(o5()).optional(),theme:nJ(["light","dark"]).optional()}),y=nM({icons:nA(h).optional()}),g=nM({name:o5(),title:o5().optional()}),_=g.extend({...g.shape,...y.shape,version:o5(),websiteUrl:o5().optional(),description:o5().optional()}),v=nH(nM({applyDefaults:nR().optional()}),t),b=aa(e=>e&&"object"==typeof e&&!Array.isArray(e)&&0===Object.keys(e).length?{form:{}}:e,nH(nM({form:v.optional(),url:t.optional()}),t.optional())),$=nN({list:t.optional(),cancel:t.optional(),requests:nN({sampling:nN({createMessage:t.optional()}).optional(),elicitation:nN({create:t.optional()}).optional()}).optional()}),S=nN({list:t.optional(),cancel:t.optional(),requests:nN({tools:nN({call:t.optional()}).optional()}).optional()}),k=nM({experimental:nB(o5(),t).optional(),sampling:nM({context:t.optional(),tools:t.optional()}).optional(),elicitation:b.optional(),roots:nM({listChanged:nR().optional()}).optional(),tasks:$.optional(),extensions:nB(o5(),t).optional()}),w=nM({experimental:nB(o5(),t).optional(),logging:t.optional(),completions:t.optional(),prompts:nM({listChanged:nR().optional()}).optional(),resources:nM({subscribe:nR().optional(),listChanged:nR().optional()}).optional(),tools:nM({listChanged:nR().optional()}).optional(),tasks:S.optional(),extensions:nB(o5(),t).optional()}),P=nM({progress:nk(),total:n0(nk()),message:n0(o5())}),V=nM({...m.shape,...P.shape,progressToken:r}),R=f.extend({method:nQ("notifications/progress"),params:V}),q=m.extend({level:a,logger:o5().optional(),data:nT()}),I=f.extend({method:nQ("notifications/message"),params:q}),x=nM({uri:o5(),mimeType:n0(o5()),_meta:nB(o5(),nT()).optional()}),j=x.extend({text:o5()}),C=x.extend({blob:s}),T=nM({audience:nA(n).optional(),priority:nk().min(0).max(1).optional(),lastModified:as({offset:!0}).optional()}),O=nM({...g.shape,...y.shape,uri:o5(),description:n0(o5()),mimeType:n0(o5()),size:n0(nk()),annotations:T.optional(),_meta:n0(nN({}))}),E=nM({...g.shape,...y.shape,uriTemplate:o5(),description:n0(o5()),mimeType:n0(o5()),annotations:T.optional(),_meta:n0(nN({}))}),A=f.extend({method:nQ("notifications/resources/list_changed"),params:m.optional()}),W=m.extend({uri:o5()}),M=f.extend({method:nQ("notifications/resources/updated"),params:W}),N=nM({name:o5(),description:n0(o5()),required:n0(nR())}),z=nM({...g.shape,...y.shape,description:n0(o5()),arguments:n0(nA(N)),_meta:n0(nN({}))}),D=f.extend({method:nQ("notifications/prompts/list_changed"),params:m.optional()}),F=nM({type:nQ("text"),text:o5(),annotations:T.optional(),_meta:nB(o5(),nT()).optional()}),L=nM({type:nQ("image"),data:s,mimeType:o5(),annotations:T.optional(),_meta:nB(o5(),nT()).optional()}),U=nM({type:nQ("audio"),data:s,mimeType:o5(),annotations:T.optional(),_meta:nB(o5(),nT()).optional()}),H=nM({type:nQ("tool_use"),name:o5(),id:o5(),input:nB(o5(),nT()),_meta:nB(o5(),nT()).optional()}),G=nM({type:nQ("resource"),resource:nD([j,C]),annotations:T.optional(),_meta:nB(o5(),nT()).optional()}),B=O.extend({type:nQ("resource_link")}),K=nD([F,L,U,B,G]),J=nM({role:n,content:K}),Z=nM({title:o5().optional(),readOnlyHint:nR().optional(),destructiveHint:nR().optional(),idempotentHint:nR().optional(),openWorldHint:nR().optional()}),Q=f.extend({method:nQ("notifications/tools/list_changed"),params:m.optional()}),X=nM({name:o5().optional()}),Y=nM({hints:nA(X).optional(),costPriority:nk().min(0).max(1).optional(),speedPriority:nk().min(0).max(1).optional(),intelligencePriority:nk().min(0).max(1).optional()}),ee=nM({mode:nJ(["auto","required","none"]).optional()}),et=nM({type:nQ("boolean"),title:o5().optional(),description:o5().optional(),default:nR().optional()}),er=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),minLength:nk().optional(),maxLength:nk().optional(),format:nJ(["email","uri","date","date-time"]).optional(),default:o5().optional()}),ei=nM({type:nJ(["number","integer"]),title:o5().optional(),description:o5().optional(),minimum:nk().optional(),maximum:nk().optional(),default:nk().optional()}),eo=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),enum:nA(o5()),default:o5().optional()}),en=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),oneOf:nA(nM({const:o5(),title:o5()})),default:o5().optional()}),ea=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),enum:nA(o5()),enumNames:nA(o5()).optional(),default:o5().optional()}),es=nD([eo,en]),ed=nM({type:nQ("array"),title:o5().optional(),description:o5().optional(),minItems:nk().optional(),maxItems:nk().optional(),items:nM({type:nQ("string"),enum:nA(o5())}),default:nA(o5()).optional()}),ec=nM({type:nQ("array"),title:o5().optional(),description:o5().optional(),minItems:nk().optional(),maxItems:nk().optional(),items:nM({anyOf:nA(nM({const:o5(),title:o5()}))}),default:nA(o5()).optional()}),el=nD([ed,ec]),ep=nD([ea,es,el]),eu=nD([ep,et,er,ei]),em=u.extend({mode:nQ("form").optional(),message:o5(),requestedSchema:nM({type:nQ("object"),properties:nB(o5(),eu),required:nA(o5()).optional()}).catchall(nT())}),ef=nM({type:nQ("ref/resource"),uri:o5()}),eh=nM({type:nQ("ref/prompt"),name:o5()}),ey=nM({uri:o5().startsWith("file://"),name:o5().optional(),_meta:nB(o5(),nT()).optional()}),eg=k.shape,e_=nM({experimental:eg.experimental,sampling:eg.sampling,elicitation:eg.elicitation,roots:eg.roots,extensions:eg.extensions}),ev=w.shape,eb=nM({experimental:ev.experimental,logging:ev.logging,completions:ev.completions,prompts:ev.prompts,resources:ev.resources,tools:ev.tools,extensions:ev.extensions}),e$=nN({progressToken:r.optional(),[al]:o5(),[ap]:_.optional(),[am]:e_,[ah]:a.optional()}),eS=nM({...g.shape,...y.shape,description:o5().optional(),inputSchema:nN({$schema:o5().optional(),type:nQ("object")}),outputSchema:nN({$schema:o5().optional()}).optional(),annotations:Z.optional(),_meta:nB(o5(),nT()).optional()}),ek=nM({type:nQ("tool_result"),toolUseId:o5(),content:nA(K),structuredContent:nT().optional(),isError:nR().optional(),_meta:nB(o5(),nT()).optional()}),ew=nD([F,L,U,H,ek]),eP=nM({role:n,content:nD([ew,nA(ew)]),_meta:nB(o5(),nT()).optional()}),eV=o5(),eR=nN({[au]:_.optional().catch(void 0)}),eq=eR.optional();function eI(e){return nN({_meta:eq,resultType:eV.default("complete"),...e})}let ex=eI({}),ej=eI({nextCursor:i.optional()}),eC=eI({content:nA(K),structuredContent:nT().optional(),isError:nR().optional()}),eT=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),tools:nA(eS),nextCursor:i.optional()}),eO=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),prompts:nA(z),nextCursor:i.optional()}),eE=eI({description:o5().optional(),messages:nA(J)}),eA=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),resources:nA(O),nextCursor:i.optional()}),eW=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),resourceTemplates:nA(E),nextCursor:i.optional()}),eM=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),contents:nA(nD([j,C]))}),eN=eI({completion:nM({values:nA(o5()).max(100),total:nk().int().optional(),hasMore:nR().optional()}).loose()}),ez=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"])}),eD=eI({ttlMs:nk().int().min(0).catch(0),cacheScope:nJ(["public","private"]).catch("private"),supportedVersions:nA(o5()),capabilities:eb,instructions:o5().optional()}),eF=nM({messages:nA(eP),modelPreferences:Y.optional(),systemPrompt:o5().optional(),includeContext:nJ(["none","thisServer","allServers"]).optional(),temperature:nk().optional(),maxTokens:nk().int(),stopSequences:nA(o5()).optional(),metadata:t.optional(),tools:nA(eS).optional(),toolChoice:ee.optional()}),eL=nM({method:nQ("sampling/createMessage"),params:eF}),eU=nM({method:nQ("roots/list"),params:nM({_meta:nB(o5(),nT()).optional()}).optional()}),eH=nM({...eP.shape,model:o5(),stopReason:o5().optional()}),eG=nM({roots:nA(ey)}),eB=nM({action:nJ(["accept","decline","cancel"]),content:nB(o5(),nD([o5(),nk(),nR(),nA(o5())])).optional()}),eK=nM({mode:nQ("url"),message:o5(),url:o5().url()}),eJ=nD([em,eK]),eZ=nM({method:nQ("elicitation/create"),params:eJ}),eQ=nD([eL,eU,eZ]),eX=nD([eH,eG,eB]),eY=nB(o5(),eQ),e1=nB(o5(),eX),e0=eI({inputRequests:eY.optional(),requestState:o5().optional()}),e2={inputResponses:e1.optional(),requestState:o5().optional()},e4=nM({_meta:e$,...e2}),e6=nN({progressToken:r.optional()});function e3(e,t){return nM({method:nQ(e),params:nM({_meta:e$,...t})})}function e9(e,t){return nM({method:nQ(e),params:nM({_meta:e6.optional(),...t}).optional()})}let e5={name:o5(),arguments:nB(o5(),nT()).optional(),...e2},e8={cursor:i.optional()},e7=e3("tools/call",e5),te=e3("tools/list",e8),tt=e3("prompts/list",e8),tr=e3("prompts/get",{name:o5(),arguments:nB(o5(),o5()).optional(),...e2}),ti=e3("resources/list",e8),to=e3("resources/templates/list",e8),tn=e3("resources/read",{uri:o5(),...e2}),ta={ref:nD([eh,ef]),argument:nM({name:o5(),value:o5()}),context:nM({arguments:nB(o5(),o5()).optional()}).optional()},ts=e3("completion/complete",ta),td=e3("server/discover",{}),tc=nM({toolsListChanged:nR().optional(),promptsListChanged:nR().optional(),resourcesListChanged:nR().optional(),resourceSubscriptions:nA(o5()).optional()}),tl={notifications:tc},tp=e3("subscriptions/listen",tl),tu=eR.extend({"io.modelcontextprotocol/subscriptionId":o}),tm=nN({_meta:tu,resultType:eV.default("complete")}),tf={"tools/call":e9("tools/call",e5),"tools/list":e9("tools/list",e8),"prompts/get":e9("prompts/get",{name:o5(),arguments:nB(o5(),o5()).optional()}),"prompts/list":e9("prompts/list",e8),"resources/list":e9("resources/list",e8),"resources/templates/list":e9("resources/templates/list",e8),"resources/read":e9("resources/read",{uri:o5()}),"completion/complete":e9("completion/complete",ta),"server/discover":e9("server/discover",{}),"subscriptions/listen":e9("subscriptions/listen",tl)};function th(e){return nN({_meta:eq,...e})}let ty={"tools/call":th({content:nA(K),structuredContent:nT().optional(),isError:nR().optional()}),"tools/list":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),tools:nA(eS),nextCursor:i.optional()}),"prompts/get":th({description:o5().optional(),messages:nA(J)}),"prompts/list":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),prompts:nA(z),nextCursor:i.optional()}),"resources/list":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),resources:nA(O),nextCursor:i.optional()}),"resources/templates/list":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),resourceTemplates:nA(E),nextCursor:i.optional()}),"resources/read":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),contents:nA(nD([j,C]))}),"completion/complete":th({completion:nM({values:nA(o5()).max(100),total:nk().int().optional(),hasMore:nR().optional()}).loose()}),"server/discover":th({ttlMs:nk().int().min(0).catch(0),cacheScope:nJ(["public","private"]).catch("private"),supportedVersions:nA(o5()),capabilities:eb,instructions:o5().optional()}),"subscriptions/listen":th({})},tg=nN({"io.modelcontextprotocol/subscriptionId":o.optional()}),t_=nM({method:nQ("notifications/subscriptions/acknowledged"),params:nM({_meta:tg.optional(),notifications:tc})}),tv=nM({_meta:tg.optional(),requestId:o,reason:o5().optional()}),tb=nM({method:nQ("notifications/cancelled"),params:tv}),t$=e=>nM({jsonrpc:nQ("2.0"),id:nD([o5(),nk().int()]),result:e}).strict();return{JSONValueSchema:e,JSONObjectSchema:t,ProgressTokenSchema:r,CursorSchema:i,RequestIdSchema:o,RoleSchema:n,LoggingLevelSchema:a,TaskMetadataSchema:d,RelatedTaskMetadataSchema:c,RequestMetaSchema:l,BaseRequestParamsSchema:p,TaskAugmentedRequestParamsSchema:u,NotificationsParamsSchema:m,NotificationSchema:f,IconSchema:h,IconsSchema:y,BaseMetadataSchema:g,ImplementationSchema:_,ClientTasksCapabilitySchema:$,ServerTasksCapabilitySchema:S,ClientCapabilitiesSchema:k,ServerCapabilitiesSchema:w,ProgressSchema:P,ProgressNotificationParamsSchema:V,ProgressNotificationSchema:R,LoggingMessageNotificationParamsSchema:q,LoggingMessageNotificationSchema:I,ResourceContentsSchema:x,TextResourceContentsSchema:j,BlobResourceContentsSchema:C,AnnotationsSchema:T,ResourceSchema:O,ResourceTemplateSchema:E,ResourceListChangedNotificationSchema:A,ResourceUpdatedNotificationParamsSchema:W,ResourceUpdatedNotificationSchema:M,PromptArgumentSchema:N,PromptSchema:z,PromptListChangedNotificationSchema:D,TextContentSchema:F,ImageContentSchema:L,AudioContentSchema:U,ToolUseContentSchema:H,EmbeddedResourceSchema:G,ResourceLinkSchema:B,ContentBlockSchema:K,PromptMessageSchema:J,ToolAnnotationsSchema:Z,ToolListChangedNotificationSchema:Q,ModelHintSchema:X,ModelPreferencesSchema:Y,ToolChoiceSchema:ee,BooleanSchemaSchema:et,StringSchemaSchema:er,NumberSchemaSchema:ei,UntitledSingleSelectEnumSchemaSchema:eo,TitledSingleSelectEnumSchemaSchema:en,LegacyTitledEnumSchemaSchema:ea,SingleSelectEnumSchemaSchema:es,UntitledMultiSelectEnumSchemaSchema:ed,TitledMultiSelectEnumSchemaSchema:ec,MultiSelectEnumSchemaSchema:el,EnumSchemaSchema:ep,PrimitiveSchemaDefinitionSchema:eu,ElicitRequestFormParamsSchema:em,ResourceTemplateReferenceSchema:ef,PromptReferenceSchema:eh,RootSchema:ey,ClientCapabilities2026Schema:e_,ServerCapabilities2026Schema:eb,RequestMetaEnvelopeSchema:e$,ToolSchema:eS,ToolResultContentSchema:ek,SamplingMessageContentBlockSchema:ew,SamplingMessageSchema:eP,ResultTypeSchema:eV,ResultMetaSchema:eR,ResultSchema:ex,PaginatedResultSchema:ej,CallToolResultSchema:eC,ListToolsResultSchema:eT,ListPromptsResultSchema:eO,GetPromptResultSchema:eE,ListResourcesResultSchema:eA,ListResourceTemplatesResultSchema:eW,ReadResourceResultSchema:eM,CompleteResultSchema:eN,CacheableResultSchema:ez,DiscoverResultSchema:eD,CreateMessageRequestParamsSchema:eF,CreateMessageRequestSchema:eL,ListRootsRequestSchema:eU,CreateMessageResultSchema:eH,ListRootsResultSchema:eG,ElicitResultSchema:eB,ElicitRequestURLParamsSchema:eK,ElicitRequestParamsSchema:eJ,ElicitRequestSchema:eZ,InputRequestSchema:eQ,InputResponseSchema:eX,InputRequestsSchema:eY,InputResponsesSchema:e1,InputRequiredResultSchema:e0,InputResponseRequestParamsSchema:e4,CallToolRequestSchema:e7,ListToolsRequestSchema:te,ListPromptsRequestSchema:tt,GetPromptRequestSchema:tr,ListResourcesRequestSchema:ti,ListResourceTemplatesRequestSchema:to,ReadResourceRequestSchema:tn,CompleteRequestSchema:ts,DiscoverRequestSchema:td,SubscriptionFilterSchema:tc,SubscriptionsListenRequestSchema:tp,SubscriptionsListenResultMetaSchema:tu,SubscriptionsListenResultSchema:tm,dispatchRequestSchemas:tf,dispatchResultSchemas:ty,NotificationMetaSchema:tg,SubscriptionsAcknowledgedNotificationSchema:t_,CancelledNotificationParamsSchema:tv,CancelledNotificationSchema:tb,notificationSchemas2026:{"notifications/cancelled":tb,"notifications/progress":R,"notifications/message":I,"notifications/resources/updated":M,"notifications/resources/list_changed":A,"notifications/tools/list_changed":Q,"notifications/prompts/list_changed":D,"notifications/subscriptions/acknowledged":t_},JSONRPCResultResponseSchema:t$(ex),CallToolResultResponseSchema:t$(nD([eC,e0])),ListToolsResultResponseSchema:t$(eT),ListPromptsResultResponseSchema:t$(eO),GetPromptResultResponseSchema:t$(nD([eE,e0])),ListResourcesResultResponseSchema:t$(eA),ListResourceTemplatesResultResponseSchema:t$(eW),ReadResourceResultResponseSchema:t$(nD([eM,e0])),CompleteResultResponseSchema:t$(eN),DiscoverResultResponseSchema:t$(eD),SubscriptionsListenResultResponseSchema:t$(tm)}}()}let wn=["tools/list","prompts/list","resources/list","resources/templates/list","resources/read","server/discover"],wa=Symbol("modelcontextprotocol.resultCacheHintFallback");function ws(e){return"number"==typeof e&&Number.isSafeInteger(e)&&e>=0}function wd(e){return"public"===e||"private"===e}let wc=((Y={})[Y.ParseError=-32700]="ParseError",Y[Y.InvalidRequest=-32600]="InvalidRequest",Y[Y.MethodNotFound=-32601]="MethodNotFound",Y[Y.InvalidParams=-32602]="InvalidParams",Y[Y.InternalError=-32603]="InternalError",Y[Y.ResourceNotFound=-32002]="ResourceNotFound",Y[Y.MissingRequiredClientCapability=-32021]="MissingRequiredClientCapability",Y[Y.UnsupportedProtocolVersion=-32022]="UnsupportedProtocolVersion",Y[Y.UrlElicitationRequired=-32042]="UrlElicitationRequired",Y);var wl=class e extends Error{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.ProtocolError"})}static[Symbol.hasInstance](e){return kD(this,e)}static isInstance(e){if("function"!=typeof this)throw TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");return kD(this,e)}constructor(e,t,r){super(t),this.code=e,this.data=r,this.name="ProtocolError",kz(this,new.target)}static fromError(t,r,i){return t===wc.UrlElicitationRequired&&i&&i.elicitations?new wu(i.elicitations,r):t===wc.UnsupportedProtocolVersion&&i&&Array.isArray(i.supported)&&"string"==typeof i.requested?new wm({supported:i.supported,requested:i.requested},r):(t===wc.InvalidParams||t===wc.ResourceNotFound)&&"string"==typeof i?.uri&&(t===wc.ResourceNotFound||1===Object.keys(i).length)?new wp(i.uri,r):t===wc.MissingRequiredClientCapability&&i&&null!==i.requiredCapabilities&&"object"==typeof i.requiredCapabilities&&!Array.isArray(i.requiredCapabilities)?new wf({requiredCapabilities:i.requiredCapabilities},r):new e(t,r,i)}},wp=class extends wl{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.ResourceNotFoundError"})}constructor(e,t=`Resource not found: ${e}`){super(wc.InvalidParams,t,{uri:e})}get uri(){return this.data.uri}},wu=class extends wl{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.UrlElicitationRequiredError"})}constructor(e,t=`URL elicitation${e.length>1?"s":""} required`){super(wc.UrlElicitationRequired,t,{elicitations:e})}get elicitations(){return this.data?.elicitations??[]}},wm=class extends wl{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.UnsupportedProtocolVersionError"})}constructor(e,t=`Unsupported protocol version: ${e.requested}`){super(wc.UnsupportedProtocolVersion,t,e)}get supported(){return this.data.supported}get requested(){return this.data.requested}},wf=class extends wl{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.MissingRequiredClientCapabilityError"})}constructor(e,t=`Missing required client capabilities: ${Object.keys(e.requiredCapabilities).join(", ")}`){super(wc.MissingRequiredClientCapability,t,e)}get requiredCapabilities(){return this.data.requiredCapabilities}};let wh=["tools/call","prompts/get","resources/read"],wy=["elicitation/create","sampling/createMessage","roots/list"];function wg(){if(p)return p;let e=wo();return p={request:{"elicitation/create":nM({method:nQ("elicitation/create"),params:e.ElicitRequestParamsSchema}),"sampling/createMessage":nM({method:nQ("sampling/createMessage"),params:e.CreateMessageRequestParamsSchema}),"roots/list":nM({method:nQ("roots/list"),params:nN({}).optional()})},response:{"elicitation/create":e.ElicitResultSchema,"sampling/createMessage":e.CreateMessageResultSchema,"roots/list":e.ListRootsResultSchema}}}function w_(e){return wy.includes(e)}function wv(e){return w_(e)?wg().request[e]:void 0}let wb={"tools/call":null,"tools/list":null,"prompts/get":null,"prompts/list":null,"resources/list":null,"resources/templates/list":null,"resources/read":null,"completion/complete":null,"server/discover":null,"subscriptions/listen":null},w$={"notifications/cancelled":null,"notifications/progress":null,"notifications/message":null,"notifications/resources/updated":null,"notifications/resources/list_changed":null,"notifications/tools/list_changed":null,"notifications/prompts/list_changed":null,"notifications/subscriptions/acknowledged":null};function wS(e){return Object.prototype.hasOwnProperty.call(wb,e)}function wk(e){return Object.prototype.hasOwnProperty.call(w$,e)}function ww(e){return null!==e&&"object"==typeof e&&!Array.isArray(e)}function wP(e,t){if(void 0===e)return{ok:!1,reason:"not-in-era"};let r=e.safeParse(t);return r.success?{ok:!0,value:r.data}:{ok:!1,reason:"invalid",message:String(r.error)}}Object.keys(wb),Object.keys(w$);let wV={ok:!1,reason:"not-in-era"},wR=[al,am],wq={era:"2026-07-28",hasRequestMethod:wS,hasNotificationMethod:wk,hasInputRequestMethod:e=>void 0!==wv(e),validateRequest:(e,t)=>wP(wS(e)?wo().dispatchRequestSchemas[e]:void 0,t),validateResult:(e,t)=>wP(Object.prototype.hasOwnProperty.call(wb,e)?wo().dispatchResultSchemas[e]:void 0,t),validateNotification:(e,t)=>wP(wk(e)?wo().notificationSchemas2026[e]:void 0,t),validateInputRequest:(e,t)=>wP(wv(e),t),validateInputResponse:(e,t)=>wP(w_(e)?wg().response[e]:void 0,t),samplingResultVariant:()=>wV,outboundEnvelope:e=>({[al]:e.protocolVersion,[ap]:e.clientInfo,[am]:e.clientCapabilities,...void 0!==e.logLevel&&{[ah]:e.logLevel}}),validateEnvelopeMeta(e){let t=[];for(let r of wR)r in e||t.push({key:r,problem:"missing"});let r=wo().RequestMetaEnvelopeSchema.safeParse(e);if(!r.success)for(let e of r.error.issues){let r=e.path.map(String),i=r.length>0?r.join("."):"_meta";1===r.length&&t.some(e=>e.key===i&&"missing"===e.problem)||t.push({key:i,problem:e.message})}return t},projectCallToolResult:e=>kJ(e),inputRequestSchema:wv,decodeResult(e,t){if(!ww(t))return{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: not an object`,{method:e})};let r=t.resultType;if(void 0===r)return{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: missing required resultType — servers implementing protocol revision 2026-07-28 MUST include it (the absent-means-complete bridge applies only to earlier-revision servers)`,{method:e,violation:"missing-resultType"})};if("string"!=typeof r)return{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: non-string resultType`,{method:e,resultType:r})};if("input_required"===r){let r=t.inputRequests,i=ww(r)?r:{},o=t.requestState,n=void 0===t._meta?void 0:wo().ResultMetaSchema.safeParse(t._meta),a=n?.success?n.data:void 0;return 0===Object.keys(i).length&&"string"!=typeof o?{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: input_required carries neither inputRequests nor requestState (every input_required result must include at least one of the two)`,{method:e,violation:"input-required-missing-both"})}:{kind:"input_required",inputRequests:i,..."string"==typeof o&&{requestState:o},...void 0!==a&&{_meta:a}}}if("complete"!==r)return{kind:"invalid",error:new kL(kF.UnsupportedResultType,`Unsupported result type '${r}' for ${e}`,{resultType:r,method:e})};let i=function(){if(u)return u;let e=wo();return u={"tools/call":e.CallToolResultSchema,"tools/list":e.ListToolsResultSchema,"prompts/get":e.GetPromptResultSchema,"prompts/list":e.ListPromptsResultSchema,"resources/list":e.ListResourcesResultSchema,"resources/templates/list":e.ListResourceTemplatesResultSchema,"resources/read":e.ReadResourceResultSchema,"completion/complete":e.CompleteResultSchema,"server/discover":e.DiscoverResultSchema}}(),o=Object.hasOwn(i,e)?i[e]:void 0;if(void 0!==o){let r=o.safeParse(t);if(!r.success)return{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: ${r.error}`,{method:e})}}let n={...t};return delete n.resultType,{kind:"complete",result:n}},encodeResult:(e,t,r)=>(function(e,t){if(void 0===t)return e;let r=e._meta;return void 0===r?{...e,_meta:{[au]:t}}:null===r||"object"!=typeof r||Array.isArray(r)||void 0!==r[au]?e:{...e,_meta:{...r,[au]:t}}})(function(e,t){var r,i;let o=t[wa];if("complete"!==t.resultType||!wn.includes(e)){let e;return void 0===o?t:(e={...t},delete e[wa],e)}let n=ws(t.ttlMs)?t.ttlMs:void 0!==(r=o)&&ws(r.ttlMs)?r.ttlMs:0,a=wd(t.cacheScope)?t.cacheScope:void 0!==(i=o)&&wd(i.cacheScope)?i.cacheScope:"private",s={...t,ttlMs:n,cacheScope:a};return delete s[wa],s}(e,function(e,t){let r=t.resultType;if(void 0===r)return{...t,resultType:"complete"};if("complete"===r||wh.includes(e))return t;throw new wl(wc.InternalError,`Handler for ${e} returned resultType '${String(r)}', but results of ${e} only support 'complete' on protocol revision 2026-07-28`)}(e,function(e,t){let r=t,i=!1,o=()=>(i||(r={...r},i=!0),r),n=t.tools;"tools/list"===e&&Array.isArray(n)&&n.some(e=>ww(e)&&"execution"in e)&&(o().tools=n.map(e=>{if(!ww(e)||!("execution"in e))return e;let t={...e};return delete t.execution,t}));let a=t.capabilities;if(ww(a)&&"tasks"in a){let e={...a};delete e.tasks,o().capabilities=e}return r}(e,t))),r),encodeErrorCode:e=>-32002===e?-32602:e,checkInboundEnvelope(e){if(void 0===e.envelope)return"Request is missing the required _meta envelope for protocol revision 2026-07-28 (io.modelcontextprotocol/protocolVersion, io.modelcontextprotocol/clientCapabilities)";let t=wo().RequestMetaEnvelopeSchema.safeParse(e.envelope);if(!t.success)return`Invalid _meta envelope for protocol revision 2026-07-28: ${t.error.issues.map(e=>e.message).join("; ")}`}},wI="2026-07-28";function wx(e){return void 0!==e&&e>=kH?wq:wi}function wj(e){return void 0!==e.revision?wx(e.revision).era:"modern"===e.era?wq.era:wi.era}function wC(e){return wE.some(t=>t.hasRequestMethod(e))}function wT(e){return wE.some(t=>t.hasNotificationMethod(e))}function wO(e){return"tasks/get"===e||"tasks/cancel"===e}let wE=[wi,wq];var wA=(e=>{let t={};for(var r in e)kI(t,r,{get:e[r],enumerable:!0});return t})({AnnotationsSchema:()=>sn,AudioContentSchema:()=>sE,BaseMetadataSchema:()=>aL,BaseRequestParamsSchema:()=>aw,BlobResourceContentsSchema:()=>si,BooleanSchemaSchema:()=>ds,CallToolRequestParamsSchema:()=>sZ,CallToolRequestSchema:()=>sQ,CallToolResultSchema:()=>sK,CancelTaskRequestSchema:()=>dB,CancelTaskResultSchema:()=>dK,CancelledNotificationParamsSchema:()=>aN,CancelledNotificationSchema:()=>az,ClientCapabilitiesSchema:()=>aJ,ClientNotificationSchema:()=>dZ,ClientRequestSchema:()=>dJ,ClientResultSchema:()=>dQ,ClientTasksCapabilitySchema:()=>aB,CompatibilityCallToolResultSchema:()=>sJ,CompleteRequestParamsSchema:()=>dq,CompleteRequestSchema:()=>dI,CompleteResultSchema:()=>dx,ContentBlockSchema:()=>sN,CreateMessageRequestParamsSchema:()=>dr,CreateMessageRequestSchema:()=>di,CreateMessageResultSchema:()=>dn,CreateMessageResultWithToolsSchema:()=>da,CreateTaskResultSchema:()=>dM,CursorSchema:()=>ab,DiscoverRequestSchema:()=>a0,DiscoverResultSchema:()=>a2,ElicitRequestFormParamsSchema:()=>dv,ElicitRequestParamsSchema:()=>d$,ElicitRequestSchema:()=>dS,ElicitRequestURLParamsSchema:()=>db,ElicitResultSchema:()=>dP,ElicitationCompleteNotificationParamsSchema:()=>dk,ElicitationCompleteNotificationSchema:()=>dw,EmbeddedResourceSchema:()=>sW,EmptyResultSchema:()=>aM,EnumSchemaSchema:()=>dg,GetPromptRequestParamsSchema:()=>sj,GetPromptRequestSchema:()=>sC,GetPromptResultSchema:()=>sD,GetTaskPayloadRequestSchema:()=>dL,GetTaskPayloadResultSchema:()=>dU,GetTaskRequestSchema:()=>dD,GetTaskResultSchema:()=>dF,IconSchema:()=>aD,IconsSchema:()=>aF,ImageContentSchema:()=>sO,ImplementationSchema:()=>aU,InitializeRequestParamsSchema:()=>aZ,InitializeRequestSchema:()=>aQ,InitializeResultSchema:()=>aY,InitializedNotificationSchema:()=>a1,JSONArraySchema:()=>a_,JSONObjectSchema:()=>ag,JSONRPCErrorResponseSchema:()=>aE,JSONRPCMessageSchema:()=>aA,JSONRPCNotificationSchema:()=>aT,JSONRPCRequestSchema:()=>aC,JSONRPCResponseSchema:()=>aW,JSONRPCResultResponseSchema:()=>aO,JSONValueSchema:()=>ay,LegacyTitledEnumSchemaSchema:()=>du,ListChangedOptionsBaseSchema:()=>sY,ListPromptsRequestSchema:()=>sI,ListPromptsResultSchema:()=>sx,ListResourceTemplatesRequestSchema:()=>sl,ListResourceTemplatesResultSchema:()=>sp,ListResourcesRequestSchema:()=>sd,ListResourcesResultSchema:()=>sc,ListRootsRequestSchema:()=>dC,ListRootsResultSchema:()=>dT,ListTasksRequestSchema:()=>dH,ListTasksResultSchema:()=>dG,ListToolsRequestSchema:()=>sG,ListToolsResultSchema:()=>sB,LoggingLevelSchema:()=>s1,LoggingMessageNotificationParamsSchema:()=>s4,LoggingMessageNotificationSchema:()=>s6,ModelHintSchema:()=>s3,ModelPreferencesSchema:()=>s9,MultiSelectEnumSchemaSchema:()=>dy,NotificationSchema:()=>aq,NotificationsParamsSchema:()=>aR,NumberSchemaSchema:()=>dc,PaginatedRequestParamsSchema:()=>a5,PaginatedRequestSchema:()=>a8,PaginatedResultSchema:()=>a7,PingRequestSchema:()=>a4,PrimitiveSchemaDefinitionSchema:()=>d_,ProgressNotificationParamsSchema:()=>a3,ProgressNotificationSchema:()=>a9,ProgressSchema:()=>a6,ProgressTokenSchema:()=>av,PromptArgumentSchema:()=>sR,PromptListChangedNotificationSchema:()=>sF,PromptMessageSchema:()=>sz,PromptReferenceSchema:()=>dR,PromptSchema:()=>sq,ReadResourceRequestParamsSchema:()=>su,ReadResourceRequestSchema:()=>sm,ReadResourceResultSchema:()=>sf,RelatedTaskMetadataSchema:()=>aS,RequestIdSchema:()=>aj,RequestMetaSchema:()=>ak,RequestSchema:()=>aV,ResourceContentsSchema:()=>se,ResourceLinkSchema:()=>sM,ResourceListChangedNotificationSchema:()=>sh,ResourceRequestParamsSchema:()=>su,ResourceSchema:()=>sa,ResourceTemplateReferenceSchema:()=>dV,ResourceTemplateSchema:()=>ss,ResourceUpdatedNotificationParamsSchema:()=>sP,ResourceUpdatedNotificationSchema:()=>sV,ResultMetaObjectSchema:()=>aI,ResultSchema:()=>ax,RoleSchema:()=>so,RootSchema:()=>dj,RootsListChangedNotificationSchema:()=>dO,SamplingContentSchema:()=>s7,SamplingMessageContentBlockSchema:()=>de,SamplingMessageSchema:()=>dt,ServerCapabilitiesSchema:()=>aX,ServerNotificationSchema:()=>dY,ServerRequestSchema:()=>dX,ServerResultSchema:()=>d1,ServerTasksCapabilitySchema:()=>aK,SetLevelRequestParamsSchema:()=>s0,SetLevelRequestSchema:()=>s2,SingleSelectEnumSchemaSchema:()=>dm,StringSchemaSchema:()=>dd,SubscribeRequestParamsSchema:()=>su,SubscribeRequestSchema:()=>sy,SubscriptionFilterSchema:()=>s_,SubscriptionsAcknowledgedNotificationParamsSchema:()=>s$,SubscriptionsAcknowledgedNotificationSchema:()=>sS,SubscriptionsListenRequestParamsSchema:()=>sv,SubscriptionsListenRequestSchema:()=>sb,SubscriptionsListenResultMetaSchema:()=>sk,SubscriptionsListenResultSchema:()=>sw,TaskAugmentedRequestParamsSchema:()=>aP,TaskCreationParamsSchema:()=>dE,TaskMetadataSchema:()=>a$,TaskSchema:()=>dW,TaskStatusNotificationParamsSchema:()=>dN,TaskStatusNotificationSchema:()=>dz,TaskStatusSchema:()=>dA,TextContentSchema:()=>sT,TextResourceContentsSchema:()=>st,TitledMultiSelectEnumSchemaSchema:()=>dh,TitledSingleSelectEnumSchemaSchema:()=>dp,ToolAnnotationsSchema:()=>sL,ToolChoiceSchema:()=>s5,ToolExecutionSchema:()=>sU,ToolListChangedNotificationSchema:()=>sX,ToolResultContentSchema:()=>s8,ToolSchema:()=>sH,ToolUseContentSchema:()=>sA,UnsubscribeRequestParamsSchema:()=>su,UnsubscribeRequestSchema:()=>sg,UntitledMultiSelectEnumSchemaSchema:()=>df,UntitledSingleSelectEnumSchemaSchema:()=>dl});let wW=e=>"object"==typeof e&&null!==e&&!Array.isArray(e)&&"input_required"===e.resultType,wM="x-mcp-header",wN=/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/,wz=new Set(["string","integer","boolean"]);function wD(e){let t,r=[],i=new Map,o=(e,n,a)=>{if(null===e||"object"!=typeof e)return;if(wM in e){if(!a||0===n.length)return`${wU(n)}: x-mcp-header is only permitted on properties statically reachable via a chain of 'properties' keys (not under items, additionalProperties, oneOf/anyOf/allOf/not, if/then/else, or $ref)`;let o=e[wM];if("string"!=typeof o||0===o.length)return`${wU(n)}: x-mcp-header MUST be a non-empty string`;if(!wN.test(o))return`${wU(n)}: x-mcp-header '${o}' is not a valid RFC 9110 token (no spaces, control characters or HTTP delimiters)`;let s="string"==typeof e.type?e.type:void 0;if(void 0===s||!wz.has(s)){let e=`${wU(n)}: x-mcp-header is only permitted on primitive-typed properties (string, integer, boolean); got ${s??"<none>"}`;if("number"!==s)return e;t??=e}let d=o.toLowerCase(),c=i.get(d);if(void 0!==c)return`x-mcp-header '${o}' is not case-insensitively unique (also declared as '${c}')`;i.set(d,o),r.push({path:n,headerName:o,type:s})}let s=e.properties;if(null!==s&&"object"==typeof s)for(let[e,t]of Object.entries(s)){let r=o(t,[...n,e],a);if(void 0!==r)return r}for(let t of wF){let r=e[t];if(void 0!==r)for(let e of Array.isArray(r)?r:null!==r&&"object"==typeof r&&wL.has(t)?Object.values(r):[r]){let r=o(e,[...n,`<${t}>`],!1);if(void 0!==r)return r}}},n=o(e,[],!0);return void 0!==n?{valid:!1,reason:t??n}:void 0===t?{valid:!0,declarations:r}:{valid:!1,reason:t,declarations:r}}let wF=["items","prefixItems","contains","additionalProperties","unevaluatedProperties","unevaluatedItems","propertyNames","patternProperties","dependentSchemas","oneOf","anyOf","allOf","not","if","then","else","$defs","definitions"],wL=new Set(["patternProperties","dependentSchemas","$defs","definitions"]);function wU(e){return 0===e.length?"<root>":e.join(".")}let wH="=?base64?";function wG(e){return new Set(e.flatMap(e=>Object.keys(e.shape)))}function wB(e){if(null==e)return!1;let t=typeof e;return("object"===t||"function"===t)&&"~standard"in e&&"function"==typeof e["~standard"]?.validate}wc.InvalidRequest,wc.UnsupportedProtocolVersion,wc.InvalidParams,wc.MethodNotFound,wc.InvalidParams,wc.MissingRequiredClientCapability,wc.ParseError,wc.InvalidRequest,wc.MethodNotFound,wc.UnsupportedProtocolVersion,wc.MissingRequiredClientCapability;let wK=!1,wJ="draft-2020-12",wZ=/^#\/(\$defs|definitions)\/([^/~%]+)$/;async function wQ(e,t){let r=await e["~standard"].validate(t);return r.issues&&r.issues.length>0?{success:!1,error:r.issues.map(e=>e.path?.length?`${e.path.map(e=>String("object"==typeof e?e.key:e)).join(".")}: ${e.message}`:e.message).join(", ")}:{success:!0,data:r.value}}let wX=/\\\.\\d\{(\d+)\}/;function wY(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}let w1=new Set(["$comment","deprecated","description","examples","readOnly","title","writeOnly"]);function w0(e){return w1.has(e)||e.startsWith("x-")}let w2=new Set(["$schema",...Object.keys(dv.shape.requestedSchema.shape)]),w4={string:wG([dd,dl,dp,du]),number:wG([dc]),integer:wG([dc]),boolean:wG([ds]),array:wG([df,dh])},w6=new Set(dd.shape.format.unwrap().options);Object.assign(function(e){let t=void 0!==e.inputRequests&&Object.keys(e.inputRequests).length>0,r="string"==typeof e.requestState;if(!t&&!r)throw TypeError("inputRequired() requires at least one of inputRequests (with at least one entry) or requestState (spec: every InputRequiredResult MUST include at least one of the two)");return{resultType:"input_required",...void 0!==e.inputRequests&&{inputRequests:e.inputRequests},...void 0!==e.requestState&&{requestState:e.requestState}}},{elicit(e){try{return{method:"elicitation/create",params:function(e){var t;if(!wB(e.requestedSchema))return{...e,mode:"form",requestedSchema:e.requestedSchema};let r=e.requestedSchema["~standard"].vendor,i=function(e,t){let r={},i=[];for(let[o,n]of Object.entries(e))"properties"===o&&wY(n)?r[o]=Object.fromEntries(Object.entries(n).map(([e,r])=>[e,function(e,t,r,i){if(!wY(e))return e;let o="string"==typeof e.type&&Object.hasOwn(w4,e.type)?w4[e.type]:void 0;if(void 0===o)return e;let n={};for(let[s,d]of Object.entries(e))if(o.has(s)||w0(s))n[s]=d;else if("pattern"===s&&"string"===e.type&&"string"==typeof e.format)if(w6.has(e.format)){var a;"string"==typeof d&&(a=e.format,"zod"!==r||(function(e,t){let r;switch(e){case"email":r=[iS(ni,void 0)];break;case"uri":r=[ik(na,void 0)];break;case"date":r=[iP(ne,void 0)];break;case"date-time":let i,o;i=wX.exec(t),o=[void 0,-1,0],i&&o.push(Number(i[1])),r=[!1,!0].flatMap(e=>[!1,!0].flatMap(t=>o.map(r=>as({local:e,offset:t,precision:r}))))}return new Set(r.map(e=>{let t;return t=oq(e,{target:wJ,io:"input"}),"string"==typeof t.pattern?t.pattern:void 0}).filter(e=>void 0!==e))})(a,d).has(d))||i.push(`${t}.${s}`)}else n[s]=d;else i.push(`${t}.${s}`);return n}(r,`properties.${e}`,t,i)])):w2.has(o)?r[o]=n:w0(o)||i.push(o);if(i.length>0)throw new wl(wc.InvalidParams,`Elicitation requestedSchema contains unsupported JSON Schema constraint(s) after Standard Schema conversion: ${i.join(", ")}`);return r}(function(e){try{return function(e,t="input"){let r,i=e["~standard"];if(i.jsonSchema)r=i.jsonSchema[t]({target:wJ});else if("zod"===i.vendor){if(!("_zod"in e))throw Error("Schema appears to be from zod 3, which the SDK cannot convert to JSON Schema. Upgrade to zod >=4.2.0, or wrap your JSON Schema with fromJsonSchema().");wK||(wK=!0,console.warn("[mcp-sdk] Your zod version does not implement `~standard.jsonSchema` (added in zod 4.2.0). Falling back to z.toJSONSchema(). Upgrade to zod >=4.2.0 to silence this warning.")),r=oq(e,{target:wJ,io:t})}else throw Error(`Schema library "${i.vendor}" does not implement StandardJSONSchemaV1 (\`~standard.jsonSchema\`). Upgrade to a version that does, or wrap your JSON Schema with fromJsonSchema().`);if("output"===t)return void 0!==r.type||!function e(t,r=t){if("properties"in t||"patternProperties"in t||"additionalProperties"in t||"required"in t)return!0;let i="string"==typeof t.$ref&&wZ.exec(t.$ref);if(i&&r[i[1]]?.[i[2]]?.type==="object")return!0;for(let i of["oneOf","anyOf","allOf"]){let o=t[i];if(Array.isArray(o)&&o.length>0)return o.every(t=>null!==t&&"object"==typeof t&&("object"===t.type||e(t,"$id"in t?{}:r)))}return!1}(r)?r:{type:"object",...r};if(void 0!==r.type&&"object"!==r.type)throw Error(`MCP tool and prompt schemas must describe objects (got type: ${JSON.stringify(r.type)}). Wrap your schema in z.object({...}) or equivalent.`);return{type:"object",...r}}(e,"input")}catch(t){let e=t instanceof Error?t.message:String(t);throw new wl(wc.InvalidParams,`Elicitation requestedSchema must describe an object with flat primitive properties: ${e}`)}}(e.requestedSchema),r),o=(t=dv.shape.requestedSchema,oB(t,i));if(!o.success)throw new wl(wc.InvalidParams,`Elicitation requestedSchema only supports flat primitive properties (string, number, integer, boolean, and string enums): ${function(e,t){if(!wY(e.properties))return t;let r=Object.entries(e.properties).filter(([,e])=>!oB(d_,e).success).map(([e])=>`properties.${e}`);return r.length>0?r.join(", "):t}(i,o.error.message)}`);let n=function e(t,r,i=""){return Array.isArray(t)&&Array.isArray(r)?t.flatMap((t,o)=>e(t,r[o],`${i}[${o}]`)):wY(t)&&wY(r)?Object.entries(t).flatMap(([t,o])=>{let n=i?`${i}.${t}`:t;return Object.prototype.hasOwnProperty.call(r,t)?e(o,r[t],n):w0(t)?[]:[n]}):[]}(i,o.data);if(n.length>0)throw new wl(wc.InvalidParams,`Elicitation requestedSchema contains unsupported JSON Schema constraint(s) after Standard Schema conversion: ${n.join(", ")}`);let a=(o.data.required??[]).filter(e=>!Object.prototype.hasOwnProperty.call(o.data.properties,e));if(a.length>0)throw new wl(wc.InvalidParams,`Elicitation requestedSchema lists required properties that are not defined in properties: ${a.join(", ")}`);return{...e,mode:"form",requestedSchema:o.data}}(e)}}catch(e){throw e instanceof wl?TypeError(e.message,{cause:e}):e}},elicitUrl:e=>({method:"elicitation/create",params:{...e,mode:"url"}}),createMessage:e=>({method:"sampling/createMessage",params:e}),listRoots:()=>({method:"roots/list"})});let w3={},w9={};function w5(e,t){let r=e.slice(0,-6);w3[r]=t,w9[r]=e=>t.safeParse(e).success}for(let e of["AnnotationsSchema","AudioContentSchema","BaseMetadataSchema","BlobResourceContentsSchema","BooleanSchemaSchema","CallToolRequestSchema","CallToolRequestParamsSchema","CallToolResultSchema","CancelledNotificationSchema","CancelledNotificationParamsSchema","CancelTaskRequestSchema","CancelTaskResultSchema","ClientCapabilitiesSchema","ClientNotificationSchema","ClientRequestSchema","ClientResultSchema","CompatibilityCallToolResultSchema","CompleteRequestSchema","CompleteRequestParamsSchema","CompleteResultSchema","ContentBlockSchema","CreateMessageRequestSchema","CreateMessageRequestParamsSchema","CreateMessageResultSchema","CreateMessageResultWithToolsSchema","CreateTaskResultSchema","CursorSchema","DiscoverRequestSchema","DiscoverResultSchema","ElicitationCompleteNotificationSchema","ElicitationCompleteNotificationParamsSchema","ElicitRequestSchema","ElicitRequestFormParamsSchema","ElicitRequestParamsSchema","ElicitRequestURLParamsSchema","ElicitResultSchema","EmbeddedResourceSchema","EmptyResultSchema","EnumSchemaSchema","GetPromptRequestSchema","GetPromptRequestParamsSchema","GetPromptResultSchema","GetTaskPayloadRequestSchema","GetTaskPayloadResultSchema","GetTaskRequestSchema","GetTaskResultSchema","IconSchema","IconsSchema","ImageContentSchema","ImplementationSchema","InitializedNotificationSchema","InitializeRequestSchema","InitializeRequestParamsSchema","InitializeResultSchema","JSONArraySchema","JSONObjectSchema","JSONRPCErrorResponseSchema","JSONRPCMessageSchema","JSONRPCNotificationSchema","JSONRPCRequestSchema","JSONRPCResponseSchema","JSONRPCResultResponseSchema","JSONValueSchema","LegacyTitledEnumSchemaSchema","ListPromptsRequestSchema","ListPromptsResultSchema","ListResourcesRequestSchema","ListResourcesResultSchema","ListResourceTemplatesRequestSchema","ListResourceTemplatesResultSchema","ListRootsRequestSchema","ListRootsResultSchema","ListTasksRequestSchema","ListTasksResultSchema","ListToolsRequestSchema","ListToolsResultSchema","LoggingLevelSchema","LoggingMessageNotificationSchema","LoggingMessageNotificationParamsSchema","ModelHintSchema","ModelPreferencesSchema","MultiSelectEnumSchemaSchema","NotificationSchema","NumberSchemaSchema","PaginatedRequestSchema","PaginatedRequestParamsSchema","PaginatedResultSchema","PingRequestSchema","PrimitiveSchemaDefinitionSchema","ProgressSchema","ProgressNotificationSchema","ProgressNotificationParamsSchema","ProgressTokenSchema","PromptSchema","PromptArgumentSchema","PromptListChangedNotificationSchema","PromptMessageSchema","PromptReferenceSchema","ReadResourceRequestSchema","ReadResourceRequestParamsSchema","ReadResourceResultSchema","RelatedTaskMetadataSchema","RequestSchema","RequestIdSchema","RequestMetaSchema","ResourceSchema","ResourceContentsSchema","ResourceLinkSchema","ResourceListChangedNotificationSchema","ResourceRequestParamsSchema","ResourceTemplateSchema","ResourceTemplateReferenceSchema","ResourceUpdatedNotificationSchema","ResourceUpdatedNotificationParamsSchema","ResultMetaObjectSchema","ResultSchema","RoleSchema","RootSchema","RootsListChangedNotificationSchema","SamplingContentSchema","SamplingMessageSchema","SamplingMessageContentBlockSchema","ServerCapabilitiesSchema","ServerNotificationSchema","ServerRequestSchema","ServerResultSchema","SetLevelRequestSchema","SetLevelRequestParamsSchema","SingleSelectEnumSchemaSchema","StringSchemaSchema","SubscribeRequestSchema","SubscribeRequestParamsSchema","SubscriptionFilterSchema","SubscriptionsAcknowledgedNotificationSchema","SubscriptionsAcknowledgedNotificationParamsSchema","SubscriptionsListenRequestSchema","SubscriptionsListenRequestParamsSchema","SubscriptionsListenResultSchema","SubscriptionsListenResultMetaSchema","TaskAugmentedRequestParamsSchema","TaskCreationParamsSchema","TaskMetadataSchema","TaskSchema","TaskStatusSchema","TaskStatusNotificationSchema","TaskStatusNotificationParamsSchema","TextContentSchema","TextResourceContentsSchema","TitledMultiSelectEnumSchemaSchema","TitledSingleSelectEnumSchemaSchema","ToolSchema","ToolAnnotationsSchema","ToolChoiceSchema","ToolExecutionSchema","ToolListChangedNotificationSchema","ToolResultContentSchema","ToolUseContentSchema","UnsubscribeRequestSchema","UnsubscribeRequestParamsSchema","UntitledMultiSelectEnumSchemaSchema","UntitledSingleSelectEnumSchemaSchema"])w5(e,wA[e]);for(let[e,t]of Object.entries({IdJagTokenExchangeResponseSchema:d7,OAuthClientInformationFullSchema:co,OAuthClientInformationSchema:ci,OAuthClientMetadataSchema:cr,OAuthClientRegistrationErrorSchema:cn,OAuthErrorResponseSchema:ce,OAuthMetadataSchema:d3,OAuthProtectedResourceMetadataSchema:d6,OAuthTokenRevocationRequestSchema:ca,OAuthTokensSchema:d8,OpenIdProviderDiscoveryMetadataSchema:d5,OpenIdProviderMetadataSchema:d9}))w5(e,t);Object.freeze(w3);let w8=Object.freeze(w9),w7=[al,ap,am,ah],Pe=["inputResponses","requestState"];function Pt(e,t){let r=e.params;if(!Pn(r))return{message:e,lifted:{}};let i=r._meta,o=Pn(i)?w7.filter(e=>e in i):[],n="request"===t?Pe.filter(e=>e in r):[];if(0===o.length&&0===n.length)return{message:e,lifted:{}};let a={},s={...r};if(o.length>0&&Pn(i)){let e={},t={...i};for(let r of o)e[r]=i[r],delete t[r];a.envelope=e,Object.keys(t).length>0?s._meta=t:delete s._meta}for(let e of n)"inputResponses"===e&&(a.inputResponses=s[e]),"requestState"===e&&(a.requestState=s[e]),delete s[e];return{message:{...e,params:s},lifted:a}}function Pr(e,t){let r=e.validateResult(t,void 0);if(r.ok||"not-in-era"!==r.reason)return{"~standard":{version:1,vendor:"mcp-wire-codec",validate(r){let i=e.validateResult(t,r);return i.ok?{value:i.value}:{issues:[{message:"invalid"===i.reason?i.message:`not-in-era: ${t}`}]}}}}}let Pi=(ee=void 0,()=>ee);var Po=class{_transport;_requestMessageId=0;_requestHandlers=new Map;_customSchemaRequestMethods=new Set;_requestHandlerAbortControllers=new Map;_notificationHandlers=new Map;_responseHandlers=new Map;_progressHandlers=new Map;_timeoutInfo=new Map;_pendingDebouncedNotifications=new Set;_negotiatedProtocolVersion;_supportedProtocolVersions;onclose;onerror;fallbackRequestHandler;fallbackNotificationHandler;constructor(e){this._options=e,this._supportedProtocolVersions=e?.supportedProtocolVersions??ac,this.setNotificationHandler("notifications/cancelled",e=>{this._oncancel(e)}),this.setNotificationHandler("notifications/progress",e=>{this._onprogress(e)}),this.setRequestHandler("ping",e=>({}))}_shouldDropInbound(e){}_outboundMetaEnvelope(){}_envelopeOutbound(e){let t=this._outboundMetaEnvelope();if(void 0===t)return e;let r=e.params??{};return{...e,params:{...r,_meta:{...t,...r._meta}}}}_resolveNonCompleteResult(e,t){return Promise.reject(new kL(kF.UnsupportedResultType,`Unsupported result type '${e.kind}' for ${t.request.method}`,{resultType:e.kind,method:t.request.method}))}_getRequestHandler(e){return this._requestHandlers.get(e)}async _oncancel(e){void 0!==e.params.requestId&&this._requestHandlerAbortControllers.get(e.params.requestId)?.abort(e.params.reason)}_setupTimeout(e,t,r,i,o=!1){this._timeoutInfo.set(e,{timeoutId:setTimeout(i,t),startTime:Date.now(),timeout:t,maxTotalTimeout:r,resetTimeoutOnProgress:o,onTimeout:i})}_resetTimeout(e){let t=this._timeoutInfo.get(e);if(!t)return!1;let r=Date.now()-t.startTime;if(t.maxTotalTimeout&&r>=t.maxTotalTimeout)throw this._timeoutInfo.delete(e),new kL(kF.RequestTimeout,"Maximum total timeout exceeded",{maxTotalTimeout:t.maxTotalTimeout,totalElapsed:r});return clearTimeout(t.timeoutId),t.timeoutId=setTimeout(t.onTimeout,t.timeout),!0}_cleanupTimeout(e){let t=this._timeoutInfo.get(e);t&&(clearTimeout(t.timeoutId),this._timeoutInfo.delete(e))}async connect(e){this._transport=e;let t=this.transport?.onclose;this._transport.onclose=()=>{try{t?.()}finally{this._onclose()}};let r=this.transport?.onerror;this._transport.onerror=e=>{r?.(e),this._onerror(e)};let i=this._transport?.onmessage;this._transport.onmessage=(e,t)=>{if(i?.(e,t),aO.safeParse(e).success||aE.safeParse(e).success)this._onresponse(e);else if(aC.safeParse(e).success)this._onrequest(e,t);else aT.safeParse(e).success?this._onnotification(e,t):this._onerror(Error(`Unknown message type: ${JSON.stringify(e)}`))},e.setSupportedProtocolVersions?.(this._supportedProtocolVersions),await this._transport.start()}_onclose(){let e=this._responseHandlers;for(let e of(this._responseHandlers=new Map,this._progressHandlers.clear(),this._pendingDebouncedNotifications.clear(),this._timeoutInfo.values()))clearTimeout(e.timeoutId);this._timeoutInfo.clear();let t=this._requestHandlerAbortControllers;this._requestHandlerAbortControllers=new Map;let r=new kL(kF.ConnectionClosed,"Connection closed");this._transport=void 0;try{this.onclose?.()}finally{for(let t of e.values())t(r);for(let e of t.values())e.abort(r)}}_onerror(e){this.onerror?.(e)}_onnotification(e,t){let{message:r}=Pt(e,"notification"),i=this._negotiatedWireCodec();if(t?.classification===void 0&&"drop"===this._shouldDropInbound(e))return;if(t?.classification!==void 0){let e=wj(t.classification);if(e!==i.era)return void this._onerror(Error(`Era mismatch on inbound notification '${r.method}': classified as ${e} but this instance serves ${i.era}`))}if(wT(r.method)&&!i.hasNotificationMethod(r.method))return;let o=this._notificationHandlers.get(r.method),n=this.fallbackNotificationHandler;(void 0!==o||void 0!==n)&&Promise.resolve().then(()=>void 0===o?n(r):o(r,i)).catch(e=>this._onerror(Error(`Uncaught error in notification handler: ${e}`)))}_onrequest(e,t){var r;let{message:i,lifted:o}=Pt(e,"request"),n=this._negotiatedWireCodec();if(t?.classification===void 0&&"drop"===this._shouldDropInbound(e))return void this._onerror(Error(`Dropped inbound request '${e.method}': not servable on this connection's protocol era`));let a=this._transport,s=(e,t,r)=>{let o={jsonrpc:"2.0",id:i.id,error:{code:e,message:t,...void 0!==r&&{data:r}}};a?.send(o).catch(e=>this._onerror(Error(`Failed to send an error response: ${e}`)))};if(t?.classification!==void 0){let e=wj(t.classification);if(e!==n.era){this._onerror(Error(`Era mismatch on inbound request '${i.method}': classified as ${e} but this instance serves ${n.era}`));let r=t.classification.revision??e;s(wc.UnsupportedProtocolVersion,`Unsupported protocol version: ${r}`,{supported:this._supportedProtocolVersions,requested:r});return}}if(wC(i.method)&&!n.hasRequestMethod(i.method)&&!(wO(i.method)&&this._customSchemaRequestMethods.has(i.method)))return void s(wc.MethodNotFound,"Method not found");let d=this._requestHandlers.get(i.method)??this.fallbackRequestHandler;if(void 0===d)return void s(wc.MethodNotFound,"Method not found");let c=n.checkInboundEnvelope(o);if(void 0!==c)return void s(wc.InvalidParams,c);let l=(e,t)=>this._notificationViaCodec(this._resolveOutboundCodec(e.method),e,{...t,relatedRequestId:i.id}),p=(e,t,r)=>this._requestWithSchemaViaCodec(this._resolveOutboundCodec(e.method),e,t,{...r,relatedRequestId:i.id}),u=new AbortController;this._requestHandlerAbortControllers.set(i.id,u);let m=void 0===o.inputResponses?void 0:function(e){let t={},r=[];if(!Pa(e))return{accepted:t,droppedKeys:r};for(let[i,o]of Object.entries(e)){if(!Pa(o)||"method"in o||"result"in o){r.push(i);continue}t[i]=o}return{accepted:t,droppedKeys:r}}(o.inputResponses),f={sessionId:a?.sessionId,mcpReq:{id:i.id,method:i.method,_meta:i.params?._meta,...void 0!==o.envelope&&{envelope:o.envelope},...void 0!==m&&{inputResponses:m.accepted},...void 0!==m&&m.droppedKeys.length>0&&{droppedInputResponseKeys:m.droppedKeys},requestState:void 0===o.requestState?Pi:(r=o.requestState,()=>r),signal:u.signal,send:(e,t,r)=>{let i=this._resolveOutboundCodec(e.method);if(this._assertOutboundRequestInEra(i,e.method),wB(t))return p(e,t,r);let o=Pr(i,e.method);if(void 0===o)throw TypeError(`'${e.method}' is not a spec method; pass a result schema as the second argument to ctx.mcpReq.send().`);return p(e,o,t)},notify:l},http:t?.authInfo?{authInfo:t.authInfo}:void 0},h=this.buildContext(f,t);Promise.resolve().then(()=>d(i,h)).then(async e=>{let t;if(u.signal.aborted)return;try{t=n.encodeResult(i.method,e,this._outboundServerInfo())}catch(e){this._onerror(Error(`Failed to encode result for ${i.method}: ${e}`)),s(wc.InternalError,"Internal error");return}let r={result:t,jsonrpc:"2.0",id:i.id};await a?.send(r)},async e=>{if(u.signal.aborted)return;let t=Number.isSafeInteger(e.code)?e.code:wc.InternalError,r={jsonrpc:"2.0",id:i.id,error:{code:n.encodeErrorCode(t),message:e.message??"Internal error",...void 0!==e.data&&{data:e.data}}};await a?.send(r)}).catch(e=>this._onerror(Error(`Failed to send response: ${e}`))).finally(()=>{this._requestHandlerAbortControllers.get(i.id)===u&&this._requestHandlerAbortControllers.delete(i.id)})}_onprogress(e){let{progressToken:t,...r}=e.params,i=Number(t),o=this._progressHandlers.get(i);if(!o)return void this._onerror(Error(`Received a progress notification for an unknown token: ${JSON.stringify(e)}`));let n=this._responseHandlers.get(i),a=this._timeoutInfo.get(i);if(a&&n&&a.resetTimeoutOnProgress)try{this._resetTimeout(i)}catch(e){this._responseHandlers.delete(i),this._progressHandlers.delete(i),this._cleanupTimeout(i),n(e);return}o(r)}_onresponse(e){let t=Number(e.id),r=this._responseHandlers.get(t);void 0===r?this._onerror(Error(`Received a response for an unknown message ID: ${JSON.stringify(e)}`)):(this._responseHandlers.delete(t),this._cleanupTimeout(t),this._progressHandlers.delete(t),r(aO.safeParse(e).success?e:wl.fromError(e.error.code,e.error.message,e.error.data)))}get transport(){return this._transport}async close(){await this._transport?.close()}request(e,t,r){let i=this._resolveOutboundCodec(e.method);if(wB(t))return wO(e.method)||this._assertOutboundRequestInEra(i,e.method),this._requestWithSchemaViaCodec(i,e,t,r);this._assertOutboundRequestInEra(i,e.method);let o=Pr(i,e.method);if(void 0===o)throw TypeError(`'${e.method}' is not a spec method; pass a result schema as the second argument to request().`);return this._requestWithSchemaViaCodec(i,e,o,t)}_negotiatedWireCodec(){return wx(this._negotiatedProtocolVersion)}_wireCodec(){return this._negotiatedWireCodec()}_resolveOutboundCodec(e){if(void 0===this._negotiatedProtocolVersion){let t=function(e){switch(e){case"initialize":case"notifications/initialized":return wx(void 0);case"server/discover":return wx(wI);default:return}}(e);if(t)return t}return this._negotiatedWireCodec()}_assertOutboundRequestInEra(e,t){if(wC(t)&&!e.hasRequestMethod(t))throw new kL(kF.MethodNotSupportedByProtocolVersion,`Method '${t}' is not supported by the negotiated protocol version (wire era ${e.era})`,{method:t,era:e.era})}_requestWithSchema(e,t,r){let i=this._resolveOutboundCodec(e.method);return this._assertOutboundRequestInEra(i,e.method),this._requestWithSchemaViaCodec(i,e,t,r)}_requestWithSchemaViaCodec(e,t,r,i){let o,n,{relatedRequestId:a,resumptionToken:s,onresumptiontoken:d,headers:c}=i??{},l=Date.now();return new Promise((p,u)=>{let m=e=>{u(e)};if(!this._transport)return void m(Error("Not connected"));if(this._options?.enforceStrictCapabilities===!0)try{this.assertCapabilityForMethod(t.method)}catch(e){m(e);return}if(i?.signal?.aborted){let e=i.signal.reason;throw e instanceof kL?e:new kL(kF.RequestTimeout,String(e))}let f=e.era===wI&&!0===this._transport.hasPerRequestStream?new AbortController:void 0,h=this._requestMessageId++;n=h;let y={...t,jsonrpc:"2.0",id:h};i?.onprogress&&(this._progressHandlers.set(h,i.onprogress),y.params={...t.params,_meta:{...t.params?._meta,progressToken:h}});let g=this._envelopeOutbound(y),_=!1,v=e=>{_||(this._progressHandlers.delete(h),void 0===f?"initialize"!==t.method&&this._transport?.send(this._envelopeOutbound({jsonrpc:"2.0",method:"notifications/cancelled",params:{requestId:h,reason:String(e)}}),{relatedRequestId:a,resumptionToken:s,onresumptiontoken:d}).catch(e=>this._onerror(Error(`Failed to send cancellation: ${e}`))):f.abort(),u(e instanceof kL?e:new kL(kF.RequestTimeout,String(e))))};this._responseHandlers.set(h,o=>{let n;if(!i?.signal?.aborted){if(_=!0,o instanceof Error)return u(o);try{n=e.decodeResult(t.method,o.result)}catch(e){return u(e instanceof Error?e:Error(String(e)))}if("invalid"===n.kind)return u(n.error);if("input_required"===n.kind){var a;return i?.allowInputRequired===!0?p({resultType:"input_required",inputRequests:(a=n).inputRequests,...void 0!==a.requestState&&{requestState:a.requestState},...void 0!==a._meta&&{_meta:a._meta}}):p(this._resolveNonCompleteResult(n,{codec:e,request:t,resultSchema:r,options:i,flowStartedAt:l,retry:(i,o)=>this._requestWithSchemaViaCodec(e,void 0===i?{method:t.method}:{method:t.method,params:i},r,o)}))}wQ(r,n.result).then(e=>{e.success?p(e.data):u(new kL(kF.InvalidResult,`Invalid result for ${t.method}: ${e.error}`))},u)}}),o=()=>v(i?.signal?.reason),i?.signal?.addEventListener("abort",o,{once:!0});let b=i?.timeout??6e4;this._setupTimeout(h,b,i?.maxTotalTimeout,()=>v(new kL(kF.RequestTimeout,"Request timed out",{timeout:b})),i?.resetTimeoutOnProgress??!1),this._transport.send(g,{relatedRequestId:a,resumptionToken:s,onresumptiontoken:d,headers:c,requestSignal:f?.signal}).catch(e=>{this._progressHandlers.delete(h),u(e)})}).finally(()=>{o&&i?.signal?.removeEventListener("abort",o),void 0!==n&&(this._responseHandlers.delete(n),this._cleanupTimeout(n))})}async notification(e,t){return await this._notificationViaCodec(this._resolveOutboundCodec(e.method),e,t)}async _notificationViaCodec(e,t,r){if(!this._transport)throw new kL(kF.NotConnected,"Not connected");if(wT(t.method)&&!e.hasNotificationMethod(t.method))throw new kL(kF.MethodNotSupportedByProtocolVersion,`Notification '${t.method}' is not supported by the negotiated protocol version (wire era ${e.era})`,{method:t.method,era:e.era});this.assertNotificationCapability(t.method);let i=this._envelopeOutbound({jsonrpc:"2.0",...t});if((this._options?.debouncedNotificationMethods??[]).includes(t.method)&&!t.params&&r?.relatedRequestId===void 0){if(this._pendingDebouncedNotifications.has(t.method))return;this._pendingDebouncedNotifications.add(t.method),Promise.resolve().then(()=>{this._pendingDebouncedNotifications.delete(t.method),this._transport&&this._transport?.send(i,r).catch(e=>this._onerror(e))});return}await this._transport.send(i,r)}setRequestHandler(e,t,r){let i;if(this.assertRequestHandlerCapability(e),"function"==typeof t){if(!wC(e))throw TypeError(`'${e}' is not a spec request method; pass schemas as the second argument to setRequestHandler().`);i=(r,i)=>{let o=this._negotiatedWireCodec(),n=o.validateRequest(e,r);if(n.ok||"not-in-era"!==n.reason||(n=o.validateInputRequest(e,r)),!n.ok){if("not-in-era"===n.reason)throw new wl(wc.InternalError,`No wire schema for ${e} in the resolved era`);throw Error(n.message)}return Promise.resolve(t(n.value,i))}}else if(r)i=async(i,o)=>{let n=await wQ(t.params,{...i.params});if(!n.success)throw new wl(wc.InvalidParams,`Invalid params for ${e}: ${n.error}`);return r(n.data,o)};else throw TypeError("setRequestHandler: handler is required");"function"==typeof t?this._customSchemaRequestMethods.delete(e):this._customSchemaRequestMethods.add(e),this._requestHandlers.set(e,this._wrapHandler(e,i))}_wrapHandler(e,t){return t}_outboundServerInfo(){}removeRequestHandler(e){this._requestHandlers.delete(e),this._customSchemaRequestMethods.delete(e)}assertCanSetRequestHandler(e){if(this._requestHandlers.has(e))throw Error(`A request handler for ${e} already exists, which would be overridden`)}setNotificationHandler(e,t,r){if("function"==typeof t){if(!wT(e))throw TypeError(`'${e}' is not a spec notification method; pass schemas as the second argument to setNotificationHandler().`);this._notificationHandlers.set(e,(r,i)=>{let o=i.validateNotification(e,r);if(!o.ok){if("not-in-era"===o.reason)throw new wl(wc.InternalError,`No wire schema for ${e} in the resolved era`);throw Error(o.message)}return Promise.resolve(t(o.value))});return}if(!r)throw TypeError("setNotificationHandler: handler is required");this._notificationHandlers.set(e,async i=>{let o=await wQ(t.params,{...i.params});if(!o.success)throw new wl(wc.InvalidParams,`Invalid params for notification ${e}: ${o.error}`);await r(o.data,i)})}removeNotificationHandler(e){this._notificationHandlers.delete(e)}};function Pn(e){return null!==e&&"object"==typeof e&&!Array.isArray(e)}function Pa(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function Ps(e){throw new kL(kF.SendFailed,`ctx.mcpReq.${e} is not available while fulfilling an embedded input request: the request is fulfilled locally and has no related peer request`)}(kO(e=>{var t=/; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g,r=/\\([\u000b\u0020-\u00ff])/g,i=/^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;function o(e){this.parameters=Object.create(null),this.type=e}e.parse=function(e){if(!e)throw TypeError("argument string is required");var n,a,s,d="object"==typeof e?function(e){var t;if("function"==typeof e.getHeader?t=e.getHeader("content-type"):"object"==typeof e.headers&&(t=e.headers&&e.headers["content-type"]),"string"!=typeof t)throw TypeError("content-type header is missing from object");return t}(e):e;if("string"!=typeof d)throw TypeError("argument string is required to be a string");var c=d.indexOf(";"),l=-1!==c?d.slice(0,c).trim():d.trim();if(!i.test(l))throw TypeError("invalid media type");var p=new o(l.toLowerCase());if(-1!==c){for(t.lastIndex=c;a=t.exec(d);){if(a.index!==c)throw TypeError("invalid parameter format");c+=a[0].length,n=a[1].toLowerCase(),34===(s=a[2]).charCodeAt(0)&&-1!==(s=s.slice(1,-1)).indexOf("\\")&&(s=s.replace(r,"$1")),p.parameters[n]=s}if(c!==d.length)throw TypeError("invalid parameter format")}return p}}))();var Pd=class{_buffer;_maxBufferSize;constructor(e){this._maxBufferSize=e?.maxBufferSize??0xa00000}append(e){if((this._buffer?.length??0)+e.length>this._maxBufferSize)throw this.clear(),Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);this._buffer=this._buffer?Buffer.concat([this._buffer,e]):e}readMessage(){for(;this._buffer;){let t=this._buffer.indexOf("\n");if(-1===t)break;let r=this._buffer.toString("utf8",0,t).replace(/\r$/,"");this._buffer=this._buffer.subarray(t+1);try{var e;return e=r,aA.parse(JSON.parse(e))}catch(e){if(e instanceof SyntaxError)continue;throw e}}return null}clear(){this._buffer=void 0}};let Pc=ed("../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"),Pl="win32"===N.platform?["APPDATA","COMSPEC","HOMEDRIVE","HOMEPATH","LOCALAPPDATA","PATH","PATHEXT","PROCESSOR_ARCHITECTURE","PROGRAMDATA","PROGRAMFILES","PROGRAMFILES(X86)","PROGRAMW6432","SYSTEMDRIVE","SYSTEMROOT","TEMP","USERNAME","USERPROFILE","WINDIR"]:["HOME","LOGNAME","PATH","SHELL","TERM","USER"];var Pp=class{_process;_readBuffer;_serverParams;_stderrStream=null;onclose;onerror;onmessage;constructor(e){this._serverParams=e,this._readBuffer=new Pd({maxBufferSize:e.maxBufferSize}),("pipe"===e.stderr||"overlapped"===e.stderr)&&(this._stderrStream=new F)}async start(){if(this._process)throw Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");return new Promise((e,t)=>{this._process=Pc(this._serverParams.command,this._serverParams.args??[],{env:{...function(){let e={};for(let t of Pl){let r=N.env[t];void 0!==r&&(r.startsWith("()")||(e[t]=r))}return e}(),...this._serverParams.env},stdio:["pipe","pipe",this._serverParams.stderr??"inherit"],shell:!1,windowsHide:"win32"===N.platform,cwd:this._serverParams.cwd}),this._process.on("error",e=>{t(e),this.onerror?.(e)}),this._process.on("spawn",()=>{e()}),this._process.on("close",e=>{this._process=void 0,this.onclose?.()}),this._process.stdin?.on("error",e=>{this.onerror?.(e)}),this._process.stdout?.on("data",e=>{try{this._readBuffer.append(e),this.processReadBuffer()}catch(e){this.onerror?.(e),this.close().catch(()=>{})}}),this._process.stdout?.on("error",e=>{this.onerror?.(e)}),this._stderrStream&&this._process.stderr&&this._process.stderr.pipe(this._stderrStream)})}get stderr(){return this._stderrStream?this._stderrStream:this._process?.stderr??null}get pid(){return this._process?.pid??null}processReadBuffer(){for(;;)try{let e=this._readBuffer.readMessage();if(null===e)break;this.onmessage?.(e)}catch(e){this.onerror?.(e)}}async _dispose(){let e=this._process;if(this._process=void 0,e&&null===e.exitCode&&null===e.signalCode){let t=new Promise(t=>e.once("exit",()=>t()));try{e.stdin?.end()}catch{}try{e.kill("SIGTERM")}catch{}if(await Promise.race([t,new Promise(e=>setTimeout(e,1e3).unref())]),null===e.exitCode&&null===e.signalCode)try{e.kill("SIGKILL")}catch{}await t}try{e?.stdout?.destroy()}catch{}try{e?.stdin?.destroy()}catch{}try{e?.stderr?.destroy()}catch{}this._readBuffer.clear()}async close(){if(this._process){let e=this._process;this._process=void 0;let t=new Promise(t=>{e.once("close",()=>{t()})});try{e.stdin?.end()}catch{}if(await Promise.race([t,new Promise(e=>setTimeout(e,2e3).unref())]),null===e.exitCode){try{e.kill("SIGTERM")}catch{}await Promise.race([t,new Promise(e=>setTimeout(e,2e3).unref())])}if(null===e.exitCode)try{e.kill("SIGKILL")}catch{}}this._readBuffer.clear()}send(e){return new Promise(t=>{if(!this._process?.stdin)throw new kL(kF.NotConnected,"Not connected");let r=JSON.stringify(e)+"\n";this._process.stdin.write(r)?t():this._process.stdin.once("drain",t)})}};let Pu=new TextEncoder,Pm=new TextDecoder,Pf=new TextDecoder("utf-8",{fatal:!0});function Ph(...e){let t=new Uint8Array(e.reduce((e,{length:t})=>e+t,0)),r=0;for(let i of e)t.set(i,r),r+=i.length;return t}function Py(e,t,r){if(t<0||t>=0x100000000)throw RangeError(`value must be >= 0 and <= 4294967295. Received ${t}`);e.set([t>>>24,t>>>16,t>>>8,255&t],r)}function Pg(e){let t=Math.floor(e/0x100000000),r=new Uint8Array(8);return Py(r,t,0),Py(r,e%0x100000000,4),r}function P_(e){let t=new Uint8Array(4);return Py(t,e),t}let Pv=/[^\x00-\x7f]/;function Pb(e){if("string"==typeof e&&e.length>=128){if(Pv.test(e))throw TypeError("non-ASCII string encountered in encode()");return Pu.encode(e)}let t=new Uint8Array(e.length);for(let r=0;r<e.length;r++){let i=e.charCodeAt(r);if(i>127)throw TypeError("non-ASCII string encountered in encode()");t[r]=i}return t}function P$(e,t=!1){if(Uint8Array.prototype.toBase64)return e.toBase64({alphabet:t?"base64url":"base64",omitPadding:t});let r=[];for(let t=0;t<e.length;t+=32768)r.push(String.fromCharCode.apply(null,e.subarray(t,t+32768)));let i=btoa(r.join(""));return t?i.replace(/=/g,"").replace(/\+/g,"-").replace(/\//g,"_"):i}function PS(e,t=!1){if(Uint8Array.fromBase64)return Uint8Array.fromBase64(e,{alphabet:t?"base64url":"base64"});if(t){if(e.includes("+")||e.includes("/"))throw TypeError("Invalid base64url");e=e.replace(/-/g,"+").replace(/_/g,"/")}let r=atob(e),i=new Uint8Array(r.length);for(let e=0;e<r.length;e++)i[e]=r.charCodeAt(e);return i}async function Pk(e,t){let r=`SHA-${e.slice(-3)}`;return new Uint8Array(await crypto.subtle.digest(r,t))}class Pw extends Error{static code="ERR_JOSE_GENERIC";code="ERR_JOSE_GENERIC";constructor(e,t){super(e,t),this.name=this.constructor.name,Error.captureStackTrace?.(this,this.constructor)}}class PP extends Pw{static code="ERR_JWT_CLAIM_VALIDATION_FAILED";code="ERR_JWT_CLAIM_VALIDATION_FAILED";claim;reason;payload;constructor(e,t,r="unspecified",i="unspecified"){super(e,{cause:{claim:r,reason:i,payload:t}}),this.claim=r,this.reason=i,this.payload=t}}class PV extends Pw{static code="ERR_JWT_EXPIRED";code="ERR_JWT_EXPIRED";claim;reason;payload;constructor(e,t,r="unspecified",i="unspecified"){super(e,{cause:{claim:r,reason:i,payload:t}}),this.claim=r,this.reason=i,this.payload=t}}class PR extends Pw{static code="ERR_JOSE_ALG_NOT_ALLOWED";code="ERR_JOSE_ALG_NOT_ALLOWED"}class Pq extends Pw{static code="ERR_JOSE_NOT_SUPPORTED";code="ERR_JOSE_NOT_SUPPORTED"}class PI extends Pw{static code="ERR_JWE_DECRYPTION_FAILED";code="ERR_JWE_DECRYPTION_FAILED";constructor(e="decryption operation failed",t){super(e,t)}}class Px extends Pw{static code="ERR_JWE_INVALID";code="ERR_JWE_INVALID"}class Pj extends Pw{static code="ERR_JWS_INVALID";code="ERR_JWS_INVALID"}class PC extends Pw{static code="ERR_JWT_INVALID";code="ERR_JWT_INVALID"}class PT extends Pw{static code="ERR_JWK_INVALID";code="ERR_JWK_INVALID"}class PO extends Pw{static code="ERR_JWKS_INVALID";code="ERR_JWKS_INVALID"}class PE extends Pw{static code="ERR_JWKS_NO_MATCHING_KEY";code="ERR_JWKS_NO_MATCHING_KEY";constructor(e="no applicable key found in the JSON Web Key Set",t){super(e,t)}}class PA extends Pw{[Symbol.asyncIterator]=async function*(){};static code="ERR_JWKS_MULTIPLE_MATCHING_KEYS";code="ERR_JWKS_MULTIPLE_MATCHING_KEYS";constructor(e="multiple matching keys found in the JSON Web Key Set",t){super(e,t)}}class PW extends Pw{static code="ERR_JWKS_TIMEOUT";code="ERR_JWKS_TIMEOUT";constructor(e="request timed out",t){super(e,t)}}class PM extends Pw{static code="ERR_JWS_SIGNATURE_VERIFICATION_FAILED";code="ERR_JWS_SIGNATURE_VERIFICATION_FAILED";constructor(e="signature verification failed",t){super(e,t)}}function PN(e){try{return PS("string"==typeof e?e:Pm.decode(e),!0)}catch(e){throw TypeError("The input to be decoded is not correctly encoded.",{cause:e})}}function Pz(e){return P$("string"==typeof e?Pu.encode(e):e,!0)}function PD(e,t){if(!(e instanceof Uint8Array))throw TypeError(`${t} must be an instance of Uint8Array`)}function PF(e){if("object"!=typeof e||null===e||"[object Object]"!==Object.prototype.toString.call(e))return!1;let t=Object.getPrototypeOf(e);return null===t||null===Object.getPrototypeOf(t)}function PL(e){return PF(e)&&Array.isArray(e.keys)&&Array.from(e.keys).every(PF)}function PU(...e){let t=new Set;for(let r of e)if(r)for(let e of Object.keys(r)){if(t.has(e))return!1;t.add(e)}return!0}function PH(e,t){if(void 0!==e)throw TypeError(`${t} can only be called once`)}function PG(e,t,r){try{return PN(e)}catch{throw new r(`Failed to base64url decode the ${t}`)}}function PB(e,t,r){try{return Pb(e)}catch{throw new r(`The ${t} is not a valid base64url string`)}}function PK(e,t,r){let i;try{i=JSON.parse(Pf.decode(PN(e)))}catch{throw new t(r)}if(!PF(i))throw new t(r);return i}let PJ={__proto__:null,b64:!0},PZ={__proto__:null};function PQ(e,t){if(void 0!==t&&(!Array.isArray(t)||t.some(e=>"string"!=typeof e)))throw TypeError(`"${e}" option must be an array of strings`);return void 0===t?void 0:new Set(t)}function PX(e,t){let{crit:r}=t??{};if(Array.isArray(r)&&new Set(r).size!==r.length)throw new e('"crit" (Critical) Header Parameter MUST NOT contain duplicate values')}function PY(e,t,r,i,o){if(void 0!==o.crit&&i?.crit===void 0)throw new e('"crit" (Critical) Header Parameter MUST be integrity protected');if(!i||void 0===i.crit)return[];if(!Array.isArray(i.crit)||0===i.crit.length||i.crit.some(e=>"string"!=typeof e||0===e.length))throw new e('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');let n=void 0===r?t:{__proto__:null,...r,...t};for(let t of i.crit){if(!(t in n))throw new Pq(`Extension Header Parameter "${t}" is not recognized`);if(!Object.hasOwn(o,t)||void 0===o[t])throw new e(`Extension Header Parameter "${t}" is missing`);if(n[t]&&(!Object.hasOwn(i,t)||void 0===i[t]))throw new e(`Extension Header Parameter "${t}" MUST be integrity protected`)}return i.crit}function P1(e,t){if(t.includes("b64")){let t=e.b64;if("boolean"!=typeof t)throw new Pj('The "b64" (base64url-encode payload) Header Parameter must be a boolean');return t}return!0}function P0(e,t){let r,i;try{r=JSON.stringify(t),i=JSON.parse(r)}catch(t){throw new e("JOSE Header is not valid JSON",{cause:t})}if(!PF(i))throw new e("JOSE Header is not a JSON object");return[i,r]}async function P2(e,t,r){let i,o,{alg:n,secret:a}=e,s="decrypt"===r||"sign"===r;if(a&&t instanceof Uint8Array)return t;if(PF(t)){if("string"!=typeof(i=Va(t)).kty)throw Ve(n,t,a);if(!(a?"oct"===i.kty&&"string"==typeof i.k:"oct"!==i.kty&&(s?"AKP"===i.kty&&"string"==typeof i.priv||"string"==typeof i.d:void 0===i.d&&void 0===i.priv)))throw TypeError(a?'JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present':`JSON Web Key for this operation must be a ${s?"private":"public"} JWK`);if(((e,t,r)=>{let{alg:i}=e;if(void 0!==t.use){let e="sign"===r||"verify"===r?"sig":"enc";if(t.use!==e)throw TypeError(`Invalid key for this operation, its "use" must be "${e}" when present`)}if(void 0!==t.alg&&t.alg!==i)throw TypeError(`Invalid key for this operation, its "alg" must be "${i}" when present`);if(Array.isArray(t.key_ops)){let i="encrypt"===r||"decrypt"===r?e.ops?.[+("encrypt"!==r)]:r;if(i&&!t.key_ops.includes(i))throw TypeError(`Invalid key for this operation, its "key_ops" must include "${i}" when present`)}})(e,i,r),"oct"===i.kty)return PN(i.k);if(!Object.isFrozen(t)){let{key_ops:e}=t;Array.isArray(e)&&Object.freeze(e),Object.freeze(t)}}else{if(!P5(t))throw Ve(n,t,a);let e=a?"secret":s?"private":"public";if(t.type!==e&&(a||["secret","public","private"].includes(t.type)))throw TypeError(`${t[Symbol.toStringTag]} instances must be of type "${e}" for the ${n} algorithm`);if(P3(t))return t;if("secret"===(o=t).type)return o.export()}let d=(m||=new WeakMap).get(t);if(d?.[n])return d[n];if(d||m.set(t,d={}),o&&"function"==typeof o.toCryptoKey){let t="public"===o.type,r=P4[o.asymmetricKeyDetails?.namedCurve],i=e.resolve?.({crv:r,asymmetricKeyType:o.asymmetricKeyType})??e.subtle;return d[n]=o.toCryptoKey(i,t,e.usages[+!t])}return(i??=o.export({format:"jwk"})).alg=n,d[n]=await Vd(e,i)}let P4={__proto__:null,prime256v1:"P-256",secp384r1:"P-384",secp521r1:"P-521"};function P6(e){if(!P3(e))throw Error("CryptoKey instance expected")}let P3=e=>{if(e?.[Symbol.toStringTag]==="CryptoKey")return!0;try{return e instanceof CryptoKey}catch{return!1}},P9=e=>e?.[Symbol.toStringTag]==="KeyObject",P5=e=>P3(e)||P9(e);function P8(e,t,...r){if(r.length>2){let t=r.pop();e+=`one of type ${r.join(", ")}, or ${t}.`}else 2===r.length?e+=`one of type ${r[0]} or ${r[1]}.`:e+=`of type ${r[0]}.`;return null==t?e+=` Received ${t}`:"function"==typeof t&&t.name?e+=` Received function ${t.name}`:"object"==typeof t&&null!=t&&t.constructor?.name&&(e+=` Received an instance of ${t.constructor.name}`),e}let P7=(e,...t)=>P8("Key must be ",e,...t);function Ve(e,t,r){let i=["CryptoKey","KeyObject","JSON Web Key"];return r&&i.push("Uint8Array"),TypeError(P8(`Key for the ${e} algorithm must be `,t,...i))}let Vt=(e,t="algorithm.name")=>TypeError(`CryptoKey does not support this operation, its ${t} must be ${e}`);function Vr(e,t){if(t&&!e.usages.includes(t))throw TypeError(`CryptoKey does not support this operation, its usages must include ${t}.`)}function Vi(e,t){let{modulusLength:r}=t.algorithm;if("number"!=typeof r||r<2048)throw TypeError(`${e} requires key modulusLength to be 2048 bits or larger`)}function Vo(e,t,r){let i=e.algorithm;if(i.name!==t.name)throw Vt(t.name);if(t.hash&&i.hash?.name!==t.hash)throw Vt(t.hash,"algorithm.hash");if(t.namedCurve&&i.namedCurve!==t.namedCurve)throw Vt(t.namedCurve,"algorithm.namedCurve");if(void 0!==t.length&&i.length!==t.length)throw Vt(t.length,"algorithm.length");Vr(e,r)}function Vn(e){return{__proto__:null,...e}}function Va(e){let t=Vn(e);if(void 0!==t.ext&&"boolean"!=typeof t.ext)throw TypeError('"ext" (Extractable) Parameter must be a boolean');if(void 0!==t.key_ops){let e=t.key_ops,r=Array.isArray(e)?[...e]:void 0;if(!r||r.some(e=>"string"!=typeof e)||new Set(r).size!==r.length)throw TypeError('"key_ops" (Key Operations) Parameter must be an array of unique strings');t.key_ops=r}return t}function Vs(e){if(void 0!==e&&"boolean"!=typeof e)throw TypeError('"extractable" option must be a boolean');return e}async function Vd(e,t,r){if(!e.kty.includes(t.kty))throw new Pq('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');let i=e.resolve?.({kty:t.kty,crv:t.crv})??e.subtle,o=!!(t.d||t.priv),n={...t,ext:r??t.ext};return"AKP"!==n.kty&&delete n.alg,delete n.use,crypto.subtle.importKey("jwk",n,i,n.ext??!o,t.key_ops??e.usages[+!!o])}async function Vc(e,t,r,i=!1){return e instanceof Uint8Array&&(e=await crypto.subtle.importKey("raw",e,t,i,[r])),Vo(e,t,r),e}let Vl=e=>crypto.getRandomValues(new Uint8Array(e.cekBits>>3));function Vp(e,t){let r=e.byteLength<<3;if(r!==t)throw new Px(`Invalid Content Encryption Key length. Expected ${t} bits, got ${r} bits`)}function Vu(e,t){if(t.length<<3!==e.ivBits)throw new Px("Invalid Initialization Vector length")}async function Vm(e,t,r){if(!(t instanceof Uint8Array))throw TypeError(P7(t,"Uint8Array"));let i=e.cekBits>>1;return[await crypto.subtle.importKey("raw",t.subarray(i>>3),"AES-CBC",!1,[r]),await crypto.subtle.importKey("raw",t.subarray(0,i>>3),{hash:`SHA-${i<<1}`,name:"HMAC"},!1,["sign"]),i]}async function Vf(e,t,r){return new Uint8Array((await crypto.subtle.sign("HMAC",e,t)).slice(0,r>>3))}async function Vh(e,t,r,i,o){if(!P3(r)&&!(r instanceof Uint8Array))throw TypeError(P7(r,"CryptoKey","KeyObject","Uint8Array","JSON Web Key"));if(i?Vu(e,i):i=crypto.getRandomValues(new Uint8Array(e.ivBits>>3)),r instanceof Uint8Array&&Vp(r,e.cekBits),e.cbc)return async function(e,t,r,i,o){let[n,a,s]=await Vm(e,r,"encrypt"),d=new Uint8Array(await crypto.subtle.encrypt({iv:i,name:"AES-CBC"},n,t)),c=Ph(o,i,d,Pg(8*o.length));return{ciphertext:d,tag:await Vf(a,c,s),iv:i}}(e,t,r,i,o);let n=await Vc(r,e.subtle,"encrypt"),a=new Uint8Array(await crypto.subtle.encrypt({additionalData:o,iv:i,name:"AES-GCM",tagLength:128},n,t));return{ciphertext:a.subarray(0,-16),tag:a.subarray(-16),iv:i}}async function Vy(e,t,r,i,o,n){if(!P3(t)&&!(t instanceof Uint8Array))throw TypeError(P7(t,"CryptoKey","KeyObject","Uint8Array","JSON Web Key"));if(!i)throw new Px("JWE Initialization Vector missing");if(!o)throw new Px("JWE Authentication Tag missing");if(!e.cbc&&16!==o.length)throw new Px("Invalid Authentication Tag length");if(Vu(e,i),t instanceof Uint8Array&&Vp(t,e.cekBits),e.cbc)return async function(e,t,r,i,o,n){let[a,s,d]=await Vm(e,t,"decrypt"),c=Ph(n,i,r,Pg(8*n.length)),l=await Vf(s,c,d);try{if(await async function(e,t){let r={name:"HMAC",hash:"SHA-256"},i=await crypto.subtle.generateKey(r,!1,["sign","verify"]),o=await crypto.subtle.sign(r,i,e);return crypto.subtle.verify(r,i,o,t)}(o,l))return new Uint8Array(await crypto.subtle.decrypt({iv:i,name:"AES-CBC"},a,r))}catch{}throw new PI}(e,t,r,i,o,n);let a=await Vc(t,e.subtle,"decrypt");try{return new Uint8Array(await crypto.subtle.decrypt({additionalData:n,iv:i,name:"AES-GCM",tagLength:128},a,Ph(r,o)))}catch{throw new PI}}function Vg(e){let t={__proto__:null};for(let r in e)t[r]={...e[r],alg:r};return t}let V_=[["encrypt","wrapKey"],["decrypt","unwrapKey"]],Vv=[[],["deriveBits"]],Vb=[[],[]];function V$(e){return{kty:["RSA"],mode:"key-encryption",subtle:{name:"RSA-OAEP",hash:`SHA-${e}`},usages:V_,ops:["wrapKey","unwrapKey"]}}function VS(e){return{kty:["EC","OKP"],mode:e,subtle:{name:"ECDH"},resolve:({kty:e,crv:t,asymmetricKeyType:r})=>{if("X25519"===t||"x25519"===r)return{name:"X25519"};if("OKP"===e)throw new Pq('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');return{name:"ECDH",namedCurve:t}},usages:Vv,ops:[void 0,"deriveBits"]}}function Vk(e,t=!1){return{kty:["oct"],mode:"key-wrapping",secret:!0,subtle:{name:t?"AES-GCM":"AES-KW",length:e},usages:Vb,ops:t?["encrypt","decrypt"]:["wrapKey","unwrapKey"]}}function Vw(){return{kty:["oct"],mode:"key-wrapping",secret:!0,subtle:{name:"PBKDF2"},usages:Vb,ops:["deriveBits","deriveBits"]}}let VP=Vg({dir:{kty:["oct"],mode:"direct-encryption",secret:!0,subtle:{name:"AES-GCM"},usages:Vb,ops:["encrypt","decrypt"]},"RSA-OAEP":V$(1),"RSA-OAEP-256":V$(256),"RSA-OAEP-384":V$(384),"RSA-OAEP-512":V$(512),"ECDH-ES":VS("direct-key-agreement"),"ECDH-ES+A128KW":VS("key-agreement-with-key-wrapping"),"ECDH-ES+A192KW":VS("key-agreement-with-key-wrapping"),"ECDH-ES+A256KW":VS("key-agreement-with-key-wrapping"),A128KW:Vk(128),A192KW:Vk(192),A256KW:Vk(256),A128GCMKW:Vk(128,!0),A192GCMKW:Vk(192,!0),A256GCMKW:Vk(256,!0),"PBES2-HS256+A128KW":Vw(),"PBES2-HS384+A192KW":Vw(),"PBES2-HS512+A256KW":Vw()}),VV=["encrypt","decrypt"];function VR(e,t=!1){return{kty:["oct"],secret:!0,subtle:{name:t?"AES-CBC":"AES-GCM",length:e},usages:Vb,ops:VV,cekBits:e,ivBits:t?128:96,cbc:t}}let Vq=Vg({A128GCM:VR(128),A192GCM:VR(192),A256GCM:VR(256),"A128CBC-HS256":VR(256,!0),"A192CBC-HS384":VR(384,!0),"A256CBC-HS512":VR(512,!0)});function VI(e,t){throw new Pq(`Invalid or unsupported "${e}" (JWE ${t}) header value`)}function Vx(e){return("string"==typeof e?VP[e]:void 0)??VI("alg","Algorithm")}function Vj(e){return"key-wrapping"===e.mode||"key-encryption"===e.mode||"key-agreement-with-key-wrapping"===e.mode}function VC(e){return("string"==typeof e?Vq[e]:void 0)??VI("enc","Encryption Algorithm")}function VT(e,t){if("ECDH"!==e.algorithm.name&&"X25519"!==e.algorithm.name)throw TypeError("CryptoKey does not support this operation, its algorithm.name must be ECDH or X25519");Vr(e,t)}function VO(e,t,r){Vo(t,Vx(e).subtle,r),Vi(e,t)}async function VE(e,t,r,i){if(!(e instanceof Uint8Array)||e.length<8)throw new Px("PBES2 Salt Input must be 8 or more octets");if(!Number.isSafeInteger(r)||1!==Math.sign(r))throw new Px("PBES2 Count Input must be a positive integer");let o=Ph(Pb(t),Uint8Array.of(0),e),n=parseInt(t.slice(13,16),10),a={hash:`SHA-${t.slice(8,11)}`,iterations:r,name:"PBKDF2",salt:o},s=await Vc(i,Vx(t).subtle,"deriveBits");return new Uint8Array(await crypto.subtle.deriveBits(a,s,n))}function VA(e){return Ph(P_(e.length),e)}async function VW(e,t,r,i,o=new Uint8Array,n=new Uint8Array){VT(e),VT(t,"deriveBits");let a=Ph(VA(Pb(r)),VA(o),VA(n),P_(i));return async function(e,t,r){let i=t>>3,o=Math.ceil(i/32),n=new Uint8Array(32*o);for(let t=1;t<=o;t++){let i=await Pk("sha256",Ph(P_(t),e,r));n.set(i,(t-1)*32)}return n.slice(0,i)}(new Uint8Array(await crypto.subtle.deriveBits({name:e.algorithm.name,public:e},t,"X25519"===e.algorithm.name?256:Math.ceil(parseInt(e.algorithm.namedCurve.slice(-3),10)/8)<<3)),i,a)}function VM(e){P6(e);let t=e.algorithm.namedCurve;if("P-256"!==t&&"P-384"!==t&&"P-521"!==t&&"X25519"!==e.algorithm.name)throw new Pq("ECDH with the provided key is not allowed or not supported by your javascript runtime")}function VN(e,t){let r=e[t];if(void 0!==r){if("string"!=typeof r)throw new Px(`JOSE Header "${t}" (Agreement Party${"apu"===t?"U":"V"}Info) invalid`);return PG(r,t,Px)}}function Vz(e,t){if(void 0!==e&&void 0!==t&&e.byteLength===t.byteLength){for(let r=0;r<e.byteLength;r++)if(e[r]!==t[r])return;throw new Px('JOSE Header "apu" and "apv" values must be distinct')}}function VD(e){if(void 0!==e)throw new Px("Encountered unexpected JWE Encrypted Key")}async function VF(e,t,r,i,o,n={}){let a,s,{alg:d,mode:c}=e,l=Vj(e);if(void 0!==o&&!l)throw TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${d}`);let p=await P2("direct-encryption"===c?t:e,r,"encrypt");if("direct-encryption"===c)return[p,void 0,void 0];let u=l?o??Vl(t):void 0;switch(u&&Vp(u,t.cekBits),e.subtle.name){case"ECDH":{let r;VM(p);let{apu:o,apv:a}=n;void 0!==o&&PD(o,'"apu"'),void 0!==a&&PD(a,'"apv"');let l=o??VN(i,"apu"),u=a??VN(i,"apv");Vz(l,u),r=void 0!==n.epk?await P2(e,n.epk,"decrypt"):(await crypto.subtle.generateKey(p.algorithm,!0,["deriveBits"])).privateKey;let m=crypto.subtle,f=r;if(!f.extractable){if("function"!=typeof m.getPublicKey)throw TypeError('CryptoKey for "epk" must be extractable');f=await m.getPublicKey(r,[])}let{x:h,y,crv:g,kty:_}=await m.exportKey("jwk",f),v="direct-key-agreement"===c,b=await VW(p,r,v?t.alg:d,v?t.cekBits:parseInt(d.slice(-5,-2),10),l,u),$={x:h,crv:g,kty:_};if("EC"===_&&($.y=y),s={epk:$},void 0!==o&&(s.apu=Pz(o)),void 0!==a&&(s.apv=Pz(a)),v)return[b,void 0,s];p=b;break}case"RSA-OAEP":P6(p),VO(d,p,"encrypt"),a=new Uint8Array(await crypto.subtle.encrypt("RSA-OAEP",p,u));break;case"PBKDF2":{let{p2c:e=2048,p2s:t=crypto.getRandomValues(new Uint8Array(16))}=n;p=await VE(t,d,e,p),s={p2c:e,p2s:Pz(t)};break}case"AES-GCM":{let e=void 0===n.iv?crypto.getRandomValues(new Uint8Array(12)):n.iv;if(!(e instanceof Uint8Array))throw TypeError('"iv" must be an instance of Uint8Array');let t=await Vh(VC(d.slice(0,-2)),u,p,e,new Uint8Array);a=t.ciphertext,s={iv:Pz(t.iv),tag:Pz(t.tag)}}}if(!((a??=await async function(e,t,r){let i=await Vc(t,Vx(e).subtle,"wrapKey",!0),o=await crypto.subtle.importKey("raw",r,{hash:"SHA-256",name:"HMAC"},!0,["sign"]);return new Uint8Array(await crypto.subtle.wrapKey("raw",o,i,"AES-KW"))}(d.slice(-6),p,u))instanceof Uint8Array)||!a.byteLength)throw TypeError("JWE key management algorithm did not produce an Encrypted Key");return[u,a,s]}function VL(e,t){if(void 0!==e.zip&&"DEF"!==e.zip)throw new Pq('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');if(void 0!==e.zip&&!t?.zip)throw new Px('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.')}function VU(e){if(typeof globalThis[e]>"u")throw new Pq(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${e} API.`)}async function VH(e,t,r=1/0){let i=e.writable.getWriter();i.write(t).catch(()=>{}),i.close().catch(()=>{});let o=[],n=0,a=e.readable.getReader();for(;;){let{value:e,done:t}=await a.read();if(t)break;if(o.push(e),n+=e.byteLength,1/0!==r&&n>r)throw new Px("Decompressed plaintext exceeded the configured limit")}return Ph(...o)}function VG(e){let{aad:t,ciphertext:r,iv:i,protected:o,tag:n,unprotected:a}=e;if(void 0!==i&&("string"!=typeof i||!i))throw new Px("JWE Initialization Vector incorrect type");if("string"!=typeof r)throw new Px("JWE Ciphertext missing or incorrect type");if(void 0!==n&&("string"!=typeof n||!n))throw new Px("JWE Authentication Tag incorrect type");if(void 0!==o&&"string"!=typeof o)throw new Px("JWE Protected Header incorrect type");if(void 0!==t&&("string"!=typeof t||!t))throw new Px("JWE AAD incorrect type");if(void 0!==a&&!PF(a))throw new Px("JWE Shared Unprotected Header incorrect type");return{aad:t,ciphertext:r,iv:i,protected:o,tag:n,unprotected:void 0===a?void 0:{...a}}}function VB(e){let t,r;try{let{header:i}=e;if(PF(i)){r=i.alg;let e=Object.keys(i);e.includes("alg")||(r=void 0),t=Object.fromEntries(e.map(e=>[e,"alg"===e?r:i[e]]))}else t=i;let{encrypted_key:o}=e;return[{encrypted_key:o,header:t},r]}catch(e){return[void 0,r,e]}}function VK(e){let{encrypted_key:t,header:r}=e;if(void 0!==t&&"string"!=typeof t)throw new Px("JWE Encrypted Key incorrect type");if(void 0!==r&&!PF(r))throw new Px("JWE Per-Recipient Unprotected Header incorrect type");if(void 0===e.protected&&void 0===r&&void 0===e.unprotected)throw new Px("JOSE Header missing")}function VJ(e){let t,{protected:r,ciphertext:i,iv:o,tag:n,aad:a}=e;return void 0!==r&&(t=PK(r,Px,"JWE Protected Header is invalid")),[t,PG(i,"ciphertext",Px),void 0!==o?PG(o,"iv",Px):void 0,void 0!==n?PG(n,"tag",Px):void 0,PB((r??"")+(void 0!==a?`.${a}`:""),"aad",Px)]}function VZ(e){return[e&&PQ("keyManagementAlgorithms",e.keyManagementAlgorithms),e&&PQ("contentEncryptionAlgorithms",e.contentEncryptionAlgorithms),e?.crit,e?.maxPBES2Count,e?.maxDecompressedLength]}async function VQ(e,t,r,i=VJ(e)){let o,n,a,s,[d,c,l,p,u]=i,{header:m,unprotected:f,aad:h}=e;if(void 0!==m||void 0!==f){if(!PU(d,m,f))throw new Px("JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint");o={...d,...m,...f}}else o=d??{};let[y,g,_,v,b]=t,{encrypted_key:$}=e;PY(Px,PZ,_,d,o),VL(o,d);let{alg:S,enc:k}=o;if("string"!=typeof S||!S)throw new Px("missing JWE Algorithm (alg) in JWE Header");let w=VP[S];if(""===$&&(!w||!Vj(w)))throw new Px("JWE Encrypted Key incorrect type");let P=w?.mode==="integrated-encryption";if(!P&&("string"!=typeof k||!k))throw new Px("missing JWE Encryption Algorithm (enc) in JWE Header");if(y&&!y.has(S)||!y&&S.startsWith("PBES2"))throw new PR('"alg" (Algorithm) Header Parameter value not allowed');if(P){if(void 0!==k)throw new Px('JWE "enc" (Encryption Algorithm) Header Parameter must not be present for integrated encryption');if(l?.byteLength)throw new Px("JWE Initialization Vector must be empty for integrated encryption");if(p?.byteLength)throw new Px("JWE Authentication Tag must be empty for integrated encryption")}else{if(g&&!g.has(k))throw new PR('"enc" (Encryption Algorithm) Header Parameter value not allowed');n=VC(k)}if(void 0!==$)try{a=PG($,"encrypted_key",Px)}catch(e){if(!w||!Vj(w))throw e;a=new Uint8Array}let V=!1;"function"==typeof r&&(r=await r(d,e),V=!0);let R=w??Vx(S);Vj(R)&&void 0===a&&(a=new Uint8Array);let q=await P2("direct-encryption"===R.mode?n:R,r,"decrypt");if("integrated-encryption"===R.mode)s=await R.decrypt(q,a,c,u,d,o);else{let e,t=n;try{e=await async function(e,t,r,i,o,n){let{alg:a}=e,s=e.mode;if("direct-encryption"===s)return VD(i),r;let d="direct-key-agreement"===s;switch(d?VD(i):function(e){if(void 0===e)throw new Px("JWE Encrypted Key missing")}(i),e.subtle.name){case"ECDH":{let{epk:i}=o;if(!PF(i)||["d","k","p","q","dp","dq","qi","oth","priv"].some(e=>Object.hasOwn(i,e)))throw new Px('JOSE Header "epk" (Ephemeral Public Key) missing or invalid');VM(r);let n=await Vd(e,i),s=VN(o,"apu"),c=VN(o,"apv");Vz(s,c);let l=await VW(n,r,d?t.alg:a,d?t.cekBits:parseInt(a.slice(-5,-2),10),s,c);if(d)return l;r=l;break}case"RSA-OAEP":return P6(r),VO(a,r,"decrypt"),new Uint8Array(await crypto.subtle.decrypt("RSA-OAEP",r,i));case"PBKDF2":{if("number"!=typeof o.p2c)throw new Px('JOSE Header "p2c" (PBES2 Count) missing or invalid');if(void 0!==n&&1/0!==n&&(!Number.isSafeInteger(n)||n<1))throw TypeError("maxPBES2Count must be a positive safe integer or Infinity");if(o.p2c>(n??1e4))throw new Px('JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds');if("string"!=typeof o.p2s)throw new Px('JOSE Header "p2s" (PBES2 Salt) missing or invalid');let e=PG(o.p2s,"p2s",Px);r=await VE(e,a,o.p2c,r);break}case"AES-GCM":{if("string"!=typeof o.iv)throw new Px('JOSE Header "iv" (Initialization Vector) missing or invalid');if("string"!=typeof o.tag)throw new Px('JOSE Header "tag" (Authentication Tag) missing or invalid');let e=PG(o.iv,"iv",Px),t=PG(o.tag,"tag",Px);if(12!==e.byteLength)throw new Px("Invalid Initialization Vector length");if(16!==t.byteLength)throw new Px("Invalid Authentication Tag length");return Vy(VC(a.slice(0,-2)),r,i,e,t,new Uint8Array)}}return async function(e,t,r){let i=await Vc(t,Vx(e).subtle,"unwrapKey",!0),o=await crypto.subtle.unwrapKey("raw",r,i,"AES-KW",{hash:"SHA-256",name:"HMAC"},!0,["sign"]);return new Uint8Array(await crypto.subtle.exportKey("raw",o))}(a.slice(-6),r,i)}(R,t,q,a,o,v),Vj(R)&&e instanceof Uint8Array&&e.byteLength<<3!==t.cekBits&&(e=Vl(t))}catch(r){if(r instanceof TypeError||r instanceof Px||r instanceof Pq)throw r;e=Vl(t)}s=await Vy(t,e,c,l,p,u)}if("DEF"===o.zip){let e=b??25e4;if(0===e)throw new Pq('JWE "zip" (Compression Algorithm) Header Parameter is not supported.');if(1/0!==e&&(!Number.isSafeInteger(e)||e<1))throw TypeError("maxDecompressedLength must be 0, a positive safe integer, or Infinity");s=await (async function(e,t){return VU("DecompressionStream"),VH(new DecompressionStream("deflate-raw"),e,t)})(s,e).catch(e=>{throw e instanceof Px?e:new Px("Failed to decompress plaintext",{cause:e})})}return{plaintext:s,...d&&{protectedHeader:d},...void 0!==h&&{additionalAuthenticatedData:PG(h,"aad",Px)},...f&&{sharedUnprotectedHeader:f},...m&&{unprotectedHeader:m},...V&&{key:q}}}async function VX(e,t,r){if(e instanceof Uint8Array&&(e=Pm.decode(e)),"string"!=typeof e)throw new Px("Compact JWE must be a string or Uint8Array");let{0:i,1:o,2:n,3:a,4:s,length:d}=e.split(".");if(5!==d)throw new Px("Invalid Compact JWE");return VQ({ciphertext:a,iv:n||void 0,protected:i,tag:s||void 0,encrypted_key:o||void 0},t,r)}async function VY(e,t,r){return VX(e,VZ(r),t)}async function V1(e,t,r){if(!PF(e))throw new Px("Flattened JWE must be an object");let i=VG(e),[o,,n]=VB(e);if(!o)throw n;let a={...i,...o};return VK(a),VQ(a,VZ(r),t)}async function V0(e,t,r){let i,o,n;if(!PF(e))throw new Px("General JWE must be an object");let a=e.recipients;if(!Array.isArray(a))throw new Px("JWE Recipients missing or incorrect type");let s=Array.from(a);if(!s.every(PF))throw new Px("JWE Recipients missing or incorrect type");if(!s.length)throw new Px("JWE Recipients has no members");try{i=VZ(r),o=VG(e),n=VJ(o)}catch{throw new PI}let d=s.map(e=>VB(e));if(s.length>1)for(let[,e]of d){let t=n[0]?.alg??e??o.unprotected?.alg,r="string"==typeof t?VP[t]:void 0;if(r&&!Vj(r))throw new Px(`"${t}" alg may only have a single recipient`)}for(let[e]of d)if(e)try{let r={...o,...e};return VK(r),await VQ(r,i,t,n)}catch{}throw new PI}function V2(e,t,r){if(!PU(e,t,r))throw new Px("JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint")}function V4(e,t,r=!1){if(!e[1]&&!e[2]&&!e[3])throw new Px("either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()");void 0!==t&&(e[8]=t?.crit);let[,i,o,n,a,s,d,c,l]=e;if(void 0!==a&&PD(a,"JWE Additional Authenticated Data"),void 0!==s&&PD(s,"JWE Content Encryption Key"),void 0!==d&&PD(d,"JWE Initialization Vector"),r||void 0===i||(i=P0(Px,i)[0],e[1]=i),void 0!==o&&(o=P0(Px,o)[0],e[2]=o),r||void 0===n||(n=P0(Px,n)[0],e[3]=n),void 0!==c&&!PF(c))throw TypeError("JWE Key Management Parameters must be an object");V2(i,o,n);let p={...i,...o,...n};PX(Px,i),PY(Px,PZ,l,i,p),VL(p,i);let{alg:u,enc:m}=p;if("string"!=typeof u||!u)throw new Px('JWE "alg" (Algorithm) Header Parameter missing or invalid');let f=VP[u];if(f?.mode==="integrated-encryption"){if(void 0!==m)throw new Px('JWE "enc" (Encryption Algorithm) Header Parameter must not be present for integrated encryption');if(void 0!==s)throw TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${u}`);if(void 0!==d)throw TypeError(`setInitializationVector cannot be called with JWE "alg" (Algorithm) Header ${u}`);return[p,void 0,f]}if("string"!=typeof m||!m)throw new Px('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');return[p,VC(m),f]}async function V6(e,t,r){let i,o,n,a,s,d,[c,l,p]=t,[u,m,f,h,y,g,_,v,,b]=e,$=m,S=f,k=p??Vx(c.alg);"integrated-encryption"===k.mode?n=await P2(k,r,"encrypt"):[n,i,o]=await VF(k,l,r,c,g,v),o&&(b?S=S?{...S,...o}:o:$=$?{...$,...o}:o,V2($,S,h));let w=$?Pz(JSON.stringify($)):"",P=y?.byteLength?Pz(y):void 0,V=Pb(P?`${w}.${P}`:w),R=u;"DEF"===c.zip&&(R=await (async function(e){return VU("CompressionStream"),VH(new CompressionStream("deflate-raw"),e)})(R).catch(e=>{throw new Px("Failed to compress plaintext",{cause:e})})),"integrated-encryption"===k.mode?[i,a]=await k.encrypt(n,R,V,$,c,v):{ciphertext:a,tag:s,iv:d}=await Vh(l,R,n,_,V);let q={ciphertext:Pz(a)};return d&&(q.iv=Pz(d)),s&&(q.tag=Pz(s)),i?.byteLength&&(q.encrypted_key=Pz(i)),P&&(q.aad=P),$&&(q.protected=w),h&&(q.unprotected=h),S&&(q.header=S),q}async function V3(e,t,r){return V6(e,V4(e,r),t)}function V9(e){return[e.protected,e.encrypted_key,e.iv,e.ciphertext,e.tag].join(".")}class V5{#f;state;constructor(e,t,r){this.#f=e,this.state=[void 0,void 0,t,r]}setUnprotectedHeader(e){return PH(this.state[0],"setUnprotectedHeader"),this.state[0]=e,this}setKeyManagementParameters(e){return PH(this.state[1],"setKeyManagementParameters"),this.state[1]=e,this}addRecipient(...e){return this.#f.addRecipient(...e)}encrypt(...e){return this.#f.encrypt(...e)}done(){return this.#f}}class V8{#h;#y=[];#g;#_;#v;constructor(e){this.#h=e}addRecipient(e,t){let r=new V5(this,e,t?.crit);return this.#y.push(r),r}setProtectedHeader(e){return PH(this.#g,"setProtectedHeader"),this.#g=e,this}setSharedUnprotectedHeader(e){return PH(this.#_,"setSharedUnprotectedHeader"),this.#_=e,this}setAdditionalAuthenticatedData(e){return this.#v=e,this}async encrypt(){if(!this.#y.length)throw new Px("at least one recipient must be added");PD(this.#h,"plaintext");let e=this.#y.length>1,t,r=this.#g,i=this.#_,o=[];for(let n of this.#y){let[a,s,d,c]=n.state,l=[this.#h,r,a,i,this.#v,void 0,void 0,s,c,e],p=V4(l,void 0,o.length>0);o.length||(r=l[1],i=l[3]),o.push([l,p,d]);let[{alg:u,enc:m},,f]=p;if(e&&f&&!Vj(f))throw new Px(`"${u}" alg may only have a single recipient`);if(t){if(t!==m)throw new Px('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients')}else t=m}for(let[,e]of o)e[2]??=Vx(e[0].alg);let[n,a,s]=o[0],d=e?Vl(a[1]):void 0;n[5]=d;let{encrypted_key:c,header:l,...p}=await V6(n,a,s),u={...p,recipients:[{}]};c&&(u.recipients[0].encrypted_key=c),l&&(u.recipients[0].header=l);for(let e=1;e<o.length;e++){let[t,[r,i,n],a]=o[e],s=t[2],[,c,l]=await VF(n,i,a,r,d,t[7]),p={encrypted_key:Pz(c)};if(s||l){let e={...s,...l};l&&V2(t[1],e,t[3]),p.header=e}u.recipients.push(p)}return u}}let V7=[["verify"],["sign"]];function Re(e){let t={name:"HMAC",hash:`SHA-${e}`};return{kty:["oct"],secret:!0,subtle:t,signing:t,usages:V7}}function Rt(e,t){let r={name:t?"RSA-PSS":"RSASSA-PKCS1-v1_5",hash:`SHA-${e}`};return{kty:["RSA"],subtle:r,signing:t?{...r,saltLength:t}:r,usages:V7,minRsaBits:2048}}function Rr(e,t){return{kty:["EC"],crv:e,subtle:{name:"ECDSA",namedCurve:e},signing:{name:"ECDSA",hash:`SHA-${t}`},usages:V7}}function Ri(){let e={name:"Ed25519"};return{kty:["OKP"],crv:"Ed25519",subtle:e,signing:e,usages:V7}}function Ro(e){let t={name:`ML-DSA-${e}`};return{kty:["AKP"],subtle:t,signing:t,usages:V7}}let Rn=Vg({HS256:Re(256),HS384:Re(384),HS512:Re(512),RS256:Rt(256),RS384:Rt(384),RS512:Rt(512),PS256:Rt(256,32),PS384:Rt(384,48),PS512:Rt(512,64),ES256:Rr("P-256",256),ES384:Rr("P-384",384),ES512:Rr("P-521",512),EdDSA:Ri(),Ed25519:Ri(),"ML-DSA-44":Ro(44),"ML-DSA-65":Ro(65),"ML-DSA-87":Ro(87)});function Ra(e){let t="string"==typeof e?Rn[e]:void 0;if(!t)throw new Pq(`alg ${e} is not supported either by JOSE or your javascript runtime`);return t}function Rs(e,t){let r=e.protected,i=e.header,o=PF(i)?{...i}:i,n=t?t[0]:e.payload;!t&&n instanceof Uint8Array&&(n=new Uint8Array(n));let a=e.signature,s={payload:n,signature:a};if(void 0!==r&&(s.protected=r),void 0!==i&&(s.header=o),void 0===r&&void 0===o)throw new Pj('Flattened JWS must have either of the "protected" or "header" members');if(void 0!==r&&"string"!=typeof r)throw new Pj("JWS Protected Header incorrect type");if(void 0===n)throw new Pj("JWS Payload missing");if("string"!=typeof a)throw new Pj("JWS Signature missing or incorrect type");if(void 0!==o&&!PF(o))throw new Pj("JWS Unprotected Header incorrect type");return s}function Rd(e){return[e&&PQ("algorithms",e.algorithms),e?.crit]}function Rc(e){return void 0===e?{}:PK(e,Pj,"JWS Protected Header is invalid")}function Rl(e){let t=/[\p{Cs}\p{Cn}]/u.exec(e)?.[0];if(void 0!==t)throw new Pj(/\p{Cs}/u.test(t)?"JWS Payload must be a well-formed Unicode string":"JWS Payload must not contain unassigned Unicode code points");return Pu.encode(e)}function Rp(e){try{return Pb(e)}catch{throw new Pj("JWS Compact Serialization payload must use only ASCII characters")}}async function Ru(e,t,r,i,o){let{protected:n,header:a,payload:s}=e,d=o??Rc(n);if(!PU(d,a))throw new Pj("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");let c={...d,...a},l=P1(d,PY(Pj,PJ,t[1],d,c)),{alg:p}=c;if("string"!=typeof p||!p)throw new Pj('JWS "alg" (Algorithm) Header Parameter missing or invalid');if(t[0]&&!t[0].has(p))throw new PR('"alg" (Algorithm) Header Parameter value not allowed');if(l){if("string"!=typeof s)throw new Pj("JWS Payload must be a string")}else if("string"!=typeof s&&!(s instanceof Uint8Array))throw new Pj("JWS Payload must be a string or an Uint8Array instance");let u=l||"string"!=typeof s?s:i(s),m=!1;"function"==typeof r&&(r=await r(d,e),m=!0);let f=Ra(p),h=Ph(void 0!==n?Pb(n):new Uint8Array,Pb("."),"string"==typeof u?t[2]??=PB(u,"payload",Pj):u),y=PG(e.signature,"signature",Pj),g=await P2(f,r,"verify"),_=await Vc(g,f.subtle,"verify");f.minRsaBits&&Vi(f.alg,_);let v=!1;try{v=await crypto.subtle.verify(f.signing,_,y,h)}catch{}if(!v)throw new PM;let b={payload:"string"==typeof u?PG(u,"payload",Pj):u};return void 0!==n&&(b.protectedHeader=d),void 0!==a&&(b.unprotectedHeader=a),m?[{...b,key:g},l]:[b,l]}async function Rm(e,t,r){if(e instanceof Uint8Array&&(e=Pm.decode(e)),"string"!=typeof e)throw new Pj("Compact JWS must be a string or Uint8Array");let{0:i,1:o,2:n,length:a}=e.split(".");if(3!==a)throw new Pj("Invalid Compact JWS");return Ru({payload:o,protected:i,signature:n},t,r,Rp)}async function Rf(e,t,r){let[i]=await Rm(e,Rd(r),t);return i}async function Rh(e,t,r){if(!PF(e))throw new Pj("Flattened JWS must be an object");let i=Rs(e),[o]=await Ru(i,Rd(r),t,Rl);return o}async function Ry(e,t,r){let i;if(!PF(e))throw new Pj("General JWS must be an object");let{signatures:o,payload:n}=e;if(!Array.isArray(o))throw new Pj("JWS Signatures missing or incorrect type");let a=Array.from(o);if(!a.every(PF))throw new Pj("JWS Signatures missing or incorrect type");try{if(void 0===n)throw Error();i=Rd(r)}catch{throw new PM}let s=n instanceof Uint8Array?new Uint8Array(n):n,d=a.map(e=>(function(e,t){try{let r=Rs(e,[t]),i=Rc(r.protected),{b64:o,crit:n}=i;return[r,i,Array.isArray(n)&&n.includes("b64")?"boolean"==typeof o?o?1:2:0:1]}catch{return}})(e,s)).filter(e=>void 0!==e),c=0;for(let[,,e]of d)if(3==(c|=e))throw new Pj("inconsistent use of JWS Unencoded Payload (RFC7797)");for(let e of d)try{let[r]=await Ru(e[0],i,t,Rl,e[1]);return r}catch{}throw new PM}let Rg=e=>Math.floor(e.getTime()/1e3),R_={s:1,m:60,h:3600,d:86400,w:604800,y:0x1e187e0},Rv=/^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i,Rb="check_failed";function R$(){throw TypeError("Invalid time period format")}function RS(e){"string"!=typeof e&&R$();let t=Rv.exec(e);(!t||t[4]&&t[1])&&R$();let r=Math.round(parseFloat(t[2])*R_[t[3][0].toLowerCase()]);return Number.isFinite(r)||R$(),"-"===t[1]||"ago"===t[4]?-r:r}function Rk(e,t){if(!Number.isFinite(t))throw TypeError(`Invalid ${e} input`);return t}function Rw(e,t){if("string"!=typeof t)throw TypeError(`"${e}" claim must be a string`)}function RP(e,t){return"number"==typeof e?Rk(t,e):e instanceof Date?Rk(t,Rg(e)):Rg(new Date)+RS(e)}let RV=e=>{let t=e.toLowerCase();return e.includes("/")?t:`application/${t}`};function RR(e,t,r=!1){let i=e[t];if(!(void 0===i&&!r)){if("number"!=typeof i)throw new PP(`"${t}" claim must be a number`,e,t,"invalid");return i}}function Rq(e,t){throw new PP(`unexpected "${t}" claim value`,e,t,Rb)}function RI(e,t,r={}){let i,o,n;try{i=JSON.parse(Pf.decode(t))}catch{}if(!PF(i))throw new PC("JWT Claims Set must be a top-level JSON object");let{typ:a}=r;if(void 0!==a&&("string"!=typeof e.typ||RV(e.typ)!==RV(a)))throw new PP('unexpected "typ" JWT header value',i,"typ",Rb);let{requiredClaims:s=[],issuer:d,subject:c,audience:l,maxTokenAge:p}=r,u=[...s];for(let e of(void 0!==p&&u.push("iat"),void 0!==l&&u.push("aud"),void 0!==c&&u.push("sub"),void 0!==d&&u.push("iss"),new Set(u.reverse())))if(!Object.hasOwn(i,e))throw new PP(`missing required "${e}" claim`,i,e,"missing");void 0===d||(Array.isArray(d)?d:[d]).includes(i.iss)||Rq(i,"iss"),void 0!==c&&i.sub!==c&&Rq(i,"sub"),void 0===l||(o=i.aud,n="string"==typeof l?[l]:l,"string"==typeof o?n.includes(o):!!Array.isArray(o)&&n.some(e=>o.includes(e)))||Rq(i,"aud");let{clockTolerance:m}=r,f=0;if("string"==typeof m)f=RS(m);else if(void 0!==m){if("number"!=typeof m)throw TypeError("Invalid clockTolerance option type");f=m}Rk("clockTolerance option",f);let{currentDate:h}=r,y=Rk("currentDate option",Rg(void 0===h?new Date:h)),g=RR(i,"iat",void 0!==p),_=RR(i,"nbf");if(void 0!==_&&_>y+f)throw new PP('"nbf" claim timestamp check failed',i,"nbf",Rb);let v=RR(i,"exp");if(void 0!==v&&v<=y-f)throw new PV('"exp" claim timestamp check failed',i,"exp",Rb);if(void 0!==p){let e=y-g;if(e-f>Rk("maxTokenAge option","number"==typeof p?p:RS(p)))throw new PV('"iat" claim timestamp check failed (too far in the past)',i,"iat",Rb);if(e<-f)throw new PP('"iat" claim timestamp check failed (it should be in the past)',i,"iat",Rb)}return i}function Rx(e){return f.get(e)}function Rj(e){let t=Rx(e);for(let e of["iat","nbf","exp"]){let r=t[e];if("number"==typeof r&&!Number.isFinite(r))throw TypeError(`"${e}" claim must be a finite number`)}return Pu.encode(JSON.stringify(t))}class RC{constructor(e={}){if(!PF(e))throw TypeError("JWT Claims Set MUST be an object");(f||=new WeakMap).set(this,structuredClone(e))}setIssuer(e){return Rw("iss",e),Rx(this).iss=e,this}setSubject(e){return Rw("sub",e),Rx(this).sub=e,this}setAudience(e){return function(e){if("string"!=typeof e&&(!Array.isArray(e)||Array.from(e).some(e=>"string"!=typeof e)))throw TypeError('"aud" claim must be a string or an array of strings')}(e),Rx(this).aud=e,this}setJti(e){return Rw("jti",e),Rx(this).jti=e,this}setNotBefore(e){return Rx(this).nbf=RP(e,"setNotBefore"),this}setExpirationTime(e){return Rx(this).exp=RP(e,"setExpirationTime"),this}setIssuedAt(e){let t=Rx(this);return void 0===e?t.iat=Rg(new Date):"string"==typeof e?t.iat=Rk("setIssuedAt",Rg(new Date)+RS(e)):t.iat=RP(e,"setIssuedAt"),this}}async function RT(e,t,r){let[i,o]=await Rm(e,Rd(r),t);if(!o)throw new PC("JWTs MUST NOT use unencoded payload");let n=RI(i.protectedHeader,i.payload,r);return{...i,payload:n}}async function RO(e,t,r){let{plaintext:i,...o}=await VX(e,VZ(r),t),{protectedHeader:n}=o,a=RI(n,i,r);for(let e of["iss","sub","aud"])if(void 0!==n[e]&&("aud"===e?JSON.stringify(n.aud)!==JSON.stringify(a.aud):n[e]!==a[e]))throw new PP(`replicated "${e}" claim header parameter mismatch`,a,e,"mismatch");return{payload:a,...o}}class RE{#b;constructor(e){PD(e,"plaintext"),this.#b=[e]}setContentEncryptionKey(e){return PH(this.#b[5],"setContentEncryptionKey"),this.#b[5]=e,this}setInitializationVector(e){return PH(this.#b[6],"setInitializationVector"),this.#b[6]=e,this}setProtectedHeader(e){return PH(this.#b[1],"setProtectedHeader"),this.#b[1]=e,this}setKeyManagementParameters(e){return PH(this.#b[7],"setKeyManagementParameters"),this.#b[7]=e,this}async encrypt(e,t){return V9(await V3([...this.#b],e,t))}}class RA{#b;constructor(e){PD(e,"plaintext"),this.#b=[e]}setKeyManagementParameters(e){return PH(this.#b[7],"setKeyManagementParameters"),this.#b[7]=e,this}setProtectedHeader(e){return PH(this.#b[1],"setProtectedHeader"),this.#b[1]=e,this}setSharedUnprotectedHeader(e){return PH(this.#b[3],"setSharedUnprotectedHeader"),this.#b[3]=e,this}setUnprotectedHeader(e){return PH(this.#b[2],"setUnprotectedHeader"),this.#b[2]=e,this}setAdditionalAuthenticatedData(e){return this.#b[4]=e,this}setContentEncryptionKey(e){return PH(this.#b[5],"setContentEncryptionKey"),this.#b[5]=e,this}setInitializationVector(e){return PH(this.#b[6],"setInitializationVector"),this.#b[6]=e,this}async encrypt(e,t){return V3([...this.#b],e,t)}}async function RW(e,t,r){let[i,o,n,a]=e,s="";if(void 0!==o){let e=P0(Pj,o);o=e[0],s=Pz(e[1])}if(void 0!==n&&(n=P0(Pj,n)[0]),!o&&!n)throw new Pj("either setProtectedHeader or setUnprotectedHeader must be called before #sign()");if(!PU(o,n))throw new Pj("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");let d={...o,...n};PX(Pj,o);let c=P1(o,PY(Pj,PJ,a,o,d));c||r?.();let{alg:l}=d;if("string"!=typeof l||!l)throw new Pj('JWS "alg" (Algorithm) Header Parameter missing or invalid');let p=Ra(l),u="",m=i,f;if(c){let t=e[4];t?(u=t[0]??=Pz(i),m=t[1]??=Pb(u)):(u=Pz(i),f=Pu.encode(`${s}.${u}`))}f??=Ph(Pb(s),Pb("."),m);let h=await Vc(await P2(p,t,"sign"),p.subtle,"sign");p.minRsaBits&&Vi(p.alg,h);let y={signature:Pz(new Uint8Array(await crypto.subtle.sign(p.signing,h,f))),payload:u};return o&&(y.protected=s),n&&(y.header=n),[y,c]}async function RM(e,t,r,i,o){let[n]=await RW([e,t,void 0,r],i,o);return`${n.protected}.${n.payload}.${n.signature}`}class RN{#$;#g;constructor(e){PD(e,"payload"),this.#$=e}setProtectedHeader(e){return PH(this.#g,"setProtectedHeader"),this.#g=e,this}async sign(e,t){return RM(this.#$,this.#g,t?.crit,e,()=>{throw TypeError("use the flattened module for creating JWS with b64: false")})}}class Rz{#b;constructor(e){PD(e,"payload"),this.#b=[e]}setProtectedHeader(e){return PH(this.#b[1],"setProtectedHeader"),this.#b[1]=e,this}setUnprotectedHeader(e){return PH(this.#b[2],"setUnprotectedHeader"),this.#b[2]=e,this}async sign(e,t){let r=[...this.#b];r[3]=t?.crit;let[i]=await RW(r,e);return i}}class RD{#f;state;constructor(e,t,r){this.#f=e,this.state=[void 0,void 0,t,r?.crit]}setProtectedHeader(e){return PH(this.state[0],"setProtectedHeader"),this.state[0]=e,this}setUnprotectedHeader(e){return PH(this.state[1],"setUnprotectedHeader"),this.state[1]=e,this}addSignature(...e){return this.#f.addSignature(...e)}sign(...e){return this.#f.sign(...e)}done(){return this.#f}}class RF{#$;#S=[];constructor(e){this.#$=e}addSignature(e,t){let r=new RD(this,e,t);return this.#S.push(r),r}async sign(){let e;if(!this.#S.length)throw new Pj("at least one signature must be added");PD(this.#$,"payload");let t={signatures:[],payload:""},r=[];for(let i of this.#S){let[o,n,a,s]=i.state,[{payload:d,...c},l]=await RW([this.#$,o,n,s,r],a);if(void 0===e)e=l,t.payload=d;else if(e!==l)throw new Pj("inconsistent use of JWS Unencoded Payload (RFC7797)");t.signatures.push(c)}return t}}let RL=RC;class RU extends RL{#g;setProtectedHeader(e){return PH(this.#g,"setProtectedHeader"),this.#g=e,this}async sign(e,t){return RM(Rj(this),this.#g,t?.crit,e,()=>{throw new PC("JWTs MUST NOT use unencoded payload")})}}let RH=RC;class RG extends RH{#b=[void 0];#k;#w;#P;setProtectedHeader(e){return PH(this.#b[1],"setProtectedHeader"),this.#b[1]=e,this}setKeyManagementParameters(e){return PH(this.#b[7],"setKeyManagementParameters"),this.#b[7]=e,this}setContentEncryptionKey(e){return PH(this.#b[5],"setContentEncryptionKey"),this.#b[5]=e,this}setInitializationVector(e){return PH(this.#b[6],"setInitializationVector"),this.#b[6]=e,this}replicateIssuerAsHeader(){return this.#k=!0,this}replicateSubjectAsHeader(){return this.#w=!0,this}replicateAudienceAsHeader(){return this.#P=!0,this}async encrypt(e,t){let r=Rj(this);this.#b[1]&&(this.#k||this.#w||this.#P)&&(this.#b[1]={...this.#b[1],iss:this.#k?Rx(this).iss:void 0,sub:this.#w?Rx(this).sub:void 0,aud:this.#P?Rx(this).aud:void 0});let i=[...this.#b];return i[0]=r,V9(await V3(i,e,t))}}let RB='"alg" (Algorithm)';function RK(e='JWK "alg" (Algorithm) Parameter'){throw new Pq(`Invalid or unsupported ${e} value`)}function RJ(e,t){return("string"==typeof e?Rn[e]??VP[e]:void 0)??RK(t)}let RZ=async(e,t,r)=>{var i,o;let n;if(P9(r)){if(r.type!==e)throw TypeError(`key is not a ${e} key`);return r.export({format:"pem",type:t})}if(!P3(r))throw TypeError(P7(r,"CryptoKey","KeyObject"));if(!r.extractable)throw TypeError("CryptoKey is not extractable");if(r.type!==e)throw TypeError(`key is not a ${e} key`);return i=P$(new Uint8Array(await crypto.subtle.exportKey(t,r))),o=`${e.toUpperCase()} KEY`,n=(i.match(/.{1,64}/g)||[]).join(`
+`,e.enqueue(t.encode(o)),!0}catch(e){return this.onerror?.(e),!1}}handleUnsupportedRequest(){return this.onerror?.(Error("Method not allowed.")),Response.json({jsonrpc:"2.0",error:{code:-32e3,message:"Method not allowed."},id:null},{status:405,headers:{Allow:"GET, POST, DELETE","Content-Type":"application/json"}})}async handlePostRequest(e,t){try{var r,i;let o,n,a,s,d,c=e.headers.get("accept");if(!c?.includes("application/json")||!c.includes("text/event-stream"))return this.onerror?.(Error("Not Acceptable: Client must accept both application/json and text/event-stream")),this.createJsonErrorResponse(406,-32e3,"Not Acceptable: Client must accept both application/json and text/event-stream");if(r=e.headers.get("content-type"),"application/json"!==r&&"application/json"!==function(e){if(e)try{return lU.parse(e).type}catch{let t=(e.split(";",1)[0]??"").trim().toLowerCase();if(""===t||e.slice(t.length).includes(","))return;return t}}(r))return this.onerror?.(Error("Unsupported Media Type: Content-Type must be application/json")),this.createJsonErrorResponse(415,-32e3,"Unsupported Media Type: Content-Type must be application/json");if(t?.parsedBody===void 0)try{let t=await async function(e,t=4194304){if(Number(e.headers.get("content-length"))>t)return{tooLarge:!0};if(null===e.body)return{tooLarge:!1,text:""};let r=e.body.getReader(),i=new TextDecoder,o=0,n="";try{for(;;){let{done:e,value:a}=await r.read();if(e)break;if((o+=a.byteLength)>t)return{tooLarge:!0};n+=i.decode(a,{stream:!0})}}finally{r.releaseLock()}return{tooLarge:!1,text:n+i.decode()}}(e,this._maxRequestBodySize);if(t.tooLarge){let e=(i=this._maxRequestBodySize,`Payload Too Large: Request body must not exceed ${i} bytes`);return this.onerror?.(Error(e)),this.createJsonErrorResponse(413,-32e3,e)}o=JSON.parse(t.text)}catch(e){return this.onerror?.(e),this.createJsonErrorResponse(400,-32700,"Parse error: Invalid JSON")}else o=t.parsedBody;if(Array.isArray(o)&&o.length>100)return this.onerror?.(Error("Invalid Request: Batch must not exceed 100 messages")),this.createJsonErrorResponse(400,-32600,"Invalid Request: Batch must not exceed 100 messages");try{n=Array.isArray(o)?o.map(e=>aA.parse(e)):[aA.parse(o)]}catch(e){return this.onerror?.(e),this.createJsonErrorResponse(400,-32700,"Parse error: Invalid JSON-RPC message")}if(this._closed)return this.createJsonErrorResponse(404,-32001,"Session not found");let l=n.some(e=>aQ.safeParse(e).success);if(l){if(this._initialized&&void 0!==this.sessionId)return this.onerror?.(Error("Invalid Request: Server already initialized")),this.createJsonErrorResponse(400,-32600,"Invalid Request: Server already initialized");if(n.length>1)return this.onerror?.(Error("Invalid Request: Only one initialization request is allowed")),this.createJsonErrorResponse(400,-32600,"Invalid Request: Only one initialization request is allowed");this.sessionId=this.sessionIdGenerator?.(),this._initialized=!0,this.sessionId&&this._onsessioninitialized&&await Promise.resolve(this._onsessioninitialized(this.sessionId))}if(!l){let t=this.validateSession(e);if(t)return t;let r=this.validateProtocolVersion(e);if(r)return r}if(this._closed)return this.createJsonErrorResponse(404,-32001,"Session not found");try{a=await this._checkScopeChallenge(n,t?.authInfo)}catch(e){return this.onerror?.(e),this.createJsonErrorResponse(500,-32603,"Internal server error")}if(a)return a;if(!n.some(e=>lc(e))){for(let r of n)this.onmessage?.(r,{authInfo:t?.authInfo,request:e});return new Response(null,{status:202})}let p=crypto.randomUUID(),u=n.find(e=>aQ.safeParse(e).success),m=u?u.params.protocolVersion:e.headers.get("mcp-protocol-version")??"2025-03-26";if(this._enableJsonResponse)return new Promise(r=>{for(let e of(this._streamMapping.set(p,{resolveJson:r,cleanup:()=>{this._streamMapping.delete(p)}}),n))lc(e)&&this._requestToStreamMapping.set(e.id,p);for(let r of n)this.onmessage?.(r,{authInfo:t?.authInfo,request:e})});let f=new TextEncoder,h=new ReadableStream({start:e=>{s=e},cancel:()=>{void 0!==d&&clearInterval(d),this._streamMapping.get(p)?.controller===s&&this._streamMapping.delete(p)}}),y={"Content-Type":"text/event-stream","Cache-Control":"no-cache, no-transform",Connection:"keep-alive","X-Accel-Buffering":"no"};for(let e of(void 0!==this.sessionId&&(y["mcp-session-id"]=this.sessionId),n))lc(e)&&(this._streamMapping.set(p,{controller:s,encoder:f,cleanup:()=>{void 0!==d&&clearInterval(d),this._streamMapping.delete(p);try{s.close()}catch{}}}),this._requestToStreamMapping.set(e.id,p));for(let r of(await this.writePrimingEvent(s,f,p,m),n)){let i,o;lc(r)&&this._eventStore&&this.supportsEmptySSEData(m)&&(i=()=>{this.closeSSEStream(r.id)},o=()=>{this.closeStandaloneSSEStream()}),this.onmessage?.(r,{authInfo:t?.authInfo,request:e,closeSSEStream:i,closeStandaloneSSEStream:o})}return this._streamMapping.get(p)?.controller===s&&(d=this.startKeepAlive(s,f)),new Response(h,{status:200,headers:y})}catch(e){return this.onerror?.(e),this.createJsonErrorResponse(400,-32700,"Parse error",{data:String(e)})}}async handleDeleteRequest(e){let t=this.validateSession(e);if(t)return t;let r=this.validateProtocolVersion(e);if(r)return r;try{return await Promise.resolve(this._onsessionclosed?.(this.sessionId)),new Response(null,{status:200})}finally{await this.close()}}validateSession(e){if(void 0===this.sessionIdGenerator)return;if(!this._initialized)return this.onerror?.(Error("Bad Request: Server not initialized")),this.createJsonErrorResponse(400,-32e3,"Bad Request: Server not initialized");let t=e.headers.get("mcp-session-id");return t?t!==this.sessionId?(this.onerror?.(Error("Session not found")),this.createJsonErrorResponse(404,-32001,"Session not found")):void 0:(this.onerror?.(Error("Bad Request: Mcp-Session-Id header is required")),this.createJsonErrorResponse(400,-32e3,"Bad Request: Mcp-Session-Id header is required"))}validateProtocolVersion(e){let t=e.headers.get("mcp-protocol-version");if(null!==t&&!this._supportedProtocolVersions.includes(t)){let e=`Bad Request: Unsupported protocol version: ${t} (supported versions: ${this._supportedProtocolVersions.join(", ")})`;return this.onerror?.(Error(e)),this.createJsonErrorResponse(400,-32e3,e)}}async close(){if(!this._closed){for(let{cleanup:e}of(this._closed=!0,this._streamMapping.values()))e();this._streamMapping.clear(),this._requestResponseMap.clear(),this.onclose?.()}}closeSSEStream(e){let t=this._requestToStreamMapping.get(e);if(!t)return;let r=this._streamMapping.get(t);r&&r.cleanup()}closeStandaloneSSEStream(){let e=this._streamMapping.get(this._standaloneSseStreamId);e&&e.cleanup()}async send(e,t){let r=t?.relatedRequestId;if((aO.safeParse(e).success||aE.safeParse(e).success)&&(r=e.id),void 0===r){let t;if(aO.safeParse(e).success||aE.safeParse(e).success)throw Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");this._eventStore&&(t=await this._eventStore.storeEvent(this._standaloneSseStreamId,e));let r=this._streamMapping.get(this._standaloneSseStreamId);if(void 0===r)return;r.controller&&r.encoder&&(void 0===t||!r.replayedEventIds?.has(t))&&this.writeSSEEvent(r.controller,r.encoder,e,t);return}let i=this._requestToStreamMapping.get(r);if(!i)throw Error(`No connection established for request ID: ${String(r)}`);let o=this._streamMapping.get(i);if(!this._enableJsonResponse){let t;this._eventStore&&(t=await this._eventStore.storeEvent(i,e),o=this._streamMapping.get(i)),o?.controller&&o?.encoder&&(void 0===t||!o.replayedEventIds?.has(t))&&this.writeSSEEvent(o.controller,o.encoder,e,t)}if(aO.safeParse(e).success||aE.safeParse(e).success){this._requestResponseMap.set(r,e);let t=[...this._requestToStreamMapping.entries()].filter(([e,t])=>t===i).map(([e])=>e);if(t.every(e=>this._requestResponseMap.has(e))){if(!o){if(this._enableJsonResponse)throw Error(`No connection established for request ID: ${String(r)}`);if(!this._eventStore){for(let e of(this.onerror?.(Error(`Response for request ID ${String(r)} is undeliverable: per-request stream is disconnected and no eventStore is configured`)),t))this._requestResponseMap.delete(e),this._requestToStreamMapping.delete(e);return}for(let e of t)this._requestResponseMap.delete(e),this._requestToStreamMapping.delete(e);return}if(this._enableJsonResponse&&o.resolveJson){let e={"Content-Type":"application/json"};void 0!==this.sessionId&&(e["mcp-session-id"]=this.sessionId);let r=t.map(e=>this._requestResponseMap.get(e));1===r.length?o.resolveJson(Response.json(r[0],{status:200,headers:e})):o.resolveJson(Response.json(r,{status:200,headers:e})),o.cleanup()}else o.cleanup();for(let e of t)this._requestResponseMap.delete(e),this._requestToStreamMapping.delete(e)}}}};let uY=Symbol("swallowsErrorsAfterClose");var u1=class{_readBuffer;_started=!1;_closed=!1;constructor(e=N.stdin,t=N.stdout,r){this._stdin=e,this._stdout=t,this._readBuffer=new lH({maxBufferSize:r?.maxBufferSize})}onclose;onerror;onmessage;_ondata=e=>{try{this._readBuffer.append(e),this.processReadBuffer()}catch(e){this.onerror?.(e),this.close().catch(()=>{})}};_onerror=e=>{this.onerror?.(e)};_onstdouterror=e=>{this._closed||(this.onerror?.(e),this.close().catch(()=>{}))};_onstdinclose=()=>{this.close().catch(()=>{})};async start(){if(this._started)throw Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");for(let e of(this._started=!0,this._stdout.listeners("error")))e[uY]&&this._stdout.off("error",e);(this._stdin.readableEnded||this._stdin.destroyed)&&setImmediate(this._onstdinclose),this._stdin.on("data",this._ondata),this._stdin.on("error",this._onerror),this._stdin.on("end",this._onstdinclose),this._stdin.on("close",this._onstdinclose),this._stdout.on("error",this._onstdouterror)}processReadBuffer(){for(;;)try{let e=this._readBuffer.readMessage();if(null===e)break;this.onmessage?.(e)}catch(e){this.onerror?.(e)}}async close(){this._closed||(this._closed=!0,this._stdin.off("data",this._ondata),this._stdin.off("error",this._onerror),this._stdin.off("end",this._onstdinclose),this._stdin.off("close",this._onstdinclose),this._onstdouterror[uY]=!0,0===this._stdin.listenerCount("data")&&this._stdin.pause(),this._readBuffer.clear(),this.onclose?.())}send(e){return this._closed?Promise.reject(Error("StdioServerTransport is closed")):new Promise((t,r)=>{let i=JSON.stringify(e)+"\n",o=!1,n=e=>{o||(o=!0,this._stdout.off("error",n),this._stdout.off("drain",a),r(e))},a=()=>{o||(o=!0,this._stdout.off("error",n),this._stdout.off("drain",a),t())};if(this._stdout.once("error",n),this._stdout.write(i)){if(o)return;o=!0,this._stdout.off("error",n),t()}else o||this._stdout.once("drain",a)})}},u0=class extends Error{constructor(e,t){super(e,t),this.name="RequestError"}};let u2=new Set(["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","server","user-agent"]),u4=/^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/,u6=e=>9===e||10===e||13===e||32===e,u3=e=>{if(!u6(e.charCodeAt(0))&&!u6(e.charCodeAt(e.length-1)))return e;let t=0,r=e.length;for(;t<r&&u6(e.charCodeAt(t));)t++;for(;r>t&&u6(e.charCodeAt(r-1));)r--;return e.slice(t,r)},u9=/[\0\r\n]/,u5=globalThis.Headers,u8=(e,t=u5)=>{let r=new t;for(let t=0;t<e.length;t+=2){let i=e[t];i.startsWith(":")||r.append(i,e[t+1])}return r};var u7=class{#e;#t;#r;#i;constructor(e){this.#e=e,e instanceof z&&(this.#t=e.rawHeaders.slice())}get #o(){return this.#t??=this.#e.rawHeaders.slice()}get #n(){return this.#r||(this.#r=u8(this.#o),this.#t=void 0),this.#r}#a(e){if("string"==typeof e){if(!u4.test(e))throw TypeError(`Invalid header name: ${e}`);return e.toLowerCase()}}#s(e){let t=this.#e instanceof z?void 0:this.#e.headers;if(!t||u2.has(e)||"set-cookie"===e||"__proto__"===e)return;if(!Object.hasOwn(t,e))return null;let r=t[e];if("string"==typeof r){let e=u3(r);return u9.test(e)?void 0:e}}#d(e,t){let r="cookie"===t?"; ":", ",i=null;for(let o=0;o<e.length;o+=2){let n=e[o];if(n.length===t.length&&n.toLowerCase()===t){let t=u3(e[o+1]);if(u9.test(t)){this.#i=!0;return}i=null===i?t:i+r+t}}return i}append(e,t){this.#n.append(e,t)}delete(e){this.#n.delete(e)}get(e){let t=this.#a(e);if(t&&!this.#r&&!this.#i){let e=this.#s(t);if(void 0!==e)return e;let r=this.#d(this.#o,t);if(void 0!==r)return r}return this.#n.get(e)}has(e){let t=this.#a(e);if(t&&!this.#r&&!this.#i){let e=this.#s(t);if(void 0!==e)return null!==e;let r=this.#d(this.#o,t);if(void 0!==r)return null!==r}return this.#n.has(e)}set(e,t){this.#n.set(e,t)}getSetCookie(){return this.#n.getSetCookie()}keys(){return this.#n.keys()}values(){return this.#n.values()}entries(){return this.#n.entries()}forEach(e,t){this.#n.forEach((r,i)=>{e.call(t,r,i,this)})}[Symbol.iterator](){return this.entries()}};Object.defineProperty(u7.prototype,Symbol.for("nodejs.util.inspect.custom"),{value:function(e,t,r){return`Headers (lightweight) ${r(Object.fromEntries(this),{...t,depth:null==e?null:e-1})}`}}),Object.setPrototypeOf(u7.prototype,u5.prototype);let me=e=>globalThis.Headers===u5?new u7(e):u8(e.rawHeaders,globalThis.Headers),mt=/^\/[!#$&-;=?-\[\]_a-z~]*$/,mr=/\/\.\.?(?:[/?#]|$)/,mi=/^[a-z0-9._-]+(?::(?:[1-5]\d{3,4}|[6-9]\d{3}))?$/,mo=global.Request;var mn=class extends mo{constructor(e,t){if("object"==typeof e&&mh in e){let r=void 0!==t&&"body"in t&&null!=t.body;if(e[mV]&&!r)throw TypeError("Cannot construct a Request with a Request object that has already been used.");e=e[mh]()}void 0!==t?.body?.getReader&&(t.duplex??="half"),super(e,t)}};let ma=Symbol("wrapBodyStream"),ms=new Set(["latin1","binary","hex","base64","base64url"]),md=Symbol("bodyBufferedBeforeDisconnect"),mc=Symbol("bodyBufferedLengthBeforeDisconnect"),ml=(e,t)=>Buffer.isBuffer(e)?e:Buffer.from(e,t??"utf8"),mp=e=>{let t;return!(e instanceof z)&&!!e.complete&&!!e.readableAborted&&"function"==typeof e.read&&(null===(t=e.readableEncoding)||ms.has(t))},mu=e=>{e.readableDidRead||!mp(e)||(e[mc]??=e.readableLength)},mm=(e,t)=>{let r;if(e.readableDidRead&&!t||!mp(e))return;if(void 0!==e[md])return e[md];let i=e.errored;if(i&&"ECONNRESET"!==i.code)r=i;else if(void 0!==e[mc]&&e.readableLength!==e[mc])r=mI();else{let i=t??[],o=e.read();null!==o&&i.push(ml(o,e.readableEncoding));let n=1===i.length?i[0]:Buffer.concat(i);r=n;let a=e.headers["content-length"];if("string"==typeof a&&/^\d+$/.test(a)){let e=Number(a);Number.isSafeInteger(e)&&n.length!==e&&(r=mI())}}return e[md]=r,r},mf=(e,t)=>{t instanceof Error?e.error(t):(t.length>0&&e.enqueue(t),e.close())},mh=Symbol("getRequestCache"),my=Symbol("requestCache"),mg=Symbol("incomingKey"),m_=Symbol("urlKey"),mv=Symbol("methodKey"),mb=Symbol("headersKey"),m$=Symbol("abortControllerKey"),mS=Symbol("getAbortController"),mk=Symbol("abortRequest"),mw=Symbol("bodyBuffer"),mP=Symbol("bodyReadPromise"),mV=Symbol("bodyConsumedDirectly"),mR=Symbol("bodyLockReader"),mq=Symbol("abortReason"),mI=()=>TypeError("Body is unusable"),mx=new TextDecoder,mj=/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/,mC=(e,t,r)=>{if(e[mV])return Promise.reject(mI());let i=e.method;if("GET"===i||"HEAD"===i)return e[mh]()[t]();let o=(e=>{if(!mj.test(e))return TypeError(`'${e}' is not a valid HTTP method.`);let t=e.toUpperCase();if("CONNECT"===t||"TRACK"===t||"TRACE"===t&&"TRACE"!==e)return TypeError(`'${e}' HTTP method is unsupported.`)})(i);if(o)return Promise.reject(o);if(e[my]&&"TRACE"!==i)return e[my][t]();let n=(e=>{if(e[mV])return Promise.reject(mI());e[mV]=!0})(e);if(n)return n;let a=mT(e);if(a){let t=Promise.resolve(r(a,e));return e[mw]=void 0,t}return mE(e).then(t=>{let i=r(t,e);return e[mw]=void 0,i})},mT=e=>{let t=e[mg];if("rawBody"in t&&t.rawBody instanceof Buffer)return t.rawBody},mO=(e,t)=>{if(t.errored)return t.errored;let r=e[mq];return void 0!==r?r instanceof Error?r:Error(String(r)):Error("Client connection prematurely closed.")},mE=e=>{if(e[mw])return Promise.resolve(e[mw]);if(e[mP])return e[mP];let t=e[mg];if(t.readableDidRead)return Promise.reject(mI());let r=mm(t);if(void 0!==r)return r instanceof Error?Promise.reject(r):(e[mw]=r,Promise.resolve(r));let i=new Promise((r,i)=>{let o=[],n=!1,a=e=>{n||(n=!0,u(),e())},s=n=>{let s=t.errored??n;return!!mp(t)&&(!s||"ECONNRESET"===s.code)&&(a(()=>{let a=mm(t,o);a instanceof Error?i(a):void 0===a?i(n??mO(e,t)):(e[mw]=a,r(a))}),!0)},d=e=>{o.push(ml(e,t.readableEncoding))},c=()=>{a(()=>{let t=1===o.length?o[0]:Buffer.concat(o);e[mw]=t,r(t)})},l=e=>{s(e)||a(()=>{i(e)})},p=()=>{t.readableEnded?c():s()||a(()=>{i(mO(e,t))})},u=()=>{t.off("data",d),t.off("end",c),t.off("error",l),t.off("close",p),e[mP]=void 0};t.on("data",d),t.on("end",c),t.on("error",l),t.on("close",p),queueMicrotask(()=>{!n&&(t.readableEnded?c():t.errored?l(t.errored):t.destroyed&&p())})});return e[mP]=i,i},mA={get method(){return this[mv]},get url(){return this[m_]},get headers(){return this[mb]||=me(this[mg])},[mk](e){void 0===this[mq]&&(this[mq]=e);let t=this[m$];t&&!t.signal.aborted&&t.abort(e)},[mS](){return this[m$]||=new AbortController,void 0===this[mq]||this[m$].signal.aborted||this[m$].abort(this[mq]),this[m$]},[mh](){let e=this[mS]();if(this[my])return this[my];let t=this.method;if(this[mV]&&"GET"!==t&&"HEAD"!==t){this[mw]=void 0;let r={method:"TRACE"===t?"GET":t,headers:this.headers,signal:e.signal};"TRACE"!==t&&(r.body=new ReadableStream({start(e){e.close()}}),r.duplex="half");let i=new mn(this[m_],r);return"TRACE"===t&&Object.defineProperty(i,"method",{get:()=>"TRACE"}),this[my]=i}return this[my]=((e,t,r,i,o)=>{let n={method:e,headers:r,signal:o.signal};if("TRACE"===e){n.method="GET";let e=new mn(t,n);return Object.defineProperty(e,"method",{get:()=>"TRACE"}),e}if("GET"!==e&&"HEAD"!==e)if("rawBody"in i&&i.rawBody instanceof Buffer)n.body=new ReadableStream({start(e){e.enqueue(i.rawBody),e.close()}});else if(i[ma]){let e;n.body=new ReadableStream({async pull(t){try{if(!e){let e=mm(i);if(void 0!==e)return void mf(t,e)}e||=L.toWeb(i).getReader();let{done:r,value:o}=await e.read();r?t.close():t.enqueue(o)}catch(e){t.error(e)}}})}else{let e=mm(i);void 0!==e?n.body=new ReadableStream({start(t){mf(t,e)}}):n.body=L.toWeb(i)}return new mn(t,n)})(this.method,this[m_],this.headers,this[mg],e)},get body(){if(!this[mV])return this[mh]().body;let e=this[mh]();return!this[mR]&&e.body&&(this[mR]=e.body.getReader()),e.body},get bodyUsed(){return!!this[mV]||!!this[my]&&this[my].bodyUsed}};Object.defineProperty(mA,"signal",{get(){return this[mS]().signal}}),["cache","credentials","destination","integrity","mode","redirect","referrer","referrerPolicy","keepalive"].forEach(e=>{Object.defineProperty(mA,e,{get(){return this[mh]()[e]}})}),["clone","formData"].forEach(e=>{Object.defineProperty(mA,e,{value:function(){if(this[mV]){if("clone"===e)throw mI();return Promise.reject(mI())}return this[mh]()[e]()}})}),Object.defineProperty(mA,"text",{value:function(){return mC(this,"text",e=>mx.decode(e))}}),Object.defineProperty(mA,"arrayBuffer",{value:function(){return mC(this,"arrayBuffer",e=>e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength))}}),Object.defineProperty(mA,"blob",{value:function(){return mC(this,"blob",(e,t)=>{let r=(t[mb]||=me(t[mg])).get("content-type")||"";return new Response(e,r?{headers:{"content-type":r}}:void 0).blob()})}}),Object.defineProperty(mA,"json",{value:function(){return this[mV]?Promise.reject(mI()):this.text().then(JSON.parse)}}),Object.defineProperty(mA,Symbol.for("nodejs.util.inspect.custom"),{value:function(e,t,r){return`Request (lightweight) ${r({method:this.method,url:this.url,headers:this.headers,nativeRequest:this[my]},{...t,depth:null==e?null:e-1})}`}}),Object.setPrototypeOf(mA,mn.prototype);let mW="text/plain; charset=UTF-8",mM=Symbol("responseCache"),mN=Symbol("getResponseCache"),mz=Symbol("cache"),mD=global.Response;var mF=class e{#c;#l;[mN](){let e=this[mz],t=e&&e[2]instanceof Headers?e[2]:void 0;return delete this[mz],this[mM]||=new mD(this.#c,t?{status:this.#l?.status,statusText:this.#l?.statusText,headers:t}:this.#l)}constructor(t,r){let i;if(this.#c=t,r instanceof mD){let t=r[mM];if(t){this.#l=t,this[mN]();return}this.#l=r instanceof e?r.#l:r,i=new Headers(r.headers)}else this.#l=r;(null==t||"string"==typeof t||void 0!==t?.getReader||t instanceof Blob||t instanceof Uint8Array)&&(this[mz]=[r?.status||200,t??null,i||r?.headers])}get headers(){let e=this[mz];return e?(e[2]instanceof Headers||(e[2]=new Headers(e[2]||(null===e[1]?void 0:{"content-type":mW}))),e[2]):this[mN]().headers}get status(){return this[mz]?.[0]??this[mN]().status}get ok(){let e=this.status;return e>=200&&e<300}};["body","bodyUsed","redirected","statusText","trailers","type","url"].forEach(e=>{Object.defineProperty(mF.prototype,e,{get(){return this[mN]()[e]}})}),["arrayBuffer","blob","clone","formData","json","text"].forEach(e=>{Object.defineProperty(mF.prototype,e,{value:function(){return this[mN]()[e]()}})}),Object.defineProperty(mF.prototype,Symbol.for("nodejs.util.inspect.custom"),{value:function(e,t,r){return`Response (lightweight) ${r({status:this.status,headers:this.headers,ok:this.ok,nativeResponse:this[mM]},{...t,depth:null==e?null:e-1})}`}}),Object.setPrototypeOf(mF,mD),Object.setPrototypeOf(mF.prototype,mD.prototype);let mL=/^https?:\/\/[!#-;=?-[\]_a-z~A-Z]+$/,mU=new Set([301,302,303,307,308]);function mH(e,t,r){let i=t=>{e.cancel(t).catch(()=>{})};return t.on("close",i),t.on("error",i),(r??e.read()).then(a,o),e.closed.finally(()=>{t.off("close",i),t.off("error",i)});function o(e){e&&t.destroy(e)}function n(){e.read().then(a,o)}function a({done:r,value:i}){try{if(r)t.end();else{if(t.write(i))return e.read().then(a,o);t.once("drain",n)}}catch(e){o(e)}}}function mG(e,t){if(e.locked)throw TypeError("ReadableStream is locked.");if(!t.destroyed)return mH(e.getReader(),t)}Object.defineProperty(mF,"redirect",{value:function(e,t=302){if(!mU.has(t))throw RangeError("Invalid status code");return new mF(null,{status:t,headers:{location:e instanceof URL?e.href:mL.test(e)?e:new URL(e).href}})},writable:!0,configurable:!0}),Object.defineProperty(mF,"json",{value:function(e,t){let r,i=JSON.stringify(e);if(void 0===i)throw TypeError("The data is not JSON serializable");let o=t?.headers;return o?(r=new Headers(o)).has("content-type")||r.set("content-type","application/json"):r={"content-type":"application/json"},new mF(i,{status:t?.status??200,statusText:t?.statusText,headers:r})},writable:!0,configurable:!0});let mB=(e,t)=>{let r={};if(e instanceof Headers||(e=new Headers(e??void 0)),e.has("set-cookie")){let t=[];for(let[i,o]of e)"set-cookie"===i?t.push(o):r[i]=o;t.length>0&&(r["set-cookie"]=t)}else for(let[t,i]of e)r[t]=i;return t&&(r["content-type"]??=t),r},mK=Symbol("outgoingEnded"),mJ=Symbol("incomingDraining"),mZ=e=>{if(e.destroyed||e[mJ])return;if(e[mJ]=!0,e instanceof z){try{e.stream?.close?.(D.NGHTTP2_NO_ERROR)}catch{}return}let t=0,r=()=>{clearTimeout(o),e.off("data",n),e.off("end",r),e.off("error",r)},i=()=>{r();let t=e.socket;t&&!t.destroyed&&("function"==typeof t.destroySoon?t.destroySoon():"function"==typeof t.destroy&&t.destroy())},o=setTimeout(i,500);o.unref?.();let n=e=>{(t+=e.length)>0x4000000&&i()};e.on("data",n),e.on("end",r),e.on("error",r),e.resume()},mQ=e=>new Response(null,{status:e instanceof Error&&("TimeoutError"===e.name||"TimeoutError"===e.constructor.name)?504:500}),mX=(e,t)=>{let r=e instanceof Error?e:Error("unknown error",{cause:e});"ERR_STREAM_PREMATURE_CLOSE"===r.code?console.info("The user aborted a request."):(console.error(e),t.headersSent||(t instanceof T&&(t._contentLength=null),t.writeHead(500,{"Content-Type":"text/plain"})),t.end(`Error: ${r.message}`),t.destroy(r))},mY=e=>{"flushHeaders"in e&&e.writable&&e.flushHeaders()},m1=(e,t,r)=>!(null!==e._contentLength||!e._hasBody||!e.useChunkedEncodingByDefault||e._removedContLen||!(t>=200)||204===t||304===t||e.hasHeader("content-length")||e.hasHeader("transfer-encoding")||e.hasHeader("trailer"))&&(e._contentLength=r,!0),m0=(e,t,r)=>{m1(e,t,r)?e.writeHead(t,{"Content-Type":mW}):e.writeHead(t,{"Content-Type":mW,"Content-Length":r})},m2=async(e,t)=>{let[r,i,o]=e[mz];if(!o){null===i?(t.writeHead(r),t.end()):"string"==typeof i?(m0(t,r,Buffer.byteLength(i)),t.end(i)):i instanceof Uint8Array?(m0(t,r,i.byteLength),t.end(i)):i instanceof Blob?(m0(t,r,i.size),t.end(new Uint8Array(await i.arrayBuffer()))):(t.writeHead(r,{"Content-Type":mW}),mY(t),await mG(i,t)?.catch(e=>mX(e,t))),t[mK]?.();return}let n=!1,a=!1,s=!0;if(o instanceof Headers)n=o.has("content-length"),o=mB(o,null===i?void 0:mW);else if(Array.isArray(o)){let e=new Headers(o);n=e.has("content-length"),o=mB(e,null===i?void 0:mW)}else for(let e in a=!0,o){if(14===e.length&&"content-length"===e.toLowerCase()){n=!0;break}(17===e.length&&"transfer-encoding"===e.toLowerCase()||7===e.length&&"trailer"===e.toLowerCase())&&(s=!1)}if(!n){let e;"string"==typeof i?e=Buffer.byteLength(i):i instanceof Uint8Array?e=i.byteLength:i instanceof Blob&&(e=i.size),void 0===e||a&&s&&m1(t,r,e)||(a&&(o={...o}),o["Content-Length"]=e)}t.writeHead(r,o),null==i?t.end():"string"==typeof i||i instanceof Uint8Array?t.end(i):i instanceof Blob?t.end(new Uint8Array(await i.arrayBuffer())):(mY(t),await mG(i,t)?.catch(e=>mX(e,t))),t[mK]?.()},m4=(e,t={})=>{let r=t.autoCleanupIncoming??!0;return!1!==t.overrideGlobalObjects&&global.Request!==mn&&(Object.defineProperty(global,"Request",{value:mn}),Object.defineProperty(global,"Response",{value:mF})),async(i,o)=>{let n,a,s=!1,d=!1,c=()=>{if(a&&!d){let e,t;d=!0,o.on("close",(e=a,t=s,()=>{i.errored?(mu(i),e[mk](i.errored.toString())):(!o.writableFinished||i instanceof z&&i.aborted)&&(mu(i),e[mk]("Client connection prematurely closed.")),t&&!i.readableEnded&&setTimeout(()=>{i.readableEnded||setTimeout(()=>{mZ(i)})})}))}};try{let d;if(a=((e,t)=>{let r,i=Object.create(mA);i[mg]=e,i[mv]=(e=>{if("string"!=typeof e||0===e.length)return"GET";switch(e){case"DELETE":case"GET":case"HEAD":case"OPTIONS":case"PATCH":case"POST":case"PUT":case"QUERY":return e}let t=e.toUpperCase();switch(t){case"DELETE":case"GET":case"HEAD":case"OPTIONS":case"POST":case"PUT":return t;default:return e}})(e.method);let o=e.url||"";if("/"!==o[0]&&(o.startsWith("http://")||o.startsWith("https://"))){if(e instanceof z)throw new u0("Absolute URL for :path is not allowed in HTTP/2");try{i[m_]=new URL(o).href}catch(e){throw new u0("Invalid absolute URL",{cause:e})}return i}let n=(e instanceof z?e.authority:e.headers.host)||t;if(!n)throw new u0("Missing host header");if(e instanceof z){if("http"!==(r=e.scheme)&&"https"!==r)throw new u0("Unsupported scheme")}else r=e.socket&&e.socket.encrypted?"https":"http";try{i[m_]=((e,t,r)=>{let i=`${e}://${t}${r}`;if(mi.test(t)){if(0===r.length)return i+"/";if(47!==r.charCodeAt(0))throw new u0("Invalid URL");return!mt.test(r)||mr.test(r)?new URL(i).href:i}{let e=new URL(i);if(e.hostname.length!==t.length&&e.hostname!==(t.includes(":")?t.replace(/:\d+$/,""):t).toLowerCase())throw new u0("Invalid host header");return e.href}})(r,n,o)}catch(e){if(e instanceof u0)throw e;throw new u0("Invalid URL",{cause:e})}return i})(i,t.hostname),(s=r&&"GET"!==i.method&&"HEAD"!==i.method)&&(i[ma]=!0,i instanceof z&&(o[mK]=()=>{i.readableEnded||setTimeout(()=>{i.readableEnded||setTimeout(()=>{i.destroy(),o.destroy()})})})),d=n=e(a,{incoming:i,outgoing:o}),"function"!=typeof d.then&&(e=>{if(!(mz in e))return!1;let t=e[mz][1];return null===t||"string"==typeof t||t instanceof Uint8Array})(n))return s&&!i.readableEnded&&o.once("finish",()=>{i.readableEnded||mZ(i)}),m2(n,o);c()}catch(e){if(n)return mX(e,o);if(t.errorHandler){if(c(),!(n=await t.errorHandler(a||e instanceof u0?e:new u0(e.message,{cause:e}))))return}else n=a?mQ(e):new Response(null,{status:400})}try{return await (async(e,t,r={})=>{if("function"==typeof e.then)if(r.errorHandler)try{e=await e}catch(i){let t=await r.errorHandler(i);if(!t)return;e=t}else e=await e.catch(mQ);if(mz in e)return m2(e,t);let i=mB(e.headers,null===e.body?void 0:mW);if(e.body){let r,o=e.body.getReader(),n=[],a=!1;if("chunked"!==i["transfer-encoding"]){let e=2;for(let t=0;t<e;t++){r||=o.read();let i=await (async function(e){return Promise.race([e,Promise.resolve().then(()=>Promise.resolve(void 0))])})(r).catch(e=>{console.error(e),a=!0});if(!i){if(1===t){await new Promise(e=>setTimeout(e)),e=3;continue}break}if(r=void 0,i.value&&n.push(i.value),i.done){a=!0;break}}!a||"content-length"in i||(i["content-length"]=n.reduce((e,t)=>e+t.length,0))}t.writeHead(e.status,i),n.forEach(e=>{t.write(e)}),a?t.end():(0===n.length&&mY(t),await mH(o,t,r))}else i["x-hono-already-sent"]||(t.writeHead(e.status,i),t.end());t[mK]?.()})(n,o,t)}catch(e){return mX(e,o)}}};globalThis.CloseEvent??Event,globalThis.ErrorEvent??Event,Symbol("CONNECTION_SYMBOL_KEY"),Symbol("WAIT_FOR_WEBSOCKET_SYMBOL");var m6=class{_webStandardTransport;_requestListener;_requestContext=new WeakMap;constructor(e={}){this._webStandardTransport=new uX(e),this._requestListener=m4(async e=>{let t=this._requestContext.get(e);return this._webStandardTransport.handleRequest(e,{authInfo:t?.authInfo,parsedBody:t?.parsedBody})},{overrideGlobalObjects:!1})}get sessionId(){return this._webStandardTransport.sessionId}set onclose(e){this._webStandardTransport.onclose=e}get onclose(){return this._webStandardTransport.onclose}set onerror(e){this._webStandardTransport.onerror=e}get onerror(){return this._webStandardTransport.onerror}set onmessage(e){this._webStandardTransport.onmessage=e}get onmessage(){return this._webStandardTransport.onmessage}async start(){return this._webStandardTransport.start()}async close(){return this._webStandardTransport.close()}async send(e,t){return this._webStandardTransport.send(e,t)}setSupportedProtocolVersions(e){this._webStandardTransport.setSupportedProtocolVersions(e)}setScopeChallengeResolver(e){this._webStandardTransport.setScopeChallengeResolver(e)}async handleRequest(e,t,r){let i=e.auth;await m4(async e=>this._webStandardTransport.handleRequest(e,{authInfo:i,parsedBody:r}),{overrideGlobalObjects:!1})(e,t)}closeSSEStream(e){this._webStandardTransport.closeSSEStream(e)}closeStandaloneSSEStream(){this._webStandardTransport.closeStandaloneSSEStream()}};function m3(e=process.env){let t=e.TRACEDECAY_DATA_DIR;if(void 0!==t&&t.length>0)return E.resolve(t);let r="win32"===process.platform?e.USERPROFILE:e.HOME,i=void 0!==r&&r.length>0?r:U.homedir();return E.join(i,".tracedecay")}let m9=o5().min(1),m5=nM({pid:nk().int().nonnegative(),process_run_id:o5(),started_at_unix_secs:nk().int(),epoch:nk().int().nonnegative(),version:o5(),endpoint:nT(),http_application_endpoint:m9.nullable().optional(),auth_token:o5().min(1),profile_root:o5().min(1)});function m8(e){if(e<=0)return!1;try{return process.kill(e,0),!0}catch(e){return"object"==typeof e&&null!==e&&"code"in e&&"EPERM"===e.code}}function m7(e){let t=e.http_application_endpoint;return null==t?null:`http://${t}`}function fe(e){let t=JSON.stringify(function e(t){return Array.isArray(t)?t.map(e):"object"==typeof t&&null!==t?Object.fromEntries(Object.entries(t).sort(([e],[t])=>e<t?-1:+(e>t)).map(([t,r])=>[t,e(r)])):t}(e));if(void 0===t)throw TypeError("value is not canonical JSON");return t}function ft(e,t){if("object"!=typeof e||null===e||Array.isArray(e))throw TypeError(`malformed canonical schema: ${t} must be an object`);return e}function fr(e,t){switch(t){case"null":return null===e;case"boolean":return"boolean"==typeof e;case"integer":return"number"==typeof e&&Number.isSafeInteger(e);case"number":return"number"==typeof e&&Number.isFinite(e);case"string":return"string"==typeof e;case"array":return Array.isArray(e);case"object":return"object"==typeof e&&null!==e&&!Array.isArray(e);default:throw TypeError(`unsupported canonical schema type: ${t}`)}}function fi(e,t){if("object"!=typeof e||null===e||Array.isArray(e))throw TypeError(`malformed canonical envelope: ${t} must be an object`);return e}function fo(e,t){if("string"!=typeof e)throw TypeError(`malformed canonical envelope: ${t} must be a string`);return e}function fn(e,t){if("number"!=typeof e||!Number.isFinite(e))throw TypeError(`malformed canonical envelope: ${t} must be a finite number`);return e}function fa(e,t){if(!Array.isArray(e))throw TypeError(`malformed canonical envelope: ${t} must be an array`);return e}function fs(e,t){let r=fn(e,t);if(!Number.isSafeInteger(r))throw TypeError(`malformed canonical envelope: ${t} must be a safe integer`);return r}function fd(e,t){let r=fs(e,t);if(r<0)throw TypeError(`malformed canonical envelope: ${t} must be non-negative`);return r}let fc=new TextEncoder;function fl(e,t,r){let i=fo(e,t);if(0===i.length||i.trim()!==i||fc.encode(i).byteLength>r||/\p{Cc}/u.test(i))throw TypeError(`malformed canonical envelope: ${t} is not a bounded identifier`);return i}function fp(e,t,r,i,o,n,a,s,d){let c=fi(e,"success envelope");if(fo(c.binding_id,"binding_id")!==t)throw TypeError("malformed canonical envelope: binding mismatch");let l=fi(c.contract,"contract");if(fo(l.schema_id,"contract.schema_id")!==r||fn(l.schema_revision,"contract.schema_revision")!==i)throw TypeError("malformed canonical envelope: result contract mismatch");fo(c.request_id,"request_id"),fi(c.scope,"scope");let p=fi(c.outcome,"outcome"),u=fo(p.outcome,"outcome.outcome");return{...c,outcome:{...p,outcome:u,value:function(e,t,r,i,o,n,a){let s=fi(t,"outcome.value");if(!("payload"in s))throw TypeError("malformed canonical envelope: outcome.value.payload is required");if(("durable_effect"!==o||"required"!==n||"effect"!==e)&&("operation"!==o||"not_required"!==n||"evidence"!==e&&"preview"!==e))throw TypeError(`malformed canonical envelope: outcome ${e} is outside the operation receipt contract`);if(!function(e,t,r){let i=fi(e,"outcome.value.execution");if(fn(i.started_at,"execution.started_at"),fn(i.ended_at,"execution.ended_at"),!("effective_deadline"in i)||!("cancellation"in i))throw TypeError("malformed canonical envelope: receipt fields are required");let o=fi(i.budget,"execution.budget");fn(o.units_consumed,"budget.units_consumed"),fn(o.bytes_consumed,"budget.bytes_consumed"),fn(o.elapsed_micros,"budget.elapsed_micros");let n=fo(i.termination,"execution.termination");if(!t.includes(n))throw TypeError(`malformed canonical envelope: termination ${n} is not legal for this operation`);if(("cancelled"===n||"timed_out"===n)&&null===i.cancellation)throw TypeError("malformed canonical envelope: terminal cancellation observation is required");if(null!==i.cancellation){let e=fi(r,"operation.cancellation"),t=fo(e.mode,"operation.cancellation.mode"),o=fi(i.cancellation,"execution.cancellation"),a=fo(o.stage,"execution.cancellation.stage");if(fs(o.observed_at,"execution.cancellation.observed_at"),!["before_admission","before_read","during_read","before_effect","effect_in_flight","reconciling","after_commit"].includes(a))throw TypeError(`malformed canonical envelope: unknown cancellation stage ${a}`);if("not_cancellable"===t){if("timed_out"!==n)throw TypeError("malformed canonical envelope: non-cancellable operation returned cancellation evidence")}else if(!fa(e.points,"operation.cancellation.points").includes(a))throw TypeError(`malformed canonical envelope: cancellation stage ${a} is not legal for this operation`)}}(s.execution,r,i),"evidence"===e)fi(s.temporal,"temporal"),fi(s.authority,"authority"),fa(s.evidence_authorities,"evidence_authorities"),fi(s.coverage,"coverage"),fa(s.omissions,"omissions"),fa(s.scores,"scores"),fa(s.contributions,"contributions"),function(e){let t=fi(e,"outcome.value.page");if(fl(t.sort_contract_id,"page.sort_contract_id",192),1>fd(t.sort_revision,"page.sort_revision"))throw TypeError("malformed canonical envelope: page sort_revision must be positive");let r=null===t.total?null:fd(t.total,"page.total"),i=fd(t.returned,"page.returned");if(null!==r&&i>r)throw TypeError("malformed canonical envelope: page returned exceeds total");null!==t.cursor&&function(e){let t=fi(e,"page.cursor"),r=fo(t.kind,"page.cursor.kind");if("opaque"===r)fl(t.cursor,"page.cursor.cursor",4096);else throw TypeError(`malformed canonical envelope: unsupported page cursor kind ${r}`)}(t.cursor),null!==t.expires_at&&fs(t.expires_at,"page.expires_at")}(s.page);else if("preview"===e)fo(s.preview_id,"preview_id"),fo(s.preview_digest,"preview_digest"),fo(s.effect_class,"effect_class"),fi(s.authority,"authority"),fo(s.expected_state,"expected_state");else if("effect"===e)fo(s.effect_id,"effect_id"),fo(s.effect_class,"effect_class"),fo(s.idempotency_key,"idempotency_key"),fi(s.authority,"authority"),fo(s.expected_state,"expected_state"),fo(s.reconciliation,"reconciliation"),fi(s.receipt,"receipt");else throw TypeError(`malformed canonical envelope: unsupported outcome ${e}`);return{...s,payload:null===s.payload?null:a(s.payload)}}(u,p.value,o,n,a,s,d)}}}function fu(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function fm(e){return"number"==typeof e&&Number.isSafeInteger(e)&&e>=0}function ff(e){return"number"==typeof e&&Number.isSafeInteger(e)}function fh(e,t){return"string"==typeof e&&e.length>0&&e.trim()===e&&fc.encode(e).byteLength<=t&&!/\p{Cc}/u.test(e)}async function fy(e){let t=await crypto.subtle.digest("SHA-256",fc.encode(fe(e)));return`sha256:${Array.from(new Uint8Array(t),e=>e.toString(16).padStart(2,"0")).join("")}`}function fg(e){return fu(e)&&"string"==typeof e.code&&"string"==typeof e.message}let f_={description:"Strongly typed algorithm-tagged integrity digest: `AccessPolicyDigest`.",type:"string"},fv={description:"Strongly typed canonical identity: `AccessRuleId`.",type:"string"},fb={description:"Strongly typed canonical identity: `ActorId`.",type:"string"},f$={description:"Strongly typed canonical identity: `AgentInstanceId`.",type:"string"},fS={enum:["memory_curator","session_reflector","skill_writer","combined_review","user_job"],type:"string"},fk={properties:{coverage:{$ref:"#/$defs/MetricCoverageV1"},current:{anyOf:[{$ref:"#/$defs/AnalyticsModeV1"},{type:"null"}]},transition_watermark:{type:["string","null"]},unavailable_reason:{type:["string","null"]}},required:["coverage"],type:"object"},fw={enum:["off","local_only","aggregate_share"],type:"string"},fP={oneOf:[{const:"project",description:"Analytics events of the resolved project.",type:"string"},{const:"all",description:"Analytics events of every registered project.",type:"string"}]},fV={description:"Strongly typed canonical identity: `AnalyzerEnvironmentVariable`.",type:"string"},fR={description:"Strongly typed canonical identity: `AnalyzerExecutableId`.",type:"string"},fq={oneOf:[{properties:{executable_id:{$ref:"#/$defs/AnalyzerExecutableId"},kind:{const:"built_in",type:"string"}},required:["kind","executable_id"],type:"object"},{properties:{executable_digest:{$ref:"#/$defs/ManifestDigest"},kind:{const:"approved_external",type:"string"}},required:["kind","executable_digest"],type:"object"}]},fI={description:"Strongly typed canonical identity: `AnalyzerLanguageId`.",type:"string"},fx={additionalProperties:!1,description:"One language's analyzer selection. Host registration may project only the\nnon-sensitive `language_id`/`enabled` pair; all other fields remain in the\nconfiguration authority.",properties:{arguments:{items:{type:"string"},type:"array"},enabled:{type:"boolean"},environment_allowlist:{items:{$ref:"#/$defs/AnalyzerEnvironmentVariable"},type:"array",uniqueItems:!0},executable:{$ref:"#/$defs/AnalyzerExecutableReferenceV1"},initialization_options:{additionalProperties:{$ref:"#/$defs/AnalyzerStructuredValueV1"},type:"object"},language_id:{$ref:"#/$defs/AnalyzerLanguageId"},privacy_class:{$ref:"#/$defs/AnalyzerPrivacyClassV1"},resource_limits:{$ref:"#/$defs/AnalyzerResourceLimitsV1"},restart_policy:{$ref:"#/$defs/AnalyzerRestartPolicyV1"},settings:{additionalProperties:{$ref:"#/$defs/AnalyzerStructuredValueV1"},type:"object"}},required:["language_id","enabled","executable","arguments","initialization_options","settings","environment_allowlist","privacy_class","resource_limits","restart_policy"],type:"object"},fj={enum:["non_sensitive","sensitive","restricted"],type:"string"},fC={additionalProperties:!1,properties:{maximum_memory_mib:{format:"uint32",minimum:0,type:"integer"},request_timeout_millis:{format:"uint64",minimum:0,type:"integer"},startup_timeout_millis:{format:"uint64",minimum:0,type:"integer"}},required:["maximum_memory_mib","startup_timeout_millis","request_timeout_millis"],type:"object"},fT={enum:["restart_on_configuration_change","manual_restart_only"],type:"string"},fO={additionalProperties:!1,description:"Canonical analyzer settings. A changed selection produces a new\nconfiguration revision/digest; cache invalidation remains owned elsewhere.",properties:{schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"},selections:{items:{$ref:"#/$defs/AnalyzerLanguageSelectionV1"},type:"array"}},required:["schema_version","selections"],type:"object"},fE={description:"A structured analyzer option value. This deliberately excludes raw\nenvironment values, commands, credential material, and transport blobs.",oneOf:[{properties:{kind:{const:"boolean",type:"string"},value:{type:"boolean"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"integer",type:"string"},value:{format:"int64",type:"integer"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"text",type:"string"},value:{type:"string"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"text_list",type:"string"},value:{items:{type:"string"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"object",type:"string"},value:{additionalProperties:{$ref:"#/$defs/AnalyzerStructuredValueV1"},type:"object"}},required:["kind","value"],type:"object"}]},fA={description:"The structured facts behind a problem. Adapters read these fields; the\nproblem's `message` is only their one human rendering.",oneOf:[{additionalProperties:!1,description:"The worktree's code index is parked until the operator applies\n`remedy`; repeating the request cannot change the answer.",properties:{cause:{type:"string"},kind:{const:"parked",type:"string"},remedy:{type:"string"},retries_on_wake:{type:"boolean"}},required:["kind","cause","remedy","retries_on_wake"],type:"object"},{additionalProperties:!1,description:"A session refresh asked to begin from a source frontier the\ncommitted projection has already passed.",properties:{active:{format:"uint64",minimum:0,type:"integer"},committed:{format:"uint64",minimum:0,type:"integer"},kind:{const:"stale_refresh_frontier",type:"string"},requested:{format:"uint64",minimum:0,type:"integer"}},required:["kind","requested","committed","active"],type:"object"},{additionalProperties:!1,description:"A compare-and-swap request named `requested` in `field`, but the\nauthority holds `current`. Resending with `current` is a new request.",properties:{current:{format:"uint64",minimum:0,type:"integer"},field:{type:"string"},kind:{const:"stale_precondition",type:"string"},requested:{format:"uint64",minimum:0,type:"integer"}},required:["kind","field","requested","current"],type:"object"},{additionalProperties:!1,description:"A workflow step effect named placement digest `found`, but the step's\ncurrent placement is `expected`: the effect was settled against a\nplacement the run has since replaced.",properties:{expected:{type:"string"},found:{type:"string"},kind:{const:"workflow_placement_digest_stale",type:"string"}},required:["kind","expected","found"],type:"object"},{additionalProperties:!1,description:"A writer lock stayed held by other writers past its admission\ndeadline.",properties:{deadline_ms:{format:"uint64",minimum:0,type:"integer"},kind:{const:"lock_deadline",type:"string"},resource:{type:"string"}},required:["kind","resource","deadline_ms"],type:"object"},{additionalProperties:!1,description:"A persisted store whose shape this binary does not open. It is served\nin this typed state until the operator runs `remedy`, which deletes\nthe old data; nothing is migrated or backed up.",properties:{authority:{type:"string"},found_version:{format:"int64",type:["integer","null"]},kind:{const:"reset_required",type:"string"},reason:{type:"string"},remedy:{type:"string"},required_version:{format:"int64",type:["integer","null"]}},required:["kind","authority","reason","remedy"],type:"object"},{additionalProperties:!1,description:"No compiler runs automatically for the diagnostics scope: no tsconfig\nowns `file`, or, for a workspace read (`file` null), none exists under\nthe project root. `searched` lists the owner search's candidates,\nnearest first; it is empty for a workspace read or a file outside the\nproject root.",properties:{file:{type:["string","null"]},kind:{const:"diagnostics_unsupported",type:"string"},searched:{items:{$ref:"#/$defs/DiagnosticsSearchedTsconfigV1"},type:"array"}},required:["kind","searched"],type:"object"},{additionalProperties:!1,description:"The TypeScript `producer` has not published diagnostics for the\ncurrent code generation yet. `generation` is the last generation it\npublished, null when it has published none.",properties:{generation:{type:["string","null"]},kind:{const:"diagnostics_pending",type:"string"},producer:{type:"string"}},required:["kind","producer"],type:"object"},{additionalProperties:!1,description:"The code graph's engine or catalog was released for memory and was\nstill warming again when the read's budget ran out;\n`retry_after_millis` is the measured warm-up it still needs.",properties:{kind:{const:"code_graph_rewarming",type:"string"},retry_after_millis:{format:"uint64",minimum:0,type:"integer"}},required:["kind","retry_after_millis"],type:"object"},{additionalProperties:!1,description:"No TraceDecay daemon accepts connections on `socket`. `named_by` is\nthe environment variable that chose the socket, when one did;\n`service_unit` is what this client observed of the managed service.",properties:{kind:{const:"daemon_unreachable",type:"string"},named_by:{type:["string","null"]},service_unit:{$ref:"#/$defs/DaemonServiceUnitObservationV1"},socket:{type:"string"}},required:["kind","socket","service_unit"],type:"object"}]},fW={description:"Strongly typed canonical identity: `AttemptId`.",type:"string"},fM={description:"Authoritative scope of a source binding. A mutable path, label, or host\nprofile cannot be represented as authority.",oneOf:[{properties:{id:{$ref:"#/$defs/ProjectId"},kind:{const:"project",type:"string"}},required:["kind","id"],type:"object"},{properties:{id:{$ref:"#/$defs/UserProfileId"},kind:{const:"projectless_hermes",type:"string"}},required:["kind","id"],type:"object"}]},fN={additionalProperties:!1,description:"One exact application scope paired with its registered physical locator.\n\nThe scope remains the identity authority. The locator is retained only so\na later read or restart can reopen the exact registered root without an\nactive-graph or CWD fallback.",properties:{locator:{anyOf:[{$ref:"#/$defs/RegisteredRootLocatorV1"},{type:"null"}]},scope:{$ref:"#/$defs/ResolvedScope"}},required:["scope"],type:"object"},fz={additionalProperties:!1,description:"Immutable canonical set of exact roots admitted by their existing request\ncontexts. A registered locator participates only as frozen reopening\nevidence; its paired [`ResolvedScope`](crate::context::ResolvedScope) remains\nthe root identity authority.",properties:{actor_id:{$ref:"#/$defs/ActorId"},digest:{$ref:"#/$defs/ManifestDigest"},revision:{$ref:"#/$defs/ScopeSetRevision"},roots:{items:{$ref:"#/$defs/AuthorizedRoot"},type:"array"},scope_set_id:{$ref:"#/$defs/ScopeSetId"}},required:["scope_set_id","revision","actor_id","roots","digest"],type:"object"},fD={description:"A terminal automatic-fact receipt state.",enum:["applied","quarantined"],type:"string"},fF={oneOf:[{properties:{kind:{const:"disabled",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"eligible_only",type:"string"},maximum_per_run:{format:"uint16",maximum:65535,minimum:1,type:"integer"},minimum_idle_seconds:{format:"uint64",minimum:1,type:"integer"}},required:["kind","minimum_idle_seconds","maximum_per_run"],type:"object"}]},fL={enum:["disabled","codex_app_server"],type:"string"},fU={enum:["standalone","delegated_host"],type:"string"},fH={description:"The settled status every successful read in this family reports.",enum:["ok"],type:"string"},fG={description:"Which owner's automation schedulers a reconcile covers.",oneOf:[{const:"project",description:"The served project's scheduler, answered by the project's owner.",type:"string"},{const:"profile",description:"Every cached project scheduler of the profile, answered by the\ndaemon's profile owner.",type:"string"}]},fB={properties:{created_at:{type:"string"},kind:{type:"string"},path:{type:"string"},schema_version:{format:"uint32",minimum:0,type:"integer"},sha256:{type:"string"},summary:{type:["string","null"]}},required:["schema_version","kind","path","sha256","created_at"],type:"object"},fK={description:"Automation run reads answer from the active project's ledger only.",enum:["active_project"],type:"string"},fJ={enum:["queued","running","succeeded","failed","skipped"],type:"string"},fZ={additionalProperties:!1,properties:{allow_job_commands:{type:"boolean"},backend:{$ref:"#/$defs/AutomationBackendV1"},combine_due_tasks:{type:"boolean"},enabled:{type:"boolean"},host_mode:{$ref:"#/$defs/AutomationHostModeV1"},model_id:{type:["string","null"]},scheduler_tick_secs:{format:"uint64",minimum:0,type:"integer"},schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"},tasks:{$ref:"#/$defs/AutomationTaskSetV1"},timeout_secs:{format:"uint64",minimum:0,type:"integer"}},required:["schema_version","enabled","backend","host_mode","timeout_secs","scheduler_tick_secs","combine_due_tasks","allow_job_commands","tasks"],type:"object"},fQ={additionalProperties:!1,properties:{memory_curator:{$ref:"#/$defs/AutomationTaskSettingsV1"},session_reflector:{$ref:"#/$defs/AutomationTaskSettingsV1"},skill_writer:{$ref:"#/$defs/AutomationTaskSettingsV1"}},required:["memory_curator","session_reflector","skill_writer"],type:"object"},fX={additionalProperties:!1,properties:{cooldown_secs:{format:"uint64",minimum:0,type:["integer","null"]},enabled:{type:"boolean"},interval_secs:{format:"uint64",minimum:0,type:["integer","null"]},min_idle_secs:{format:"uint64",minimum:0,type:["integer","null"]},schedule:{type:["string","null"]},session_evidence_budget_backoff_secs:{description:"Suppression window between session-evidence retrieval attempts while\nthe evidence budget stays exhausted. Unset uses the automation crate's\none-hour default. Distinct from `cooldown_secs`, which paces retries\nafter failed runs; budget exhaustion is a skip, not a failure.",format:"uint64",minimum:0,type:["integer","null"]}},required:["enabled"],type:"object"},fY={enum:["manual_cli","manual_mcp","dashboard","application","scheduler","host_receipt"],type:"string"},f1={description:"Strongly typed canonical identity: `BrainId`.",type:"string"},f0={oneOf:[{properties:{kind:{const:"reject",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"append_monotonic_ordinal",type:"string"},maximum_attempts:{format:"uint16",maximum:65535,minimum:1,type:"integer"}},required:["kind","maximum_attempts"],type:"object"}]},f2={oneOf:[{properties:{bytes:{format:"uint8",maximum:255,minimum:1,type:"integer"},kind:{const:"task_id_digest_prefix",type:"string"}},required:["kind","bytes"],type:"object"},{properties:{kind:{const:"repository_slug",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"work_class",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"monotonic_collision_ordinal",type:"string"}},required:["kind"],type:"object"}]},f4={enum:["hyphen","underscore","slash"],type:"string"},f6={additionalProperties:!1,properties:{collision:{$ref:"#/$defs/BranchCollisionPolicyV1"},components:{items:{$ref:"#/$defs/BranchNameComponentV1"},type:"array"},maximum_bytes:{format:"uint16",maximum:65535,minimum:1,type:"integer"},prefix:{$ref:"#/$defs/CanonicalGitRefPrefix"},separator:{$ref:"#/$defs/BranchNameSeparatorV1"}},required:["prefix","components","separator","maximum_bytes","collision"],type:"object"},f3={additionalProperties:!1,description:"A declared dependency edge; propagation direction remains an application\ndecision and is never inferred from this edge.",properties:{dependency:{$ref:"#/$defs/StackNodeId"},dependent:{$ref:"#/$defs/StackNodeId"}},required:["dependency","dependent"],type:"object"},f9={description:"Strongly typed canonical identity: `BranchStackId`.",type:"string"},f5={additionalProperties:!1,description:"One visible branch/ref at one immutable tip.",properties:{node_id:{$ref:"#/$defs/StackNodeId"},project_id:{$ref:"#/$defs/ProjectId"},reference:{$ref:"#/$defs/RefId"},repository_id:{$ref:"#/$defs/RepositoryId"},tip:{$ref:"#/$defs/CommitId"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["node_id","project_id","repository_id","reference","tip"],type:"object"},f8={description:"Strongly typed canonical identity: `BranchStackRevisionId`.",type:"string"},f7={additionalProperties:!1,description:"Immutable branch-stack projection at one exact inventory revision.",properties:{canonical_order:{items:{$ref:"#/$defs/StackNodeId"},type:"array"},digest:{$ref:"#/$defs/ManifestDigest"},edges:{items:{$ref:"#/$defs/BranchStackEdgeV1"},type:"array"},inventory_epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},inventory_snapshot_id:{$ref:"#/$defs/WorktreeInventorySnapshotId"},nodes:{items:{$ref:"#/$defs/BranchStackNodeV1"},type:"array"},revision_id:{$ref:"#/$defs/BranchStackRevisionId"},source:{$ref:"#/$defs/BranchStackSourceV1"},stack_id:{$ref:"#/$defs/BranchStackId"}},required:["stack_id","revision_id","inventory_snapshot_id","inventory_epoch","source","nodes","edges","canonical_order","digest"],type:"object"},he={description:"Authoritative source that declared the exact stack topology.",enum:["explicit_declaration","accepted_task_branch_topology"],type:"string"},ht={enum:["no_branches","unbranched","independent_branches","local_stack"],type:"string"},hr={additionalProperties:!1,properties:{allowed:{items:{$ref:"#/$defs/BranchTopologyKindV1"},type:"array",uniqueItems:!0}},required:["allowed"],type:"object"},hi={description:"Strongly typed canonical identity: `CalibrationProfileId`.",type:"string"},ho={additionalProperties:!1,description:"Surface-owned query semantics. Page size remains an invocation control, but\ncontinuation is a request field so CLI, MCP, and HTTP callers all have the\nsame channel for spending a `next_cursor`.",properties:{cursor:{default:null,type:["string","null"]},order:{$ref:"#/$defs/RetrievalOrder"},projection:{$ref:"#/$defs/ResultProjection"}},required:["projection","order"],type:"object"},hn={additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"},stage:{$ref:"#/$defs/CancellationStage"}},required:["stage","observed_at"],type:"object"},ha={description:"Exact stage at which cancellation or deadline state was observed.",enum:["before_admission","before_read","during_read","before_effect","effect_in_flight","reconciling","after_commit"],type:"string"},hs={additionalProperties:!1,description:"One retriever's scored contribution to a fused candidate. Every ranked\ncandidate retains every retriever's raw score domain, ordinal rank,\ncalibrated feature, weight, and weighted contribution.",properties:{calibrated_feature_micros:{format:"uint32",minimum:0,type:"integer"},calibration_profile_id:{$ref:"#/$defs/CalibrationProfileId"},ordinal_rank:{format:"uint32",minimum:0,type:"integer"},raw_score:{$ref:"#/$defs/FixedPointScore"},retriever:{$ref:"#/$defs/RetrieverKind"},retriever_revision:{$ref:"#/$defs/ComponentRevision"},score_domain:{$ref:"#/$defs/ScoreDomainId"},source_occurrence_id:{$ref:"#/$defs/SourceOccurrenceId"},weight_micros:{format:"uint32",minimum:0,type:"integer"},weighted_contribution_micros:{format:"uint64",minimum:0,type:"integer"}},required:["retriever","retriever_revision","source_occurrence_id","ordinal_rank","raw_score","score_domain","calibration_profile_id","calibrated_feature_micros","weight_micros","weighted_contribution_micros"],type:"object"},hd={description:"A validated full native Git ref name, such as `refs/heads/main`.",type:"string"},hc={description:"A validated ref/branch prefix. Branch naming accepts a short branch prefix\n(for example `tracedecay/`) while protected-ref selectors use full\n`refs/.../` prefixes.",type:"string"},hl={description:"Strongly typed canonical identity: `CapabilityId`.",type:"string"},hp={description:"Strongly typed canonical identity: `CatalogGenerationId`.",type:"string"},hu={description:"Strongly typed canonical identity: `ChangePlanId`.",type:"string"},hm={additionalProperties:!1,properties:{from_inclusive:{format:"int64",type:["integer","null"]},through_inclusive:{format:"int64",type:["integer","null"]}},type:"object"},hf={additionalProperties:!1,description:'Why co-change mining produced no answer, so an empty\n`missing_co_change_partners` does not read as "no partner is missing".',properties:{reason:{type:"string"},retryable:{type:"boolean"}},required:["reason","retryable"],type:"object"},hh={enum:["kind","language","path"],type:"string"},hy={description:"Strongly typed canonical identity: `CodeGenerationId`.",type:"string"},hg={description:"Freshness of the generation a verified graph read serves.",oneOf:[{properties:{state:{const:"current",type:"string"}},required:["state"],type:"object"},{properties:{rebuild_in_flight:{type:"boolean"},sealed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"last_complete_stale",type:"string"}},required:["state","sealed_at","rebuild_in_flight"],type:"object"}]},h_={description:"A typed reason an otherwise active generation cannot make durable progress.",enum:["resident_memory","source_unavailable","artifact_store_unavailable","retry_backoff","publication_authority_corrupt"],type:"string"},hv={description:'A deterministic contract violation that parked background convergence.\n\nParked is not dead: the worker keeps re-observing the violation on its\nordinary wake cadence, so an operator fix (for example restoring an\nowner-private mode) is picked up on the next wake without a restart. The\nstate exists so `status`, doctor, and the dashboard report the violation\ntyped instead of an indefinite "warming".',properties:{blocked_reason:{anyOf:[{$ref:"#/$defs/CodeIndexBuildBlockedReasonV1"},{type:"null"}],description:"Stable class for callers that must decide whether new work is admissible."},observed_passes:{description:"Background passes that re-observed the violation since parking.",format:"uint64",minimum:0,type:"integer"},parked_at_micros:{description:"When the violation was first observed (microseconds since the Unix epoch).",format:"int64",type:"integer"},reason:{description:"Exact typed failure that parked convergence.",type:"string"},remediation:{description:"Operator action that clears the violation.",type:"string"},retries_on_wake:{description:"Whether the worker re-checks this violation on every ordinary wake.\nTrue for filesystem/contract violations an operator fix clears in\nplace; false for an abnormal task failure that only changed input (a\nnew sealed generation) retries.",type:"boolean"}},required:["reason","remediation","parked_at_micros","observed_passes","retries_on_wake"],type:"object"},hb={properties:{display_path:{description:"`git_path_bytes` decoded for display, invalid UTF-8 replaced.",type:"string"},git_path_bytes:{description:"The exact Git path bytes, which need not be UTF-8.",items:{format:"uint8",maximum:255,minimum:0,type:"integer"},type:"array"},reason:{$ref:"#/$defs/CodeIndexSourceOmissionReasonV1"}},required:["git_path_bytes","display_path","reason"],type:"object"},h$={description:"Sources a sealed snapshot captured but does not index.",properties:{count:{description:"Every omitted source in the snapshot.",format:"uint64",minimum:0,type:"integer"},sources:{description:"The first omitted sources in Git path order, at most\n[`CODE_INDEX_OMITTED_SOURCE_LIST_LIMIT`].",items:{$ref:"#/$defs/CodeIndexOmittedSourceV1"},type:"array"}},required:["count","sources"],type:"object"},hS={oneOf:[{description:"No logical path can carry the Git path: not UTF-8, a backslash, a\ncontrol character, or leading or trailing whitespace.",properties:{kind:{const:"unrepresentable_path",type:"string"}},required:["kind"],type:"object"},{description:"The privacy boundary withheld the file's bytes.",properties:{detail:{type:"string"},kind:{const:"privacy_withheld",type:"string"}},required:["kind","detail"],type:"object"}]},hk={description:"Closed staleness ladder for one mounted worktree.\n\nThe scheduler publishes one of these tokens. MCP, the dashboard, and the\nCLI must match the variant, not a hand-copied string, so a new ladder\nstate cannot appear at one caller and be missed at the others.",enum:["fresh","stale","indexing","refreshing","restoring","verifying","parked"],type:"string"},hw={description:"Profile-level worker-count intent for the process-wide code-index pool.\n`Automatic` delegates the concrete count to runtime resource admission;\n`Exact` persists an operator-requested positive worker count.",oneOf:[{additionalProperties:!1,properties:{mode:{const:"automatic",type:"string"}},required:["mode"],type:"object"},{additionalProperties:!1,properties:{mode:{const:"exact",type:"string"},workers:{format:"uint16",maximum:65535,minimum:0,type:"integer"}},required:["mode","workers"],type:"object"}]},hP={additionalProperties:!1,properties:{chunk:{anyOf:[{$ref:"#/$defs/CodeSearchChunkId"},{type:"null"}]},file:{$ref:"#/$defs/FileOccurrenceId"},path:{type:"string"},span:{$ref:"#/$defs/SourceSpan"},symbol:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}]}},required:["file","path","span"],type:"object"},hV={additionalProperties:!1,description:"One immutable code-index generation inside the authorized single root.\nThe path prefix narrows a query but never establishes project identity.",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},path_prefix:{type:["string","null"]}},required:["generation"],type:"object"},hR={description:"Strongly typed canonical identity: `CodeSearchChunkId`.",type:"string"},hq={description:"Strongly typed canonical identity: `CommitId`.",type:"string"},hI={enum:["promote","reject","insufficient_evidence"],type:"string"},hx={description:"Whether the bounded complexity walk over a symbol's body ran to the end.\n\nThe extractor stops walking a body once its traversal budget is spent. The\ncounters accumulated by then are lower bounds over the visited prefix, not\nfacts about the whole body, so every surface that prints, ranks, or\naggregates complexity must render this state instead of treating those\ncounters as exact.",oneOf:[{enum:["complete"],type:"string"},{const:"traversal_budget_exhausted",description:"The walk stopped when the traversal budget ran out.",type:"string"}]},hj={description:"Strongly typed canonical identity: `ComponentRevision`.",type:"string"},hC={description:"Strongly typed canonical identity: `ComponentVersion`.",type:"string"},hT={enum:["config_summary"],type:"string"},hO={additionalProperties:!1,description:"One entry per changed config file instead of one per config key.",properties:{config_keys:{format:"uint",minimum:0,type:"integer"},file:{type:"string"},kind:{$ref:"#/$defs/ConfigSummaryKindV1"}},required:["file","kind","config_keys"],type:"object"},hE={description:"Strongly typed canonical identity: `ConfigurationIdempotencyKey`.",type:"string"},hA={description:"A typed configuration layer identity. The default layer intentionally has\nno caller-controlled identifier.",oneOf:[{properties:{kind:{const:"default",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"user_profile",type:"string"},profile_id:{$ref:"#/$defs/UserProfileId"}},required:["kind","profile_id"],type:"object"},{properties:{kind:{const:"project",type:"string"},project_id:{$ref:"#/$defs/ProjectId"}},required:["kind","project_id"],type:"object"},{properties:{collection_id:{$ref:"#/$defs/QueryCollectionId"},kind:{const:"collection",type:"string"}},required:["kind","collection_id"],type:"object"}]},hW={description:"Strongly typed canonical identity: `ConfigurationReceiptId`.",type:"string"},hM={description:"Strongly typed canonical identity: `ConfigurationRevisionId`.",type:"string"},hN={description:"Strongly typed canonical identity: `ConfigurationSnapshotId`.",type:"string"},hz={description:"Values that the typed registry can accept.",oneOf:[{properties:{kind:{const:"boolean",type:"string"},value:{type:"boolean"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"unsigned",type:"string"},value:{format:"uint64",minimum:0,type:"integer"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"code_index_worker_selection",type:"string"},value:{$ref:"#/$defs/CodeIndexWorkerSelectionV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"text",type:"string"},value:{type:"string"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"string_list",type:"string"},value:{items:{type:"string"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"source_bindings",type:"string"},value:{items:{$ref:"#/$defs/ScopeSourceBinding"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"access_rules",type:"string"},value:{items:{$ref:"#/$defs/ScopeAccessRule"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"analyzer_settings",type:"string"},value:{$ref:"#/$defs/AnalyzerSettingsV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"work_topology_policy",type:"string"},value:{$ref:"#/$defs/WorkTopologyPolicyV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"work_executable_bindings",type:"string"},value:{items:{$ref:"#/$defs/WorkExecutableBindingV1"},type:"array"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"work_expertise_consent",type:"string"},value:{$ref:"#/$defs/WorkExpertiseConsentV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"context_scout_settings",type:"string"},value:{$ref:"#/$defs/ContextScoutSettingsV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"automation_settings",type:"string"},value:{$ref:"#/$defs/AutomationSettingsV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"lcm_summarizer_executables",type:"string"},value:{$ref:"#/$defs/LcmSummarizerExecutablesV1"}},required:["kind","value"],type:"object"}]},hD={description:"Strongly typed algorithm-tagged integrity digest: `ContentDigest`.",type:"string"},hF={description:"What one caller `lexical_anchors` entry contributed to the response, in\ncaller order.",oneOf:[{additionalProperties:!1,description:"`matched` indexed rows carried the anchor; `admitted` result sites\ncarrying it are in this response, and `dropped` counts the sites the\nlexical lane admitted that a later stage removed, by reason.",properties:{admitted:{format:"uint64",minimum:0,type:"integer"},anchor:{type:"string"},dropped:{items:{$ref:"#/$defs/LexicalAnchorDropV1"},type:"array"},matched:{format:"uint64",minimum:0,type:"integer"},outcome:{const:"matched",type:"string"}},required:["outcome","anchor","matched","admitted"],type:"object"},{additionalProperties:!1,description:"No indexed row carries the anchor.",properties:{anchor:{type:"string"},outcome:{const:"unmatched",type:"string"}},required:["outcome","anchor"],type:"object"},{additionalProperties:!1,description:"The anchor's route did not serve; `coverage` names the lane state.",properties:{anchor:{type:"string"},outcome:{const:"not_served",type:"string"}},required:["outcome","anchor"],type:"object"}]},hL={enum:["explore","plan"],type:"string"},hU={additionalProperties:!1,description:"Exact opaque destination for one public Context Scout operation.\n\nThe daemon converts this transport-neutral address into its runtime value\nonly after catalog admission. Keeping the public wire here makes CLI, MCP,\nHTTP, and both SDKs share one generated schema authority.",properties:{agent_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},logical_message_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},profile_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},project_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},protected_session_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},provider_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},thread_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},turn_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"}},required:["profile_id","provider_id","protected_session_id","thread_id","turn_id","agent_id","logical_message_id","project_id"],type:"object"},hH={enum:["retrieval","diagnostic","coordination","verification"],type:"string"},hG={additionalProperties:!1,description:"Public lease proof. It carries only opaque identities; the daemon resolves\nit back to the durable queue row before recording delivery.",properties:{envelope_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},lease_expires_at:{$ref:"#/$defs/UtcMicros"},lease_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},work:{$ref:"#/$defs/ContextScoutWorkV1"}},required:["work","envelope_id","lease_id","lease_expires_at"],type:"object"},hB={additionalProperties:!1,properties:{max_candidates:{format:"uint32",minimum:0,type:"integer"},max_evidence:{format:"uint32",minimum:0,type:"integer"},max_model_input_tokens:{format:"uint32",minimum:0,type:"integer"},max_model_output_tokens:{format:"uint32",minimum:0,type:"integer"},max_text_bytes:{format:"uint32",minimum:0,type:"integer"}},required:["max_candidates","max_evidence","max_text_bytes","max_model_input_tokens","max_model_output_tokens"],type:"object"},hK={enum:["deterministic","configured_model"],type:"string"},hJ={enum:["active","paused","disabled"],type:"string"},hZ={enum:["codex_app_server"],type:"string"},hQ={enum:["attempted","delayed","displayed","expanded","explicitly_accepted","explicitly_rejected","dismissed","expired_unseen","corrected","unknown"],type:"string"},hX={additionalProperties:!1,properties:{delivered_at:{$ref:"#/$defs/UtcMicros"},envelope_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},outcome:{$ref:"#/$defs/ContextScoutDeliveryOutcomeV1"},receipt_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"}},required:["receipt_id","envelope_id","delivered_at","outcome"],type:"object"},hY={enum:["immediate","next_boundary","idle_window","on_request","suppressed"],type:"string"},h1={enum:["complete","partial","stale","cancelled","unavailable"],type:"string"},h0={additionalProperties:!1,properties:{anchor_ids:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},availability:{$ref:"#/$defs/ContextScoutEvidenceAvailabilityV1"},claim_digest:{$ref:"#/$defs/ManifestDigest"},content_generation:{$ref:"#/$defs/CodeGenerationId"},session_window:{anyOf:[{$ref:"#/$defs/ContextScoutSessionWindowV1"},{type:"null"}],description:"Session turns a session-evidence suggestion was judged from. Absent for\ncode evidence."}},required:["content_generation","availability","anchor_ids","claim_digest"],type:"object"},h2={enum:["explicitly_accepted","explicitly_rejected","dismissed","corrected"],type:"string"},h4={additionalProperties:!1,properties:{kind:{$ref:"#/$defs/ContextScoutFeedbackKindV1"},receipt_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"}},required:["receipt_id","kind"],type:"object"},h6={description:"One user intent the Scout can recognize. The serialized keys are the\nhistorical hook hint category keys, so persisted hint analytics, hint\nsettlement, and evals keep one vocabulary.",enum:["search","semantic_search","file_read","tool_descriptor_read","broad_read","call_graph","impact","symbol_lookup","file_lookup","project_context","session_recall","atomic_edit","type_orientation","explore_subagent","subagent_start_context","build_diagnostics","review_changes","memory_store","edit_redundancy","unexpected_changes"],type:"string"},h3={additionalProperties:!1,description:"Operator configuration for the Context Scout intent pass.",properties:{action_fact_score_permille:{description:"Score a deterministic action fact contributes for its intent.",format:"uint16",maximum:65535,minimum:0,type:"integer"},enabled:{type:"boolean"},engine:{$ref:"#/$defs/DecisionEngineSettingsV1"},min_delivery_gap_secs:{format:"uint32",minimum:0,type:"integer"},prompt_lookup_deadline_ms:{format:"uint32",minimum:0,type:"integer"},questions:{items:{$ref:"#/$defs/IntentQuestionSettingsV1"},type:"array"},ttl_secs:{format:"uint32",minimum:0,type:"integer"},window:{$ref:"#/$defs/IntentWindowSettingsV1"}},required:["enabled","engine","window","questions","action_fact_score_permille","ttl_secs","min_delivery_gap_secs","prompt_lookup_deadline_ms"],type:"object"},h9={additionalProperties:!1,properties:{max_candidates:{format:"uint",minimum:0,type:"integer"},max_evidence:{format:"uint",minimum:0,type:"integer"},max_model_input_tokens:{format:"uint",minimum:0,type:"integer"},max_model_output_tokens:{format:"uint",minimum:0,type:"integer"},max_text_bytes:{format:"uint",minimum:0,type:"integer"}},required:["max_candidates","max_evidence","max_text_bytes","max_model_input_tokens","max_model_output_tokens"],type:"object"},h5={enum:["disabled","codex_app_server","unsupported","decision_engine"],type:"string"},h8={oneOf:[{enum:["not_requested","succeeded","disabled","unavailable","denied","disconnected","cancelled","deadline_exceeded","token_budget_exceeded","invalid_output"],type:"string"},{const:"backpressured",description:"The engine's concurrency bound was full; the request was not sent.",type:"string"}]},h7={additionalProperties:!1,properties:{actual_model:{type:["string","null"]},actual_provider:{type:["string","null"]},estimated_cost_microusd:{format:"uint64",minimum:0,type:["integer","null"]},input_tokens:{format:"uint64",minimum:0,type:["integer","null"]},output_tokens:{format:"uint64",minimum:0,type:["integer","null"]},requested_backend:{$ref:"#/$defs/ContextScoutModelBackendV1"}},required:["requested_backend"],type:"object"},ye={additionalProperties:!1,properties:{feedback:{anyOf:[{$ref:"#/$defs/ContextScoutFeedbackV1"},{type:"null"}]},receipt:{$ref:"#/$defs/ContextScoutDeliveryReceiptV1"},suggestion:{$ref:"#/$defs/ContextScoutSuggestionProjectionV1"}},required:["suggestion","receipt"],type:"object"},yt={oneOf:[{enum:["deterministic","model_assisted","deterministic_fallback"],type:"string"},{const:"decision_engine",description:"Produced by the session intent pass: decision-engine answers combined\nwith deterministic action facts.",type:"string"}]},yr={enum:["deterministic","configured_model"],type:"string"},yi={enum:["active","paused","disabled"],type:"string"},yo={additionalProperties:!1,description:"Exact bounded span of one session's transcript an intent pass read. The\nwindow body is never retained; only its digest and store-id bounds are.",properties:{first_store_id:{format:"int64",type:"integer"},last_store_id:{format:"int64",type:"integer"},message_count:{format:"uint16",maximum:65535,minimum:0,type:"integer"},newest_timestamp:{format:"int64",type:["integer","null"]},window_digest:{$ref:"#/$defs/ManifestDigest"}},required:["first_store_id","last_store_id","message_count","window_digest"],type:"object"},yn={additionalProperties:!1,description:"Canonical Context Scout control-plane value. Disabled is the only stock\nstate; deterministic or configured-model execution requires an explicit\nconfiguration revision.",properties:{intent:{anyOf:[{$ref:"#/$defs/ContextScoutIntentSettingsV1"},{type:"null"}],description:"Session intent pass. Absent means the Scout runs no intent pass; the\nfield is omitted from the canonical encoding so settings written before\nit existed keep their behavior digest."},limits:{$ref:"#/$defs/ContextScoutConfigurationLimitsV1"},mode:{$ref:"#/$defs/ContextScoutConfigurationModeV1"},model_id:{type:["string","null"]},model_path:{anyOf:[{$ref:"#/$defs/ContextScoutConfiguredModelPathV1"},{type:"null"}]},model_timeout_secs:{format:"uint64",minimum:0,type:["integer","null"]},schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"},state:{$ref:"#/$defs/ContextScoutConfigurationStateV1"}},required:["schema_version","state","mode","limits"],type:"object"},ya={enum:["stored","duplicate","superseded"],type:"string"},ys={additionalProperties:!1,properties:{category:{$ref:"#/$defs/ContextScoutCategoryV1"},configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},dedupe_key:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},delivery_window:{$ref:"#/$defs/ContextScoutDeliveryWindowV1"},envelope_id:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:16,minItems:16,type:"array"},evidence:{$ref:"#/$defs/ContextScoutEvidenceProjectionV1"},expires_at:{$ref:"#/$defs/UtcMicros"},model_outcome:{$ref:"#/$defs/ContextScoutModelOutcomeV1"},model_receipt:{anyOf:[{$ref:"#/$defs/ContextScoutModelReceiptV1"},{type:"null"}]},relevance_score:{format:"uint16",maximum:65535,minimum:0,type:"integer"},route:{$ref:"#/$defs/ContextScoutRouteV1"},suggestion_text:{type:"string"},work:{$ref:"#/$defs/ContextScoutWorkV1"}},required:["work","envelope_id","configuration_revision","delivery_window","route","model_outcome","dedupe_key","category","relevance_score","suggestion_text","evidence","expires_at"],type:"object"},yd={oneOf:[{enum:["disabled","paused","dirty_overlay","quiet_or_unreceptive","no_eligible_candidate","expired","duplicate","cancelled","model_output_invalid","evidence_partial","evidence_stale","evidence_unavailable"],type:"string"},{const:"pending_sibling",description:"A suggestion for the same session is already pending delivery.",type:"string"}]},yc={additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},generation:{format:"uint64",minimum:0,type:"integer"},input_watermark:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"}},required:["address","generation","input_watermark"],type:"object"},yl={properties:{authorized_scope_ref:{type:"string"},current:{type:"boolean"},estimated_cost:{items:{$ref:"#/$defs/MetricValueV1"},type:"array"},horizon:{$ref:"#/$defs/ObservabilityHorizonV1"},latency:{description:"Provider-backed operation latency, projected from the same retained\nPlan 26 operation-resource events as Observatory. Each entry keeps\nprovider/model identity explicit; `None` is a real uncorrelated state,\nnever a client-side guess.",items:{$ref:"#/$defs/ProviderLatencyReadModelV1"},type:"array"},observed_at_micros:{format:"int64",type:"integer"},pricing_revision:{type:["string","null"]},usage:{items:{$ref:"#/$defs/MetricValueV1"},type:"array"},watermark:{type:"string"}},required:["authorized_scope_ref","horizon","watermark","observed_at_micros","current","usage","estimated_cost","latency"],type:"object"},yp={description:"Which side of a file dependency the coupling report counts.",enum:["fan_in","fan_out"],type:"string"},yu={description:"Completeness is explicit; unknown never renders as clean.",enum:["complete","partial","unknown"],type:"string"},ym={additionalProperties:!1,properties:{completeness:{$ref:"#/$defs/CoverageCompleteness"},domain:{$ref:"#/$defs/EvidenceDomain"}},required:["domain","completeness"],type:"object"},yf={enum:["known","partial","stale","unknown","sampled","capped"],type:"string"},yh={description:"Strongly typed canonical identity: `CredentialReferenceId`.",type:"string"},yy={enum:["disabled","manual_receipt_only","fast_forward_only","merge_commit","cherry_pick_exact_commits"],type:"string"},yg={additionalProperties:!1,properties:{allow_cross_repository:{type:"boolean"},allowed_modes:{items:{$ref:"#/$defs/CrossMergeModeV1"},type:"array",uniqueItems:!0},default_mode:{$ref:"#/$defs/CrossMergeModeV1"}},required:["allowed_modes","default_mode","allow_cross_repository"],type:"object"},y_={description:"The managed daemon service unit as a client observed it, from the unit\nfile alone.",oneOf:[{additionalProperties:!1,properties:{state:{const:"not_installed",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The unit file could not be read.",properties:{error:{type:"string"},state:{const:"unobservable",type:"string"}},required:["state","error"],type:"object"},{additionalProperties:!1,description:"The unit file at `path` serves the socket `serves`.",properties:{path:{type:"string"},serves:{type:"string"},state:{const:"installed",type:"string"}},required:["state","path","serves"],type:"object"}]},yv={additionalProperties:!1,description:"One immutable deadline supplied by the caller or upstream admission layer.",properties:{expires_at:{$ref:"#/$defs/UtcMicros"}},required:["expires_at"],type:"object"},yb={additionalProperties:!1,description:"The decision engine the intent pass asks. There is no default endpoint or\nmodel; both come only from explicit operator configuration.",properties:{base_url:{type:"string"},max_concurrent:{format:"uint8",maximum:255,minimum:0,type:"integer"},max_state_bytes:{format:"uint32",minimum:0,type:"integer"},model:{type:["string","null"]},timeout_ms:{format:"uint32",minimum:0,type:"integer"}},required:["base_url","timeout_ms","max_concurrent","max_state_bytes"],type:"object"},y$={description:"Diagnostic severity. Source severity is preserved exactly; TraceDecay\nnever raises severity because several producers agree.",enum:["error","warning","information","hint"],type:"string"},yS={additionalProperties:!1,description:"One tsconfig location the diagnostics owner search checked.",properties:{path:{description:"Relative to the project root, forward-slash separated.",type:"string"},present:{description:"The config exists, but neither it nor its references include the\nfile.",type:"boolean"}},required:["path","present"],type:"object"},yk={description:"Whether Doctor observed all of a family's evidence sources.",oneOf:[{const:"complete",description:"Every relevant evidence source for the family was observed.",type:"string"},{const:"partial",description:"Some evidence sources were observed; others were omitted.",type:"string"},{const:"unknown",description:"Whether coverage is complete could not be determined.",type:"string"}]},yw={description:"Shape of the design-structure-matrix report.",enum:["stats","clusters","matrix"],type:"string"},yP={enum:["prevented","committed","unknown","not_applicable"],type:"string"},yV={enum:["exact_duplicate","superseded_overlap","repeated_investigation","duplicate_effect","not_duplicate","censored","unknown"],type:"string"},yR={description:"The stable effect classification of one application operation.\n\nGit index writes remain separate classes so policy cannot accidentally\nsubstitute one index mutation for another.",oneOf:[{enum:["read","preview","source_edit","git_index_stage","git_index_unstage","configuration_write","administrative"],type:"string"},{const:"spawns_process",description:"Runs a child process in the project (e.g. the project's test runner).",type:"string"},{const:"binds_server",description:"Binds a listening server in the daemon process.",type:"string"},{const:"schedules_work",description:"Queues work on a daemon-owned scheduler; the call answers with the\nscheduler's admission, not the finished work.",type:"string"},{const:"maintains_owner_state",description:"Maintains bookkeeping the daemon keeps for the project or profile it\nserves: resets a usage counter, records registry token accounting, or\nreconciles automation schedulers with the saved configuration. Each\nwrite settles within the call and answers its new state.",type:"string"},{const:"maintains_profile_state",description:"Reads and rewrites the daemon profile's own state: its project\nregistry, accounting ledgers, and session stores. Unlike bookkeeping,\nit includes long work, a registry collection or a transcript import,\nthat a cancelled call stops.",type:"string"},{const:"records_host_evidence",description:"Records a host's session evidence (transcripts, hook admissions,\nreceipts) in daemon-owned session stores.",type:"string"}]},yq={additionalProperties:!1,description:"Durable effect proof. It records identities and receipts, never credentials\nor arbitrary command text.",properties:{actor:{$ref:"#/$defs/ActorId"},catalog_digest:{$ref:"#/$defs/ManifestDigest"},committed_state:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},configuration_digest:{$ref:"#/$defs/ManifestDigest"},effect_class:{$ref:"#/$defs/EffectClass"},expected_state:{$ref:"#/$defs/ManifestDigest"},external_proof:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},idempotency_key:{type:"string"},input_digest:{$ref:"#/$defs/ManifestDigest"},operation:{$ref:"#/$defs/UseCaseId"},outcome:{$ref:"#/$defs/EffectTermination"},policy_digest:{$ref:"#/$defs/ManifestDigest"},privacy_digest:{$ref:"#/$defs/ManifestDigest"},request_id:{type:"string"},scope:{$ref:"#/$defs/ResolvedScope"}},required:["operation","request_id","actor","scope","effect_class","idempotency_key","input_digest","expected_state","policy_digest","configuration_digest","catalog_digest","privacy_digest","outcome"],type:"object"},yI={description:"Durable effect receipt terminal state.",enum:["completed","cancelled","timed_out","failed","partial","effect_unknown"],type:"string"},yx={additionalProperties:!1,description:"Deterministic coverage fold input for an evidence packet.",properties:{completeness:{$ref:"#/$defs/CoverageCompleteness"},domains:{items:{$ref:"#/$defs/CoverageDomainState"},type:"array"},eligible:{format:"uint64",minimum:0,type:["integer","null"]},requested_domains:{items:{$ref:"#/$defs/EvidenceDomain"},type:"array"},returned:{format:"uint64",minimum:0,type:"integer"},visited:{format:"uint64",minimum:0,type:["integer","null"]}},required:["requested_domains","returned","completeness","domains"],type:"object"},yj={description:"Requested evidence domain for bounded coverage and omissions.",enum:["symbol","source","graph","test","temporal","anchor","operational","diagnostic"],type:"string"},yC={description:"Evidence role used by dedupe/diversity caps. Independent corroboration\nand contradictions are preserved.",enum:["primary","corroboration","contradiction","context"],type:"string"},yT={description:"The exact tiers, lexicographically ordered above all approximate\ncandidates. Fusion derives this only from a validated [`ExactAdmissionProof`].",enum:["exact_message","exact_literal_phrase","approximate"],type:"string"},yO={description:"The classification of one whole exact technical term. Whole exact terms\nand language-profiled subtokens are distinct fields.",enum:["whole_symbol","qualified_name","path","compiler_error_code","compiler_error_text","runtime_error_code","runtime_error_text","cli_flag","tool_name","configuration_key","commit_identifier"],type:"string"},yE={description:"Strongly typed canonical identity: `FactAssertionId`.",type:"string"},yA={enum:["general","user_pref","project","tool","decision","code_area"],type:"string"},yW={enum:["committed","idempotent_replay"],type:"string"},yM={oneOf:[{additionalProperties:!1,properties:{kind:{const:"profile",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"project",type:"string"},project_id:{$ref:"#/$defs/ProjectId"}},required:["kind","project_id"],type:"object"}]},yN={additionalProperties:!1,properties:{active_assertion_id:{anyOf:[{$ref:"#/$defs/FactAssertionId"},{type:"null"}]},committed_event_ids:{items:{$ref:"#/$defs/FactEventId"},type:"array"},disposition:{$ref:"#/$defs/FactCommitDispositionV1"},fact_id:{$ref:"#/$defs/FactId"},last_event_id:{$ref:"#/$defs/FactEventId"},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["disposition","fact_id","owner","committed_event_ids","last_event_id"],type:"object"},yz={description:"Strongly typed canonical identity: `FactEventId`.",type:"string"},yD={enum:["helpful","unhelpful"],type:"string"},yF={description:"Strongly typed canonical identity: `FactId`.",type:"string"},yL={oneOf:[{additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},kind:{const:"evidence",type:"string"},stable_key:{$ref:"#/$defs/LocatorDigest"}},required:["kind","anchor_id","stable_key"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"application",type:"string"},operation_id:{$ref:"#/$defs/ProvenanceId"}},required:["kind","operation_id"],type:"object"}]},yU={description:"Payload states that structurally cannot expose an available fact payload.",enum:["redacted","quarantined","retention_expired","deleted","unavailable","ambiguous"],type:"string"},yH={oneOf:[{additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactV1"},kind:{const:"available",type:"string"}},required:["kind","fact"],type:"object"},{additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactV1"},kind:{const:"superseded",type:"string"},superseded_by:{$ref:"#/$defs/FactId"}},required:["kind","fact","superseded_by"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"unavailable",type:"string"},status:{$ref:"#/$defs/FactStatusV1"}},required:["kind","status"],type:"object"}]},yG={oneOf:[{additionalProperties:!1,properties:{kind:{const:"not_applicable",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"not_mounted",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{expanded_fact_count:{format:"uint",minimum:0,type:"integer"},kind:{const:"complete",type:"string"},relation_count:{format:"uint",minimum:0,type:"integer"},root_count:{format:"uint",minimum:0,type:"integer"}},required:["kind","root_count","relation_count","expanded_fact_count"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"degraded",type:"string"},reason:{$ref:"#/$defs/FactSearchGraphDegradationV1"}},required:["kind","reason"],type:"object"}]},yB={enum:["conflict","unavailable","budget_exhausted","deadline_exceeded"],type:"string"},yK={additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactV1"},scores:{$ref:"#/$defs/FactSearchScoresV1"},why:{type:["string","null"]}},required:["fact","scores"],type:"object"},yJ={additionalProperties:!1,properties:{fts_score_millionths:{format:"uint32",minimum:0,type:"integer"},holographic_score_millionths:{format:"uint32",minimum:0,type:"integer"},jaccard_score_millionths:{format:"uint32",minimum:0,type:"integer"},score_millionths:{format:"uint32",minimum:0,type:"integer"},trust_score_millionths:{format:"uint32",minimum:0,type:"integer"}},required:["score_millionths","fts_score_millionths","jaccard_score_millionths","holographic_score_millionths","trust_score_millionths"],type:"object"},yZ={additionalProperties:!1,properties:{fact_id:{$ref:"#/$defs/FactId"},owner:{$ref:"#/$defs/FactCommitOwnerV1"},payload_access:{$ref:"#/$defs/FactPayloadAccessV1"},projected_as_of:{$ref:"#/$defs/UtcMicros"}},required:["owner","fact_id","payload_access","projected_as_of"],type:"object"},yQ={additionalProperties:!1,properties:{access_count:{format:"uint64",minimum:0,type:"integer"},created_at:{$ref:"#/$defs/UtcMicros"},helpful_count:{format:"uint64",minimum:0,type:"integer"},last_feedback_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},last_recalled_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},last_retrieved_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},retrieval_count:{format:"uint64",minimum:0,type:"integer"},unhelpful_count:{format:"uint64",minimum:0,type:"integer"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["retrieval_count","access_count","helpful_count","unhelpful_count","created_at","updated_at"],type:"object"},yX={additionalProperties:!1,description:"Available fact projection. Unavailable payload states use\n[`FactProjectionV1::Unavailable`] and cannot fabricate payload fields.",properties:{active_assertion_id:{$ref:"#/$defs/FactAssertionId"},category:{$ref:"#/$defs/FactCategoryV1"},content:{type:"string"},entities:{items:{type:"string"},type:"array"},fact_id:{$ref:"#/$defs/FactId"},last_event_id:{$ref:"#/$defs/FactEventId"},metadata:{additionalProperties:!0,type:"object"},owner:{$ref:"#/$defs/FactCommitOwnerV1"},projected_as_of:{$ref:"#/$defs/UtcMicros"},source:{$ref:"#/$defs/FactIdentitySourceResultV1"},source_label:{type:["string","null"]},tags:{items:{type:"string"},type:"array"},telemetry:{$ref:"#/$defs/FactTelemetryV1"},trust_score_millionths:{format:"uint32",minimum:0,type:"integer"}},required:["owner","fact_id","content","category","tags","entities","trust_score_millionths","source","active_assertion_id","last_event_id","projected_as_of","telemetry","metadata"],type:"object"},yY={additionalProperties:!1,description:"Exact source-owned state for one advisory producer in a composed feedback\ncycle. The producer tag is part of the durable cycle result so consumers\nnever infer provenance from the position of an aggregate provider state.",properties:{producer:{$ref:"#/$defs/FeedbackDiagnosticProducerV1"},state:{$ref:"#/$defs/ProviderEvaluationStateV1"}},required:["producer","state"],type:"object"},y1={description:"Availability of the canonical baseline used to classify a current\ndiagnostic. An unavailable or partial baseline never upgrades a finding\nto `New`; only an authoritative `NoPriorBaseline` state may do so without\na baseline record.",oneOf:[{enum:["complete","partial","stale","unavailable"],type:"string"},{const:"no_prior_baseline",description:"The authoritative runtime confirmed that there is no prior saved\ngeneration to compare. This is authoritative empty history, not an\ninvented horizon and not unavailable/partial coverage.",type:"string"}]},y0={description:"Content identity distinguishes durable saved content from an authorized\nephemeral document overlay. Overlay identity is deliberately local to its\nowning session and cannot be made durable by converting it to a digest.",oneOf:[{properties:{file_digest:{$ref:"#/$defs/ManifestDigest"},generation_digest:{$ref:"#/$defs/ManifestDigest"},kind:{const:"saved_content",type:"string"}},required:["kind","generation_digest","file_digest"],type:"object"},{properties:{agent_id:{anyOf:[{$ref:"#/$defs/AgentInstanceId"},{type:"null"}]},document_version:{format:"uint64",minimum:0,type:"integer"},kind:{const:"ephemeral_overlay",type:"string"},overlay_digest:{$ref:"#/$defs/ManifestDigest"},owner_client_id:{$ref:"#/$defs/HostInstanceId"},session_id:{$ref:"#/$defs/SessionId"}},required:["kind","session_id","owner_client_id","document_version","overlay_digest"],type:"object"}]},y2={description:"Strongly typed canonical identity: `FeedbackCycleId`.",type:"string"},y4={enum:["clean","duplicate_noop","blocked","incomplete_coverage","stale_replan_required","budget_exceeded","cancelled","user_stop","daemon_unavailable"],type:"string"},y6={enum:["new","pre_existing","unknown"],type:"string"},y3={description:"Closed producer vocabulary for standard diagnostic projection.",enum:["code_diagnostic","git_hub_review","ci_localization","proximity"],type:"string"},y9={additionalProperties:!1,description:"Bounded code location used only to project an anchored advisory finding\ninto an editor. The finding's `retrieval_anchor_id` remains the evidence\nexpansion authority; this value carries no source body or provider payload.",properties:{code:{type:"string"},code_description_uri:{type:["string","null"]},file:{$ref:"#/$defs/FileOccurrenceId"},producer:{$ref:"#/$defs/FeedbackDiagnosticProducerV1"},safe_bounded_message:{type:"string"},severity:{$ref:"#/$defs/DiagnosticSeverityV1"},span:{$ref:"#/$defs/SourceSpan"},symbol:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}]}},required:["file","span","code","severity","safe_bounded_message","producer"],type:"object"},y5={enum:["durable","session_only"],type:"string"},y8={description:"Strongly typed canonical identity: `FeedbackFindingId`.",type:"string"},y7={enum:["active","superseded","resolved","cleared"],type:"string"},ge={additionalProperties:!1,properties:{cycle_id:{$ref:"#/$defs/FeedbackCycleId"},expand_handle:{description:"Server-minted request handle for `feedback_expand`, present only when\nthe canonical finding has a retained retrieval anchor.",type:["string","null"]},finding:{$ref:"#/$defs/FeedbackFindingV1"},get_handle:{description:"Server-minted request handle for `feedback_get`; durable identity remains\n`finding.finding_id`.\n\nCursor identity types are deliberately absent from the generated schema\nsurface; the public wire form is the bounded opaque string.",type:"string"},result_id:{$ref:"#/$defs/FeedbackResultId"},scope:{$ref:"#/$defs/FeedbackScopeV1"}},required:["result_id","cycle_id","scope","finding","get_handle"],type:"object"},gt={additionalProperties:!1,description:"Reference-only post-edit feedback finding. The safe preview is bounded display framing,\nnever a source-text copy or a second diagnostic store.",properties:{classification:{$ref:"#/$defs/FeedbackDiagnosticClassificationV1"},diagnostic_projection:{anyOf:[{$ref:"#/$defs/FeedbackDiagnosticProjectionV1"},{type:"null"}]},finding_id:{$ref:"#/$defs/FeedbackFindingId"},lifecycle:{$ref:"#/$defs/FeedbackFindingLifecycleV1"},provider_state:{$ref:"#/$defs/ProviderEvaluationStateV1"},retrieval_anchor_id:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},safe_bounded_preview:{type:["string","null"]}},required:["finding_id","classification","lifecycle","provider_state"],type:"object"},gr={description:"Coverage state for graph impact and affected-test evidence. An empty impact\nset is clean only when its state is complete.",enum:["complete","partial","stale","unavailable"],type:"string"},gi={additionalProperties:!1,description:"Reference-only graph and test impact for one feedback target. The owning\ngraph/query layer supplies these identities; this contract does not create\nanother graph, test map, or evidence store.",properties:{affected_callers:{items:{$ref:"#/$defs/SymbolOccurrenceId"},type:"array"},affected_files:{items:{$ref:"#/$defs/FileOccurrenceId"},type:"array"},affected_tests:{items:{$ref:"#/$defs/SymbolOccurrenceId"},type:"array"},affected_tests_state:{$ref:"#/$defs/FeedbackImpactStateV1"},evidence_anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},state:{$ref:"#/$defs/FeedbackImpactStateV1"},target:{$ref:"#/$defs/FeedbackTargetV1"}},required:["target","affected_files","affected_callers","affected_tests","evidence_anchors","state","affected_tests_state"],type:"object"},go={description:"Strongly typed canonical identity: `FeedbackResultId`.",type:"string"},gn={additionalProperties:!1,description:"Exact repository scope used for a feedback evaluation. A path, current\nworking directory, repository display name, or mutable branch label is not\na substitute for this identity.",properties:{branch_ref:{type:"string"},head_commit_id:{$ref:"#/$defs/CommitId"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["project_id","repository_id","worktree_id","branch_ref","head_commit_id"],type:"object"},ga={additionalProperties:!1,description:"Exact changed-code address for one single-root feedback evaluation. The\naddress carries canonical file/range/symbol identities, never a path or\nmutable line number.",properties:{file:{$ref:"#/$defs/FileOccurrenceId"},generation_id:{anyOf:[{$ref:"#/$defs/CodeGenerationId"},{type:"null"}]},span:{anyOf:[{$ref:"#/$defs/SourceSpan"},{type:"null"}]},symbol:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}]}},required:["file"],type:"object"},gs={description:"Strongly typed canonical identity: `FileOccurrenceId`.",type:"string"},gd={description:"How `tracedecay_files` lays out its listing.",oneOf:[{const:"flat",description:"One file per line.",type:"string"},{const:"grouped",description:"Grouped by directory.",type:"string"}]},gc={description:"Deterministic fixed-point score in millionths. No floating point crosses\nthis boundary.",format:"uint64",minimum:0,type:"integer"},gl={description:"Compatibility state of one source/projection pair.",enum:["current","stale","incompatible","missing","unknown"],type:"string"},gp={additionalProperties:!1,description:"A candidate after contribution grouping and fixed-point fusion.",properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},contributions:{items:{$ref:"#/$defs/CandidateContribution"},type:"array"},decisions:{items:{$ref:"#/$defs/RankingDecision"},type:"array"},exact_class:{$ref:"#/$defs/ExactClass"},freshness:{items:{$ref:"#/$defs/SourceFreshness"},type:"array"},logical_evidence_id:{$ref:"#/$defs/LogicalEvidenceId"},occurrences:{items:{$ref:"#/$defs/OccurrenceProvenance"},type:"array"},source_role:{$ref:"#/$defs/RetrievalSourceRoleV1",description:"Strongest source role across the fused occurrences."},utility_micros:{format:"uint64",minimum:0,type:"integer"}},required:["anchor_id","logical_evidence_id","occurrences","exact_class","source_role","utility_micros","contributions","freshness","decisions"],type:"object"},gu={description:"Metric whose distribution the Gini report measures.",enum:["complexity","lines","fan_in","fan_out","members"],type:"string"},gm={description:"Unit the Gini report aggregates its metric over.",enum:["file","symbol"],type:"string"},gf={description:"Expected blob identity, or explicit absent-file state.",oneOf:[{enum:["absent_file"],type:"string"},{additionalProperties:!1,properties:{present:{$ref:"#/$defs/GitOidV1"}},required:["present"],type:"object"}]},gh={description:"Native change kind for one side (index or worktree) of a status entry,\nor for a whole-file diff record.",enum:["unmodified","modified","added","deleted","renamed","copied","type_changed","unmerged"],type:"string"},gy={additionalProperties:!1,description:"A symbol the exact base/head branch-generation comparison reports.",properties:{content_digest:{type:"string"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},name:{type:"string"},qualified_name:{type:"string"}},required:["id","name","qualified_name","kind","file","content_digest"],type:"object"},gg={oneOf:[{additionalProperties:!1,description:"Caller-selected files: symbols may be unchanged or not yet edited.",properties:{kind:{const:"proposed_files",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{base:{$ref:"#/$defs/GitOidV1"},head:{$ref:"#/$defs/GitOidV1"},kind:{const:"commit_range",type:"string"}},required:["kind","base","head"],type:"object"},{additionalProperties:!1,description:"Pinned HEAD (or empty tree) to the selected immutable index blobs.",properties:{head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},kind:{const:"staged",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,description:"Selected index blobs to captured working-tree bytes.",properties:{kind:{const:"working_tree",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,description:"Net change from pinned HEAD (or empty tree), including untracked files.",properties:{head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},kind:{const:"head_to_worktree",type:"string"}},required:["kind"],type:"object"}]},g_={additionalProperties:!1,description:"A verified-graph symbol a git-context read reports.",properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line"],type:"object"},gv={additionalProperties:!1,description:"Typed coverage of a read-only Git result: the sorted, de-duplicated set\nof degradations observed while capturing it.",properties:{degradations:{items:{$ref:"#/$defs/GitDegradationV1"},type:"array"}},required:["degradations"],type:"object"},gb={description:"Typed coverage/degradation reasons for a read-only Git result. A result\ncarrying any degradation is truthful but not complete; callers must not\ntreat it as a clean full view.",oneOf:[{enum:["detached_head","unborn_branch","sparse_checkout","split_index","unreadable_state","unsupported_object_format","in_progress_operation","shallow_boundary","truncated_output"],type:"string"},{const:"ignored_collision",description:"Ignored content shares a directory with live tracked/untracked\nentries, so the untracked/ignored view may be collapsed by Git.",type:"string"},{const:"conflicted_state",description:"Unmerged index stages are present.",type:"string"},{const:"submodule_state",description:"Submodule entries exist; the adapter does not recurse into them.",type:"string"}]},g$={description:"A native Git file mode as stored in tree/index records (six octal digits,\ne.g. `100644`, `100755`, `120000` symlink, `160000` gitlink/submodule).",type:"string"},gS={description:"A changed file's semantic role.",enum:["config","docs","source","test"],type:"string"},gk={description:"Native HEAD state. Missing, unborn, and detached states are explicit,\nnever guessed.",oneOf:[{properties:{branch:{type:"string"},commit:{$ref:"#/$defs/GitOidV1"},state:{const:"attached",type:"string"}},required:["state","branch","commit"],type:"object"},{properties:{commit:{$ref:"#/$defs/GitOidV1"},state:{const:"detached",type:"string"}},required:["state","commit"],type:"object"},{properties:{branch:{type:"string"},state:{const:"unborn",type:"string"}},required:["state","branch"],type:"object"}]},gw={enum:["disabled","probe_private_preview"],type:"string"},gP={additionalProperties:!1,description:"Expected index entry state for compare-and-swap: blob identity (or\nabsent), mode, and unmerged-stage state. `unmerged_stage` is `None` for a\nmerged (stage-0) entry.",properties:{blob:{$ref:"#/$defs/GitBlobExpectationV1"},mode:{anyOf:[{$ref:"#/$defs/GitFileModeV1"},{type:"null"}]},unmerged_stage:{format:"uint8",maximum:255,minimum:0,type:["integer","null"]}},required:["blob"],type:"object"},gV={description:"Strongly typed canonical identity: `GitIndexPreviewId`.",type:"string"},gR={description:"The only native Git mutations represented by the index-transaction runtime. Generic Git execution,\nref rewrites, commits, merge/rebase/cherry-pick, push, and worktree writes are\ndeliberately absent.",enum:["stage_hunks","unstage_hunks"],type:"string"},gq={description:"A native Git object id (commit, tree, or blob), lowercase hex, SHA-1 or\nSHA-256 length. This is identity evidence only; it never authorizes\nobject reconstruction or traversal outside native Git.",type:"string"},gI={description:"In-progress native Git operation state, read from repository metadata.",enum:["none","merge","rebase","cherry_pick","revert","bisect","sequencer","unknown"],type:"string"},gx={description:"Whether a bounded page holds every answer or stopped at its limit.",enum:["complete","partial"],type:"string"},gj={enum:["complete"],type:"string"},gC={enum:["partial"],type:"string"},gT={enum:["unavailable"],type:"string"},gO={enum:["result_limit"],type:"string"},gE={additionalProperties:!1,properties:{branch:{type:["string","null"]},commit:{type:["string","null"]},worktree:{type:["string","null"]}},type:"object"},gA={description:"Flat public selector for an admitted Git diff scope.\n\nThis intentionally differs from [`tracedecay_domain::GitDiffScopeV1`]: MCP\nand CLI accept `scope`, `base`, and `head` as sibling fields, then\ntransport parsing builds the canonical domain scope after checking their\nlegal combinations.",enum:["working_tree","staged","commit_range"],type:"string"},gW={enum:["git"],type:"string"},gM={additionalProperties:!1,properties:{kind:{$ref:"#/$defs/GitToolErrorKindV1"},message:{type:"string"},operation:{$ref:"#/$defs/GitToolOperationV1"}},required:["kind","operation","message"],type:"object"},gN={additionalProperties:!1,description:"Git itself refused the refs, worktree status, or history the tool reads.",properties:{error:{$ref:"#/$defs/GitToolErrorV1"}},required:["error"],type:"object"},gz={description:"The git step that refused the read.",enum:["diff","status","log"],type:"string"},gD={additionalProperties:!1,properties:{binding_digest:{$ref:"#/$defs/ManifestDigest"},consumed_at:{$ref:"#/$defs/UtcMicros"},input_digest:{$ref:"#/$defs/ManifestDigest"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},request_id:{type:"string"},token_digest:{$ref:"#/$defs/ManifestDigest"}},required:["binding_digest","token_digest","request_id","input_digest","consumed_at","receipt_digest"],type:"object"},gF={enum:["forbid_force_and_rebase"],type:"string"},gL={description:"Strongly typed canonical identity: `HostInstanceId`.",type:"string"},gU={description:"`HunkRef` operation direction: working tree to index, or index to\nHEAD/base. No other direction is encodable.",enum:["working_tree_to_index","index_to_head"],type:"string"},gH={additionalProperties:!1,description:"Immutable hunk identity for compare-and-swap. A hunk is identified by exact repository,\ndirection, path, expected base/index/worktree identity, normalized hunk\nheader, context and patch digests, and the preview that issued the\nreference, never by display ordinal or line number alone.\n\nquery mints these as read-only identity evidence only. Applying them is a\ndaemon Git mutation path and is not representable here.",properties:{attributes_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Attributes/filter identity relevant to clean/smudge and EOL handling."},context_digest:{$ref:"#/$defs/ManifestDigest"},direction:{$ref:"#/$defs/HunkDirectionV1"},expected_base_blob:{$ref:"#/$defs/GitBlobExpectationV1"},expected_index_entry:{$ref:"#/$defs/GitIndexEntryExpectationV1"},expected_worktree_blob:{anyOf:[{$ref:"#/$defs/GitBlobExpectationV1"},{type:"null"}],description:"Expected working-tree identity when the operation reads the worktree:\na native content digest or explicit absent-file state. `None` means\nthe operation direction does not read the worktree."},expected_worktree_mode:{anyOf:[{$ref:"#/$defs/GitFileModeV1"},{type:"null"}]},hunk_header:{description:"Normalized `@@ -o,l +n,m @@` header text.",type:"string"},original_path:{description:"Old path for a rename or copy.",type:["string","null"]},patch_digest:{$ref:"#/$defs/ManifestDigest"},path:{type:"string"},preview_id:{type:"string"},repository:{$ref:"#/$defs/RepositoryId"},schema_version:{type:"string"},selected_line_bitmap:{description:"Selected hunk-line bitmap (little-endian word order, line 1 = bit 0\nof word 0). Full-hunk identity covers the larger old/new side so\ndeletion-only hunks remain representable.",items:{format:"uint64",minimum:0,type:"integer"},type:"array"},snapshot_digest:{$ref:"#/$defs/ManifestDigest"},worktree:{$ref:"#/$defs/WorktreeId"}},required:["repository","worktree","direction","path","expected_base_blob","expected_index_entry","hunk_header","context_digest","patch_digest","selected_line_bitmap","preview_id","schema_version","snapshot_digest"],type:"object"},gG={enum:["available","retained_but_unavailable","redacted","deleted","retention_expired","unauthorized","locked","unverifiable"],type:"string"},gB={additionalProperties:!1,description:"One yes/no question asked of the decision engine for one intent. The\nintent is a candidate when the engine's probability reaches\n`threshold_permille` and, when set, exceeds the runner-up by\n`margin_permille`.",properties:{instructions:{type:"string"},intent:{$ref:"#/$defs/ContextScoutIntentKindV1"},margin_permille:{format:"uint16",maximum:65535,minimum:0,type:["integer","null"]},threshold_permille:{format:"uint16",maximum:65535,minimum:0,type:"integer"}},required:["intent","instructions","threshold_permille"],type:"object"},gK={additionalProperties:!1,description:"Bounds on the recent-session window one intent pass reads.",properties:{freshen_budget_ms:{description:"Time the pass may wait for the transcript store to ingest the newest\nturn before it reads the window as it stands.",format:"uint32",minimum:0,type:"integer"},max_age_secs:{format:"uint32",minimum:0,type:"integer"},max_bytes:{format:"uint32",minimum:0,type:"integer"},max_messages:{format:"uint8",maximum:255,minimum:0,type:"integer"},max_user_turns:{format:"uint8",maximum:255,minimum:0,type:"integer"}},required:["max_user_turns","max_messages","max_bytes","max_age_secs","freshen_budget_ms"],type:"object"},gJ={description:"p50/p95/p99 for one provider operation latency stage.",properties:{p50:{$ref:"#/$defs/MetricValueV1"},p95:{$ref:"#/$defs/MetricValueV1"},p99:{$ref:"#/$defs/MetricValueV1"}},required:["p50","p95","p99"],type:"object"},gZ={oneOf:[{properties:{state:{const:"ready",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"cancelled",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"timed_out",type:"string"}},required:["state"],type:"object"},{properties:{reason:{type:"string"},state:{const:"unavailable",type:"string"}},required:["state","reason"],type:"object"},{properties:{diagnostic:{type:"string"},state:{const:"failed",type:"string"}},required:["state","diagnostic"],type:"object"}]},gQ={additionalProperties:!1,properties:{limit:{format:"uint64",minimum:0,type:"integer"},offset:{format:"uint64",minimum:0,type:"integer"},returned_chars:{format:"uint64",minimum:0,type:"integer"},total_chars:{format:"uint64",minimum:0,type:"integer"},truncated:{type:"boolean"}},required:["offset","limit","returned_chars","total_chars","truncated"],type:"object"},gX={description:"Whether historical discovery, projection publication, and summary\nconvergence have all settled for everything the store's sources hold.",oneOf:[{const:"converging",description:"A stage still owes committed work.",type:"string"},{const:"converged",description:"The worker committed the last owed item and has nothing pending.",type:"string"},{const:"blocked",description:"Every runnable stage settled, but historical discovery is blocked.",type:"string"},{const:"unavailable",description:"No worker is serving the store.",type:"string"}]},gY={additionalProperties:!1,properties:{converged_at_unix_micros:{description:"When the latest convergence event was published.",format:"int64",type:["integer","null"]},epoch:{description:"Convergence events this worker has published; a larger value is a\nnewer event.",format:"uint64",minimum:0,type:"integer"},reason:{description:"The historical discovery blocker when `state` is `blocked`.",type:["string","null"]},state:{$ref:"#/$defs/LcmConvergenceStateV1"}},required:["state","epoch"],type:"object"},g1={description:"Whether the refresh worker that serves this store's temporal projection\nis current, still converging history, or not serving at all.",enum:["current","stale","unavailable"],type:"string"},g0={additionalProperties:!1,description:"The temporal projection's serving state at diagnosis time. A store whose\nschema is healthy can still have nothing to serve while history is being\nre-derived (for example on a fresh profile); this is where\nthat state is named instead of being read as absent data.",properties:{convergence:{$ref:"#/$defs/LcmConvergenceV1"},reason:{description:"Machine reason for a non-current state: `historical_convergence`,\n`historical_retry:<code>`, `historical_blocked:<code>`, or the worker\nunavailability (`worker_missing`, `worker_recovering`, `worker_stalled`,\n`worker_stopped`).",type:["string","null"]},state:{$ref:"#/$defs/LcmDoctorProjectionStateV1"},worker:{$ref:"#/$defs/RetrievalWorkerStatusV1"}},required:["state","worker","convergence"],type:"object"},g2={additionalProperties:!1,properties:{content:{type:"string"},content_hash:{type:"string"},message_id:{type:"string"},metadata_json:{type:["string","null"]},ordinal:{format:"int64",type:"integer"},payload_ref:{type:["string","null"]},provider:{type:"string"},role:{type:"string"},session_id:{type:"string"},storage_kind:{$ref:"#/$defs/LcmStorageKindV1"},store_id:{format:"int64",type:"integer"},timestamp:{format:"int64",type:["integer","null"]}},required:["provider","message_id","session_id","store_id","role","ordinal","content","content_hash","storage_kind"],type:"object"},g4={oneOf:[{properties:{freshness:{$ref:"#/$defs/TemporalFreshnessV1"},outcome:{const:"complete",type:"string"}},required:["outcome","freshness"],type:"object"},{properties:{freshness:{$ref:"#/$defs/TemporalFreshnessV1"},omitted:{format:"uint64",minimum:0,type:"integer"},outcome:{const:"partial",type:"string"}},required:["outcome","freshness","omitted"],type:"object"},{properties:{freshness:{$ref:"#/$defs/TemporalFreshnessV1"},outcome:{const:"stale",type:"string"}},required:["outcome","freshness"],type:"object"}]},g6={oneOf:[{properties:{kind:{const:"raw_message",type:"string"},store_id:{format:"int64",type:"integer"}},required:["kind","store_id"],type:"object"},{properties:{kind:{const:"summary_node",type:"string"},node_id:{type:"string"}},required:["kind","node_id"],type:"object"}]},g3={enum:["inline","external","canonical_occurrence"],type:"string"},g9={description:"One provider's summarizer executable: absent by default, or the exact\nabsolute path the operator configured with its optional tuning.",oneOf:[{properties:{state:{const:"unconfigured",type:"string"}},required:["state"],type:"object"},{properties:{canonical_path:{type:"string"},model:{description:"Model requested for summary turns; the provider default when absent.",type:["string","null"]},state:{const:"configured",type:"string"},timeout_secs:{description:"Wall-clock budget for one summary run, within\n[`LCM_SUMMARIZER_TIMEOUT_SECS_RANGE`]; the caller's default when absent.",format:"uint64",minimum:0,type:["integer","null"]}},required:["state","canonical_path"],type:"object"}]},g5={additionalProperties:!1,description:"The per-provider summarizer executables one configuration snapshot admits.",properties:{codex:{$ref:"#/$defs/LcmSummarizerExecutableV1",default:{state:"unconfigured"},description:"`codex`, driven over app-server JSON-RPC for Codex sessions."},cursor_agent:{$ref:"#/$defs/LcmSummarizerExecutableV1",default:{state:"unconfigured"},description:"`cursor-agent`, asked for a summary of Cursor sessions."}},type:"object"},g8={additionalProperties:!1,properties:{conversation_id:{type:"string"},created_at:{format:"int64",type:"integer"},depth:{format:"int64",type:"integer"},expand_hint:{type:["string","null"]},metadata_json:{type:["string","null"]},node_id:{type:"string"},provider:{type:"string"},session_id:{type:"string"},source_refs:{items:{$ref:"#/$defs/LcmSourceRefV1"},type:"array"},source_time_end:{format:"int64",type:["integer","null"]},source_time_start:{format:"int64",type:["integer","null"]},source_token_count:{format:"int64",type:"integer"},summary_hash:{type:"string"},summary_text:{type:"string"},summary_token_count:{format:"int64",type:"integer"}},required:["node_id","provider","conversation_id","session_id","depth","summary_text","summary_hash","source_refs","summary_token_count","source_token_count","created_at"],type:"object"},g7={additionalProperties:!1,properties:{anchors:{items:{type:"string"},type:"array"},authorized_root:{type:["string","null"]},coverage:{$ref:"#/$defs/TemporalCoverageV1"},explanations:{items:{$ref:"#/$defs/TemporalExplanationV1"},type:"array"},next_cursor:{type:["string","null"]},omissions:{items:{$ref:"#/$defs/TemporalOmissionV1"},type:"array"},source_coverage:{items:{$ref:"#/$defs/SessionSourceCoverageV1"},type:"array"},watermarks:{$ref:"#/$defs/TemporalWatermarksV1"}},required:["anchors","watermarks","coverage","explanations"],type:"object"},_e={description:"Why a site the lexical lane admitted for a caller anchor is absent from\nthe response.",oneOf:[{const:"diversity_cap",description:"Collapsed as a duplicate or held back by the per-file diversity cap.",type:"string"},{const:"outside_page",description:"Ranked, but outside the returned page: an earlier page, or behind\n`next_cursor`.",type:"string"},{const:"not_hydrated",description:"On the page, but late hydration returned no source for it.",type:"string"},{const:"out_of_scope",description:"Outside the caller's scope prefix.",type:"string"}]},_t={additionalProperties:!1,description:"Anchor sites one serving stage removed from the response.",properties:{reason:{$ref:"#/$defs/LexicalAnchorDropReasonV1"},sites:{format:"uint64",minimum:0,type:"integer"}},required:["reason","sites"],type:"object"},_r={description:"Strongly typed algorithm-tagged integrity digest: `LocatorDigest`.",type:"string"},_i={description:"Strongly typed canonical identity: `LogicalCopyClusterId`.",type:"string"},_o={description:"Strongly typed canonical identity: `LogicalEvidenceId`.",type:"string"},_n={enum:["global","project"],type:"string"},_a={properties:{absorbed_into:{type:["string","null"]},activated_at:{format:"int64",type:["integer","null"]},archived_reason:{type:["string","null"]},category:{type:"string"},checksum:{type:"string"},created_at:{format:"int64",type:"integer"},id:{type:"string"},materialization_scope:{$ref:"#/$defs/ManagedSkillMaterializationScope"},pinned:{type:"boolean"},provenance:{$ref:"#/$defs/ManagedSkillProvenance"},routing_description:{type:"string"},state:{$ref:"#/$defs/ManagedSkillState"},summary:{type:"string"},targets:{default:["cursor","codex","claude","agents","opencode","kimi","kiro","hermes"],items:{$ref:"#/$defs/SkillInstallTarget"},type:"array"},title:{type:"string"},updated_at:{format:"int64",type:"integer"}},required:["id","title","summary","routing_description","category","state","pinned","checksum","created_at","updated_at","provenance"],type:"object"},_s={properties:{actor:{type:"string"},run_id:{type:["string","null"]},source:{$ref:"#/$defs/ManagedSkillSource"}},required:["source","actor"],type:"object"},_d={enum:["automation_run","user","import"],type:"string"},_c={enum:["active","disabled","archived"],type:"string"},_l={description:"Strongly typed algorithm-tagged integrity digest: `ManifestDigest`.",type:"string"},_p={description:"The only Git histories this product operation can create.",enum:["fast_forward","two_parent_merge","cherry_pick_exact_commits"],type:"string"},_u={enum:["project","user"],type:"string"},_m={enum:["all","parents_only","subagents_only"],type:"string"},_f={enum:["all","direct_user","tool_result"],type:"string"},_h={properties:{calibration_revision:{type:"string"},cohort_revision:{type:"string"},drift_valid:{type:"boolean"},estimator_revision:{type:"string"},support:{format:"uint64",minimum:0,type:"integer"}},required:["estimator_revision","calibration_revision","cohort_revision","support","drift_valid"],type:"object"},_y={properties:{descriptor_revision:{type:"string"},eligible_population:{type:"string"}},required:["descriptor_revision","eligible_population"],type:"object"},_g={properties:{censored:{format:"uint64",minimum:0,type:"integer"},completed:{format:"uint64",minimum:0,type:"integer"},eligible:{description:"Exact denominator cardinality. `None` means the denominator is unknown.",format:"uint64",minimum:0,type:["integer","null"]},excluded:{format:"uint64",minimum:0,type:"integer"},observed:{format:"uint64",minimum:0,type:"integer"},state:{$ref:"#/$defs/CoverageStateV1"},unknown:{format:"uint64",minimum:0,type:"integer"}},required:["observed","completed","censored","unknown","excluded","state"],type:"object"},__={enum:["measurement","association","calibrated_prediction"],type:"string"},_v={properties:{projector_revision:{type:"string"},source:{$ref:"#/$defs/MetricSourceV1"},source_revision:{type:"string"},watermark:{type:"string"}},required:["source","source_revision","projector_revision","watermark"],type:"object"},_b={enum:["observability_envelope","feedback_observations","provider_usage_observation","savings_ledger"],type:"string"},_$={properties:{baseline_watermark:{type:["string","null"]},delta:{format:"double",type:["number","null"]},horizon:{$ref:"#/$defs/ObservabilityHorizonV1"}},required:["horizon"],type:"object"},_S={properties:{lower:{format:"double",type:["number","null"]},reason:{type:["string","null"]},upper:{format:"double",type:["number","null"]}},type:"object"},_k={properties:{calibration:{anyOf:[{$ref:"#/$defs/MetricCalibrationV1"},{type:"null"}]},cohort:{$ref:"#/$defs/MetricCohortV1"},coverage:{$ref:"#/$defs/MetricCoverageV1"},denominator:{type:"string"},denominator_value:{format:"uint64",minimum:0,type:["integer","null"]},descriptor_revision:{type:"string"},evidence_class:{$ref:"#/$defs/MetricEvidenceClassV1"},metric:{type:"string"},provenance:{$ref:"#/$defs/MetricProvenanceV1"},temporal:{$ref:"#/$defs/MetricTemporalV1"},unavailable_reason:{type:["string","null"]},uncertainty:{$ref:"#/$defs/MetricUncertaintyV1"},unit:{type:"string"},value:{description:"Aggregate value. It is absent whenever its denominator or coverage is\ninsufficient; observed lower bounds remain available in `coverage`.",format:"double",type:["number","null"]}},required:["descriptor_revision","metric","unit","denominator","coverage","evidence_class","provenance","cohort","temporal","uncertainty"],type:"object"},_w={additionalProperties:!1,description:"A file that historically changes with `partner_of` but is missing from the\nchange set under review, e.g. a migration beside its schema.",properties:{co_changes:{description:"Commits that changed both `partner_of` and `file`.",format:"uint64",minimum:0,type:"integer"},file:{type:"string"},partner_of:{type:"string"},partner_of_changes:{description:"Commits that changed `partner_of`.",format:"uint64",minimum:0,type:"integer"}},required:["file","partner_of","co_changes","partner_of_changes"],type:"object"},_P={additionalProperties:!1,description:"Frozen continuation identity shared by all participating roots.",properties:{digest:{$ref:"#/$defs/ManifestDigest"},next_page:{format:"uint64",minimum:1,type:"integer"},order_digest:{$ref:"#/$defs/ManifestDigest"},query_digest:{$ref:"#/$defs/ManifestDigest"},root_cursors:{items:{$ref:"#/$defs/RootScopeOutcomeV1_for_Nullable_string"},type:"array"},root_generations:{items:{$ref:"#/$defs/RootScopeOutcomeV1_for_Nullable_RootGenerationV1"},type:"array"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_set_digest","root_generations","root_cursors","query_digest","order_digest","next_page","digest"],type:"object"},_V={description:"Strongly typed canonical identity: `NativeIntegrationApprovalId`.",type:"string"},_R={description:"Explicit direction of one integration. Stack meaning is never inferred.",enum:["propagate_dependency_to_dependent","land_dependent_into_dependency","integrate_independent_branch"],type:"string"},_q={description:"Truthful preview classification. Only `MechanicalIntegrationEligible`\ncarries apply-eligible evidence.",oneOf:[{properties:{detail:{$ref:"#/$defs/MechanicalIntegrationModeV1"},state:{const:"mechanical_integration_eligible",type:"string"}},required:["state","detail"],type:"object"},{properties:{state:{const:"already_integrated",type:"string"}},required:["state"],type:"object"},{properties:{detail:{properties:{conflict_digest:{$ref:"#/$defs/ManifestDigest"}},required:["conflict_digest"],type:"object"},state:{const:"native_conflict",type:"string"}},required:["state","detail"],type:"object"},{properties:{detail:{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"}},required:["evidence_digest"],type:"object"},state:{const:"semantic_review_required",type:"string"}},required:["state","detail"],type:"object"},{properties:{detail:{properties:{reason:{$ref:"#/$defs/NativeIntegrationUnavailabilityV1"}},required:["reason"],type:"object"},state:{const:"partial",type:"string"}},required:["state","detail"],type:"object"},{properties:{detail:{properties:{reason:{$ref:"#/$defs/NativeIntegrationUnavailabilityV1"}},required:["reason"],type:"object"},state:{const:"unavailable",type:"string"}},required:["state","detail"],type:"object"}]},_I={description:"Strongly typed canonical identity: `NativeIntegrationPreviewId`.",type:"string"},_x={additionalProperties:!1,description:"Canonical stack-snapshot proof returned by `stack_snapshot` and consumed\nverbatim by preflight.",properties:{authorized_scope_set_digest:{$ref:"#/$defs/ManifestDigest"},authorized_scope_set_id:{$ref:"#/$defs/ScopeSetId"},authorized_scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},destination:{$ref:"#/$defs/ResolvedScope"},grant_digest:{$ref:"#/$defs/ManifestDigest"},inventory_epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},inventory_snapshot_id:{$ref:"#/$defs/WorktreeInventorySnapshotId"},policy_digest:{$ref:"#/$defs/ManifestDigest"},selection:{$ref:"#/$defs/NativeIntegrationSelectionBindingV1"},source:{$ref:"#/$defs/ResolvedScope"}},required:["source","destination","authorized_scope_set_id","authorized_scope_set_revision","authorized_scope_set_digest","inventory_snapshot_id","inventory_epoch","selection","grant_digest","policy_digest"],type:"object"},_j={description:"Canonically sealed selection passed to the topology authority.\n\n`stack_snapshot` requests carry declaration content; its boundary seals\nthat declaration into this proof, and preflight accepts the proof verbatim.\nThe topology authority never discovers roots or edges.",oneOf:[{properties:{binding:{properties:{declared_revision:{$ref:"#/$defs/BranchStackRevisionV1"},destination_node_id:{$ref:"#/$defs/StackNodeId"},direction:{$ref:"#/$defs/NativeIntegrationDirectionV1"},revision_digest:{$ref:"#/$defs/ManifestDigest"},revision_id:{$ref:"#/$defs/BranchStackRevisionId"},source_node_id:{$ref:"#/$defs/StackNodeId"},stack_id:{$ref:"#/$defs/BranchStackId"}},required:["stack_id","revision_id","revision_digest","declared_revision","source_node_id","destination_node_id","direction"],type:"object"},kind:{const:"declared_stack_edge",type:"string"}},required:["kind","binding"],type:"object"},{properties:{binding:{properties:{destination_ref:{$ref:"#/$defs/RefId"},proposal_digest:{$ref:"#/$defs/ManifestDigest"},source_ref:{$ref:"#/$defs/RefId"}},required:["proposal_digest","source_ref","destination_ref"],type:"object"},kind:{const:"independent_branch",type:"string"}},required:["kind","binding"],type:"object"}]},_C={description:"The only truthful terminal outcomes after recovery.",enum:["committed","aborted_no_change","rolled_back","needs_inspection"],type:"string"},_T={description:"Strongly typed canonical identity: `NativeIntegrationTransactionId`.",type:"string"},_O={description:"Why a preflight cannot authorize apply.",enum:["partial_evidence","stale_scope","denied","native_state_unavailable","reset_required","durability_uncertain","unsupported_hooks","signing_required","destination_occupied"],type:"string"},_E={description:"A target selected by exact registered identity. Repository inventory names\none repository; cleanup names one worktree within that repository.",oneOf:[{properties:{kind:{const:"repository",type:"string"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"}},required:["kind","project_id","repository_id"],type:"object"},{properties:{kind:{const:"worktree",type:"string"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["kind","project_id","repository_id","worktree_id"],type:"object"}]},_A={additionalProperties:!1,properties:{body:{format:"uint64",minimum:0,type:"integer"},full_file:{format:"uint64",minimum:0,type:"integer"}},required:["body","full_file"],type:"object"},_W={properties:{since_micros:{format:"int64",type:"integer"},until_micros:{format:"int64",type:"integer"}},required:["since_micros","until_micros"],type:"object"},_M={additionalProperties:!1,description:"Stable logical identity of one provider observation source.\n\nThe session identity is provider-native evidence. The physical file identity\nis represented separately by [`ObservationSourceGenerationV1`].",properties:{provider:{$ref:"#/$defs/ProviderId"},session_id:{$ref:"#/$defs/SessionId"},source_key:{anyOf:[{$ref:"#/$defs/SessionId"},{type:"null"}]}},required:["provider","session_id"],type:"object"},_N={properties:{analytics_mode:{$ref:"#/$defs/AnalyticsModeReadModelV1"},authorized_scope_ref:{type:"string"},comparison:{$ref:"#/$defs/PerformanceComparisonReadModelV1"},current:{type:"boolean"},horizon:{$ref:"#/$defs/ObservabilityHorizonV1"},metrics:{items:{$ref:"#/$defs/MetricValueV1"},type:"array"},observed_at_micros:{format:"int64",type:"integer"},rejected_arguments:{$ref:"#/$defs/RejectedArgumentAnalyticsV1"},watermark:{type:"string"}},required:["authorized_scope_ref","horizon","watermark","observed_at_micros","current","metrics","analytics_mode","comparison","rejected_arguments"],type:"object"},_z={additionalProperties:!1,description:"Structured occurrence provenance retained through fusion. Fusion\npreserves each exact `(source_occurrence_id, retriever_evidence_anchor)`\npair; parallel unassociated provenance vectors are forbidden.",properties:{evidence_role:{$ref:"#/$defs/EvidenceRole"},file_occurrence_id:{anyOf:[{$ref:"#/$defs/FileOccurrenceId"},{type:"null"}]},freshness:{$ref:"#/$defs/SourceFreshness"},logical_copy_cluster_id:{anyOf:[{$ref:"#/$defs/LogicalCopyClusterId"},{type:"null"}]},logical_copy_evidence_anchor:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},repository_id:{anyOf:[{$ref:"#/$defs/RepositoryId"},{type:"null"}]},retriever_evidence_anchor:{$ref:"#/$defs/RetrievalAnchorId"},session_or_thread_id:{anyOf:[{$ref:"#/$defs/SessionOrThreadId"},{type:"null"}]},source_namespace:{$ref:"#/$defs/SourceNamespace"},source_occurrence_id:{$ref:"#/$defs/SourceOccurrenceId"}},required:["source_occurrence_id","retriever_evidence_anchor","source_namespace","evidence_role","freshness"],type:"object"},_D={additionalProperties:!1,description:"Bounded work accounting supplied by an owning port or transaction.",properties:{bytes_consumed:{format:"uint64",minimum:0,type:"integer"},elapsed_micros:{format:"uint64",minimum:0,type:"integer"},units_consumed:{format:"uint64",minimum:0,type:"integer"}},required:["units_consumed","bytes_consumed","elapsed_micros"],type:"object"},_F={additionalProperties:!1,description:"Canonical operation evidence. An admitted failure remains represented here\nrather than being replaced by a transport exception.",properties:{budget:{$ref:"#/$defs/OperationBudgetUsage"},cancellation:{anyOf:[{$ref:"#/$defs/CancellationObservation"},{type:"null"}]},effective_deadline:{$ref:"#/$defs/Deadline"},ended_at:{$ref:"#/$defs/UtcMicros"},started_at:{$ref:"#/$defs/UtcMicros"},termination:{$ref:"#/$defs/OperationTermination"}},required:["started_at","ended_at","effective_deadline","budget","termination"],type:"object"},_L={description:"Terminal state after an operation has been admitted.",enum:["completed","cancelled","timed_out","failed","unavailable","partial","effect_unknown"],type:"string"},_U={additionalProperties:!1,description:"Bounded opaque page request. Resume authorization occurs before an adapter\ndecodes or hydrates the cursor.",properties:{cursor:{description:"Opaque resume token. The identifier type is deliberately absent from the\ngenerated schema surface, so the public wire form is its bounded string.",type:["string","null"]},page_size:{format:"uint32",minimum:0,type:"integer"}},required:["page_size"],type:"object"},_H={properties:{baseline_build:{type:["string","null"]},candidate_build:{type:["string","null"]},configuration:{type:["string","null"]},corpus:{type:["string","null"]},coverage:{$ref:"#/$defs/MetricCoverageV1"},disposition:{$ref:"#/$defs/ComparisonDispositionV1"},eligible_outcomes:{format:"uint64",minimum:0,type:["integer","null"]},environment:{type:["string","null"]},oracle:{type:["string","null"]},paired_outcomes:{format:"uint64",minimum:0,type:["integer","null"]},platform:{type:["string","null"]},regression_observed:{type:["boolean","null"]},rollback_profile:{type:["string","null"]},unavailable_reason:{type:["string","null"]},workload:{type:["string","null"]}},required:["disposition","coverage"],type:"object"},_G={oneOf:[{enum:["brief"],type:"string"},{const:"symbols",description:"Exact changed-symbol enumeration, with its existing continuation cursor.",type:"string"}]},_B={description:"Whether the served code generation is known current at serve time.",enum:["fresh","possibly_stale"],type:"string"},_K={additionalProperties:!1,description:"The indexing state behind a `possibly_stale` verdict: the served\ngeneration, the scheduler's latest sealed generation, its staleness-ladder\nstate, and the lanes that answered from an older generation. `summary` is\nthe one-line rendering agents read.",properties:{latest_generation:{type:["string","null"]},parked:{anyOf:[{$ref:"#/$defs/CodeIndexConvergenceParkedV1"},{type:"null"}],description:"The park holding convergence until the operator applies its remedy.\nNo wake retries it, so repeating the request cannot change the answer."},reason:{type:["string","null"]},rebuild_in_flight:{type:["boolean","null"]},served_generation:{type:["string","null"]},stale_lanes:{items:{type:"string"},type:"array"},staleness_state:{anyOf:[{$ref:"#/$defs/CodeIndexStalenessStateV1"},{type:"null"}]},summary:{type:"string"}},required:["summary"],type:"object"},_J={enum:["complete"],type:"string"},_Z={additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},message:{type:"string"},node_id:{type:"string"},reason_code:{type:"string"},status:{type:"string"},suggestions:{description:"Nearest served symbols by edit distance to the requested id, by id,\nsimple name, or qualified name.",items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},type:"array"}},required:["status","reason_code","node_id","message"],type:"object"},_Q={enum:["full","partial"],type:"string"},_X={additionalProperties:!1,description:"Freshness verdict carried by every search and context response. `indexing`\nis present exactly when the state is `possibly_stale`.",properties:{indexing:{anyOf:[{$ref:"#/$defs/PrimitiveIndexingStateV1"},{type:"null"}]},state:{$ref:"#/$defs/PrimitiveFreshnessStateV1"}},required:["state"],type:"object"},_Y={additionalProperties:!1,properties:{language:{type:["string","null"]},provider:{type:["string","null"]},reason:{type:"string"}},required:["reason"],type:"object"},_1={additionalProperties:!1,properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},kind:{type:"string"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"},unavailable_fields:{items:{type:"string"},type:"array"}},required:["node_id","name","qualified_name","kind","file","start_line","end_line","unavailable_fields"],type:"object"},_0={additionalProperties:!1,properties:{detail:{type:"string"},reason_code:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/PrimitiveUnavailableStatusV1"}},required:["status","reason_code","retryable","detail"],type:"object"},_2={enum:["unavailable"],type:"string"},_4={description:"Strongly typed canonical identity: `ProjectId`.",type:"string"},_6={properties:{alias_count:{format:"uint",minimum:0,type:"integer"},artifact_count:{format:"uint",minimum:0,type:"integer"},branches:{items:{type:"string"},type:"array"},canonical_root:{type:"string"},default_branch:{description:"Repository default branch recorded at registration.",type:["string","null"]},head_branch:{description:"Branch the checkout's HEAD names now; `None` when HEAD is detached or\nno checkout of this project could be read.",type:["string","null"]},is_active:{type:["boolean","null"]},kind:{type:"string"},label:{type:"string"},last_seen_at:{format:"int64",type:"integer"},project_id:{type:"string"},project_root:{type:"string"},store_count:{format:"uint",minimum:0,type:"integer"}},required:["project_id","label","project_root","canonical_root","kind","branches","store_count","artifact_count","alias_count","last_seen_at"],type:"object"},_3={properties:{project_count:{format:"uint",minimum:0,type:"integer"},repo_count:{format:"uint",minimum:0,type:"integer"},truncated:{type:"boolean"}},required:["project_count","repo_count","truncated"],type:"object"},_9={properties:{branches:{items:{type:"string"},type:"array"},git_common_dir:{type:["string","null"]},label:{type:"string"},project_count:{format:"uint",minimum:0,type:"integer"},projects:{items:{$ref:"#/$defs/ProjectRegistryEntry"},type:"array"}},required:["label","project_count","branches","projects"],type:"object"},_5={description:"Strongly typed canonical identity: `ProjectionGenerationId`.",type:"string"},_8={description:"Strongly typed canonical identity: `ProposalId`.",type:"string"},_7={enum:["reject","require_human_approval_and_independent_review"],type:"string"},ve={additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/ProtectedRefDispositionV1"},selector:{$ref:"#/$defs/ProtectedRefSelectorV1"}},required:["selector","disposition"],type:"object"},vt={oneOf:[{properties:{kind:{const:"native_default_branch",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"exact",type:"string"},value:{$ref:"#/$defs/CanonicalGitRefNameV1"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"prefix",type:"string"},value:{$ref:"#/$defs/CanonicalGitRefPrefix"}},required:["kind","value"],type:"object"}]},vr={description:"Strongly typed canonical identity: `ProvenanceId`.",type:"string"},vi={description:"Complete provider states remain distinct. Empty findings are clean only\nwhen every requested provider completed with complete supported coverage.",enum:["supported_completed_complete","unsupported","absent","indexing","stale","cancelled","timed_out","failed","partial","unavailable"],type:"string"},vo={description:"Strongly typed canonical identity: `ProviderId`.",type:"string"},vn={description:"One provider/model cohort in the Costs latency read model.\n\nThe percentile cells are ordinary canonical metrics so every value carries\nits exact unit, horizon, denominator, coverage/censoring, and projector\nprovenance. Identity provenance is kept separately because latency is\nmeasured by `OperationResourceObservedV1`, while provider/model identity\nmay be joined from an exact `ProviderUsageObservationV1` request/session.",properties:{first_progress:{$ref:"#/$defs/LatencyDistributionReadModelV1"},identity_provenance:{$ref:"#/$defs/MetricProvenanceV1"},identity_unavailable_reason:{type:["string","null"]},model:{type:["string","null"]},provider:{type:["string","null"]},queue:{$ref:"#/$defs/LatencyDistributionReadModelV1"},service:{$ref:"#/$defs/LatencyDistributionReadModelV1"},start:{$ref:"#/$defs/LatencyDistributionReadModelV1"},terminal:{$ref:"#/$defs/LatencyDistributionReadModelV1"}},required:["identity_provenance","queue","start","first_progress","service","terminal"],type:"object"},va={properties:{canonical_root:{type:"string"},created_at:{format:"int64",type:"integer"},default_branch:{description:"Repository default branch recorded at registration.",type:["string","null"]},display_root:{type:"string"},git_common_dir:{type:["string","null"]},head_branch:{description:"Branch the checkout's HEAD names now; `None` when HEAD is detached or\nno checkout of this project could be read.",type:["string","null"]},is_active:{type:["boolean","null"]},label:{type:"string"},last_seen_at:{format:"int64",type:"integer"},project_id:{type:"string"},project_root:{type:"string"}},required:["project_id","label","project_root","display_root","canonical_root","created_at","last_seen_at"],type:"object"},vs={enum:["owner_receipt","locally_measured","estimated","unknown"],type:"string"},vd={description:"Strongly typed canonical identity: `QueryCollectionId`.",type:"string"},vc={description:"Which endpoint of each counted edge the rank report ranks.",enum:["incoming","outgoing"],type:"string"},vl={description:"Relationship the rank report counts.",enum:["implements","extends","calls","uses","contains","annotates","type_of","returns","receives"],type:"string"},vp={additionalProperties:!1,description:"One recorded ranking decision. Explanations are rendered from this\nprovenance, never reconstructed from a final scalar score.",properties:{detail:{type:"string"},evidence_anchor:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},kind:{$ref:"#/$defs/RankingDecisionKind"},policy_anchor:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]},retriever:{anyOf:[{$ref:"#/$defs/RetrieverKind"},{type:"null"}]}},required:["kind","detail"],type:"object"},vu={description:"The decision kinds the pipeline must record.",enum:["exact_tier_admission","same_source_duplicate_collapse","logical_copy_representative_selection","contradiction_preservation","diversity_cap","comparator_provenance","fallback"],type:"string"},vm={description:"Strongly typed canonical identity: `RefId`.",type:"string"},vf={additionalProperties:!1,description:"Exact registered root locator retained with an authorized scope.\n\n`canonical_root` is routing evidence for the already-resolved\n[`ResolvedScope`]. It cannot replace or manufacture that scope identity.",properties:{canonical_root:{type:"string"},profile:{$ref:"#/$defs/SharedProfileStoreLocatorV1"},project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id","profile","canonical_root"],type:"object"},vh={description:"Frequency and rate projection for dispatcher rejected-argument observations.\n\nCounts may be known while `rejection_rate` stays absent: Plan 26 forbids\nfabricating a rate when the eligible-attempt denominator is unknown.",properties:{coverage:{$ref:"#/$defs/MetricCoverageV1"},eligible_attempts:{format:"uint64",minimum:0,type:["integer","null"]},groups:{items:{$ref:"#/$defs/RejectedArgumentGroupV1"},type:"array"},projector_revision:{type:"string"},redacted_name_count:{format:"uint64",minimum:0,type:"integer"},rejected_total:{format:"uint64",minimum:0,type:["integer","null"]},rejection_rate:{format:"double",type:["number","null"]},unavailable_reason:{type:["string","null"]},watermark:{type:"string"}},required:["coverage","projector_revision","watermark","redacted_name_count","groups"],type:"object"},vy={description:"Closed error class for a rejected surface argument.",enum:["missing","invalid_shape","out_of_bounds","unsupported","unauthorized","stale","unknown"],type:"string"},vg={description:"One surface \xd7 operation \xd7 argument \xd7 error-class cell in the rejected-argument view.",properties:{argument:{$ref:"#/$defs/RejectedArgumentNameV1"},count:{format:"uint64",minimum:0,type:"integer"},error_class:{$ref:"#/$defs/RejectedArgumentErrorClassV1"},operation:{type:"string"},rate:{description:"Eligible-attempt rate for this cell. Absent when the attempt\ndenominator or coverage is insufficient.",format:"double",type:["number","null"]},surface:{$ref:"#/$defs/RejectedArgumentSurfaceV1"}},required:["surface","operation","argument","error_class","count"],type:"object"},v_={description:"Normalized rejected-argument name. Raw flags, values, and tokens never\nenter this vocabulary.",enum:["request_body","pagination","request_handle","operation","lifecycle","unknown"],type:"string"},vv={description:"Transport that rejected a surface argument. Unknown preserves missing\nattribution instead of inventing cli/mcp/http.",enum:["cli","mcp","http","unknown"],type:"string"},vb={description:"Strongly typed canonical identity: `RepositoryId`.",type:"string"},v$={oneOf:[{properties:{kind:{const:"all_authorized",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"allowlist",type:"string"},repositories:{items:{$ref:"#/$defs/RepositoryId"},type:"array",uniqueItems:!0}},required:["kind","repositories"],type:"object"}]},vS={enum:["successful_terminal"],type:"string"},vk={additionalProperties:!1,properties:{capability_id:{$ref:"#/$defs/CapabilityId"},expectation:{$ref:"#/$defs/RequiredCheckExpectationV1"},maximum_age_seconds:{format:"uint32",minimum:1,type:"integer"}},required:["capability_id","expectation","maximum_age_seconds"],type:"object"},vw={additionalProperties:!1,description:"The resolved configuration scope is one exact project/repository/worktree root.\n\nPaths, CWDs, labels, and mutable branch spellings are deliberately absent.",properties:{project_id:{$ref:"#/$defs/ProjectId"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},repository_id:{$ref:"#/$defs/RepositoryId"},scope_digest:{$ref:"#/$defs/ManifestDigest"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["project_id","repository_id","worktree_id","scope_digest"],type:"object"},vP={description:"Bounded output projection chosen by a concrete use case.",enum:["summary","evidence","references_only"],type:"string"},vV={additionalProperties:!1,properties:{code:{type:"string"},kind:{type:["string","null"]},maximum:{format:"uint",minimum:0,type:["integer","null"]},message:{type:"string"},observed:{format:"uint",minimum:0,type:["integer","null"]},reason:{type:["string","null"]},retryable:{type:["boolean","null"]}},required:["code","message"],type:"object"},vR={enum:["aborted","budget_exhausted","busy","cancelled","complete","complete_zero","cursor_manifest_limit_exceeded","deadline_exceeded","deleted","denied","error","failed","joined","locked","not_found","ok","partial","recorded","redacted","running","stale","started","unavailable","unsupported_filter","wrong_scope"],type:"string"},vq={anyOf:[{format:"uint64",minimum:0,type:"integer"},{type:"string"}],description:"The temporal filter intentionally retains the established integer-or-text\nwire form (Unix timestamps, RFC3339, and relative expressions)."},vI={description:"Strongly typed canonical identity: `RetrievalAnchorId`.",type:"string"},vx={description:"Stable semantic ordering; adapters may not replace it with transport order.",enum:["relevance","source_position","temporal_descending","stable_identity"],type:"string"},vj={additionalProperties:!1,properties:{order:{$ref:"#/$defs/RetrievalOrder"},page:{$ref:"#/$defs/PageRequest"},projection:{$ref:"#/$defs/ResultProjection"},temporal:{$ref:"#/$defs/TemporalModeV1"}},required:["temporal","page","projection","order"],type:"object"},vC={description:"Source-role evidence used at lane admission and fusion.\n\nA production definition outranks a test-file hit for the same symbol even\nwhen the test has a higher measured score. Non-definition production hits\ncompete with test hits on measured scores so comments and references do\nnot crowd out relevant tests.",oneOf:[{const:"production_definition",description:"Non-test path whose name or signature matched the query.",type:"string"},{const:"production_other",description:"Non-test path that is not a name or signature definition match.",type:"string"},{const:"test_reference",description:"Hit under a test path.",type:"string"}]},vT={additionalProperties:!1,properties:{backlog:{format:"uint",minimum:0,type:"integer"},blocker:{type:["string","null"]},last_progress_at_unix_micros:{format:"int64",type:["integer","null"]},retry_class:{type:["string","null"]}},required:["backlog"],type:"object"},vO={description:"Runtime-backed retrieval lanes. Each lane is independently testable,\ndisableable, budgeted, and attributable; one lane is never an alias over\nanother.",enum:["exact_literal","lexical","graph","temporal","task_session","diagnostic"],type:"string"},vE={oneOf:[{properties:{kind:{const:"none",type:"string"}},required:["kind"],type:"object"},{properties:{count:{format:"uint16",maximum:65535,minimum:1,type:"integer"},kind:{const:"independent_review_count",type:"string"}},required:["kind","count"],type:"object"},{properties:{kind:{const:"code_owner_and_independent_review",type:"string"}},required:["kind"],type:"object"}]},vA={enum:["no_review","independent_review","standard_pull_requests","git_hub_stacked_pull_requests"],type:"string"},vW={additionalProperties:!1,properties:{allowed:{items:{$ref:"#/$defs/ReviewTopologyKindV1"},type:"array",uniqueItems:!0},github_stacked_prs:{$ref:"#/$defs/GitHubStackedPullRequestPolicyV1"}},required:["allowed","github_stacked_prs"],type:"object"},vM={additionalProperties:!1,description:"Immutable collection and stack revisions for one exact resolved root.",properties:{collection_revision:{$ref:"#/$defs/ManifestDigest"},generation_digest:{$ref:"#/$defs/ManifestDigest"},scope_digest:{$ref:"#/$defs/ManifestDigest"},stack_revision:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest","collection_revision","stack_revision","generation_digest"],type:"object"},vN={additionalProperties:!1,description:"One typed outcome pinned to the digest of an exact resolved root.",properties:{outcome:{$ref:"#/$defs/ScopeOutcome_for_Nullable_RootGenerationV1"},scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest","outcome"],type:"object"},vz={additionalProperties:!1,description:"One typed outcome pinned to the digest of an exact resolved root.",properties:{outcome:{$ref:"#/$defs/ScopeOutcome_for_Nullable_string"},scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest","outcome"],type:"object"},vD={enum:["allow","deny"],type:"string"},vF={description:"Strongly typed canonical identity: `RunId`.",type:"string"},vL={additionalProperties:!1,properties:{degraded_row:{type:["string","null"]},stage:{$ref:"#/$defs/SchemaConvergenceStageV1"},started_at_micros:{format:"int64",type:"integer"},state:{$ref:"#/$defs/SchemaConvergenceStateV1"},store:{type:"string"}},required:["store","stage","state","started_at_micros"],type:"object"},vU={enum:["registered_schema"],type:"string"},vH={oneOf:[{enum:["pending","running","completed"],type:"string"},{const:"retrying",description:"The last attempt failed and the store's convergence task tries again by\nitself. `degraded_row` carries that attempt's failure.",type:"string"},{const:"degraded",description:"Convergence stopped on a failure and nothing retries it on this mount.",type:"string"}]},vG={additionalProperties:!1,description:"Restrictive policy input. An allow never grants capabilities absent from\nthe independently authorized capability set passed to the resolver.",properties:{authority:{$ref:"#/$defs/AuthorityRef"},capabilities:{items:{$ref:"#/$defs/CapabilityId"},type:"array",uniqueItems:!0},effect:{$ref:"#/$defs/RuleEffect"},expires_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},rule_id:{$ref:"#/$defs/AccessRuleId"},subject:{$ref:"#/$defs/ScopeAccessSubjectV1"}},required:["rule_id","subject","authority","capabilities","effect"],type:"object"},vB={additionalProperties:!1,description:"Typed rule selectors. Unset dimensions match all values at that dimension,\nbut at least one dimension must be constrained. Free-form paths, labels,\ncollection names, and branch names are deliberately absent.",properties:{actor:{anyOf:[{$ref:"#/$defs/ActorId"},{type:"null"}]},operation:{anyOf:[{$ref:"#/$defs/ScopeControlOperationV1"},{type:"null"}]},source_kind:{anyOf:[{$ref:"#/$defs/SourceKindV1"},{type:"null"}]}},type:"object"},vK={enum:["read","source_bind","source_rebind","source_unbind","access_rule_upsert","access_rule_remove","replace_topology_policy","rollback"],type:"string"},vJ={description:"Truthful outcome for one authorized root or an aggregate over roots.\n\n`Denied` and `Unavailable` carry no value and therefore cannot be confused\nwith a successful empty result.",oneOf:[{properties:{outcome:{const:"exact",type:"string"},value:{anyOf:[{$ref:"#/$defs/RootGenerationV1"},{type:"null"}]}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"partial",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopePartialReasonV1"},value:{anyOf:[{$ref:"#/$defs/RootGenerationV1"},{type:"null"}]}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"denied",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopeUnavailableReasonV1"}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"}]},vZ={description:"Truthful outcome for one authorized root or an aggregate over roots.\n\n`Denied` and `Unavailable` carry no value and therefore cannot be confused\nwith a successful empty result.",oneOf:[{properties:{outcome:{const:"exact",type:"string"},value:{type:["string","null"]}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"partial",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopePartialReasonV1"},value:{type:["string","null"]}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"denied",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopeUnavailableReasonV1"}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"}]},vQ={description:"Typed explanation for a root that returned usable but incomplete data.",enum:["incomplete","stale","budget_exceeded","root_denied","root_unavailable"],type:"string"},vX={description:"Stable identity of one authorized scope-set record.",type:"string"},vY={description:"Monotonic optimistic-concurrency revision of one scope set.",format:"uint64",minimum:1,type:"integer"},v1={additionalProperties:!1,description:"A source-to-authority binding. It stores only the source kind, a redacted\nlocator digest, and the pre-resolved authority reference.",properties:{authority:{$ref:"#/$defs/AuthorityRef"},binding_id:{$ref:"#/$defs/SourceBindingId"},source_kind:{$ref:"#/$defs/SourceKindV1"},source_locator_digest:{$ref:"#/$defs/LocatorDigest"}},required:["binding_id","source_kind","source_locator_digest","authority"],type:"object"},v0={description:"Typed explanation for a root that could not return usable data.",enum:["authority_unavailable","root_missing","store_unavailable"],type:"string"},v2={description:"Strongly typed canonical identity: `ScoreDomainId`.",type:"string"},v4={additionalProperties:!1,description:"Reference-only filesystem locator. The raw path is sealed outside this\ncontract; only the privacy-bound locator digest and sealed-value digest are\nrepresentable here.",properties:{locator_digest:{$ref:"#/$defs/LocatorDigest"},sealed_value_digest:{$ref:"#/$defs/ManifestDigest"}},required:["locator_digest","sealed_value_digest"],type:"object"},v6={additionalProperties:!1,properties:{knowledge:{$ref:"#/$defs/ClosedUtcIntervalV1"},valid:{$ref:"#/$defs/ValidCoverageIntervalV1"}},required:["knowledge","valid"],type:"object"},v3={oneOf:[{properties:{kind:{const:"caught_up",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"projection_behind_source",type:"string"},lag:{format:"uint64",minimum:0,type:"integer"}},required:["kind","lag"],type:"object"},{properties:{kind:{const:"source_behind_target",type:"string"},lag:{format:"uint64",minimum:0,type:"integer"}},required:["kind","lag"],type:"object"},{properties:{kind:{const:"projection_and_source_behind",type:"string"},projection_lag:{format:"uint64",minimum:0,type:"integer"},source_lag:{format:"uint64",minimum:0,type:"integer"}},required:["kind","projection_lag","source_lag"],type:"object"},{properties:{kind:{const:"locked",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"redacted",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"retention_withheld",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"unavailable",type:"string"}},required:["kind"],type:"object"}]},v9={additionalProperties:!1,properties:{mode:{$ref:"#/$defs/TemporalModeV1"}},required:["mode"],type:"object"},v5={enum:["fresh","stale","partial","locked","redacted","retention_withheld","unavailable"],type:"string"},v8={description:"Strongly typed canonical identity: `SessionId`.",type:"string"},v7={description:"Strongly typed canonical identity: `SessionOrThreadId`.",type:"string"},be={additionalProperties:!1,properties:{committed_through:{format:"uint64",minimum:0,type:"integer"},observed_through:{format:"uint64",minimum:0,type:"integer"}},required:["observed_through","committed_through"],type:"object"},bt={additionalProperties:!1,properties:{committed_batches:{format:"uint64",minimum:0,type:"integer"},committed_records:{format:"uint64",minimum:0,type:"integer"},coverage:{$ref:"#/$defs/TemporalCoverageV1"},frontier:{$ref:"#/$defs/SessionRefreshFrontierResultV1"},operation_id:{type:"string"},session_id:{type:"string"},source_coverage:{items:{$ref:"#/$defs/SessionSourceCoverageV1"},type:"array"},updated_at:{format:"int64",type:"integer"}},required:["operation_id","session_id","frontier","coverage","committed_batches","committed_records","updated_at"],type:"object"},br={additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/TemporalCoverageV1"},failure_code:{type:["string","null"]},frontier:{$ref:"#/$defs/SessionRefreshFrontierResultV1"},operation_id:{type:"string"},session_id:{type:"string"},source_coverage:{items:{$ref:"#/$defs/SessionSourceCoverageV1"},type:"array"},state:{$ref:"#/$defs/SessionRefreshTerminalStateResultV1"},terminal_at:{format:"int64",type:"integer"}},required:["operation_id","session_id","frontier","coverage","state","terminal_at"],type:"object"},bi={enum:["complete","failed","cancelled"],type:"string"},bo={description:"Structural budget boundary that rejected a session retrieval request.\nThese causes are non-retryable request corrections; concurrent permit or\nqueue pressure remains a separate capacity-saturation failure.",enum:["request_result_limit","request_hydration_limit","request_context_bytes","request_candidate_bytes","request_record_bytes","request_hydration_bytes","estimator_version_mismatch","execution_work_exhausted","candidate_read_exhausted","record_read_exhausted","kernel_result_limit","participant_manifest_participants","participant_manifest_canonical_bytes","cursor_manifest_limit","hydration_bytes","context_bytes","context_tokens"],type:"string"},bn={additionalProperties:!1,properties:{committed_frontier:{format:"uint64",minimum:0,type:"integer"},covered_intervals:{items:{$ref:"#/$defs/SessionCoverageIntervalV1"},type:"array"},missing_intervals:{items:{$ref:"#/$defs/SessionCoverageIntervalV1"},type:"array"},observed_frontier:{format:"uint64",minimum:0,type:"integer"},reason:{$ref:"#/$defs/SessionCoverageReasonV1"},request:{$ref:"#/$defs/SessionCoverageRequestV1"},source_id:{type:"string"},state:{$ref:"#/$defs/SessionCoverageStateV1"},target_watermark:{format:"uint64",minimum:0,type:"integer"}},required:["source_id","observed_frontier","committed_frontier","target_watermark","request","covered_intervals","missing_intervals","state","reason"],type:"object"},ba={description:"Typed configuration key. Keys are lowercase, dotted product identifiers;\nuntyped host/adapter keys are not representable.",type:"string"},bs={additionalProperties:!1,description:"Logical and verified physical identity of the shared Profile shard.\n\nBrain and profile IDs select the shard; the verified store locator binds its\nphysical store. Lease incarnations and authority epochs remain runtime fences.",properties:{brain_id:{$ref:"#/$defs/BrainId"},profile_id:{$ref:"#/$defs/UserProfileId"},store_id:{type:"string"}},required:["brain_id","profile_id","store_id"],type:"object"},bd={additionalProperties:!1,properties:{complete:{type:"boolean"},family_digest:{$ref:"#/$defs/ManifestDigest"},match_class:{$ref:"#/$defs/SimilarMatchClassV1"},member_count:{format:"uint",minimum:0,type:"integer"},members:{items:{$ref:"#/$defs/SimilarOccurrenceV1"},type:"array"},next_cursor:{type:["string","null"]},normalization_revision:{format:"uint16",maximum:65535,minimum:0,type:"integer"},representative_payload_digest:{$ref:"#/$defs/ManifestDigest"}},required:["match_class","normalization_revision","family_digest","representative_payload_digest","member_count","members","complete"],type:"object"},bc={enum:["conservative_exact","rename_normalized_exact"],type:"string"},bl={additionalProperties:!1,properties:{body_span:{$ref:"#/$defs/SourceSpan"},path:{type:"string"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},snapshot_digest:{$ref:"#/$defs/ManifestDigest"},source_generation:{$ref:"#/$defs/CodeGenerationId"},symbol_occurrence_id:{$ref:"#/$defs/SymbolOccurrenceId"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["project_id","repository_id","source_generation","snapshot_digest","symbol_occurrence_id","path","body_span"],type:"object"},bp={properties:{evidence:{default:[],items:{type:"string"},type:"array"},improvement:{type:"boolean"},priority:{type:"string"},reason:{type:"string"},recommendation:{type:"string"},skill_id:{type:"string"}},required:["skill_id","improvement","recommendation","reason","priority"],type:"object"},bu={enum:["cursor","codex","claude","agents","opencode","kimi","kiro","hermes"],type:"string"},bm={properties:{evidence:{default:[],items:{type:"string"},type:"array"},reason:{type:"string"},recommendation:{type:"string"},skill_id:{type:"string"},stale:{type:"boolean"}},required:["skill_id","stale","recommendation","reason"],type:"object"},bf={description:"One skill's durable usage counters. The ledger stores one per skill; a\nsummary is the same record merged with the skill's current metadata.",properties:{activated_at:{description:"When the skill last transitioned into the active state; mirrors the\nmanaged skill metadata so outcome scoring works from summaries alone.",format:"int64",type:["integer","null"]},category:{type:["string","null"]},created_by:{type:["string","null"]},first_seen_at:{format:"int64",type:"integer"},imported_analytics_events:{description:"Import keys that already counted toward this skill. They are not a\nstore-wide set: each key names this skill, so another skill must not\nshare the write.",items:{type:"string"},type:"array",uniqueItems:!0},last_activity_at:{format:"int64",type:"integer"},last_patched_at:{format:"int64",type:["integer","null"]},last_used_at:{format:"int64",type:["integer","null"]},last_viewed_at:{format:"int64",type:["integer","null"]},patch_count:{format:"uint64",minimum:0,type:"integer"},pinned:{type:"boolean"},provenance_source:{anyOf:[{$ref:"#/$defs/ManagedSkillSource"},{type:"null"}]},schema_version:{format:"uint32",minimum:0,type:"integer"},skill_id:{type:"string"},state:{anyOf:[{$ref:"#/$defs/ManagedSkillState"},{type:"null"}]},targets:{default:[],items:{type:"string"},type:"array"},title:{type:["string","null"]},use_count:{format:"uint64",minimum:0,type:"integer"},use_count_at_activation:{format:"uint64",minimum:0,type:["integer","null"]},view_count:{format:"uint64",minimum:0,type:"integer"},view_count_at_activation:{description:"View/use totals captured at activation time so activity since activation\nis an exact delta rather than a heuristic.",format:"uint64",minimum:0,type:["integer","null"]}},required:["schema_version","skill_id","pinned","view_count","use_count","patch_count","first_seen_at","last_activity_at"],type:"object"},bh={description:"Strongly typed canonical identity: `SourceBindingId`.",type:"string"},by={additionalProperties:!1,description:"Source freshness is source- and retriever-specific: there is no global\nage-decay multiplier. Missing, stale, incompatible, and current are\ndistinct states.",properties:{compatibility:{$ref:"#/$defs/FreshnessCompatibilityV1"},generation_lag:{format:"uint64",minimum:0,type:["integer","null"]},observed_at:{$ref:"#/$defs/UtcMicros"},policy_revision:{$ref:"#/$defs/ComponentRevision"},projection_watermark:{format:"uint64",minimum:0,type:["integer","null"]},source_generation:{format:"uint64",minimum:0,type:["integer","null"]},source_instance:{$ref:"#/$defs/SourceInstanceKey"},source_namespace:{$ref:"#/$defs/SourceNamespace"},source_watermark:{format:"uint64",minimum:0,type:["integer","null"]}},required:["source_namespace","source_instance","observed_at","compatibility","policy_revision"],type:"object"},bg={description:"Strongly typed canonical identity: `SourceInstanceKey`.",type:"string"},b_={enum:["claude","codex","cursor","git_hub","hermes","kiro"],type:"string"},bv={description:"Strongly typed canonical identity: `SourceNamespace`.",type:"string"},bb={description:"Strongly typed canonical identity: `SourceOccurrenceId`.",type:"string"},b$={additionalProperties:!1,description:"Byte range inside one sanitized source file. Mutable line numbers are\nnever part of identity.",properties:{end_byte:{format:"uint64",minimum:0,type:"integer"},start_byte:{format:"uint64",minimum:0,type:"integer"}},required:["start_byte","end_byte"],type:"object"},bS={description:"Strongly typed canonical identity: `SourceStoreId`.",type:"string"},bk={description:"Strongly typed canonical identity: `StackDeliveryWatermarkId`.",type:"string"},bw={description:"Strongly typed canonical identity: `StackNodeId`.",type:"string"},bP={description:"Strongly typed canonical identity: `StackSignalId`.",type:"string"},bV={additionalProperties:!1,description:"Exact base/head symbol comparison was unavailable; the git evidence beside\nit is still the answer.",properties:{reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","reason","retryable"],type:"object"},bR={additionalProperties:!1,description:"Optional narrowing inside the immutable project/repository/worktree scope\ncarried by [`RequestContext`]. A path prefix never establishes identity or\nauthorization.",properties:{path_prefix:{type:["string","null"]}},type:"object"},bq={description:"Strongly typed canonical identity: `SymbolOccurrenceId`.",type:"string"},bI={additionalProperties:!1,properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},is_async:{type:"boolean"},kind:{type:"string"},line:{description:"One-based user-facing line.",format:"uint32",minimum:0,type:"integer"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"},score:{format:"double",type:["number","null"]},signature:{type:["string","null"]}},required:["node_id","name","qualified_name","kind","file","line","end_line","is_async"],type:"object"},bx={additionalProperties:!1,properties:{depth:{format:"uint32",minimum:0,type:["integer","null"]},dispatch_from:{type:["string","null"]},dispatch_via_trait:{type:"boolean"},edge_kind:{type:"string"},symbol:{$ref:"#/$defs/SymbolPrimitiveRecord"}},required:["symbol","edge_kind","dispatch_via_trait"],type:"object"},bj={additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},link_id:{type:"string"},observed_at:{$ref:"#/$defs/UtcMicros"},revision:{format:"uint64",minimum:0,type:"integer"},task_id:{$ref:"#/$defs/TaskId"}},required:["link_id","revision","task_id","anchor_id","evidence_digest","observed_at"],type:"object"},bC={additionalProperties:!1,properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},from_actor_id:{$ref:"#/$defs/ActorId"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},run_id:{$ref:"#/$defs/RunId"},step_id:{$ref:"#/$defs/WorkflowStepId"},task_id:{$ref:"#/$defs/TaskId"},thread_id:{$ref:"#/$defs/ThreadId"},to_actor_id:{$ref:"#/$defs/ActorId"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["project_id","repository_id","worktree_id","definition_id","definition_version","step_id","task_id","thread_id","run_id","from_actor_id","to_actor_id"],type:"object"},bT={description:"Strongly typed canonical identity: `TaskId`.",type:"string"},bO={additionalProperties:!1,properties:{hidden:{format:"uint64",minimum:0,type:"integer"},redacted:{format:"uint64",minimum:0,type:"integer"},unknown:{format:"uint64",minimum:0,type:"integer"},visible:{format:"uint64",minimum:0,type:"integer"}},required:["visible","hidden","unknown","redacted"],type:"object"},bE={additionalProperties:!1,properties:{anchor:{type:"string"},summary:{type:"string"}},required:["anchor","summary"],type:"object"},bA={oneOf:[{properties:{state:{const:"fresh",type:"string"}},required:["state"],type:"object"},{properties:{generation_lag:{format:"uint64",minimum:0,type:"integer"},state:{const:"stored",type:"string"}},required:["state","generation_lag"],type:"object"},{properties:{generation_lag:{format:"uint64",minimum:0,type:"integer"},state:{const:"partial",type:"string"}},required:["state","generation_lag"],type:"object"}]},bW={description:"Requested temporal interpretation.",oneOf:[{additionalProperties:!1,properties:{kind:{const:"current",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{cutoff:{$ref:"#/$defs/UtcMicros"},kind:{const:"as_of",type:"string"}},required:["kind","cutoff"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"evolution",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"forensic",type:"string"}},required:["kind"],type:"object"}]},bM={additionalProperties:!1,properties:{anchor:{type:"string"},rank:{format:"uint32",minimum:0,type:"integer"},reason:{$ref:"#/$defs/HydrationStateResultV1"}},required:["rank","anchor","reason"],type:"object"},bN={additionalProperties:!1,properties:{generation:{format:"uint64",minimum:0,type:"integer"},index:{format:"uint64",minimum:0,type:"integer"},projection:{format:"uint64",minimum:0,type:"integer"},source:{format:"uint64",minimum:0,type:"integer"},summary:{format:"uint64",minimum:0,type:"integer"}},required:["generation","source","projection","index","summary"],type:"object"},bz={description:"Strongly typed canonical identity: `ThreadId`.",type:"string"},bD={additionalProperties:!1,description:"What a token budget did to an answer. `est_tokens` is the kept rows.\n`over_ceiling` means a single row was larger than its section quota and\nwas kept anyway.",properties:{budget_tokens:{format:"uint32",minimum:0,type:"integer"},est_tokens:{format:"uint32",minimum:0,type:"integer"},over_ceiling:{type:"boolean"},sections:{items:{$ref:"#/$defs/TokenBudgetSectionV1"},type:"array"}},required:["budget_tokens","est_tokens","over_ceiling","sections"],type:"object"},bF={additionalProperties:!1,description:"One section a token budget kept or cut.",properties:{section:{type:"string"},shown:{format:"uint32",minimum:0,type:"integer"},total:{format:"uint32",minimum:0,type:"integer"}},required:["section","total","shown"],type:"object"},bL={additionalProperties:!1,properties:{maximum_active_per_repository:{format:"uint16",maximum:65535,minimum:1,type:"integer"},maximum_global_active:{format:"uint16",maximum:65535,minimum:1,type:"integer"},maximum_parallel_per_task:{format:"uint16",maximum:65535,minimum:1,type:"integer"},maximum_stack_depth:{format:"uint16",maximum:65535,minimum:1,type:"integer"}},required:["maximum_active_per_repository","maximum_parallel_per_task","maximum_global_active","maximum_stack_depth"],type:"object"},bU={enum:["reject","require_explicit_human_approval","require_human_approval_and_independent_review"],type:"string"},bH={additionalProperties:!1,properties:{cleanliness:{$ref:"#/$defs/WorktreeCleanlinessRequirementV1"},maximum_preflight_age_seconds:{format:"uint32",minimum:1,type:"integer"},require_fresh_preflight:{type:"boolean"},review:{$ref:"#/$defs/ReviewRequirementV1"},tests:{items:{$ref:"#/$defs/RequiredCheckV1"},type:"array"}},required:["cleanliness","tests","review","require_fresh_preflight","maximum_preflight_age_seconds"],type:"object"},bG={enum:["critical_only","lifecycle","verbose"],type:"string"},bB={description:"Risky construct the pattern scan looks for.",enum:["unwrap","expect","panic","todo","unimplemented","unsafe_block"],type:"string"},bK={description:"Stable, canonical catalog identity for `UseCaseId`.",type:"string"},bJ={description:"Strongly typed canonical identity: `UserProfileId`.",type:"string"},bZ={description:"UTC timestamp represented as microseconds from the Unix epoch.",format:"int64",type:"integer"},bQ={oneOf:[{properties:{interval:{$ref:"#/$defs/ClosedUtcIntervalV1"},kind:{const:"known",type:"string"}},required:["kind","interval"],type:"object"},{properties:{kind:{const:"unknown",type:"string"}},required:["kind"],type:"object"}]},bX={additionalProperties:!1,description:"One exact verified graph snapshot identity.",properties:{event_sequence:{format:"uint64",minimum:0,type:"integer"},graph_version:{format:"uint64",minimum:0,type:"integer"},recovered_graph_digest:{$ref:"#/$defs/ManifestDigest"},source_watermark:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},type:"object"}},required:["graph_version","event_sequence","source_watermark","recovered_graph_digest"],type:"object"},bY={additionalProperties:!1,properties:{criterion_id:{type:"string"},description:{type:"string"},evidence_required:{type:"boolean"}},required:["criterion_id","description","evidence_required"],type:"object"},b1={enum:["never","on_request"],type:"string"},b0={description:"Strongly typed canonical identity: `WorkArtifactId`.",type:"string"},b2={additionalProperties:!1,properties:{artifact_id:{$ref:"#/$defs/WorkArtifactId"},byte_length:{format:"uint64",minimum:0,type:"integer"},digest:{$ref:"#/$defs/ManifestDigest"}},required:["artifact_id","digest","byte_length"],type:"object"},b4={additionalProperties:!1,description:"Sealed terminal evidence for one provider attempt. The digest of this\nrecord is the evidence digest carried by [`WorkTerminalEvidenceV1`] and by\nthe `RuntimeEvidenceRef` attached to the Work projection, so the receipt\nin Work always names an inspectable record.",properties:{actual_route:{anyOf:[{$ref:"#/$defs/WorkProviderRouteV1"},{type:"null"}]},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{$ref:"#/$defs/WorkAttemptProviderOutcomeV1"},provider_fallback:{anyOf:[{$ref:"#/$defs/WorkProviderFallbackRecordV1"},{type:"null"}],description:"Present only when the pinned preferred backend was disqualified before\nstartup. `None` means the attempt ran on its first-choice backend."},provider_session:{anyOf:[{$ref:"#/$defs/ObservationSourceIdentityV1"},{type:"null"}],description:"Native provider-qualified session/thread identity, when the provider\nreported one. Admission cannot supply this value and no fallback is\nfabricated."},requested_route:{$ref:"#/$defs/WorkProviderRouteV1"},stderr:{anyOf:[{$ref:"#/$defs/WorkAttemptStreamSummaryV1"},{type:"null"}]},stdout:{anyOf:[{$ref:"#/$defs/WorkAttemptStreamSummaryV1"},{type:"null"}]}},required:["identity","requested_route","outcome","observed_at"],type:"object"},b6={additionalProperties:!1,properties:{attempt_id:{$ref:"#/$defs/AttemptId"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","attempt_id"],type:"object"},b3={description:"How much of the authorized attempt set one page covers.",oneOf:[{additionalProperties:!1,description:"Every attempt after the page start was returned; zero returned is the\nexplicit empty authorized result, not a concealment.",properties:{coverage:{const:"complete",type:"string"},returned:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned"],type:"object"},{additionalProperties:!1,description:"The page cap was reached; `resume` continues under the same verified\ntopology generation.",properties:{coverage:{const:"capped",type:"string"},remaining:{format:"uint32",minimum:0,type:"integer"},resume:{$ref:"#/$defs/WorkAttemptListCursorV1"},returned:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned","remaining","resume"],type:"object"}]},b9={description:"Opaque resume point for the next page of one attempt-list-family read,\nbound to the operation and `page_size` that minted it and pinned to the\nverified topology generation the page was read under.",type:"string"},b5={additionalProperties:!1,properties:{completed:{format:"uint64",minimum:0,type:"integer"},total:{format:"uint64",minimum:0,type:"integer"}},required:["completed","total"],type:"object"},b8={additionalProperties:!1,properties:{accepted_proposal:{$ref:"#/$defs/ProposalId",description:"Exact accepted proposal the attempt was admitted against. A superseded\nor cleared proposal is a different binding, not a compatible refresh."},event_sequence:{description:"Exact immutable product event that verified this graph version.",format:"uint64",minimum:0,type:"integer"},graph_version:{format:"uint64",minimum:0,type:"integer"},recovered_graph_digest:{$ref:"#/$defs/ManifestDigest",description:"Digest of the graph recovered and verified at admission."},source_watermark:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},description:"Source-frontier identity preserved from the verified product graph.",type:"object"}},required:["graph_version","event_sequence","source_watermark","recovered_graph_digest","accepted_proposal"],type:"object"},b7={description:"How one provider attempt ended, as observed by the daemon runtime.",oneOf:[{properties:{code:{format:"int32",type:"integer"},outcome:{const:"exited",type:"string"}},required:["outcome","code"],type:"object"},{properties:{outcome:{const:"signalled",type:"string"},signal:{format:"int32",type:"integer"}},required:["outcome","signal"],type:"object"},{properties:{outcome:{const:"timed_out",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"cancelled",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"provider_unavailable",type:"string"},state:{$ref:"#/$defs/WorkProviderAvailabilityV1"}},required:["outcome","state"],type:"object"},{properties:{channel:{$ref:"#/$defs/WorkAttemptStreamChannelV1"},outcome:{const:"stream_overflow",type:"string"}},required:["outcome","channel"],type:"object"},{properties:{outcome:{const:"launch_failed",type:"string"}},required:["outcome"],type:"object"},{description:"The provider started but its typed protocol session did not reach a\nterminal answer: a malformed, out-of-order, oversized, or lost frame.\nPlan 32 requires such a stream to seal failed evidence rather than a\ntext-scraped success.",properties:{outcome:{const:"protocol_failed",type:"string"}},required:["outcome"],type:"object"}]},$e={additionalProperties:!1,properties:{artifacts:{items:{$ref:"#/$defs/WorkArtifactRefV1"},type:"array"},evidence:{anyOf:[{$ref:"#/$defs/WorkAttemptEvidenceRecordV1"},{type:"null"}]},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["identity","artifacts"],type:"object"},$t={enum:["leased","running","cancellation_requested","cancellation_acknowledged","cancellation_escalated","recovery_required","succeeded","failed","timed_out","cancelled"],type:"string"},$r={enum:["stdout","stderr"],type:"string"},$i={additionalProperties:!1,description:"Bounded summary of one captured provider stream.",properties:{byte_length:{format:"uint64",minimum:0,type:"integer"},digest:{$ref:"#/$defs/ManifestDigest"},truncated:{type:"boolean"}},required:["byte_length","truncated","digest"],type:"object"},$o={additionalProperties:!1,description:"The verified Work topology snapshot one attempt-list page was read under.",properties:{generation:{description:"The verified graph generation the topology snapshot is published under.",type:"string"},task_count:{description:"The number of tasks in the verified topology.",format:"uint32",minimum:0,type:"integer"}},required:["generation","task_count"],type:"object"},$n={properties:{actual_route:{anyOf:[{$ref:"#/$defs/WorkProviderRouteV1"},{type:"null"}]},artifacts:{items:{$ref:"#/$defs/WorkArtifactRefV1"},type:"array"},cancellation:{$ref:"#/$defs/WorkCancellationStateV1"},execution:{$ref:"#/$defs/WorkExecutionEnvelopeV1"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},lease:{$ref:"#/$defs/WorkLeaseFenceV1"},progress:{anyOf:[{$ref:"#/$defs/WorkAttemptProgressV1"},{type:"null"}]},projection_binding:{$ref:"#/$defs/WorkAttemptProjectionBindingV1"},recovery:{$ref:"#/$defs/WorkRecoveryStateV1"},requested_route:{$ref:"#/$defs/WorkProviderRouteV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"},terminal:{anyOf:[{$ref:"#/$defs/WorkTerminalEvidenceV1"},{type:"null"}]}},required:["identity","projection_binding","execution","lease","state","artifacts","cancellation","recovery","requested_route"],type:"object"},$a={additionalProperties:!1,properties:{acknowledged_at:{$ref:"#/$defs/UtcMicros"},request:{$ref:"#/$defs/WorkCancellationRequestV1"}},required:["request","acknowledged_at"],type:"object"},$s={additionalProperties:!1,properties:{acknowledgement:{$ref:"#/$defs/WorkCancellationAcknowledgementV1"},escalated_at:{$ref:"#/$defs/UtcMicros"}},required:["acknowledgement","escalated_at"],type:"object"},$d={description:"Strongly typed canonical identity: `WorkCancellationRequestId`.",type:"string"},$c={additionalProperties:!1,properties:{request_id:{$ref:"#/$defs/WorkCancellationRequestId"},requested_at:{$ref:"#/$defs/UtcMicros"}},required:["request_id","requested_at"],type:"object"},$l={oneOf:[{properties:{state:{const:"none",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"requested",type:"string"},value:{$ref:"#/$defs/WorkCancellationRequestV1"}},required:["state","value"],type:"object"},{properties:{state:{const:"acknowledged",type:"string"},value:{$ref:"#/$defs/WorkCancellationAcknowledgementV1"}},required:["state","value"],type:"object"},{properties:{state:{const:"escalated",type:"string"},value:{$ref:"#/$defs/WorkCancellationEscalationV1"}},required:["state","value"],type:"object"}]},$p={description:"Strongly typed canonical identity: `WorkCommandId`.",type:"string"},$u={description:"Where a configured route places task content.",enum:["local","tenant","external"],type:"string"},$m={additionalProperties:!1,properties:{topology_generation:{$ref:"#/$defs/WorkTopologyGenerationRefV1"},work_generation:{$ref:"#/$defs/ProjectionGenerationId"}},required:["work_generation","topology_generation"],type:"object"},$f={additionalProperties:!1,properties:{cost_micros:{format:"uint64",minimum:0,type:["integer","null"]},coverage:{$ref:"#/$defs/CoverageStateV1"},effect_count:{format:"uint64",minimum:0,type:["integer","null"]},effect_outcome:{$ref:"#/$defs/DuplicateEffectOutcomeV1"},evidence:{$ref:"#/$defs/QuantityEvidenceClassV1"},test_count:{format:"uint64",minimum:0,type:["integer","null"]},token_count:{format:"uint64",minimum:0,type:["integer","null"]},wall_micros:{format:"uint64",minimum:0,type:["integer","null"]}},required:["evidence","effect_outcome","coverage"],type:"object"},$h={description:"Effect semantics admitted for one provider attempt.",enum:["observational","intercepted","compound_non_repeatable"],type:"string"},$y={description:"Declared effort class of a configured route.",enum:["minimal","standard","extended"],type:"string"},$g={enum:["deny","allowlisted"],type:"string"},$_={oneOf:[{additionalProperties:!1,properties:{cursor:{type:"string"},kind:{const:"anchor",type:"string"},link_id:{type:"string"}},required:["kind","link_id","cursor"],type:"object"},{additionalProperties:!1,properties:{continuation:{$ref:"#/$defs/WorkTaskSessionContinuationV1"},kind:{const:"task_session",type:"string"}},required:["kind","continuation"],type:"object"}]},$v={additionalProperties:!1,description:"One immutable evidence frontier. Local code/session evidence and live Git\nevidence each carry their own frontier; the evaluator never merges,\nsubstitutes, or advances one from the other.",properties:{digest:{$ref:"#/$defs/ManifestDigest"},watermark:{$ref:"#/$defs/UtcMicros"}},required:["watermark","digest"],type:"object"},$b={additionalProperties:!1,description:"Exact on-disk executable selected for one opaque executable identity.\n\nThe path is configuration data, never a lookup hint. Runtime admission\ncanonicalizes it again and verifies the file bytes against\n`executable.artifact_digest` before returning an executable binding.",properties:{canonical_path:{type:"string"},capabilities:{items:{$ref:"#/$defs/WorkExecutableCapabilityV1"},type:"array"},executable:{$ref:"#/$defs/WorkExecutableReference"},routes:{items:{$ref:"#/$defs/WorkRouteCandidateV1"},type:"array"}},required:["executable","canonical_path","capabilities","routes"],type:"object"},$$={description:"One executable capability admitted by a configured artifact binding.\n\nThe closed variants bind a provider backend to its exact wire protocol.\nCallers cannot claim an arbitrary backend/protocol combination.",enum:["claude_code_stream_json","codex_app_server_json_rpc","codex_cli_exec_json"],type:"string"},$S={additionalProperties:!1,properties:{artifact_digest:{$ref:"#/$defs/ManifestDigest"},executable_id:{type:"string"}},required:["executable_id","artifact_digest"],type:"object"},$k={additionalProperties:!1,description:"Exact immutable provider admission attached to the durable Work attempt.\n\nCallers name typed route and scope facts, never argv, environment entries,\nor executable paths. The daemon resolves the registered executable only\nafter this envelope has been persisted and admitted to the canonical queue.",properties:{attempt_identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},cancellation_generation:{format:"uint64",minimum:0,type:"integer"},commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},instructions:{description:"Exact provider instructions admitted with this attempt. The adapter\ndelivers these bytes verbatim on the provider's typed input channel;\nthey are never interpolated into argv or an ambient prompt source.",type:"string"},operation:{$ref:"#/$defs/WorkflowOperationRef"},project_id:{$ref:"#/$defs/ProjectId"},projection_binding:{$ref:"#/$defs/WorkAttemptProjectionBindingV1"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},repository_id:{$ref:"#/$defs/RepositoryId"},worktree_id:{$ref:"#/$defs/WorktreeId"},worktree_root:{type:"string"}},required:["attempt_identity","projection_binding","operation","execution_snapshot","project_id","repository_id","worktree_id","worktree_root","commit","instructions","cancellation_generation","effect_state"],type:"object"},$w={additionalProperties:!1,properties:{max_concurrency:{format:"uint32",minimum:0,type:"integer"},max_input_tokens:{format:"uint64",minimum:0,type:"integer"},max_output_tokens:{format:"uint64",minimum:0,type:"integer"},max_protocol_bytes:{format:"uint64",minimum:0,type:"integer"},max_stderr_bytes:{format:"uint64",minimum:0,type:"integer"},max_stdout_bytes:{format:"uint64",minimum:0,type:"integer"}},required:["max_input_tokens","max_output_tokens","max_stdout_bytes","max_stderr_bytes","max_protocol_bytes","max_concurrency"],type:"object"},$P={additionalProperties:!1,description:"Immutable provider and topology authority pinned for exactly one Work\nexecution. Every constraint the execution is governed by is named here;\nnothing in this value is an opaque stand-in that a reader must resolve\nagainst a mutable store.",properties:{approval:{$ref:"#/$defs/WorkApprovalPolicy"},backend:{$ref:"#/$defs/WorkProviderBackendV1"},configuration_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},configuration_snapshot_id:{$ref:"#/$defs/ConfigurationSnapshotId"},credential_references:{items:{$ref:"#/$defs/CredentialReferenceId"},type:"array",uniqueItems:!0},deadline:{$ref:"#/$defs/UtcMicros"},effective_behavior_digest:{$ref:"#/$defs/ManifestDigest"},egress:{$ref:"#/$defs/WorkEgressPolicy"},environment_allowlist:{items:{type:"string"},type:"array",uniqueItems:!0},executable:{$ref:"#/$defs/WorkExecutableReference"},fallback:{$ref:"#/$defs/WorkFallbackTopology"},filesystem:{$ref:"#/$defs/WorkFilesystemPolicy"},limits:{$ref:"#/$defs/WorkExecutionLimits"},model:{type:"string"},protocol:{$ref:"#/$defs/WorkProviderProtocol"},resolution_provenance_digest:{$ref:"#/$defs/ManifestDigest"},route:{$ref:"#/$defs/WorkProviderRouteV1"},sandbox:{$ref:"#/$defs/WorkSandboxPolicy"},topology:{$ref:"#/$defs/WorkTopologyPolicyV1",description:"See [`WorkExecutionSnapshotInput::topology`]. Validated on construction,\nso an admitted snapshot can never pin a topology that weakens the\nprotected-ref floor or permits a native integration without its gates."}},required:["configuration_revision_id","configuration_snapshot_id","effective_behavior_digest","resolution_provenance_digest","route","backend","protocol","model","executable","sandbox","approval","filesystem","egress","environment_allowlist","credential_references","limits","deadline","fallback","topology"],type:"object"},$V={enum:["language","framework","architecture","testing","operations","security","domain"],type:"string"},$R={additionalProperties:!1,description:"Explicit, expiring consent for ephemeral expertise context.\n\nUser-profile and project authorization are separate registered settings;\nWork requires both and uses only their category intersection.",properties:{allowed_categories:{items:{$ref:"#/$defs/WorkExpertiseCategoryV1"},type:"array",uniqueItems:!0},enabled:{type:"boolean"},expires_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},granted_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"}},required:["schema_version","enabled","allowed_categories"],type:"object"},$q={oneOf:[{additionalProperties:!1,properties:{kind:{const:"disabled",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{executable:{$ref:"#/$defs/WorkExecutableReference"},kind:{const:"codex_cli",type:"string"},route:{$ref:"#/$defs/WorkProviderRouteV1"}},required:["kind","route","executable"],type:"object"}]},$I={format:"uint64",minimum:0,title:"WorkFenceEpochV1",type:"integer"},$x={enum:["read_only","workspace_write"],type:"string"},$j={oneOf:[{additionalProperties:!1,properties:{item:{$ref:"#/$defs/WorkItemV1"},kind:{const:"task_added",type:"string"}},required:["kind","item"],type:"object"},{additionalProperties:!1,properties:{initiative:{$ref:"#/$defs/WorkInitiativeV1"},item:{$ref:"#/$defs/WorkItemV1"},kind:{const:"task_created",type:"string"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},plan:{$ref:"#/$defs/WorkPlanV1"}},required:["kind","initiative","plan","milestone","item"],type:"object"},{additionalProperties:!1,properties:{decided_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},kind:{const:"relation_replan_decided",type:"string"},proposal:{$ref:"#/$defs/WorkRelationReplanProposalV1"}},required:["kind","proposal","disposition","decided_at"],type:"object"},{additionalProperties:!1,properties:{applied_at:{$ref:"#/$defs/UtcMicros"},kind:{const:"task_relations_replanned",type:"string"},proposal_id:{$ref:"#/$defs/ProposalId"}},required:["kind","proposal_id","applied_at"],type:"object"},{additionalProperties:!1,properties:{evidence:{$ref:"#/$defs/TaskEvidenceLinkV1"},kind:{const:"evidence_linked",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","evidence"],type:"object"},{additionalProperties:!1,properties:{decided_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},kind:{const:"proposal_decided",type:"string"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["kind","proposal","disposition","decided_at"],type:"object"},{additionalProperties:!1,properties:{accepted_at:{$ref:"#/$defs/UtcMicros"},kind:{const:"proposal_accepted",type:"string"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["kind","proposal","accepted_at"],type:"object"},{additionalProperties:!1,properties:{admitted_at:{$ref:"#/$defs/UtcMicros"},based_on_version:{format:"uint64",minimum:0,type:"integer"},kind:{const:"execution_admitted",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","based_on_version","admitted_at"],type:"object"},{additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},kind:{const:"accepted_attempt_linked",type:"string"},linked_at:{$ref:"#/$defs/UtcMicros"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","based_on_version","identity","linked_at"],type:"object"},{additionalProperties:!1,properties:{accepted_at:{$ref:"#/$defs/UtcMicros"},evidence_by_criterion:{additionalProperties:{type:"string"},type:"object"},kind:{const:"task_accepted",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","evidence_by_criterion","accepted_at"],type:"object"},{additionalProperties:!1,properties:{handoff:{$ref:"#/$defs/WorkHandoffV1"},kind:{const:"handoff_recorded",type:"string"}},required:["kind","handoff"],type:"object"}]},$C={additionalProperties:!1,description:"One attempt on the evidence frontier: exactly which attempt, in which\nstate, backed by which sealed evidence digest (when the attempt has\nreported one). No lease or fence is part of the frontier. Those are\nruntime authority, not checkpoint evidence.",properties:{evidence_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"The digest of the sealed terminal evidence record, when the attempt\nhas one. `None` is the typed not-yet-reported state."},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"}},required:["identity","state"],type:"object"},$T={additionalProperties:!1,description:"The exact work/evidence frontier one handoff records.",properties:{attempts:{description:"The evidence frontier: every attempt the issuer knows about, in\nstable identity order.",items:{$ref:"#/$defs/WorkHandoffAttemptFrontierV1"},type:"array"},blockers:{description:"What is blocking progress. Bounded, non-empty entries.",items:{type:"string"},type:"array"},legal_actions:{description:"The actions the issuer believes are legal next steps.",items:{type:"string"},type:"array"},lineage:{$ref:"#/$defs/WorkHandoffLineageV1"},task_id:{$ref:"#/$defs/TaskId"},unknowns:{description:"What the issuer does not know yet. Bounded, non-empty entries.",items:{type:"string"},type:"array"},work_version:{description:"The exact Work version the frontier was cut at.",format:"uint64",minimum:0,type:"integer"}},required:["task_id","work_version","attempts","unknowns","blockers","legal_actions","lineage"],type:"object"},$O={additionalProperties:!1,description:"Who issued this frontier and what it supersedes.",properties:{issued_at:{$ref:"#/$defs/UtcMicros"},issued_by:{$ref:"#/$defs/ActorId"},prior_frontier_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"The canonical digest of the frontier this one supersedes, when the\ntask has been handed off before. `None` states a first handoff."}},required:["issued_by","issued_at"],type:"object"},$E={additionalProperties:!1,properties:{evidence_frontier:{items:{type:"string"},type:"array",uniqueItems:!0},from_actor:{$ref:"#/$defs/ActorId"},handed_off_at:{$ref:"#/$defs/UtcMicros"},handoff_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"},to_actor:{$ref:"#/$defs/ActorId"},unknowns:{items:{type:"string"},type:"array",uniqueItems:!0}},required:["handoff_id","task_id","from_actor","to_actor","evidence_frontier","unknowns","handed_off_at"],type:"object"},$A={additionalProperties:!1,properties:{initiative_id:{type:"string"},milestone_id:{type:"string"},plan_id:{type:"string"}},required:["initiative_id","plan_id","milestone_id"],type:"object"},$W={additionalProperties:!1,properties:{created_at:{$ref:"#/$defs/UtcMicros"},id:{type:"string"},title:{type:"string"}},required:["id","title","created_at"],type:"object"},$M={additionalProperties:!1,properties:{acceptance_criteria:{items:{$ref:"#/$defs/WorkAcceptanceCriterionV1"},type:"array"},causal_candidates:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},created_at:{$ref:"#/$defs/UtcMicros"},deadline:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},dependencies:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},effort:{format:"uint32",minimum:0,type:"integer"},hierarchy:{$ref:"#/$defs/WorkHierarchyV1"},informational_relations:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},scheduled_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},task_id:{$ref:"#/$defs/TaskId"},title:{type:"string"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["task_id","hierarchy","title","dependencies","informational_relations","causal_candidates","acceptance_criteria","effort","created_at","updated_at"],type:"object"},$N={additionalProperties:!1,properties:{accepted_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},accepted_attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},accepted_criteria:{additionalProperties:{type:"string"},type:"object"},accepted_proposal:{anyOf:[{$ref:"#/$defs/ProposalId"},{type:"null"}]},accepted_route:{anyOf:[{$ref:"#/$defs/WorkRouteDecisionV1"},{type:"null"}]},archived_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},evidence_links:{items:{type:"string"},type:"array",uniqueItems:!0},execution_admitted_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},handoffs:{items:{$ref:"#/$defs/WorkHandoffV1"},type:"array"},input:{$ref:"#/$defs/WorkItemInputV1"}},required:["input","evidence_links","accepted_criteria","accepted_attempts","handoffs"],type:"object"},$z={description:"A job task key: `[a-z0-9-]`, 1 to 48 bytes. Identities derive from it.",type:"string"},$D={additionalProperties:!1,properties:{epoch:{$ref:"#/$defs/WorkFenceEpochV1"},lease_id:{$ref:"#/$defs/WorkLeaseId"}},required:["lease_id","epoch"],type:"object"},$F={description:"Strongly typed canonical identity: `WorkLeaseId`.",type:"string"},$L={additionalProperties:!1,properties:{created_at:{$ref:"#/$defs/UtcMicros"},id:{type:"string"},plan_id:{type:"string"},title:{type:"string"}},required:["id","plan_id","title","created_at"],type:"object"},$U={description:"Ordinal band. Never a probability, never a scalar score.\n\nBands are ordered `Lowest` .. `Highest`. Comparison is the only operation\nconsumers perform over them, so no weighted sum can be reconstructed from\na recorded decision.",enum:["lowest","low","moderate","high","highest"],type:"string"},$H={description:"Closed set of conditions that block admission or removal.",oneOf:[{const:"dirty_tracked_files",description:"Tracked files differ from the index or HEAD.",type:"string"},{const:"untracked_data",description:"Untracked data is present in the target.",type:"string"},{const:"unique_commits",description:"The target holds commits reachable from nowhere else.",type:"string"},{const:"active_holder",description:"Another admitted placement holds this target.",type:"string"},{const:"unresolved_effect",description:"An effect against this placement is unresolved.",type:"string"},{const:"unacknowledged_receipt",description:"A receipt produced against this placement is unacknowledged.",type:"string"},{const:"uncertain_pull_request",description:"A pull request produced from this placement is in an uncertain state.",type:"string"},{const:"shared_ref",description:"A ref in this target is shared with another holder.",type:"string"},{const:"missing_anchor",description:"A retrieval or evidence anchor this placement referenced is missing.",type:"string"},{const:"stale_scope",description:"The authorized scope no longer matches the placement.",type:"string"},{const:"authorization_lost",description:"Authorization for this placement was lost.",type:"string"},{const:"target_unreadable",description:"The target could not be read, so its state is unknown.",type:"string"},{const:"network_required",description:"The placement declared itself network-free but the action needs network.",type:"string"}],title:"WorkPlacementBlockerV1"},$G={additionalProperties:!1,description:"Which run a placement belongs to. Placement never redefines TaskId.",properties:{run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id"],title:"WorkPlacementIdentityV1",type:"object"},$B={description:"The supported placement choices, and only those.",oneOf:[{const:"no_managed_placement",description:"TraceDecay manages no checkout for this run. No-Git work is first class.",type:"string"},{const:"clean_in_place",description:"The caller's own strictly clean checkout, explicitly acknowledged.",type:"string"},{const:"linked_worktree",description:"A linked worktree of the same repository.",type:"string"},{const:"isolated_clone",description:"An isolated local clone.",type:"string"}],title:"WorkPlacementKindV1"},$K={description:"The durable state of one admitted placement.",oneOf:[{const:"admitted",description:"The placement holds its target.",type:"string"},{const:"released",description:"The placement gave its target up cleanly. Nothing was deleted by this\ntransition; removal is a separate cleanup preflight.",type:"string"},{const:"quarantined",description:"The placement was retained because removal is blocked.",type:"string"}],title:"WorkPlacementStateV1"},$J={additionalProperties:!1,description:"The exact placement a caller asked for.",properties:{in_place_acknowledged:{description:"Set only for `CleanInPlace`: the caller states it accepts running in\nits own checkout. Acknowledgement is explicit, never inferred.",type:"boolean"},kind:{$ref:"#/$defs/WorkPlacementKindV1"},network_free:{description:"The placement declares it needs no network. Declared, not detected.",type:"boolean"},root:{description:"Absolute root, present exactly when the kind manages one.",type:["string","null"]}},required:["kind","in_place_acknowledged","network_free"],title:"WorkPlacementTargetV1",type:"object"},$Z={additionalProperties:!1,description:"One run's durable placement relation.",properties:{authority_version:{format:"uint64",minimum:0,type:"integer"},blockers:{items:{$ref:"#/$defs/WorkPlacementBlockerV1"},type:"array",uniqueItems:!0},identity:{$ref:"#/$defs/WorkPlacementIdentityV1"},retention_eligible_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}],description:"When retention makes this placement *eligible* for a fresh cleanup\npreflight. Eligibility is not delete authority."},state:{$ref:"#/$defs/WorkPlacementStateV1"},target:{$ref:"#/$defs/WorkPlacementTargetV1"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["identity","target","state","authority_version","transitioned_at","blockers"],title:"WorkPlacementV1",type:"object"},$Q={additionalProperties:!1,properties:{created_at:{$ref:"#/$defs/UtcMicros"},id:{type:"string"},initiative_id:{type:"string"},title:{type:"string"}},required:["id","initiative_id","title","created_at"],type:"object"},$X={oneOf:[{additionalProperties:!1,properties:{kind:{const:"project",type:"string"},project_id:{$ref:"#/$defs/ProjectId"}},required:["kind","project_id"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"repository",type:"string"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"}},required:["kind","project_id","repository_id"],type:"object"}]},$Y={additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},source_store_id:{$ref:"#/$defs/SourceStoreId"}},required:["source_store_id","anchor_id","evidence_digest"],type:"object"},$1={oneOf:[{additionalProperties:!1,properties:{graph:{$ref:"#/$defs/WorkProductGraphV1"},kind:{const:"created",type:"string"}},required:["kind","graph"],type:"object"},{additionalProperties:!1,properties:{change:{$ref:"#/$defs/WorkGraphChangeV1"},kind:{const:"changed",type:"string"}},required:["kind","change"],type:"object"}]},$0={additionalProperties:!1,properties:{actor_id:{$ref:"#/$defs/ActorId"},authorized_relation_scopes:{items:{$ref:"#/$defs/WorkProductAuthorizedRelationScopeV1"},type:"array"},canonical_input_digest:{$ref:"#/$defs/ManifestDigest"},catalog_generation_id:{$ref:"#/$defs/CatalogGenerationId"},causation_event_id:{type:["string","null"]},command_id:{$ref:"#/$defs/WorkCommandId"},configuration_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},event_id:{type:"string"},evidence:{items:{$ref:"#/$defs/WorkProductEventEvidenceV1"},type:"array"},expected_graph_version:{format:"uint64",minimum:0,type:["integer","null"]},occurred_at:{$ref:"#/$defs/UtcMicros"},owner_scope:{$ref:"#/$defs/WorkProductProfileScopeV1"},payload:{$ref:"#/$defs/WorkProductEventPayloadV1"},policy_revision_id:{type:"string"},result_graph_version:{format:"uint64",minimum:0,type:"integer"},sequence:{format:"uint64",minimum:0,type:"integer"},source_watermark:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},type:"object"}},required:["event_id","sequence","actor_id","owner_scope","authorized_relation_scopes","result_graph_version","command_id","canonical_input_digest","evidence","source_watermark","occurred_at","policy_revision_id","configuration_revision_id","catalog_generation_id","payload"],type:"object"},$2={oneOf:[{additionalProperties:!1,properties:{authority:{const:"no_prior_graph",type:"string"}},required:["authority"],type:"object"},{additionalProperties:!1,properties:{authority:{const:"verified",type:"string"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["authority","verified_version"],type:"object"}]},$4={additionalProperties:!1,properties:{evidence:{items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},initiatives:{items:{$ref:"#/$defs/WorkInitiativeV1"},type:"array"},items:{items:{$ref:"#/$defs/WorkItemV1"},type:"array"},milestones:{items:{$ref:"#/$defs/WorkMilestoneV1"},type:"array"},plans:{items:{$ref:"#/$defs/WorkPlanV1"},type:"array"},proposal_decisions:{items:{$ref:"#/$defs/WorkProposalDecisionV1"},type:"array"},relation_replan_decisions:{items:{$ref:"#/$defs/WorkRelationReplanDecisionV1"},type:"array"},version:{format:"uint64",minimum:0,type:"integer"}},required:["version","initiatives","plans","milestones","items","proposal_decisions","relation_replan_decisions","evidence"],type:"object"},$6={additionalProperties:!1,properties:{causation_event_id:{type:["string","null"]},command_id:{$ref:"#/$defs/WorkCommandId"},evidence:{items:{$ref:"#/$defs/WorkProductEventEvidenceV1"},type:"array"},expected_authority:{$ref:"#/$defs/WorkProductExpectedAuthorityV1"},occurred_at:{$ref:"#/$defs/UtcMicros"},revisions:{$ref:"#/$defs/WorkProductRevisionPinsV1"}},required:["expected_authority","command_id","evidence","occurred_at","revisions"],type:"object"},$3={additionalProperties:!1,properties:{event:{$ref:"#/$defs/WorkProductEventV1"},replayed:{type:"boolean"},verified_graph_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["event","verified_graph_version","replayed"],type:"object"},$9={additionalProperties:!1,properties:{brain_id:{$ref:"#/$defs/BrainId"},profile_id:{$ref:"#/$defs/UserProfileId"}},required:["brain_id","profile_id"],type:"object"},$5={oneOf:[{properties:{initiative_id:{type:"string"},kind:{const:"initiative_contains_plan",type:"string"},plan_id:{type:"string"}},required:["kind","initiative_id","plan_id"],type:"object"},{properties:{kind:{const:"plan_contains_milestone",type:"string"},milestone_id:{type:"string"},plan_id:{type:"string"}},required:["kind","plan_id","milestone_id"],type:"object"},{properties:{kind:{const:"milestone_contains_task",type:"string"},milestone_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","milestone_id","task_id"],type:"object"},{properties:{dependency:{$ref:"#/$defs/TaskId"},dependent:{$ref:"#/$defs/TaskId"},kind:{const:"gates",type:"string"}},required:["kind","dependency","dependent"],type:"object"},{properties:{kind:{const:"informational",type:"string"},source:{$ref:"#/$defs/TaskId"},target:{$ref:"#/$defs/TaskId"}},required:["kind","source","target"],type:"object"},{properties:{cause:{$ref:"#/$defs/TaskId"},effect:{$ref:"#/$defs/TaskId"},kind:{const:"causal_candidate",type:"string"}},required:["kind","cause","effect"],type:"object"},{properties:{kind:{const:"evidence",type:"string"},link_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","link_id"],type:"object"},{properties:{identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},kind:{const:"accepted_attempt",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","identity"],type:"object"},{properties:{handoff_id:{type:"string"},kind:{const:"handoff",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","handoff_id"],type:"object"},{properties:{kind:{const:"proposal_decision",type:"string"},proposal_id:{$ref:"#/$defs/ProposalId"},task_id:{$ref:"#/$defs/TaskId"}},required:["kind","task_id","proposal_id"],type:"object"}]},$8={additionalProperties:!1,properties:{catalog_generation_id:{$ref:"#/$defs/CatalogGenerationId"},configuration_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},policy_revision_id:{type:"string"}},required:["policy_revision_id","configuration_revision_id","catalog_generation_id"],type:"object"},$7={description:"The exact owner-relative relation set selected for a canonical Work graph.\n\nThis identity lives in the domain because attempt admission must retain\nit byte-for-byte through provider settlement. Reconstructing it from a\nproject context would conflate explicit no-Git work with a scoped\nrepository relation.",oneOf:[{properties:{selection:{const:"profile_owned_no_git",type:"string"}},required:["selection"],type:"object"},{properties:{relation_scopes:{items:{$ref:"#/$defs/WorkProductAuthorizedRelationScopeV1"},type:"array",uniqueItems:!0},selection:{const:"relations",type:"string"}},required:["selection","relation_scopes"],type:"object"}]},Se={additionalProperties:!1,properties:{decided_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["proposal","disposition","decided_at"],type:"object"},St={enum:["accepted","rejected","superseded"],type:"string"},Sr={additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},children:{items:{$ref:"#/$defs/WorkProposedChildV1"},type:"array"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},explanation:{type:"string"},proposal_id:{$ref:"#/$defs/ProposalId"},route:{$ref:"#/$defs/WorkRouteDecisionV1"},shape:{$ref:"#/$defs/WorkShapeAssessmentV1"},sizing:{$ref:"#/$defs/WorkSizingV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["proposal_id","task_id","based_on_version","shape","sizing","children","route","explanation","evidence_digest","configuration_digest"],type:"object"},Si={additionalProperties:!1,properties:{dependencies:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},effort:{format:"uint32",minimum:0,type:"integer"},task_id:{$ref:"#/$defs/TaskId"},title:{type:"string"}},required:["task_id","title","effort","dependencies"],type:"object"},So={description:"Typed provider availability observed at negotiation. These are product\nstates, not transport errors: each one names why the configured native\nprovider could not run, without inventing a fallback.",oneOf:[{const:"absent",description:"No executable binding is configured for the pinned executable identity.",type:"string"},{const:"stale",description:"The configured binding no longer matches the pinned reference.",type:"string"},{const:"unsupported",description:"The configured binding does not admit the pinned backend/protocol.",type:"string"},{const:"digest_mismatch",description:"The on-disk executable bytes do not match the pinned digest.",type:"string"},{const:"unavailable",description:"The configured executable could not be read or is not executable.",type:"string"}]},Sn={description:"Provider protocol selected by the pinned Work configuration snapshot.",enum:["claude_code_cli","codex_app_server","codex_cli"],type:"string"},Sa={additionalProperties:!1,description:'Why an admitted attempt did not run on the backend its pinned execution\nsnapshot preferred.\n\nPlan 32 (`docs/plans/tracedecay-v2/32-dynamic-workflow-runtime-and-sdk.md`,\n"Native provider execution") admits the Codex CLI "only when app-server is\nunsupported or absent before session start and the pinned Plan 20 snapshot\nexplicitly allows that fallback", and the plan index requires that fallback\nto be "reported rather than hidden". This record is that report: it names\nthe preferred backend, the typed state that disqualified it, and the\nconfiguration-bounded fallback that was selected, so a fallback run can\nnever be read as a first choice.\n\nIt is also written when the fallback itself was refused, so a denial keeps\nboth failures instead of collapsing them into one state.',properties:{fallback_backend:{$ref:"#/$defs/WorkProviderBackendV1",description:"The backend named by the snapshot's configured fallback topology."},fallback_route:{$ref:"#/$defs/WorkProviderRouteV1",description:"The route that fallback runs on."},fallback_state:{anyOf:[{$ref:"#/$defs/WorkProviderAvailabilityV1"},{type:"null"}],description:"`None` when the fallback actually started; `Some(state)` when the\nfallback was itself refused."},preferred_backend:{$ref:"#/$defs/WorkProviderBackendV1",description:"The backend the pinned snapshot named first."},preferred_route:{$ref:"#/$defs/WorkProviderRouteV1",description:"The route that backend would have run on."},preferred_state:{$ref:"#/$defs/WorkProviderAvailabilityV1",description:"Why the preferred backend could not be used."}},required:["preferred_backend","preferred_route","preferred_state","fallback_backend","fallback_route"],type:"object"},Ss={enum:["claude_stream_json","codex_app_server_json_rpc","codex_exec_json"],type:"string"},Sd={description:"Strongly typed canonical identity: `WorkProviderRouteId`.",type:"string"},Sc={additionalProperties:!1,properties:{provider_id:{$ref:"#/$defs/ProviderId"},route_id:{$ref:"#/$defs/WorkProviderRouteId"}},required:["provider_id","route_id"],type:"object"},Sl={oneOf:[{properties:{state:{const:"fresh",type:"string"}},required:["state"],type:"object"},{properties:{checkpoint:{anyOf:[{$ref:"#/$defs/WorkArtifactRefV1"},{type:"null"}]},source_attempt_id:{$ref:"#/$defs/AttemptId"},state:{const:"resumed",type:"string"}},required:["state","source_attempt_id"],type:"object"},{properties:{reason:{$ref:"#/$defs/WorkRestartReasonV1"},source_attempt_id:{$ref:"#/$defs/AttemptId"},state:{const:"restarted",type:"string"}},required:["state","source_attempt_id","reason"],type:"object"},{description:"The attempt cannot continue and must be recovered. A first attempt\nlost before it ever resumed anything has no predecessor, so the source\nis absent rather than pointing at the attempt itself.",properties:{observed_at:{$ref:"#/$defs/UtcMicros"},reason:{$ref:"#/$defs/WorkRestartReasonV1"},source_attempt_id:{anyOf:[{$ref:"#/$defs/AttemptId"},{type:"null"}],default:null},state:{const:"recovery_required",type:"string"}},required:["state","reason","observed_at"],type:"object"}]},Sp={additionalProperties:!1,properties:{decided_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},proposal:{$ref:"#/$defs/WorkRelationReplanProposalV1"}},required:["proposal","disposition","decided_at"],type:"object"},Su={additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},causal_candidates:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},dependencies:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},informational_relations:{items:{$ref:"#/$defs/TaskId"},type:"array",uniqueItems:!0},payload_digest:{$ref:"#/$defs/ManifestDigest"},proposal_id:{$ref:"#/$defs/ProposalId"},task_id:{$ref:"#/$defs/TaskId"}},required:["proposal_id","task_id","based_on_version","dependencies","informational_relations","causal_candidates","payload_digest"],type:"object"},Sm={enum:["lease_lost","provider_unavailable","process_lost","failure_observed"],type:"string"},Sf={enum:["runtime_failure","restart_recovery_required"],type:"string"},Sh={additionalProperties:!1,description:"A selector into the owning runtime-terminal evidence authority.\n\n`evidence_ref` is an opaque local reference. The Work retry owner resolves\nit through [`WorkRetryEvidencePortV1`]; callers never submit the evidence\ndigest, outcome, or observation time that decides eligibility.",properties:{cause:{$ref:"#/$defs/WorkRetryCauseV1"},evidence_ref:{type:"string"},source:{$ref:"#/$defs/WorkRetrySourceV1"}},required:["source","cause","evidence_ref"],type:"object"},Sy={enum:["runtime"],type:"string"},Sg={additionalProperties:!1,description:"One eligible route supplied by the authorized configuration snapshot.\n\nThe application filters these candidates by the current request grant and\nverifies the exact pinned executable before policy evaluates them.",properties:{autonomy:{$ref:"#/$defs/WorkOrdinalBandV1"},content_location:{$ref:"#/$defs/WorkContentLocationClassV1"},correctness:{$ref:"#/$defs/WorkOrdinalBandV1"},cost:{$ref:"#/$defs/WorkOrdinalBandV1"},declared_budget_ceiling:{format:"uint64",minimum:0,type:"integer"},effort:{$ref:"#/$defs/WorkEffortClassV1"},evidence_quality:{$ref:"#/$defs/WorkOrdinalBandV1"},execution:{$ref:"#/$defs/WorkRouteExecutionProfileV1"},latency:{$ref:"#/$defs/WorkOrdinalBandV1"},model_id:{type:"string"},provider_capability_id:{type:"string"},route_id:{type:"string"},sensitive_data_fitness:{$ref:"#/$defs/WorkOrdinalBandV1"}},required:["route_id","provider_capability_id","model_id","effort","declared_budget_ceiling","content_location","correctness","sensitive_data_fitness","latency","cost","autonomy","evidence_quality","execution"],type:"object"},S_={oneOf:[{properties:{alternatives:{items:{$ref:"#/$defs/WorkProviderRouteV1"},type:"array"},decision:{const:"selected",type:"string"},exclusions:{items:{type:"string"},type:"array",uniqueItems:!0},fallback:{type:"string"},recommended:{$ref:"#/$defs/WorkProviderRouteV1"}},required:["decision","recommended","alternatives","exclusions","fallback"],type:"object"},{properties:{decision:{const:"abstained",type:"string"},reason:{type:"string"}},required:["decision","reason"],type:"object"}]},Sv={additionalProperties:!1,description:"Complete execution constraints configured for one provider route.\n\nThe route candidate is the configuration authority for these values. Work\nadmission copies them into the immutable execution snapshot; provider\nadapters never supply defaults.",properties:{approval:{$ref:"#/$defs/WorkApprovalPolicy"},credential_references:{items:{$ref:"#/$defs/CredentialReferenceId"},type:"array",uniqueItems:!0},egress:{$ref:"#/$defs/WorkEgressPolicy"},environment_allowlist:{items:{type:"string"},type:"array",uniqueItems:!0},fallback:{$ref:"#/$defs/WorkFallbackTopology"},filesystem:{$ref:"#/$defs/WorkFilesystemPolicy"},limits:{$ref:"#/$defs/WorkExecutionLimits"},maximum_duration_micros:{description:"Maximum elapsed time from execution admission to provider completion.",format:"uint64",minimum:0,type:"integer"},sandbox:{$ref:"#/$defs/WorkSandboxPolicy"}},required:["sandbox","approval","filesystem","egress","environment_allowlist","credential_references","limits","maximum_duration_micros","fallback"],type:"object"},Sb={description:"A monotonically versioned control authority.",format:"uint64",minimum:0,title:"WorkRunControlAuthorityV1",type:"integer"},S$={description:"Why a run was paused or resumed. A closed vocabulary keeps the reason out\nof free text so it can be read by a projection without being a prompt.",oneOf:[{const:"operator_request",description:"An authorized operator asked for the transition.",type:"string"},{const:"human_wait",description:"The run is waiting on a human approval or answer.",type:"string"},{const:"budget_exhausted",description:"The shared budget ledger is exhausted for now.",type:"string"},{const:"recovery",description:"Recovery or failover is reconciling the run.",type:"string"}],title:"WorkRunControlReasonV1"},SS={description:'The published control state of one run.\n\nThere is no `Cancelled` here: cancellation is an attempt-level authority\nowned through the lease fence, and duplicating it as a run state would\ncreate a second place a run could be "over".',oneOf:[{const:"running",description:"New reservations are admitted.",type:"string"},{const:"paused",description:"New reservations are fenced; committed evidence is preserved.",type:"string"}],title:"WorkRunControlStateV1"},Sk={additionalProperties:!1,description:"The run's deadline as of the last control transition.\n\n`remaining_micros` is the authority; `deadline` is the absolute instant that\nremaining resolves to while the run is running. Both are recorded so a\nreader never has to recompute one from a clock it does not trust.",properties:{checkpoint_at:{$ref:"#/$defs/UtcMicros",description:"The instant the checkpoint was taken."},deadline:{$ref:"#/$defs/UtcMicros",description:"The absolute deadline the run is measured against right now."},remaining_micros:{description:"Micros left against that deadline at `checkpoint_at`. Never negative,\nand never larger than the value the previous checkpoint carried.",format:"int64",type:"integer"}},required:["deadline","remaining_micros","checkpoint_at"],title:"WorkRunDeadlineCheckpointV1",type:"object"},Sw={enum:["required"],type:"string"},SP={enum:["ordinal","heuristic","calibrated_range"],type:"string"},SV={additionalProperties:!1,properties:{ambiguity:{format:"uint8",maximum:255,minimum:0,type:"integer"},blast_radius:{format:"uint8",maximum:255,minimum:0,type:"integer"},complexity:{format:"uint8",maximum:255,minimum:0,type:"integer"},integration_overhead:{format:"uint8",maximum:255,minimum:0,type:"integer"},score_kind:{$ref:"#/$defs/WorkScoreKindV1"}},required:["score_kind","complexity","ambiguity","blast_radius","integration_overhead"],type:"object"},SR={additionalProperties:!1,properties:{coverage:{type:"string"},high:{format:"uint32",minimum:0,type:"integer"},likely:{format:"uint32",minimum:0,type:"integer"},low:{format:"uint32",minimum:0,type:"integer"},score_kind:{$ref:"#/$defs/WorkScoreKindV1"}},required:["score_kind","low","likely","high","coverage"],type:"object"},Sq={additionalProperties:!1,description:"Succeeded sources grouped by the exact artifact digest list they produced.\nGroups are ordered largest first; smaller groups are the minority\nevidence, and more than one group is the disagreement, preserved as\nstructure instead of being resolved by fiat.",properties:{artifacts:{description:"The artifact digest list every source in this group produced.",items:{$ref:"#/$defs/ManifestDigest"},type:"array"},sources:{description:"The concurring sources, in the caller's requested order.",items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"}},required:["artifacts","sources"],type:"object"},SI={description:"Why a synthesis request was answered with the unsynthesized set instead\nof an admitted attempt.",oneOf:[{const:"no_citable_sources",description:"No source contributed a citable artifact: every source failed, was\ncancelled, timed out, is still unknown, or succeeded without\ndeclaring artifacts. There is nothing a synthesis could truthfully\ncite.",type:"string"}]},Sx={additionalProperties:!1,description:"One immutable source envelope: which attempt, and what it truthfully\ncontributed at admission time.",properties:{outcome:{$ref:"#/$defs/WorkSynthesisSourceOutcomeV1"},source:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["source","outcome"],type:"object"},Sj={description:"One sibling attempt's terminal contribution, captured verbatim from the\nWork authority at admission time.",oneOf:[{description:"The source succeeded; its declared artifact digests, in declaration\norder, are the evidence a synthesis may cite.",properties:{artifacts:{items:{$ref:"#/$defs/ManifestDigest"},type:"array"},outcome:{const:"succeeded",type:"string"}},required:["outcome","artifacts"],type:"object"},{description:"The source failed; its sealed terminal evidence digest is preserved\nso the failure stays visible in the synthesis record.",properties:{evidence:{$ref:"#/$defs/ManifestDigest"},outcome:{const:"failed",type:"string"}},required:["outcome","evidence"],type:"object"},{description:"The source timed out; preserved like a failure.",properties:{evidence:{$ref:"#/$defs/ManifestDigest"},outcome:{const:"timed_out",type:"string"}},required:["outcome","evidence"],type:"object"},{description:"The source was cancelled; preserved like a failure.",properties:{evidence:{$ref:"#/$defs/ManifestDigest"},outcome:{const:"cancelled",type:"string"}},required:["outcome","evidence"],type:"object"},{description:"The source has not reached a terminal state. The unknown is preserved\nas an unknown; it contributes no citable evidence and is never\nguessed at.",properties:{outcome:{const:"unknown",type:"string"},state:{$ref:"#/$defs/WorkAttemptStateV1"}},required:["outcome","state"],type:"object"}]},SC={additionalProperties:!1,description:"The ordered, digest-sealed source envelope set a synthesis admission\nconsumed. Reordering or mutating any envelope changes the digest, so a\nreplayed or tampered set is distinguishable from the admitted one.",properties:{set_digest:{$ref:"#/$defs/ManifestDigest",description:"Canonical digest over the ordered envelopes."},sources:{description:"The envelopes, exactly in the caller's requested order.",items:{$ref:"#/$defs/WorkSynthesisSourceEnvelopeV1"},type:"array"}},required:["sources","set_digest"],type:"object"},ST={additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},binding:{description:"Binds the continuation to the retrieve-evidence operation and the\nresult-shaping request fields the envelope does not echo.",type:"string"},participant_epoch:{$ref:"#/$defs/ManifestDigest"},ranking_cursor:{type:["string","null"]},source:{$ref:"#/$defs/ObservationSourceIdentityV1"},temporal_cursor:{type:["string","null"]},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["verified_version","attempt","source","participant_epoch","binding"],type:"object"},SO={oneOf:[{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"succeeded",type:"string"}},required:["outcome","evidence_digest","observed_at"],type:"object"},{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"failed",type:"string"}},required:["outcome","evidence_digest","observed_at"],type:"object"},{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"timed_out",type:"string"}},required:["outcome","evidence_digest","observed_at"],type:"object"},{properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"cancelled",type:"string"}},required:["outcome","evidence_digest","observed_at"],type:"object"}]},SE={description:"Strongly typed algorithm-tagged integrity digest: `WorkTopologyGenerationRefV1`.",type:"string"},SA={additionalProperties:!1,description:"Complete V1 policy. Partial values are intentionally impossible: callers\nmust provide the entire policy and validation rejects adapter-local defaults.",properties:{branch_naming:{$ref:"#/$defs/BranchNamingPolicyV1"},branch_topology:{$ref:"#/$defs/BranchTopologyPolicyV1"},concurrency:{$ref:"#/$defs/TopologyConcurrencyPolicyV1"},cross_merge:{$ref:"#/$defs/CrossMergePolicyV1"},escalation:{$ref:"#/$defs/TopologyEscalationPolicyV1"},gates:{$ref:"#/$defs/TopologyGatePolicyV1"},history_rewrite:{$ref:"#/$defs/HistoryRewritePolicyV1"},notifications:{$ref:"#/$defs/TopologyNotificationLevelV1"},placement:{$ref:"#/$defs/WorktreePlacementModeV1"},protected_refs:{items:{$ref:"#/$defs/ProtectedRefRuleV1"},type:"array"},retention:{$ref:"#/$defs/WorktreeRetentionPolicyV1"},review_topology:{$ref:"#/$defs/ReviewTopologyPolicyV1"},roots:{items:{$ref:"#/$defs/WorktreeRootPolicyV1"},type:"array"},schema_version:{format:"uint16",maximum:65535,minimum:0,type:"integer"}},required:["schema_version","placement","roots","branch_topology","review_topology","branch_naming","concurrency","cross_merge","gates","protected_refs","history_rewrite","escalation","retention","notifications"],type:"object"},SW={additionalProperties:!1,properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:0,type:"integer"},pinned_catalog_digest:{$ref:"#/$defs/ManifestDigest",description:"Must equal the live Work executable catalog digest. Validation and\nactivation report the current digest when this pin is stale."},pinned_configuration_digest:{$ref:"#/$defs/ManifestDigest"},pinned_policy_digest:{$ref:"#/$defs/ManifestDigest"},project_id:{$ref:"#/$defs/ProjectId"},steps:{items:{$ref:"#/$defs/WorkflowStep"},type:"array"}},required:["definition_id","definition_version","project_id","steps","pinned_policy_digest","pinned_configuration_digest","pinned_catalog_digest"],type:"object"},SM={description:"Strongly typed canonical identity: `WorkflowDefinitionId`.",type:"string"},SN={additionalProperties:!1,properties:{max_width:{format:"uint32",minimum:0,type:"integer"}},required:["max_width"],type:"object"},Sz={description:"Strongly typed canonical identity: `WorkflowOperationRef`.",type:"string"},SD={description:"Strongly typed canonical identity: `WorkflowOutputName`.",type:"string"},SF={additionalProperties:!1,properties:{output_name:{$ref:"#/$defs/WorkflowOutputName"},producer_step_id:{$ref:"#/$defs/WorkflowStepId"}},required:["producer_step_id","output_name"],type:"object"},SL={additionalProperties:!1,properties:{fan_out:{anyOf:[{$ref:"#/$defs/WorkflowFanOut"},{type:"null"}]},inputs:{items:{$ref:"#/$defs/WorkflowOutputReference"},type:"array"},operation:{$ref:"#/$defs/WorkflowOperationRef"},outputs:{items:{$ref:"#/$defs/WorkflowOutputName"},type:"array"},predecessors:{items:{$ref:"#/$defs/WorkflowStepId"},type:"array",uniqueItems:!0},step_id:{$ref:"#/$defs/WorkflowStepId"}},required:["step_id","operation","predecessors","inputs","outputs"],type:"object"},SU={description:"Strongly typed canonical identity: `WorkflowStepId`.",type:"string"},SH={additionalProperties:!1,description:"A provider's claim that one artifact of a fan-out output synthesizes its\nsibling source artifacts.",properties:{cited_source_digests:{description:"Content digests of every source artifact the synthesis consumed.",items:{$ref:"#/$defs/ManifestDigest"},type:"array",uniqueItems:!0},output_name:{$ref:"#/$defs/WorkflowOutputName",description:"The fan-out output the synthesis belongs to."},synthesis_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1",description:"The attempt that produced the synthesis artifact inside that output."}},required:["output_name","synthesis_attempt","cited_source_digests"],type:"object"},SG={enum:["require_clean","allow_untracked_only_for_preflight","read_only_preflight_only"],type:"string"},SB={description:"Strongly typed canonical identity: `WorktreeId`.",type:"string"},SK={description:"Monotonic epoch of the worktree inventory frozen into a stack revision.",format:"uint64",minimum:0,type:"integer"},SJ={description:"Strongly typed canonical identity: `WorktreeInventorySnapshotId`.",type:"string"},SZ={oneOf:[{properties:{kind:{const:"existing_worktree_only",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"sibling_of_primary_checkout",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"repository_local_root",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"configured_root",type:"string"},root_id:{type:"string"}},required:["kind","root_id"],type:"object"}]},SQ={additionalProperties:!1,properties:{abandoned_retention_seconds:{format:"uint64",minimum:1,type:["integer","null"]},automatic_gc:{$ref:"#/$defs/AutomaticWorktreeGcV1"},maximum_retained_per_repository:{format:"uint16",maximum:65535,minimum:1,type:["integer","null"]},terminal_retention_seconds:{format:"uint64",minimum:1,type:["integer","null"]}},required:["automatic_gc"],type:"object"},SX={additionalProperties:!1,properties:{locator:{$ref:"#/$defs/SensitiveFilesystemLocatorV1"},maximum_active_worktrees:{format:"uint16",maximum:65535,minimum:1,type:"integer"},repository_scope:{$ref:"#/$defs/RepositoryPlacementScopeV1"},root_id:{type:"string"}},required:["root_id","locator","repository_scope","maximum_active_worktrees"],type:"object"},SY=[{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,title:"ActiveProjectSurfaceRequestV1",type:"object"},{$defs:{ActiveProjectBranchV1:{additionalProperties:!1,properties:{branch_drifted:{type:"boolean"},branch_resolution:{type:"string"},current_branch:{type:["string","null"]},open_active_branch:{type:["string","null"]},serving_branch:{type:["string","null"]},tracked_branch_count:{format:"uint",minimum:0,type:"integer"},warnings:{items:{type:"string"},type:"array"}},required:["branch_resolution","branch_drifted","tracked_branch_count","warnings"],type:"object"},ActiveProjectResolutionSourceV1:{enum:["active_project"],type:"string"},ActiveProjectStorageV1:{additionalProperties:!1,properties:{class:{type:"string"},data_root:{type:"string"},graph_db_exists:{type:"boolean"},graph_db_path:{type:"string"},graph_db_size_bytes:{format:"uint64",minimum:0,type:"integer"},lcm_payload_root:{type:"string"},mode:{type:"string"},response_handle_root:{type:"string"},sessions_db_path:{type:"string"}},required:["class","mode","data_root","graph_db_path","graph_db_exists","graph_db_size_bytes","sessions_db_path","response_handle_root","lcm_payload_root"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The resolved active project of this MCP session.",properties:{branch:{$ref:"#/$defs/ActiveProjectBranchV1"},project_id:{type:["string","null"]},project_root:{type:"string"},repository_id:{type:"string"},resolution_source:{$ref:"#/$defs/ActiveProjectResolutionSourceV1"},scope_prefix:{type:["string","null"]},storage:{$ref:"#/$defs/ActiveProjectStorageV1"}},required:["repository_id","project_root","resolution_source","storage","branch"],title:"ActiveProjectResultV1",type:"object"},{$defs:{AdminCliScopeV1:{description:"What a cost or analytics action reads: the served project's ledgers and\nsessions, or the whole profile's.",enum:["project","profile"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,description:"Savings and provider-usage cost over `range` (`today`, `7d`, ...).",properties:{action:{const:"cost_summary",type:"string"},range:{type:"string"},scope:{$ref:"#/$defs/AdminCliScopeV1"}},required:["action","range","scope"],type:"object"},{additionalProperties:!1,description:"Import every host's transcripts into the project's session store.",properties:{action:{const:"sessions_import",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"Converge project sessions with Git history.",properties:{action:{const:"sessions_git_sync",type:"string"},dry_run:{type:"boolean"},limit_sessions:{format:"uint",minimum:0,type:"integer"},since:{format:"int64",type:"integer"}},required:["action","since","limit_sessions","dry_run"],type:"object"},{additionalProperties:!1,properties:{action:{const:"sessions_sync_status",type:"string"},idempotency_key:{type:"string"}},required:["action","idempotency_key"],type:"object"},{additionalProperties:!1,properties:{action:{const:"sessions_sync_cancel",type:"string"},idempotency_key:{type:"string"}},required:["action","idempotency_key"],type:"object"},{additionalProperties:!1,properties:{action:{const:"sessions_unfinished",type:"string"},limit:{format:"uint",minimum:0,type:"integer"}},required:["action","limit"],type:"object"},{additionalProperties:!1,description:"Import hook analytics JSONL into the accounting ledger.",properties:{action:{const:"analytics_sync",type:"string"},scope:{$ref:"#/$defs/AdminCliScopeV1"}},required:["action","scope"],type:"object"},{additionalProperties:!1,properties:{action:{const:"analytics_diagnostics",type:"string"},all:{type:"boolean"},no_sync:{type:"boolean"},scope:{$ref:"#/$defs/AdminCliScopeV1"}},required:["action","scope","all","no_sync"],type:"object"},{additionalProperties:!1,description:"Record the served project's saved-token total.",properties:{action:{const:"registry_update",type:"string"},tokens:{format:"uint64",minimum:0,type:"integer"}},required:["action","tokens"],type:"object"},{additionalProperties:!1,properties:{action:{const:"registry_list",type:"string"},limit:{format:"uint",minimum:0,type:"integer"},project_arg:{description:"Checkout to mark active when the caller's connection names no\nproject.",type:["string","null"]},query:{type:["string","null"]}},required:["action","limit"],type:"object"},{additionalProperties:!1,properties:{action:{const:"registry_context",type:"string"},project_arg:{description:"Project path or alias; the caller's project when omitted.",type:["string","null"]}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"registry_empty",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"registry_project_tokens",type:"string"},project_args:{items:{type:"string"},type:"array"}},required:["action","project_args"],type:"object"},{additionalProperties:!1,description:"Plan, or with `apply` execute, collection of registry rows whose\ncheckout is gone.",properties:{action:{const:"registry_gc",type:"string"},apply:{type:"boolean"},prefix:{type:["string","null"]}},required:["action","apply"],type:"object"},{additionalProperties:!1,description:"One project's storage (`project_id` with `project_root`), or one page\nof the profile's.",properties:{action:{const:"storage_report",type:"string"},cursor:{default:null,type:["string","null"]},limit:{default:8,format:"uint",minimum:0,type:"integer"},project_id:{type:["string","null"]},project_root:{type:["string","null"]}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"gain_query",type:"string"},history:{type:"boolean"},project_arg:{type:["string","null"]},since:{format:"int64",type:"integer"}},required:["action","since","history"],type:"object"}],title:"AdminCliSurfaceRequestV1"},{$defs:{AdminCliAnalyticsImportV1:{additionalProperties:!1,properties:{imported:{format:"uint64",minimum:0,type:"integer"},sources:{description:"One row per hook JSONL source: `path`, `imported`, `skipped`, `error`.",items:!0,type:"array"}},required:["imported","sources"],type:"object"},AdminCliCostSummaryV1:{additionalProperties:!1,properties:{range:{type:"string"},summary:{$ref:"#/$defs/AdminCliCostTotalsV1"},today:{$ref:"#/$defs/AdminCliCostTodayV1"}},required:["range","summary","today"],type:"object"},AdminCliCostTodayV1:{additionalProperties:!1,properties:{provider_usage:!0},required:["provider_usage"],type:"object"},AdminCliCostTotalsV1:{additionalProperties:!1,properties:{efficiency_ratio:{description:"Saved over saved-plus-consumed; null when consumption is unmeasured.",format:"double",type:["number","null"]},provider_usage:{description:"The provider-usage cost summary as the session memory prices it."},tokens_saved:{format:"uint64",minimum:0,type:"integer"}},required:["provider_usage","tokens_saved"],type:"object"},AdminCliGainDayV1:{additionalProperties:!1,properties:{calls:{format:"uint64",minimum:0,type:"integer"},day:{description:"Start-of-day epoch seconds (UTC).",format:"int64",type:"integer"},saved_tokens:{format:"uint64",minimum:0,type:"integer"}},required:["day","saved_tokens","calls"],type:"object"},AdminCliGainHistoryV1:{additionalProperties:!1,properties:{history:{items:{$ref:"#/$defs/AdminCliGainDayV1"},type:"array"}},required:["history"],type:"object"},AdminCliGainTotalV1:{additionalProperties:!1,properties:{calls:{format:"uint64",minimum:0,type:"integer"},saved_tokens:{format:"uint64",minimum:0,type:"integer"}},required:["saved_tokens","calls"],type:"object"},AdminCliProjectTokenTotalV1:{additionalProperties:!1,description:"A project whose ledger could not be read reports a null total and the\nreason, never a measured zero.",properties:{error:{type:["string","null"]},project:{type:"string"},tokens:{format:"uint64",minimum:0,type:["integer","null"]}},required:["project"],type:"object"},AdminCliProjectTokensV1:{additionalProperties:!1,properties:{projects:{items:{$ref:"#/$defs/AdminCliProjectTokenTotalV1"},type:"array"}},required:["projects"],type:"object"},AdminCliRegistryContextV1:{oneOf:[{additionalProperties:!1,properties:{aliases:{description:"Alias rows exactly as the registry serializes them.",items:!0,type:"array"},profile_id:{type:"string"},project:{$ref:"#/$defs/PublicCodeProject"},status:{const:"ok",type:"string"},stores:{description:"Store rows exactly as the registry serializes them.",items:!0,type:"array"}},required:["status","profile_id","project","aliases","stores"],type:"object"},{additionalProperties:!1,description:"The call named no project and its connection has none.",properties:{project:{type:"null"},status:{const:"invalid",type:"string"}},required:["status","project"],type:"object"},{additionalProperties:!1,properties:{project:{type:"null"},status:{const:"not_found",type:"string"}},required:["status","project"],type:"object"}]},AdminCliRegistryEmptyV1:{additionalProperties:!1,properties:{empty:{type:"boolean"}},required:["empty"],type:"object"},AdminCliRegistryGcV1:{additionalProperties:!1,description:"The registry collection plan, with its deletion counters filled when it\nwas applied.",properties:{apply:{type:"boolean"},candidate_count:{format:"uint",minimum:0,type:"integer"},candidate_paths:{items:{type:"string"},type:"array"},candidates:{description:"Registry project rows exactly as the registry serializes them.",items:!0,type:"array"},code_project_candidate_count:{format:"uint",minimum:0,type:"integer"},deleted_code_project_count:{format:"uint",minimum:0,type:"integer"},deleted_count:{format:"uint",minimum:0,type:"integer"},deleted_storage_project_count:{format:"uint",minimum:0,type:"integer"},metadata_candidate_count:{format:"uint",minimum:0,type:"integer"},prefix:{type:["string","null"]},protected_code_project_count:{format:"uint",minimum:0,type:"integer"},protected_code_projects:{items:!0,type:"array"},storage_project_candidate_count:{format:"uint",minimum:0,type:"integer"},storage_project_candidates:{items:{type:"string"},type:"array"}},required:["apply","candidate_count","metadata_candidate_count","code_project_candidate_count","storage_project_candidate_count","protected_code_project_count","deleted_count","deleted_code_project_count","deleted_storage_project_count","candidate_paths","candidates","protected_code_projects","storage_project_candidates"],type:"object"},AdminCliRegistryListV1:{oneOf:[{additionalProperties:!1,properties:{limit:{format:"uint",minimum:0,type:"integer"},project_tree:{items:{$ref:"#/$defs/ProjectRepoGroup"},type:"array"},projects:{items:{$ref:"#/$defs/PublicCodeProject"},type:"array"},query:{type:["string","null"]},status:{const:"ok",type:"string"},summary:{$ref:"#/$defs/ProjectRegistrySummary"},truncated:{type:"boolean"}},required:["status","limit","truncated","summary","project_tree","projects"],type:"object"}]},AdminCliRegistryUpdateV1:{additionalProperties:!1,properties:{current:{format:"uint64",minimum:0,type:"integer"},previous:{description:"The total before this write; null when the ledger could not be read.",format:"uint64",minimum:0,type:["integer","null"]},previous_error:{type:["string","null"]}},required:["current"],type:"object"},AdminCliSessionSyncV1:{description:"The daemon session-sync owner's answer.",oneOf:[{additionalProperties:!1,properties:{accepted_at:{$ref:"#/$defs/UtcMicros"},idempotency_key:{type:"string"},operation_id:{type:"string"},status:{const:"accepted",type:"string"}},required:["status","operation_id","idempotency_key","accepted_at"],type:"object"},{additionalProperties:!1,description:"An identical sync was already running; this call joined it.",properties:{accepted_at:{$ref:"#/$defs/UtcMicros"},idempotency_key:{type:"string"},operation_id:{type:"string"},status:{const:"joined",type:"string"}},required:["status","operation_id","idempotency_key","accepted_at"],type:"object"},{additionalProperties:!1,properties:{coalesced_primary:{type:["string","null"]},completed_at:{$ref:"#/$defs/UtcMicros"},coverage:{items:{$ref:"#/$defs/SessionSyncSourceCoverageV1"},type:"array"},failure_codes:{items:{type:"string"},type:"array"},idempotency_key:{type:"string"},operation_id:{type:"string"},source:{$ref:"#/$defs/SessionSyncSourceV1"},source_frontiers:{items:{$ref:"#/$defs/SessionSyncSourceFrontierV1"},type:"array"},stats:{$ref:"#/$defs/SessionSyncStatsV1"},status:{const:"complete",type:"string"},termination:{$ref:"#/$defs/OperationTermination"}},required:["status","operation_id","idempotency_key","source","termination","stats","coverage","source_frontiers","failure_codes","completed_at"],type:"object"},{additionalProperties:!1,properties:{status:{const:"cancelled",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{status:{const:"deadline_exceeded",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{status:{const:"wrong_scope",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{reason_code:{type:"string"},status:{const:"unavailable",type:"string"}},required:["status","reason_code"],type:"object"}]},AdminCliStorageReportV1:{additionalProperties:!1,description:"One storage report page, or one project's report.",properties:{code_generation_retention:{items:!0,type:"array"},code_generation_retention_availability:{items:!0,type:"array"},coverage:!0,full_profile_size:!0,global_db_bytes:{format:"uint64",minimum:0,type:"integer"},profile_root:{type:"string"},stores:{description:"Report rows exactly as the retention report serializes them.",items:!0,type:"array"},unregistered_bytes:{format:"uint64",minimum:0,type:"integer"},unregistered_dir_count:{format:"uint",minimum:0,type:"integer"},user_sessions_db_bytes:{default:0,format:"uint64",minimum:0,type:"integer"}},required:["profile_root","stores","code_generation_retention","code_generation_retention_availability","unregistered_dir_count","unregistered_bytes","global_db_bytes","coverage"],type:"object"},AdminCliUnfinishedSessionsV1:{additionalProperties:!1,properties:{items:{description:"Workflow state rows exactly as the session store serializes them.",items:!0,type:"array"}},required:["items"],type:"object"},OperationTermination:_L,ProjectRegistryEntry:_6,ProjectRegistrySummary:_3,ProjectRepoGroup:_9,PublicCodeProject:va,SessionSyncCoverageV1:{oneOf:[{properties:{outcome:{const:"complete",type:"string"}},required:["outcome"],type:"object"},{properties:{deferred_units:{format:"uint64",minimum:0,type:"integer"},outcome:{const:"partial",type:"string"}},required:["outcome","deferred_units"],type:"object"},{properties:{admitted_units:{format:"uint64",minimum:0,type:"integer"},outcome:{const:"backpressured",type:"string"},rejected_units:{format:"uint64",minimum:0,type:"integer"}},required:["outcome","admitted_units","rejected_units"],type:"object"}]},SessionSyncSourceCoverageV1:{properties:{coverage:{$ref:"#/$defs/SessionSyncCoverageV1"},store_scope:{type:"string"}},required:["store_scope","coverage"],type:"object"},SessionSyncSourceFrontierV1:{description:"Exact canonical observation cursor committed by one source/store authority.",properties:{committed_cursor_json:{type:"string"},scope_json:{type:"string"},source_json:{type:"string"},store_scope:{type:"string"}},required:["store_scope","source_json","scope_json","committed_cursor_json"],type:"object"},SessionSyncSourceV1:{description:"The command that started a session sync, without its options.",oneOf:[{const:"import_transcripts",description:"Hands its remaining historical catch-up to the background refresh\nworkers.",type:"string"},{const:"synchronize_git",description:"A bounded foreground pass; nothing resumes its unfinished coverage.",type:"string"}]},SessionSyncStatsV1:{properties:{commits_attributed:{format:"uint64",minimum:0,type:"integer"},messages_imported:{format:"uint64",minimum:0,type:"integer"},sessions_imported:{format:"uint64",minimum:0,type:"integer"},sessions_scanned:{format:"uint64",minimum:0,type:"integer"},skipped:{format:"uint64",minimum:0,type:"integer"},spans_written:{format:"uint64",minimum:0,type:"integer"}},required:["sessions_imported","messages_imported","sessions_scanned","spans_written","commits_attributed","skipped"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/AdminCliCostSummaryV1"},{$ref:"#/$defs/AdminCliSessionSyncV1"},{$ref:"#/$defs/AdminCliUnfinishedSessionsV1"},{$ref:"#/$defs/AdminCliAnalyticsImportV1"},{$ref:"#/$defs/AdminCliRegistryUpdateV1"},{$ref:"#/$defs/AdminCliRegistryListV1"},{$ref:"#/$defs/AdminCliRegistryContextV1"},{$ref:"#/$defs/AdminCliRegistryEmptyV1"},{$ref:"#/$defs/AdminCliProjectTokensV1"},{$ref:"#/$defs/AdminCliRegistryGcV1"},{$ref:"#/$defs/AdminCliStorageReportV1"},{$ref:"#/$defs/AdminCliGainHistoryV1"},{$ref:"#/$defs/AdminCliGainTotalV1"},{description:"The diagnostics report is the analytics bridge's open document; it\ndecodes last so it never claims another action's body."}],description:"One action's answer.",title:"AdminCliResultV1"},{$defs:{AutomaticFactReceiptStateV1:fD,AutomationReconcileScope:fG},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Every action is a struct variant: an internally tagged unit variant would\nignore keys beside its tag instead of refusing them.",oneOf:[{additionalProperties:!1,description:"Read the project's local usage counter.",properties:{action:{const:"counter_get",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"Reset the project's local usage counter to zero.",properties:{action:{const:"counter_reset",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"Record the project's saved-token total in the profile registry and\nread it back beside the other projects' total.",properties:{action:{const:"status_accounting",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"List terminal automatic-fact receipts.",properties:{action:{const:"automatic_fact_receipt_list",type:"string"},limit:{format:"uint",minimum:0,type:"integer"},state:{anyOf:[{$ref:"#/$defs/AutomaticFactReceiptStateV1"},{type:"null"}],description:"Only receipts in this state (default: every state)."}},required:["action","limit"],type:"object"},{additionalProperties:!1,description:"Read one automatic-fact receipt by its apply id.",properties:{action:{const:"automatic_fact_receipt_view",type:"string"},id:{type:"string"}},required:["action","id"],type:"object"},{additionalProperties:!1,description:"Reconcile automation schedulers with the saved configuration.",properties:{action:{const:"automation_reconcile",type:"string"},scope:{$ref:"#/$defs/AutomationReconcileScope"}},required:["action","scope"],type:"object"}],title:"AdminProjectSurfaceRequestV1"},{$defs:{AdminProjectCounterResetV1:{additionalProperties:!1,properties:{reset:{description:"Always true: a reset that did not settle is a refusal.",type:"boolean"}},required:["reset"],type:"object"},AdminProjectCounterV1:{additionalProperties:!1,properties:{counter:{format:"uint64",minimum:0,type:"integer"}},required:["counter"],type:"object"},AdminProjectStatusAccountingV1:{additionalProperties:!1,properties:{global_tokens_saved:{description:"Tokens the profile's other projects saved; null when they saved none.",format:"uint64",minimum:0,type:["integer","null"]},tokens_saved:{format:"uint64",minimum:0,type:"integer"}},required:["tokens_saved"],type:"object"},AutomaticFactAddRequestV1:{additionalProperties:!1,description:"The add-fact request an automatic apply recorded.",properties:{category:{$ref:"#/$defs/FactCategoryV1"},content:{type:"string"},entities:{items:{type:"string"},type:"array"},metadata:!0,source_label:{type:["string","null"]},tags:{items:{type:"string"},type:"array"},trust:{format:"double",type:"number"}},required:["content","category","tags","entities","trust","metadata"],type:"object"},AutomaticFactEvidenceV1:{additionalProperties:!1,description:"Automation evidence retained with the receipt.",properties:{evidence_hash:{type:["string","null"]},item:!0,validation:!0},type:"object"},AutomaticFactReceiptAvailabilityV1:{oneOf:[{additionalProperties:!1,properties:{state:{const:"available",type:"string"}},required:["state"],type:"object"}]},AutomaticFactReceiptListV1:{additionalProperties:!1,properties:{availability:{$ref:"#/$defs/AutomaticFactReceiptAvailabilityV1"},count:{format:"uint",minimum:0,type:"integer"},next_after_apply_id:{description:"Continue after this apply id; null on the last page.",type:["string","null"]},receipts:{items:{$ref:"#/$defs/AutomaticFactReceiptV1"},type:"array"}},required:["availability","count","receipts"],type:"object"},AutomaticFactReceiptStateV1:fD,AutomaticFactReceiptV1:{additionalProperties:!1,description:"One terminal automatic-fact apply receipt.",properties:{add_fact_request:{$ref:"#/$defs/AutomaticFactAddRequestV1"},applied_fact_id:{description:"Present when the fact was applied.",type:["string","null"]},apply_id:{type:"string"},evidence:{$ref:"#/$defs/AutomaticFactEvidenceV1"},operation_id:{type:"string"},quarantine_reason:{description:"Present when the fact was quarantined.",type:["string","null"]},recorded_at_micros:{format:"int64",type:"integer"},state:{$ref:"#/$defs/AutomaticFactReceiptStateV1"}},required:["apply_id","state","operation_id","add_fact_request","evidence","recorded_at_micros"],type:"object"},AutomaticFactReceiptViewV1:{additionalProperties:!1,properties:{receipt:{$ref:"#/$defs/AutomaticFactReceiptV1"}},required:["receipt"],type:"object"},AutomationReconcileScope:fG,AutomationSchedulerOwnerReconcileOutcome:{additionalProperties:!1,properties:{graph_db_path:{type:"string"},outcome:{$ref:"#/$defs/AutomationSchedulerReconcileOutcome"},project_id:{type:["string","null"]},scope_prefix:{type:["string","null"]},store_root:{type:"string"}},required:["store_root","graph_db_path","outcome"],type:"object"},AutomationSchedulerReconcileOutcome:{description:"What reconciling one automation scheduler did.",enum:["started","running_notified","exiting","finished","retiring","not_configured","lifecycle_inactive","owner_unavailable"],type:"string"},FactCategoryV1:yA,ProfileAutomationReconcileReport:{additionalProperties:!1,description:"Every cached project scheduler of the profile, reconciled.",properties:{cached_owners:{format:"uint",minimum:0,type:"integer"},outcomes:{items:{$ref:"#/$defs/AutomationSchedulerOwnerReconcileOutcome"},type:"array"},scope:{$ref:"#/$defs/AutomationReconcileScope",description:"Always `profile`."},uncached_projects:{$ref:"#/$defs/UncachedProjectReconcileOutcome"}},required:["scope","cached_owners","outcomes","uncached_projects"],type:"object"},ProjectAutomationReconcileReport:{additionalProperties:!1,description:"The served project's scheduler reconcile.",properties:{outcome:{$ref:"#/$defs/AutomationSchedulerReconcileOutcome"},scope:{$ref:"#/$defs/AutomationReconcileScope",description:"Always `project`."}},required:["scope","outcome"],type:"object"},UncachedProjectReconcileOutcome:{description:"A project whose scheduler is not cached reconciles when it next starts.",enum:["deferred_until_project_startup"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/AdminProjectCounterV1"},{$ref:"#/$defs/AdminProjectCounterResetV1"},{$ref:"#/$defs/AdminProjectStatusAccountingV1"},{$ref:"#/$defs/AutomaticFactReceiptListV1"},{$ref:"#/$defs/AutomaticFactReceiptViewV1"},{$ref:"#/$defs/ProjectAutomationReconcileReport"},{$ref:"#/$defs/ProfileAutomationReconcileReport"}],description:"One action's result, in the shape the action has always answered.",title:"AdminProjectResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"`tracedecay_admin_sync` takes no arguments: it reconciles the served\nproject.",title:"AdminSyncSurfaceRequestV1",type:"object"},{$defs:{AdminSyncAdmissionV1:{description:"The code-index scheduler's admission of the reconcile.",oneOf:[{enum:["queued"],type:"string"},{const:"not_applicable",description:"Code indexing does not apply to this project.",type:"string"}]},AdminSyncReconcileScopeV1:{description:"What the reconcile covers.",enum:["authoritative_project"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{project_root:{type:"string"},reconcile_scope:{$ref:"#/$defs/AdminSyncReconcileScopeV1"},status:{$ref:"#/$defs/AdminSyncAdmissionV1"}},required:["reconcile_scope","status","project_root"],title:"AdminSyncResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{depth:{description:"Maximum dependency traversal depth (default: 5, at most 10).",format:"uint32",minimum:0,type:["integer","null"]},files:{description:"List of changed file paths to analyze.",items:{type:"string"},type:"array"},filter:{description:"Custom glob pattern for test files (default: common test patterns).",type:["string","null"]}},required:["files"],title:"AffectedSurfaceRequestV1",type:"object"},{$defs:{AffectedRankingMetadataV1:{additionalProperties:!1,properties:{distance:{type:"string"},recommended_proximity:{items:{type:"string"},type:"array"},strategy:{type:"string"}},required:["strategy","distance","recommended_proximity"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RankedAffectedTestV1:{additionalProperties:!1,properties:{distance:{format:"uint",minimum:0,type:"integer"},path:{type:"string"},proximity:{type:"string"},rank:{format:"uint",minimum:0,type:"integer"}},required:["path","rank","distance","proximity"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{changed_files:{items:{type:"string"},type:"array"},count:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ranked_tests:{items:{$ref:"#/$defs/RankedAffectedTestV1"},type:"array"},ranking_metadata:{$ref:"#/$defs/AffectedRankingMetadataV1"},recommended_tests:{description:"Tests within two dependency hops of a changed file.",items:{type:"string"},type:"array"}},required:["changed_files","count","ranked_tests","recommended_tests","ranking_metadata"],title:"AffectedResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Opaque daemon-minted handle accepted by the first feedback read invocation.",properties:{request_handle:{type:"string"}},required:["request_handle"],title:"FeedbackHandleRequestV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,FeedbackContentIdentityV1:y0,FeedbackCycleId:y2,FeedbackImpactStateV1:gr,FeedbackResultId:go,FeedbackScopeV1:gn,FeedbackTargetV1:ga,FileOccurrenceId:gs,HostInstanceId:gL,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Canonical affected-tests projection returned by `affected_tests`.",properties:{affected_tests:{items:{$ref:"#/$defs/SymbolOccurrenceId"},type:"array"},content_identity:{anyOf:[{$ref:"#/$defs/FeedbackContentIdentityV1"},{type:"null"}]},cycle_id:{$ref:"#/$defs/FeedbackCycleId"},evidence_anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},result_id:{$ref:"#/$defs/FeedbackResultId"},scope:{$ref:"#/$defs/FeedbackScopeV1"},state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},target:{anyOf:[{$ref:"#/$defs/FeedbackTargetV1"},{type:"null"}]}},required:["result_id","cycle_id","scope","affected_tests","evidence_anchors"],title:"CanonicalAffectedTestsProjectionV1",type:"object"},{$defs:{AnalyticsScopeV1:fP,AnalyticsSectionV1:{enum:["tools","hints","facts","automation"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope:{anyOf:[{$ref:"#/$defs/AnalyticsScopeV1"},{type:"null"}],description:'"project" (default) scopes analytics_events to the resolved project;\n"all" reports across every registered project.'},section:{anyOf:[{$ref:"#/$defs/AnalyticsSectionV1"},{type:"null"}],description:"Optional filter to a single section. Omit to return all sections."},window_days:{description:"Lookback window in days for events and automation runs (default: 14,\n1-365).",format:"uint32",maximum:365,minimum:1,type:["integer","null"]}},title:"AnalyticsSurfaceRequestV1",type:"object"},{$defs:{AnalyticsAutomationJobOutcomesV1:{additionalProperties:!1,properties:{failed:{format:"int64",type:"integer"},job:{type:"string"},other:{format:"int64",type:"integer"},skipped:{format:"int64",type:"integer"},succeeded:{format:"int64",type:"integer"}},required:["job","succeeded","failed","skipped","other"],type:"object"},AnalyticsAutomationOutcomesV1:{additionalProperties:!1,description:"`available` is always `true`.",properties:{available:{type:"boolean"},by_job:{items:{$ref:"#/$defs/AnalyticsAutomationJobOutcomesV1"},type:"array"},dashboard_root:{type:"string"},records_considered:{format:"uint",minimum:0,type:"integer"},records_in_window:{format:"uint",minimum:0,type:"integer"},records_truncated:{type:"boolean"}},required:["available","dashboard_root","records_considered","records_in_window","records_truncated","by_job"],type:"object"},AnalyticsAutomationSectionV1:{anyOf:[{$ref:"#/$defs/AnalyticsAutomationOutcomesV1"},{$ref:"#/$defs/AnalyticsLedgerUnavailableV1"},{$ref:"#/$defs/AnalyticsSectionUnavailableV1"}],description:"The automation run outcomes of the resolved project's ledger, or why the\nledger is unavailable."},AnalyticsCanonicalCallNameV1:{additionalProperties:!1,description:"A recorded event name that resolved to a canonical tool under another\nspelling.",properties:{calls:{format:"int64",type:"integer"},canonical_tool_name:{type:"string"},errors:{format:"int64",type:"integer"},event_name:{type:"string"}},required:["event_name","canonical_tool_name","calls","errors"],type:"object"},AnalyticsEventCallNameV1:{additionalProperties:!1,description:"A recorded event name with no advertised canonical tool.",properties:{calls:{format:"int64",type:"integer"},errors:{format:"int64",type:"integer"},event_name:{type:"string"}},required:["event_name","calls","errors"],type:"object"},AnalyticsFactFunnelV1:{additionalProperties:!1,description:"`available` is always `true`.",properties:{available:{type:"boolean"},facts:{format:"uint64",minimum:0,type:"integer"},facts_rated:{format:"uint64",minimum:0,type:"integer"},facts_retrieved:{format:"uint64",minimum:0,type:"integer"},helpful_feedback:{format:"uint64",minimum:0,type:"integer"},project_root:{type:"string"},retrievals:{format:"uint64",minimum:0,type:"integer"},unhelpful_feedback:{format:"uint64",minimum:0,type:"integer"}},required:["available","project_root","facts","retrievals","facts_retrieved","helpful_feedback","unhelpful_feedback","facts_rated"],type:"object"},AnalyticsFactsSectionV1:{anyOf:[{$ref:"#/$defs/AnalyticsFactFunnelV1"},{$ref:"#/$defs/AnalyticsProjectSectionUnavailableV1"},{$ref:"#/$defs/AnalyticsSectionUnavailableV1"}],description:"The fact-store funnel of the resolved project, or why it is unavailable.\n\nThe variants are distinguished by their exact field sets, so each one\ndenies unknown fields and the most specific shape is tried first."},AnalyticsHintCategoryV1:{properties:{category:{type:"string"},emitted:{format:"int64",type:"integer"},followed:{format:"int64",type:"integer"},ignored:{format:"int64",type:"integer"},suppressed:{format:"int64",type:"integer"}},required:["category","emitted","followed","ignored","suppressed"],type:"object"},AnalyticsHintsPayloadV1:{properties:{available:{type:"boolean"},by_category:{items:{$ref:"#/$defs/AnalyticsHintCategoryV1"},type:"array"},error:{default:null,type:["string","null"]},source:{type:"string"}},required:["available","source","by_category"],type:"object"},AnalyticsLedgerUnavailableV1:{additionalProperties:!1,description:"The ledger exists but failed to read. `available` is always `false`.",properties:{available:{type:"boolean"},dashboard_root:{type:"string"},reason:{type:"string"}},required:["available","reason","dashboard_root"],type:"object"},AnalyticsModeReadModelV1:fk,AnalyticsModeV1:fw,AnalyticsProjectSectionUnavailableV1:{additionalProperties:!1,description:"A project-scoped section whose store failed to read. `available` is\nalways `false`.",properties:{available:{type:"boolean"},project_root:{type:"string"},reason:{type:"string"}},required:["available","reason","project_root"],type:"object"},AnalyticsReportStatusV1:{description:"The settled status of an analytics report.",enum:["ok"],type:"string"},AnalyticsScopeV1:fP,AnalyticsSectionUnavailableV1:{additionalProperties:!1,description:"A section the report could not read. `available` is always `false`.",properties:{available:{type:"boolean"},reason:{type:"string"}},required:["available","reason"],type:"object"},AnalyticsTierCountsV1:{additionalProperties:!1,properties:{calls:{format:"int64",type:"integer"},errors:{format:"int64",type:"integer"},tier:{type:"string"}},required:["tier","calls","errors"],type:"object"},AnalyticsToolsSectionV1:{additionalProperties:!1,properties:{aliased_call_names:{items:{$ref:"#/$defs/AnalyticsCanonicalCallNameV1"},type:"array"},available:{type:"boolean"},available_defined_tool_count:{format:"uint",minimum:0,type:"integer"},bound_internal_call_names:{items:{$ref:"#/$defs/AnalyticsEventCallNameV1"},type:"array"},called_available_defined_tool_count:{format:"uint",minimum:0,type:"integer"},raw_distinct_event_name_count:{format:"uint",minimum:0,type:"integer"},tiers:{items:{$ref:"#/$defs/AnalyticsTierCountsV1"},type:"array"},top_tools:{items:{$ref:"#/$defs/AnalyticsTopToolV1"},type:"array"},unknown_or_retired_call_names:{items:{$ref:"#/$defs/AnalyticsEventCallNameV1"},type:"array"},zero_call_available_defined_tools:{$ref:"#/$defs/AnalyticsZeroCallToolsV1"}},required:["available","tiers","top_tools","raw_distinct_event_name_count","called_available_defined_tool_count","available_defined_tool_count","aliased_call_names","bound_internal_call_names","unknown_or_retired_call_names","zero_call_available_defined_tools"],type:"object"},AnalyticsTopToolV1:{additionalProperties:!1,properties:{calls:{format:"int64",type:"integer"},errors:{format:"int64",type:"integer"},tier:{type:"string"},tool_name:{type:"string"}},required:["tool_name","tier","calls","errors"],type:"object"},AnalyticsZeroCallToolsV1:{additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:"integer"},sample:{items:{type:"string"},type:"array"},sample_truncated:{type:"boolean"}},required:["count","sample","sample_truncated"],type:"object"},ComparisonDispositionV1:hI,CostsReadModelV1:yl,CoverageStateV1:yf,LatencyDistributionReadModelV1:gJ,MetricCalibrationV1:_h,MetricCohortV1:_y,MetricCoverageV1:_g,MetricEvidenceClassV1:__,MetricProvenanceV1:_v,MetricSourceV1:_b,MetricTemporalV1:_$,MetricUncertaintyV1:_S,MetricValueV1:_k,ObservabilityHorizonV1:_W,ObservatoryReadModelV1:_N,PerformanceComparisonReadModelV1:_H,ProviderLatencyReadModelV1:vn,RejectedArgumentAnalyticsV1:vh,RejectedArgumentErrorClassV1:vy,RejectedArgumentGroupV1:vg,RejectedArgumentNameV1:v_,RejectedArgumentSurfaceV1:vv},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{automation:{anyOf:[{$ref:"#/$defs/AnalyticsAutomationSectionV1"},{type:"null"}]},costs:{anyOf:[{$ref:"#/$defs/CostsReadModelV1"},{type:"null"}],description:"Present only when no section filter was requested."},event_count:{format:"int64",type:"integer"},event_count_truncated:{type:"boolean"},facts:{anyOf:[{$ref:"#/$defs/AnalyticsFactsSectionV1"},{type:"null"}]},hints:{anyOf:[{$ref:"#/$defs/AnalyticsHintsPayloadV1"},{type:"null"}]},observatory:{anyOf:[{$ref:"#/$defs/ObservatoryReadModelV1"},{type:"null"}],description:"Present only when no section filter was requested."},project_id:{description:'The canonical analytics project key; `None` for `scope: "all"`.',type:["string","null"]},project_root:{type:"string"},scope:{$ref:"#/$defs/AnalyticsScopeV1"},since:{format:"int64",type:"integer"},status:{$ref:"#/$defs/AnalyticsReportStatusV1"},tools:{anyOf:[{$ref:"#/$defs/AnalyticsToolsSectionV1"},{type:"null"}]},window_days:{format:"uint32",minimum:0,type:"integer"}},required:["status","scope","project_root","window_days","since","event_count","event_count_truncated"],title:"AnalyticsResultV1",type:"object"},{$defs:{ManifestDigest:_l,NativeIntegrationApprovalId:_V,NativeIntegrationPreviewId:_I,NativeIntegrationTransactionId:_T},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact one-use apply request.\n\nApply accepts only an unexpired preview identity/digest plus a one-use\ncontent-bound approval. Arbitrary Git arguments, caller-supplied paths,\nSHAs, patches, commit lists, messages, environment, or config are\nunrepresentable.",properties:{approval_digest:{$ref:"#/$defs/ManifestDigest"},approval_id:{$ref:"#/$defs/NativeIntegrationApprovalId"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"}},required:["preview_id","preview_digest","approval_id","approval_digest","transaction_id"],title:"NativeIntegrationApplySurfaceRequest",type:"object"},{$defs:{ActorId:fb,BranchStackEdgeV1:f3,BranchStackId:f9,BranchStackNodeV1:f5,BranchStackRevisionId:f8,BranchStackRevisionV1:f7,BranchStackSourceV1:he,CapabilityId:hl,CodeGenerationId:hy,CommitId:hq,ContentDigest:hD,GitOidV1:gq,GitOperationStateV1:gI,ManifestDigest:_l,MechanicalIntegrationModeV1:_p,NativeIntegrationAnalysisAnchorV1:{additionalProperties:!1,description:"Source-local anchor for a semantic conflict finding.",properties:{generation_id:{$ref:"#/$defs/CodeGenerationId"},logical_path:{type:"string"},source_span:{$ref:"#/$defs/SourceSpan"}},required:["generation_id","logical_path","source_span"],type:"object"},NativeIntegrationAnalysisCoverageV1:{description:"Completeness of one independently evaluated semantic evidence lane.",enum:["complete","partial","unsupported"],type:"string"},NativeIntegrationAnalysisGapV1:{description:"Why one semantic evidence lane cannot authorize integration.",enum:["parser_failure","unresolved_required_edge","withheld_source","stale_evidence","unsupported_language","dynamic_schema","unbound_migration_order","capacity_unavailable","authority_unavailable"],type:"string"},NativeIntegrationAnalysisLaneV1:{additionalProperties:!1,description:"Coverage and exact gaps for one independently evaluated analysis lane.",properties:{coverage:{$ref:"#/$defs/NativeIntegrationAnalysisCoverageV1"},gaps:{items:{$ref:"#/$defs/NativeIntegrationAnalysisGapV1"},type:"array"}},required:["coverage","gaps"],type:"object"},NativeIntegrationAnalysisReportV1:{additionalProperties:!1,description:"Daemon-produced semantic evidence for one exact native candidate tree.",properties:{analyzer_revision:{type:"string"},candidate:{$ref:"#/$defs/NativeIntegrationGenerationBindingV1"},conflicts:{items:{$ref:"#/$defs/NativeIntegrationSemanticConflictV1"},type:"array"},destination:{$ref:"#/$defs/NativeIntegrationGenerationBindingV1"},digest:{$ref:"#/$defs/ManifestDigest"},graph:{$ref:"#/$defs/NativeIntegrationAnalysisLaneV1"},merge_base:{$ref:"#/$defs/NativeIntegrationGenerationBindingV1"},migrations:{$ref:"#/$defs/NativeIntegrationAnalysisLaneV1"},schema:{$ref:"#/$defs/NativeIntegrationAnalysisLaneV1"},source:{$ref:"#/$defs/NativeIntegrationGenerationBindingV1"},tests:{$ref:"#/$defs/NativeIntegrationAnalysisLaneV1"}},required:["merge_base","source","destination","candidate","graph","tests","schema","migrations","conflicts","analyzer_revision","digest"],type:"object"},NativeIntegrationApprovalId:_V,NativeIntegrationDirectionV1:_R,NativeIntegrationGenerationBindingV1:{additionalProperties:!1,description:"One immutable code-generation binding used by native integration analysis.",properties:{content_identity:{$ref:"#/$defs/ContentDigest"},generation_id:{$ref:"#/$defs/CodeGenerationId"},project_id:{$ref:"#/$defs/ProjectId"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},repository_id:{$ref:"#/$defs/RepositoryId"},seal_digest:{$ref:"#/$defs/ManifestDigest"},snapshot_digest:{$ref:"#/$defs/ManifestDigest"},source_revision:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},source_tree:{$ref:"#/$defs/GitOidV1"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["generation_id","project_id","repository_id","snapshot_digest","content_identity","source_tree","seal_digest"],type:"object"},NativeIntegrationPhaseV1:{description:"Durable transaction phase. `RefCommitStarted` is the cancellation boundary.",enum:["prepared","candidate_verified","ref_commit_started","final_state_verification","terminal"],type:"string"},NativeIntegrationPreviewDispositionV1:_q,NativeIntegrationPreviewId:_I,NativeIntegrationSealedStackSnapshotV1:_x,NativeIntegrationSelectionBindingV1:_j,NativeIntegrationSemanticConflictKindV1:{description:"Static conflict class produced from canonical generation evidence.",enum:["divergent_symbol","signature_dependent","test_write_interaction","divergent_schema","migration_order"],type:"string"},NativeIntegrationSemanticConflictV1:{additionalProperties:!1,description:"One deterministic conflict finding with source evidence from both branches.",properties:{destination:{$ref:"#/$defs/NativeIntegrationAnalysisAnchorV1"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},kind:{$ref:"#/$defs/NativeIntegrationSemanticConflictKindV1"},source:{$ref:"#/$defs/NativeIntegrationAnalysisAnchorV1"}},required:["kind","source","destination","evidence_digest"],type:"object"},NativeIntegrationSnapshotProjectionV1:{additionalProperties:!1,description:"Bounded projection of one frozen selection.",properties:{destination_ref:{$ref:"#/$defs/RefId"},frozen_at:{$ref:"#/$defs/UtcMicros"},inventory_epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},selection_digest:{$ref:"#/$defs/ManifestDigest"},source_ref:{$ref:"#/$defs/RefId"}},required:["selection_digest","project_id","repository_id","source_ref","destination_ref","inventory_epoch","frozen_at"],type:"object"},NativeIntegrationStatusProjectionV1:{additionalProperties:!1,description:"Bounded projection of one durable transaction status.",properties:{cancellation_requested:{type:"boolean"},destination_ref:{$ref:"#/$defs/RefId"},phase:{$ref:"#/$defs/NativeIntegrationPhaseV1"},phase_revision:{format:"uint64",minimum:0,type:"integer"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},repository_id:{$ref:"#/$defs/RepositoryId"},terminal_outcome:{anyOf:[{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"},{type:"null"}]},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["transaction_id","preview_id","preview_digest","repository_id","destination_ref","phase","phase_revision","cancellation_requested","updated_at"],type:"object"},NativeIntegrationSurfaceUnavailableV1:{description:"Why a native-integration operation produced no advancing state.\n\nEvery variant is read-only and truthful. None of them authorizes apply, and\na denied or absent target is reported indistinguishably from an unavailable\nauthority so no identity, path, count, or topology leaks.",oneOf:[{enum:["partial","stale","denied","reset_required","durability_uncertain","cancelled","approval_conflict","transaction_conflict","recovery_required","needs_inspection","unknown_transaction"],type:"string"},{const:"authority_unmounted",description:"No native-integration runtime authority is mounted for this daemon.",type:"string"}]},NativeIntegrationTerminalOutcomeV1:_C,NativeIntegrationTransactionId:_T,NativeIntegrationUnavailabilityV1:_O,NativeWorktreeSurfaceResultV1:{oneOf:[{oneOf:[{properties:{coverage:{$ref:"#/$defs/WorktreeCoverageV1"},digest:{$ref:"#/$defs/ManifestDigest"},entries:{items:{$ref:"#/$defs/WorktreeInventoryEntryV1"},type:"array"},epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},observed_at:{$ref:"#/$defs/UtcMicros"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},snapshot_id:{$ref:"#/$defs/WorktreeInventorySnapshotId"},state:{const:"snapshot",type:"string"}},required:["state","scope_set_id","scope_set_revision","scope_set_digest","snapshot_id","epoch","entries","coverage","observed_at","digest"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}],properties:{operation:{const:"inventory",type:"string"}},required:["operation"],type:"object"},{oneOf:[{properties:{clean:{$ref:"#/$defs/WorktreeObservationV1",description:"Whether Git status contains no tracked or untracked changes."},head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},holder:{$ref:"#/$defs/WorktreeObservationV1"},inspection_digest:{$ref:"#/$defs/ManifestDigest"},kind:{anyOf:[{$ref:"#/$defs/WorktreeKindV1"},{type:"null"}]},locked:{$ref:"#/$defs/WorktreeObservationV1"},observed_at:{$ref:"#/$defs/UtcMicros"},operation_state:{anyOf:[{$ref:"#/$defs/GitOperationStateV1"},{type:"null"}]},presence:{$ref:"#/$defs/WorktreePresenceV1"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},state:{const:"inspection",type:"string"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"},unique_data:{$ref:"#/$defs/WorktreeObservationV1"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["state","target","presence","worktree_id","clean","locked","holder","unique_data","observed_at","inspection_digest"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"foreign",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}],properties:{operation:{const:"inspection",type:"string"}},required:["operation"],type:"object"},{oneOf:[{properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},confirmed_at:{$ref:"#/$defs/UtcMicros"},inspection_digest:{$ref:"#/$defs/ManifestDigest"},state:{const:"confirmed",type:"string"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["state","target","inspection_digest","confirmation_digest","confirmed_at"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"needs_inspection",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}],properties:{operation:{const:"confirmation",type:"string"}},required:["operation"],type:"object"},{$ref:"#/$defs/WorktreeCleanupRemovalV1",properties:{operation:{const:"removal",type:"string"}},required:["operation"],type:"object"},{$ref:"#/$defs/WorktreeCleanupReconciliationV1",properties:{operation:{const:"reconciliation",type:"string"}},required:["operation"],type:"object"}]},NativeWorktreeTargetV1:_E,ProjectId:_4,RefId:vm,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,SourceSpan:b$,StackNodeId:bw,UtcMicros:bZ,WorktreeCleanupReconciliationV1:{oneOf:[{properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"removed",type:"string"}},required:["state","confirmation_digest","observed_at"],type:"object"},{properties:{state:{const:"still_present",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"durability_uncertain",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}]},WorktreeCleanupRemovalV1:{oneOf:[{properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"removed",type:"string"}},required:["state","confirmation_digest","observed_at"],type:"object"},{properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"already_removed",type:"string"}},required:["state","confirmation_digest","observed_at"],type:"object"},{properties:{state:{const:"denied",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"stale",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"durability_uncertain",type:"string"}},required:["state"],type:"object"},{properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"}]},WorktreeCoverageV1:{enum:["complete","partial"],type:"string"},WorktreeId:SB,WorktreeInventoryEntryV1:{additionalProperties:!1,properties:{clean:{$ref:"#/$defs/WorktreeObservationV1",description:"Whether Git status contains no tracked or untracked changes."},evidence_digest:{$ref:"#/$defs/ManifestDigest"},head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},holder:{$ref:"#/$defs/WorktreeObservationV1"},kind:{anyOf:[{$ref:"#/$defs/WorktreeKindV1"},{type:"null"}]},locked:{$ref:"#/$defs/WorktreeObservationV1"},observed_at:{$ref:"#/$defs/UtcMicros"},operation:{anyOf:[{$ref:"#/$defs/GitOperationStateV1"},{type:"null"}]},presence:{$ref:"#/$defs/WorktreePresenceV1"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},target:{$ref:"#/$defs/NativeWorktreeTargetV1"},unique_data:{$ref:"#/$defs/WorktreeObservationV1"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["target","presence","clean","locked","holder","unique_data","observed_at","evidence_digest"],type:"object"},WorktreeInventoryEpoch:SK,WorktreeInventorySnapshotId:SJ,WorktreeKindV1:{description:"Native Git worktree kind visible to an authorized caller.",enum:["main","linked","bare"],type:"string"},WorktreeObservationV1:{enum:["yes","no","unknown"],type:"string"},WorktreePresenceV1:{description:"Presence is intentionally not a bool: stale, unavailable and foreign are\npolicy-safe states with different reconciliation consequences.",enum:["present","stale","unavailable","foreign"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One typed result for every native-integration surface operation.",oneOf:[{additionalProperties:!1,description:"Frozen selection summary plus the exact sealed proof preflight accepts.",properties:{outcome:{const:"stack_snapshot",type:"string"},sealed_snapshot:{$ref:"#/$defs/NativeIntegrationSealedStackSnapshotV1"},selection:{$ref:"#/$defs/NativeIntegrationSnapshotProjectionV1"}},required:["outcome","selection","sealed_snapshot"],type:"object"},{additionalProperties:!1,description:"Bounded projection of one immutable preview.\n\nCandidate trees, conflict bodies, and ordered commit objects stay behind the\npreview digest: the surface reports identity, classification, and expiry so\na caller can approve exactly this preview and nothing else.",properties:{analysis:{anyOf:[{$ref:"#/$defs/NativeIntegrationAnalysisReportV1"},{type:"null"}]},created_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/NativeIntegrationPreviewDispositionV1"},expires_at:{$ref:"#/$defs/UtcMicros"},ordered_commit_count:{format:"uint32",minimum:0,type:"integer"},outcome:{const:"preview",type:"string"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},selection:{$ref:"#/$defs/NativeIntegrationSnapshotProjectionV1"}},required:["outcome","preview_id","preview_digest","selection","disposition","ordered_commit_count","created_at","expires_at"],type:"object"},{additionalProperties:!1,description:"Bounded projection of one issued one-use approval.\n\nThe approval digest is the caller's proof-of-issuance handle for apply;\nthe preview binding and expiry are audit metadata. No preview body,\ncandidate tree, or commit content crosses this boundary.",properties:{approval_digest:{$ref:"#/$defs/ManifestDigest"},approval_id:{$ref:"#/$defs/NativeIntegrationApprovalId"},capability:{$ref:"#/$defs/CapabilityId"},expires_at:{$ref:"#/$defs/UtcMicros"},issued_at:{$ref:"#/$defs/UtcMicros"},outcome:{const:"approval",type:"string"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},principal:{$ref:"#/$defs/ActorId"},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId",description:"Daemon-minted identity consumed verbatim by apply, status, and cancel."}},required:["outcome","transaction_id","approval_id","preview_id","preview_digest","principal","capability","issued_at","expires_at","approval_digest"],type:"object"},{additionalProperties:!1,description:"Bounded projection of one durable terminal receipt.\n\nThe receipt digest and final ref/tree identity are audit metadata; no patch,\nworktree body, or source content crosses this boundary.",properties:{completed_at:{$ref:"#/$defs/UtcMicros"},final_ref_tip:{type:"string"},final_tree:{type:"string"},outcome:{const:"receipt",type:"string"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},status:{$ref:"#/$defs/NativeIntegrationStatusProjectionV1"},terminal_outcome:{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"}},required:["outcome","status","terminal_outcome","final_ref_tip","final_tree","completed_at","receipt_digest"],type:"object"},{additionalProperties:!1,description:"Bounded projection of one durable transaction status.",properties:{cancellation_requested:{type:"boolean"},destination_ref:{$ref:"#/$defs/RefId"},outcome:{const:"status",type:"string"},phase:{$ref:"#/$defs/NativeIntegrationPhaseV1"},phase_revision:{format:"uint64",minimum:0,type:"integer"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},repository_id:{$ref:"#/$defs/RepositoryId"},terminal_outcome:{anyOf:[{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"},{type:"null"}]},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["outcome","transaction_id","preview_id","preview_digest","repository_id","destination_ref","phase","phase_revision","cancellation_requested","updated_at"],type:"object"},{description:"Cancellation disposition. After the native commit point the committed\nreceipt is returned instead of a cancellation claim.",oneOf:[{enum:["cancellation_requested","commit_point_passed"],type:"string"},{properties:{already_terminal:{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"}},required:["already_terminal"],type:"object"}],properties:{outcome:{const:"cancellation",type:"string"}},required:["outcome"],type:"object"},{$ref:"#/$defs/NativeWorktreeSurfaceResultV1",properties:{outcome:{const:"worktree",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},reason:{$ref:"#/$defs/NativeIntegrationSurfaceUnavailableV1"}},required:["outcome","reason"],type:"object"}],title:"NativeIntegrationSurfaceResultV1"},{$defs:{ManifestDigest:_l,NativeIntegrationPreviewId:_I},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact approval-issuance request (the owner-decided sixth operation).\n\nThe caller names one unexpired preview by exact identity *and* digest;\napproving an identity without its content digest is unrepresentable. The\ndaemon mints the one-use approval bound to the requesting principal, the\napply capability, the current grant lineage, and a bounded expiry, none\nof which the caller can choose.",properties:{preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"}},required:["preview_id","preview_digest"],title:"NativeIntegrationApproveSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_ast_grep_rewrite`.",properties:{dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},path:{type:"string"},pattern:{type:"string"},rewrite:{type:"string"},verify:{default:!1,type:"boolean"}},required:["path","pattern","rewrite"],title:"AstGrepRewriteSurfaceRequestV1",type:"object"},{$defs:{ActorId:fb,AstGrepResult:{description:"Result of an ast-grep rewrite operation.",properties:{diff:{description:"Bounded preview of the would-be change. Populated only on a successful\ndry run; `None` for real edits and for failures.",type:["string","null"]},dry_run:{description:"True when this was a dry run: the rewrite was resolved but nothing was\nwritten.",type:"boolean"},file_path:{type:"string"},message:{type:"string"},pattern:{type:"string"},rewrite:{type:"string"},success:{type:"boolean"}},required:["success","file_path","pattern","rewrite","message"],type:"object"},AuthorityReceipt:{additionalProperties:!1,description:"Proof that this request crossed the current authorization boundary.",properties:{authorized_scope_digest:{$ref:"#/$defs/ManifestDigest"},disclosure:{$ref:"#/$defs/DisclosureClass"},grant_digest:{$ref:"#/$defs/ManifestDigest"},grant_id:{type:"string"},grant_revision:{format:"uint64",minimum:0,type:"integer"},policy:{$ref:"#/$defs/PolicyDecisionRef"},revalidated_at:{$ref:"#/$defs/UtcMicros"}},required:["grant_id","grant_revision","grant_digest","authorized_scope_digest","disclosure","policy","revalidated_at"],type:"object"},CancellationObservation:hn,CancellationStage:ha,ComponentVersion:hC,Deadline:yv,DisclosureClass:{description:"Disclosure ceiling carried by an immutable grant and revalidated at sinks.",enum:["metadata","evidence","sensitive"],type:"string"},EditResult:{description:"Result of a single string replacement edit.",properties:{diff:{description:"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.",type:["string","null"]},dry_run:{description:"True when this was a dry run: validation, spans, and the resulting\ncontent were all computed, but nothing was written to disk.",type:"boolean"},file_path:{type:"string"},matched_str:{type:"string"},message:{type:"string"},new_str:{type:"string"},replaced_span:{description:"The exact source text that was replaced. For `replace_symbol` this is\nthe item's full span, including any leading doc-comment / attribute\nblock, so callers can recover its docs/attrs if the replacement\ndropped them; for `str_replace` it is the matched `old_str` text.\n`None` only on a failed edit, where nothing was resolved to replace.",type:["string","null"]},success:{type:"boolean"}},required:["success","file_path","matched_str","new_str","message"],type:"object"},EffectClass:yR,EffectReceipt:yq,EffectResult:{additionalProperties:!1,description:"Result of an admitted effect. `EffectUnknown` remains a receipt state and\ncannot be remapped into a pre-admission problem.",properties:{authority:{$ref:"#/$defs/AuthorityReceipt"},effect_class:{$ref:"#/$defs/EffectClass"},effect_id:{type:"string"},execution:{$ref:"#/$defs/OperationReceipt"},expected_state:{$ref:"#/$defs/ManifestDigest"},idempotency_key:{type:"string"},payload:{anyOf:[{$ref:"#/$defs/SourceEditDurableEffectPayloadV1"},{type:"null"}]},receipt:{$ref:"#/$defs/EffectReceipt"},reconciliation:{$ref:"#/$defs/ReconciliationState"}},required:["effect_id","effect_class","idempotency_key","authority","expected_state","execution","reconciliation","receipt"],type:"object"},EffectTermination:yI,InsertResult:{description:"Result of an insert-at operation.",properties:{anchor_line:{format:"uint32",minimum:0,type:"integer"},before:{type:"boolean"},content:{type:"string"},diff:{description:"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.",type:["string","null"]},dry_run:{description:"True when this was a dry run: the insertion point was resolved and the\nresulting content computed, but nothing was written to disk.",type:"boolean"},file_path:{type:"string"},message:{type:"string"},success:{type:"boolean"}},required:["success","file_path","anchor_line","content","before","message"],type:"object"},ManifestDigest:_l,MoveHint:{description:"One evidence-based, actionable finding produced by the `move_symbol` impact\nengine. Each hint points at a concrete file/line and carries a suggestion\nthe caller (or a follow-up refactor) can act on. Hints are derived from graph\nedges (callers/callees) and parse-level facts (identifiers, `use` lines,\nmodule declarations), never speculative noise.",properties:{detail:{description:"Human-readable description of what the move breaks or affects.",type:"string"},file:{description:"File the finding concerns (the caller's file, the destination, or the\nsource), project-relative.",type:"string"},kind:{description:"Taxonomy tag: `caller_reference`, `dependency_broken`, `import_needed`,\n`visibility_required`, `collision`, `module_missing`, `cycle_risk`,\n`orphaned_import`, or `cfg_context`.",type:"string"},line:{description:"1-based line the finding concerns, when a specific site is known.",format:"uint32",minimum:0,type:["integer","null"]},suggestion:{description:"The exact change to make (e.g. a `use` line to add, a path to rewrite, a\nvisibility to escalate). `None` when no single mechanical fix applies.",type:["string","null"]}},required:["kind","file","detail"],type:"object"},MoveResult:{description:"Result of a `move_symbol` operation: the moved span, a dry-run diff of the\nsource + destination files, and the centerpiece, the impact report of\neverything the move breaks or that needs attention.",properties:{applied_imports:{description:"`use` lines auto-inserted at the destination because the moved body's\ndependency on them was unambiguous. Reported so the caller sees exactly\nwhat the move added.",items:{type:"string"},type:"array"},dest_file:{type:"string"},diff:{description:"Combined preview diff of the source (removal) and destination (insertion)\nfiles. Populated on a successful dry run; `None` for real moves.",type:["string","null"]},dry_run:{description:"True when this was a dry run: spans, the destination shape, and the\nimpact report were all computed, but nothing was written to disk.",type:"boolean"},impact:{description:"The impact report: every actionable finding. Empty on a truly clean\nmove.",items:{$ref:"#/$defs/MoveHint"},type:"array"},message:{type:"string"},moved_span:{description:"The exact source span that was moved, including its leading\ndoc-comment / attribute block. `None` on failure.",type:["string","null"]},source_file:{type:"string"},success:{type:"boolean"},symbol:{description:"The resolved symbol that was (or would be) moved, `name (kind)`.",type:"string"}},required:["success","symbol","source_file","dest_file","message"],type:"object"},MultiEditResult:{description:"Result of a multi-string replacement edit.",properties:{applied_count:{format:"uint",minimum:0,type:"integer"},diff:{description:"Bounded preview diff of the would-be change. Populated only on a\nsuccessful dry run; `None` for real edits and for failures.",type:["string","null"]},dry_run:{description:"True when this was a dry run: replacements were validated and the\nresulting content computed, but nothing was written to disk.",type:"boolean"},file_path:{type:"string"},message:{type:"string"},success:{type:"boolean"}},required:["success","file_path","applied_count","message"],type:"object"},OperationBudgetUsage:_D,OperationReceipt:_F,OperationTermination:_L,PolicyDecisionRef:{additionalProperties:!1,description:"A policy decision pinned into a receipt or provider identity.",properties:{decision_id:{type:"string"},digest:{$ref:"#/$defs/ManifestDigest"},evaluator_revision:{$ref:"#/$defs/ComponentVersion"},revision:{format:"uint64",minimum:0,type:"integer"}},required:["decision_id","revision","digest","evaluator_revision"],type:"object"},ProjectId:_4,ReconciliationState:{description:"Reconciliation state retained after an admitted effect.",enum:["pending","reconciled","failed"],type:"string"},RefId:vm,RenameDispositionCountsV1:{additionalProperties:!1,properties:{blocked:{format:"uint",minimum:0,type:"integer"},changed:{format:"uint",minimum:0,type:"integer"},skipped:{format:"uint",minimum:0,type:"integer"},unchanged:{format:"uint",minimum:0,type:"integer"}},required:["changed","unchanged","skipped","blocked"],type:"object"},RenameFileEditV1:{additionalProperties:!1,description:"One file a rename changed (or would change), with the exact bound-site count.",properties:{file:{type:"string"},replaced_count:{format:"uint",minimum:0,type:"integer"}},required:["file","replaced_count"],type:"object"},RenameHazardKindV1:{enum:["invalid_identifier","stale_evidence","ambiguous_symbol","namespace_collision","changed_resolution","shadowing","unsupported_syntax","macro_expansion","generated_source","overlapping_site"],type:"string"},RenameHazardV1:{additionalProperties:!1,properties:{blocking:{type:"boolean"},kind:{$ref:"#/$defs/RenameHazardKindV1"},message:{type:"string"},site_id:{type:["string","null"]}},required:["kind","blocking","message"],type:"object"},RenameImpactV1:{additionalProperties:!1,properties:{affected_files:{items:{type:"string"},type:"array"},affected_tests:{items:{type:"string"},type:"array"},callers:{items:{type:"string"},type:"array"},reexports:{items:{type:"string"},type:"array"}},required:["callers","reexports","affected_files","affected_tests"],type:"object"},RenameProtectedValueCategoryV1:{enum:["wire_value","serialized_name","sql_identifier","persisted_name","schema_epoch","hash_domain","protocol_name","contract_snapshot","string_literal","byte_literal"],type:"string"},RenameProtectedValueV1:{additionalProperties:!1,description:"A byte-exact stable value deliberately preserved by the rename.",properties:{category:{$ref:"#/$defs/RenameProtectedValueCategoryV1"},end_byte:{format:"uint64",minimum:0,type:"integer"},exact_bytes:{type:"string"},file:{type:"string"},site_id:{type:"string"},start_byte:{format:"uint64",minimum:0,type:"integer"}},required:["site_id","file","start_byte","end_byte","category","exact_bytes"],type:"object"},RenameResult:{description:"The same typed payload is serialized by application, CLI, and MCP paths.",properties:{diff:{type:["string","null"]},dispositions:{$ref:"#/$defs/RenameDispositionCountsV1"},dry_run:{type:"boolean"},files:{items:{$ref:"#/$defs/RenameFileEditV1"},type:"array"},graph_revision:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Digest of the admitted generation, exact target, same-name symbols,\nand graph edges used to classify bound and protected sites."},hazards:{items:{$ref:"#/$defs/RenameHazardV1"},type:"array"},impact:{$ref:"#/$defs/RenameImpactV1"},message:{type:"string"},new_name:{type:"string"},old_name:{type:"string"},plan_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Digest of the complete typed site/hazard/protected-value manifest."},preview_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Exact candidate-state digest that apply must echo as `expected_state`."},preview_id:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Digest-addressed identity of the bound symbol plus proposed name."},protected_values:{items:{$ref:"#/$defs/RenameProtectedValueV1"},type:"array"},reference_count:{format:"uint",minimum:0,type:"integer"},repository_revision:{default:null,description:"Current Git HEAD when the worktree has one; dirty bytes remain bound by\n`preview_digest` independently of this revision.",type:["string","null"]},sites:{items:{$ref:"#/$defs/RenameSiteV1"},type:"array"},success:{type:"boolean"},symbol:{description:"Qualified name of the renamed symbol at plan time.",type:"string"}},required:["success","symbol","old_name","new_name","reference_count","dispositions","impact","message"],type:"object"},RenameSiteDispositionV1:{enum:["changed","unchanged","skipped","blocked"],type:"string"},RenameSiteKindV1:{enum:["declaration","import","reexport","qualified_path","unqualified_path","annotation","generic_argument","constructor","pattern","trait_declaration","trait_implementation","resolved_call","inherent_method","enum_variant","test","example","documentation","protected_value","unresolved_text"],type:"string"},RenameSiteV1:{additionalProperties:!1,description:"One exact old-name occurrence and the rename planner's disposition.",properties:{disposition:{$ref:"#/$defs/RenameSiteDispositionV1"},end_byte:{format:"uint64",minimum:0,type:"integer"},expected_bytes:{type:"string"},file:{type:"string"},kind:{$ref:"#/$defs/RenameSiteKindV1"},line:{format:"uint32",minimum:0,type:"integer"},reason:{type:"string"},replacement_bytes:{type:"string"},site_id:{type:"string"},source_node_id:{description:"Canonical source `SymbolOccurrenceId` that attested this site.",type:["string","null"]},start_byte:{format:"uint64",minimum:0,type:"integer"}},required:["site_id","kind","disposition","file","line","start_byte","end_byte","expected_bytes","replacement_bytes","reason"],type:"object"},RepositoryId:vb,ResolvedScope:vw,RetrievalAnchorId:vI,SourceEditCancelledResultV1:{description:"Terminal payload when cancellation is observed before an edit commits.",properties:{cancelled:{type:"boolean"},message:{type:"string"},success:{type:"boolean"}},required:["success","cancelled","message"],type:"object"},SourceEditDiagnosticV1:{properties:{code:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},message:{type:"string"}},required:["line","code","message"],type:"object"},SourceEditDurableEffectPayloadV1:{additionalProperties:!1,description:"Body-free source-edit evidence retained inside durable effect receipts.\n\nThis payload intentionally contains no caller-supplied edit text, preview\ndiff, moved span, import, diagnostic, or impact detail. It is also the\nexact replay outcome, so replay never fabricates a live edit body.",properties:{before:{type:["boolean","null"]},cancelled:{type:"boolean"},change_count:{format:"uint",minimum:0,type:["integer","null"]},durable_metadata_only:{type:"boolean"},effect_unknown:{type:"boolean"},failed:{type:"boolean"},files:{items:{type:"string"},type:"array"},finding_count:{format:"uint",minimum:0,type:["integer","null"]},import_count:{format:"uint",minimum:0,type:["integer","null"]},line:{format:"uint32",minimum:0,type:["integer","null"]},message:{type:"string"},observed_state:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Exact candidate-file observation from an inspection attempt."},operation:{$ref:"#/$defs/UseCaseId"},reconciled:{type:"boolean"},success:{type:"boolean"},timed_out:{type:"boolean"}},required:["operation","success","files","failed","cancelled","timed_out","effect_unknown","reconciled","durable_metadata_only","message"],type:"object"},SourceEditEffectUnknownResultV1:{description:"Terminal payload when publication may have occurred and inspection is required.",properties:{effect_unknown:{type:"boolean"},message:{type:"string"},success:{type:"boolean"}},required:["success","effect_unknown","message"],type:"object"},SourceEditFailedResultV1:{description:"Terminal payload when an edit is refused before it can publish an effect.",properties:{failed:{type:"boolean"},message:{type:"string"},success:{type:"boolean"}},required:["success","failed","message"],type:"object"},SourceEditReconciledResultV1:{description:"Terminal payload returned by explicit reconciliation.",properties:{message:{type:"string"},reconciled:{type:"boolean"},success:{type:"boolean"}},required:["success","reconciled","message"],type:"object"},SourceEditTimedOutResultV1:{description:"Terminal payload when an edit deadline expires before commit.",properties:{message:{type:"string"},success:{type:"boolean"},timed_out:{type:"boolean"}},required:["success","timed_out","message"],type:"object"},SourceEditVerificationStateV1:{enum:["clean","errors","unavailable","failed","cancelled"],type:"string"},SourceEditVerificationV1:{properties:{error_count:{format:"uint",minimum:0,type:"integer"},first_errors:{items:{$ref:"#/$defs/SourceEditDiagnosticV1"},type:"array"},message:{type:["string","null"]},state:{$ref:"#/$defs/SourceEditVerificationStateV1"},verdict:{type:"string"},warning_count:{format:"uint",minimum:0,type:"integer"}},required:["state","verdict","error_count","warning_count","first_errors"],type:"object"},UseCaseId:bK,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/SourceEditDurableEffectPayloadV1"},{$ref:"#/$defs/EditResult"},{$ref:"#/$defs/MultiEditResult"},{$ref:"#/$defs/InsertResult"},{$ref:"#/$defs/AstGrepResult"},{$ref:"#/$defs/MoveResult"},{$ref:"#/$defs/RenameResult"},{$ref:"#/$defs/SourceEditFailedResultV1"},{$ref:"#/$defs/SourceEditCancelledResultV1"},{$ref:"#/$defs/SourceEditTimedOutResultV1"},{$ref:"#/$defs/SourceEditEffectUnknownResultV1"},{$ref:"#/$defs/SourceEditReconciledResultV1"}],description:"Canonical result returned directly by every source-edit use case.",properties:{effect:{anyOf:[{$ref:"#/$defs/EffectResult"},{type:"null"}]},expected_state:{$ref:"#/$defs/ManifestDigest"},predicted_state:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},replayed:{type:"boolean"},verification:{anyOf:[{$ref:"#/$defs/SourceEditVerificationV1"},{type:"null"}]}},required:["expected_state","replayed"],title:"SourceEditSurfaceResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{lang:{description:"Optional language key to force (e.g. 'rust', 'typescript', 'python').\nOmit to auto-detect each file from its extension.",type:["string","null"]},max_results:{description:"Maximum number of matches to return (default: 50, max: 200).",format:"uint32",minimum:0,type:["integer","null"]},path_glob:{description:"Optional glob restricting which files are searched, matched against\nproject-relative paths (e.g. 'src/**/*.rs').",type:["string","null"]},pattern:{description:"ast-grep structural pattern (SGPattern syntax), e.g.\n'reserve_stock($$$)' or 'Result<$T, $E>'.",type:"string"}},required:["pattern"],title:"AstGrepSearchSurfaceRequestV1",type:"object"},{$defs:{AstGrepSearchMatchV1:{additionalProperties:!1,properties:{column:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},lang:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},line_text:{type:"string"},match:{type:"string"}},required:["file","line","column","lang","match","line_text"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{files_scanned:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{format:"uint64",minimum:0,type:"integer"},results:{items:{$ref:"#/$defs/AstGrepSearchMatchV1"},type:"array"},truncated:{type:"boolean"}},required:["results","match_count","files_scanned","truncated"],title:"AstGrepSearchResultV1",type:"object"},{$defs:{AutomationRunArtifactKind:{enum:["traces","feedback","generated_evals","validation_gate","optimizer_diagnosis","codex_handoff"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kind:{$ref:"#/$defs/AutomationRunArtifactKind",description:"Artifact kind to read."},run_id:{description:"Automation run id to inspect.",type:"string"}},required:["run_id","kind"],title:"AutomationRunArtifactViewSurfaceRequestV1",type:"object"},{$defs:{AutomationReadStatusV1:fH,AutomationRunArtifact:fB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{artifact:{$ref:"#/$defs/AutomationRunArtifact"},payload:{description:"The hash-verified artifact document, as the run wrote it."},run_id:{type:"string"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","run_id","artifact","payload"],title:"AutomationRunArtifactViewResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum run records to return (default: 50, max: 200).",format:"uint32",maximum:200,minimum:1,type:["integer","null"]}},title:"AutomationRunListSurfaceRequestV1",type:"object"},{$defs:{AgentTaskKind:fS,AutomationReadStatusV1:fH,AutomationRunListEntryV1:{additionalProperties:!1,description:"One run as the list shows it: the ledger record's identity, outcome and\nartifact kinds, without the artifact payloads or operation bodies.",properties:{accepted_count:{format:"uint",minimum:0,type:"integer"},artifact_kinds:{items:{type:"string"},type:"array"},backend:{type:"string"},completed_at:{type:"string"},error:{type:["string","null"]},model:{type:["string","null"]},rejected_count:{format:"uint",minimum:0,type:"integer"},reviewed_count:{format:"uint",minimum:0,type:"integer"},run_id:{type:"string"},skipped_count:{format:"uint",minimum:0,type:"integer"},started_at:{type:"string"},status:{$ref:"#/$defs/AutomationRunStatus"},task:{$ref:"#/$defs/AgentTaskKind"},task_key:{type:"string"},trigger:{$ref:"#/$defs/AutomationTrigger"}},required:["run_id","task","task_key","trigger","backend","status","reviewed_count","accepted_count","rejected_count","skipped_count","started_at","completed_at","artifact_kinds"],type:"object"},AutomationRunPageCompletenessV1:{description:"Whether a run page read every ledger row it examined.",oneOf:[{const:"known",description:"Every examined row decoded.",type:"string"},{const:"partial",description:"The page skipped malformed rows or more runs exist past it.",type:"string"}]},AutomationRunScopeV1:fK,AutomationRunStatus:fJ,AutomationTrigger:fY},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{completeness:{$ref:"#/$defs/AutomationRunPageCompletenessV1"},count:{format:"uint",minimum:0,type:"integer"},has_more:{type:"boolean"},limit:{format:"uint32",minimum:0,type:"integer"},malformed_row_count:{format:"uint",minimum:0,type:"integer"},runs:{items:{$ref:"#/$defs/AutomationRunListEntryV1"},type:"array"},scope:{$ref:"#/$defs/AutomationRunScopeV1"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","scope","runs","count","limit","has_more","malformed_row_count","completeness"],title:"AutomationRunListResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run_id:{description:"Exact automation run id to inspect.",minLength:1,type:"string"}},required:["run_id"],title:"AutomationRunViewSurfaceRequestV1",type:"object"},{$defs:{AgentTaskFailureClass:{oneOf:[{enum:["retryable","permanent","timeout","unavailable","denied","disconnected","malformed_output"],type:"string"},{const:"input_too_large",description:"The backend refused the request because it exceeds its input or\ncontext-window limit.",type:"string"}]},AgentTaskKind:fS,AgentTaskRetryAttempt:{properties:{attempt:{format:"uint32",minimum:0,type:"integer"},backoff_millis:{format:"uint64",minimum:0,type:"integer"},failure_classification:{anyOf:[{$ref:"#/$defs/AgentTaskFailureClass"},{type:"null"}]},succeeded:{type:"boolean"}},required:["attempt","succeeded","backoff_millis"],type:"object"},AutomationReadStatusV1:fH,AutomationRunArtifact:fB,AutomationRunLedgerRecord:{properties:{accepted_count:{format:"uint",minimum:0,type:"integer"},applied_ops:!0,artifacts:{items:{$ref:"#/$defs/AutomationRunArtifact"},type:"array"},backend:{type:"string"},backend_attempt_count:{default:0,format:"uint",minimum:0,type:"integer"},backend_attempts:{items:{$ref:"#/$defs/AgentTaskRetryAttempt"},type:"array"},backend_identity:{description:"The durable backend/configuration identity this run executed under.\n\nA settled deterministic failure stays suppressed only while this\nmatches the identity now configured, so the scheduler can re-admit the\ntask the moment the backend or configuration changes. Records written\nbefore this field existed carry `None` and never suppress: an\nunidentified failure cannot be shown to have failed under the current\nidentity.",type:["string","null"]},completed_at:{type:"string"},completed_at_micros:{format:"int64",type:["integer","null"]},error:{type:["string","null"]},error_classification:{anyOf:[{$ref:"#/$defs/AgentTaskFailureClass"},{type:"null"}]},error_retryable:{type:["boolean","null"]},evidence_hash:{type:["string","null"]},fallback_status:{type:["string","null"]},host_mode:{type:["string","null"]},input_hash:{type:["string","null"]},model:{type:["string","null"]},output_hash:{type:["string","null"]},prompt_version:{type:["string","null"]},proposed_ops:!0,rejected_count:{format:"uint",minimum:0,type:"integer"},rejected_ops:!0,report_ref:!0,response_schema:!0,reviewed_count:{default:0,format:"uint",minimum:0,type:"integer"},run_id:{type:"string"},schema_version:{format:"uint32",minimum:0,type:"integer"},session_evidence_budget_stage:{anyOf:[{$ref:"#/$defs/SessionRetrievalBudgetStageV1"},{type:"null"}],description:"Exhausted retrieval boundary of a `session_evidence_budget_exhausted`\nskip; present exactly on those skips."},skipped_count:{default:0,format:"uint",minimum:0,type:"integer"},started_at:{type:"string"},status:{$ref:"#/$defs/AutomationRunStatus"},strict_json:{type:["boolean","null"]},task:{$ref:"#/$defs/AgentTaskKind"},task_key:{type:"string"},trigger:{$ref:"#/$defs/AutomationTrigger"},validation_report:!0},required:["schema_version","run_id","trigger","task","task_key","backend","status","accepted_count","rejected_count","started_at","completed_at"],type:"object"},AutomationRunScopeV1:fK,AutomationRunStatus:fJ,AutomationTrigger:fY,SessionRetrievalBudgetStageV1:bo},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run:{$ref:"#/$defs/AutomationRunLedgerRecord"},scope:{$ref:"#/$defs/AutomationRunScopeV1"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","scope","run"],title:"AutomationRunViewResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{base:{description:"Base local branch name (e.g. 'main').",type:"string"},cursor:{description:"Authenticated continuation cursor returned by the preceding exact\nbranch-diff page.",type:["string","null"]},file:{description:"Optional file path filter, only show diffs for symbols in this file.",type:["string","null"]},head:{description:"Head local branch name (e.g. 'feature/foo'). Defaults to the current\nbranch.",type:["string","null"]},kind:{description:"Optional kind filter, only show diffs for this symbol kind (e.g.\n'function', 'struct').",type:["string","null"]},limit:{description:"Maximum combined added, removed, and changed results (default: 100,\nat most 256).",format:"uint32",minimum:0,type:["integer","null"]}},required:["base"],title:"BranchDiffSurfaceRequestV1",type:"object"},{$defs:{BranchDiffCompleteV1:{additionalProperties:!1,properties:{base:{type:"string"},base_generation:{type:"string"},base_revision:{type:"string"},base_tree:{type:"string"},changes:{items:{$ref:"#/$defs/BranchSymbolChangeV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},head:{type:"string"},head_generation:{type:"string"},head_revision:{type:"string"},head_tree:{type:"string"},status:{$ref:"#/$defs/GitReadCompleteV1"},summary:{$ref:"#/$defs/BranchDiffSummaryV1"},total_changes:{format:"uint",minimum:0,type:"integer"}},required:["status","base","head","base_revision","base_tree","head_revision","head_tree","base_generation","head_generation","total_changes","summary","changes"],type:"object"},BranchDiffPartialV1:{additionalProperties:!1,properties:{base:{type:"string"},base_generation:{type:"string"},base_revision:{type:"string"},base_tree:{type:"string"},changes:{items:{$ref:"#/$defs/BranchSymbolChangeV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},head:{type:"string"},head_generation:{type:"string"},head_revision:{type:"string"},head_tree:{type:"string"},next_cursor:{type:"string"},reason:{$ref:"#/$defs/GitResultLimitV1"},status:{$ref:"#/$defs/GitReadPartialV1"},summary:{$ref:"#/$defs/BranchDiffSummaryV1"},total_changes:{format:"uint",minimum:0,type:"integer"}},required:["status","reason","base","head","base_revision","base_tree","head_revision","head_tree","base_generation","head_generation","total_changes","next_cursor","summary","changes"],type:"object"},BranchDiffReferenceUnavailableV1:{additionalProperties:!1,description:"Either branch of `base..head` does not resolve to a local commit.",properties:{base_or_head:{description:"The requested range, `base..head`.",type:"string"},reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","base_or_head","reason","retryable"],type:"object"},BranchDiffSummaryV1:{additionalProperties:!1,properties:{added:{format:"uint",minimum:0,type:"integer"},changed:{format:"uint",minimum:0,type:"integer"},removed:{format:"uint",minimum:0,type:"integer"}},required:["added","removed","changed"],type:"object"},BranchDiffUnavailableV1:{additionalProperties:!1,description:"No sealed code-index generations compare the two branches' commits.",properties:{base:{type:"string"},base_generation:{type:["string","null"]},base_revision:{type:"string"},head:{type:"string"},head_generation:{type:["string","null"]},head_revision:{type:"string"},reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","base","head","base_revision","head_revision","reason","retryable"],type:"object"},BranchSymbolChangeV1:{oneOf:[{additionalProperties:!1,properties:{change:{const:"added",type:"string"},symbol:{$ref:"#/$defs/BranchSymbolV1"}},required:["change","symbol"],type:"object"},{additionalProperties:!1,properties:{change:{const:"removed",type:"string"},symbol:{$ref:"#/$defs/BranchSymbolV1"}},required:["change","symbol"],type:"object"},{additionalProperties:!1,properties:{base:{$ref:"#/$defs/BranchSymbolV1"},change:{const:"changed",type:"string"},head:{$ref:"#/$defs/BranchSymbolV1"}},required:["change","base","head"],type:"object"}]},BranchSymbolV1:{additionalProperties:!1,description:"A symbol in one branch's sealed generation.",properties:{content_digest:{type:"string"},file:{type:"string"},file_identity:{type:"string"},file_occurrence_id:{type:"string"},kind:{type:"string"},name:{type:"string"},qualified_name:{type:"string"},symbol_identity:{type:"string"},symbol_occurrence_id:{type:"string"}},required:["symbol_identity","symbol_occurrence_id","file_identity","file_occurrence_id","name","qualified_name","kind","file","content_digest"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GitReadCompleteV1:gj,GitReadPartialV1:gC,GitReadUnavailableV1:gT,GitResultLimitV1:gO,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/BranchDiffCompleteV1"},{$ref:"#/$defs/BranchDiffPartialV1"},{$ref:"#/$defs/BranchDiffUnavailableV1"},{$ref:"#/$defs/BranchDiffReferenceUnavailableV1"}],title:"BranchDiffResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{description:"Continuation cursor returned as `next_cursor` by the preceding page\nwith the same `limit`.",type:["string","null"]},limit:{description:"Maximum local refs to return (default: 100, at most 128).",format:"uint32",minimum:0,type:["integer","null"]}},title:"BranchListSurfaceRequestV1",type:"object"},{$defs:{BranchListPageV1:{additionalProperties:!1,properties:{examined:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},limit:{format:"uint",minimum:0,type:"integer"},next_cursor:{type:["string","null"]},reason:{anyOf:[{$ref:"#/$defs/GitReferenceLimitV1"},{type:"null"}]},snapshot_count:{format:"uint",minimum:0,type:"integer"},snapshots:{items:{$ref:"#/$defs/BranchSnapshotEntryV1"},type:"array"},status:{$ref:"#/$defs/GitPageStatusV1"}},required:["status","snapshot_count","examined","limit","snapshots"],type:"object"},BranchReadUnavailableV1:{additionalProperties:!1,description:"A local branch read refused before any snapshot was taken.",properties:{reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","reason","retryable"],type:"object"},BranchSnapshotEntryV1:{additionalProperties:!1,properties:{branch:{type:"string"},source_revision:{type:"string"},source_tree:{type:"string"}},required:["branch","source_revision","source_tree"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GitPageStatusV1:gx,GitReadUnavailableV1:gT,GitReferenceLimitV1:{enum:["reference_limit"],type:"string"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/BranchListPageV1"},{$ref:"#/$defs/BranchReadUnavailableV1"}],title:"BranchListResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{branch:{description:"Exact local branch name to search.",type:"string"},cursor:{description:"Authenticated continuation cursor returned by the preceding exact\nbranch-search page.",type:["string","null"]},limit:{description:"Maximum number of results to return (default: 10, at most 500).",format:"uint32",minimum:0,type:["integer","null"]},query:{description:"Search query string to match against symbol names.",type:"string"}},required:["branch","query"],title:"BranchSearchSurfaceRequestV1",type:"object"},{$defs:{BranchReferenceUnavailableV1:{additionalProperties:!1,description:"The named branch does not resolve to a local commit.",properties:{branch:{type:"string"},reason:{type:"string"},retryable:{type:"boolean"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","branch","reason","retryable"],type:"object"},BranchSearchHitV1:{additionalProperties:!1,properties:{branch:{type:"string"},candidate:{$ref:"#/$defs/RankedCandidate"},code_generation:{type:"string"},kind:{type:["string","null"]},name:{type:["string","null"]},path:{type:["string","null"]},qualified_name:{type:["string","null"]},source_reference:{type:"string"},source_revision:{type:"string"},source_tree:{type:"string"}},required:["candidate","branch","source_reference","source_revision","source_tree","code_generation"],type:"object"},BranchSearchPageV1:{additionalProperties:!1,properties:{branch:{type:"string"},code_generation:{type:"string"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},next_cursor:{type:["string","null"]},reason:{anyOf:[{$ref:"#/$defs/GitResultLimitV1"},{type:"null"}]},results:{items:{$ref:"#/$defs/BranchSearchHitV1"},type:"array"},source_reference:{type:"string"},source_revision:{type:"string"},source_tree:{type:"string"},status:{$ref:"#/$defs/GitPageStatusV1"}},required:["status","branch","source_reference","source_revision","source_tree","code_generation","results"],type:"object"},BranchSearchUnavailableV1:{additionalProperties:!1,description:"No sealed code-index generation answers for the branch's commit.",properties:{branch:{type:"string"},code_generation:{type:["string","null"]},reason:{type:"string"},retryable:{type:"boolean"},source_revision:{type:"string"},status:{$ref:"#/$defs/GitReadUnavailableV1"}},required:["status","branch","source_revision","reason","retryable"],type:"object"},CalibrationProfileId:hi,CandidateContribution:hs,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComponentRevision:hj,EvidenceRole:yC,ExactClass:yT,FileOccurrenceId:gs,FixedPointScore:gc,FreshnessCompatibilityV1:gl,FusedCandidate:gp,GitPageStatusV1:gx,GitReadUnavailableV1:gT,GitResultLimitV1:gO,LogicalCopyClusterId:_i,LogicalEvidenceId:_o,OccurrenceProvenance:_z,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RankedCandidate:{additionalProperties:!1,description:"A fused candidate with its final deterministic ordinal.",properties:{candidate:{$ref:"#/$defs/FusedCandidate"},final_ordinal:{format:"uint32",minimum:0,type:"integer"}},required:["candidate","final_ordinal"],type:"object"},RankingDecision:vp,RankingDecisionKind:vu,RepositoryId:vb,RetrievalAnchorId:vI,RetrievalSourceRoleV1:vC,RetrieverKind:vO,ScoreDomainId:v2,SessionOrThreadId:v7,SourceFreshness:by,SourceInstanceKey:bg,SourceNamespace:bv,SourceOccurrenceId:bb,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/BranchSearchPageV1"},{$ref:"#/$defs/BranchSearchUnavailableV1"},{$ref:"#/$defs/BranchReferenceUnavailableV1"}],title:"BranchSearchResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{qualified_name:{description:"The exact qualified name to look up.",type:"string"}},required:["qualified_name"],title:"ByQualifiedNameSurfaceRequestV1",type:"object"},{$defs:{PrimitiveSymbolLocationV1:_1},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Every indexed symbol sharing one qualified name (overloads, generics,\nseparate impl blocks).",items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},title:"ByQualifiedNameResultV1",type:"array"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{from_node_id:{type:"string"},maximum_depth:{default:8,format:"uint32",minimum:0,type:"integer"},to_node_id:{type:"string"}},required:["from_node_id","to_node_id"],title:"CallChainPrimitiveRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{edge_kinds:{items:{type:"string"},type:"array"},node_ids:{items:{type:"string"},type:"array"}},required:["node_ids","edge_kinds"],title:"CallChainPrimitiveResult",type:"object"},{$defs:{NativeIntegrationTransactionId:_T},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"}},required:["transaction_id"],title:"NativeIntegrationCancelSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{from_ref:{description:"Starting git ref (commit, branch, tag).",type:"string"},to_ref:{description:"Ending git ref (commit, branch, tag).",type:"string"}},required:["from_ref","to_ref"],title:"ChangelogSurfaceRequestV1",type:"object"},{$defs:{ChangelogCompleteV1:{additionalProperties:!1,properties:{base_generation:{type:"string"},changed_file_count:{format:"uint",minimum:0,type:"integer"},changed_files:{items:{type:"string"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},from_ref:{type:"string"},head_generation:{type:"string"},status:{$ref:"#/$defs/GitReadCompleteV1"},symbol_changes_coverage:{$ref:"#/$defs/SymbolChangesCompleteV1"},symbols_added:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},symbols_modified:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},symbols_removed:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},to_ref:{type:"string"}},required:["status","from_ref","to_ref","changed_file_count","changed_files","base_generation","head_generation","symbols_added","symbols_removed","symbols_modified","symbol_changes_coverage"],type:"object"},ChangelogPartialV1:{additionalProperties:!1,description:"The tree diff without symbol changes: the refs are not both exact local\nbranches with sealed generations.",properties:{changed_file_count:{format:"uint",minimum:0,type:"integer"},changed_files:{items:{type:"string"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},from_ref:{type:"string"},status:{$ref:"#/$defs/GitReadPartialV1"},symbol_changes_coverage:{$ref:"#/$defs/SymbolChangesUnavailableV1"},symbols_added:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},symbols_modified:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},symbols_removed:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},to_ref:{type:"string"}},required:["status","from_ref","to_ref","changed_file_count","changed_files","symbols_added","symbols_removed","symbols_modified","symbol_changes_coverage"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GitComparedSymbolV1:gy,GitReadCompleteV1:gj,GitReadPartialV1:gC,GitReadUnavailableV1:gT,GitToolErrorKindV1:gW,GitToolErrorV1:gM,GitToolFailureV1:gN,GitToolOperationV1:gz,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,SymbolChangesCompleteV1:{additionalProperties:!1,properties:{status:{$ref:"#/$defs/GitReadCompleteV1"}},required:["status"],type:"object"},SymbolChangesUnavailableV1:bV},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/ChangelogCompleteV1"},{$ref:"#/$defs/ChangelogPartialV1"},{$ref:"#/$defs/GitToolFailureV1"}],title:"ChangelogResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of cycles to report, largest first (default: 25, max:\n200). The response always states the total detected and how many were\nomitted.",format:"uint32",minimum:0,type:["integer","null"]},member_limit:{description:"Maximum member files listed per reported cycle (default: 12, max:\n200). Each entry states its true member_count and\nomitted_member_count.",format:"uint32",minimum:0,type:["integer","null"]}},title:"CircularSurfaceRequestV1",type:"object"},{$defs:{CircularCycleV1:{additionalProperties:!1,description:"One reported file cycle: the members that fit the member bound, plus the\ncomponent's true size so the omission is stated rather than hidden.",properties:{member_count:{format:"uint64",minimum:0,type:"integer"},members:{items:{type:"string"},type:"array"},omitted_member_count:{format:"uint64",minimum:0,type:"integer"}},required:["members","member_count","omitted_member_count"],type:"object"},CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cycle_count:{format:"uint64",minimum:0,type:"integer"},cycles:{items:{$ref:"#/$defs/CircularCycleV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},limit:{format:"uint64",minimum:0,type:"integer"},member_limit:{format:"uint64",minimum:0,type:"integer"},omitted_cycle_count:{format:"uint64",minimum:0,type:"integer"},reported_cycle_count:{format:"uint64",minimum:0,type:"integer"}},required:["cycle_count","reported_cycle_count","omitted_cycle_count","limit","member_limit","cycles"],title:"CircularResultV1",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{maximum_depth:{default:3,format:"uint32",minimum:0,type:"integer"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},node_id:{type:"string"},resolve_trait_dispatch:{default:!0,type:"boolean"},scope:{$ref:"#/$defs/CodeQueryScope",default:{generation:"code-generation:unpinned-latest.v1",path_prefix:null}}},required:["node_id"],title:"CodeCalleesSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,SymbolPrimitiveRecord:bI,SymbolRelationRecord:bx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/SymbolRelationRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{maximum_depth:{default:3,format:"uint32",minimum:0,type:"integer"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},node_id:{type:"string"},scope:{$ref:"#/$defs/SymbolGraphScope",default:{path_prefix:null}}},required:["node_id"],title:"CodeCallersSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeGraphReadFreshnessV1:hg,PrimitiveSupportGap:_Y,SymbolPrimitiveRecord:bI,SymbolRelationRecord:bx,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Bounded semantic result shared by the compatibility surfaces. Rendering,\ntransport envelopes, and MCP content blocks remain outside this contract.",properties:{freshness:{$ref:"#/$defs/CodeGraphReadFreshnessV1"},generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/SymbolRelationRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},related_edge_count:{format:"uint64",minimum:0,type:["integer","null"]},support_gaps:{items:{$ref:"#/$defs/PrimitiveSupportGap"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]},truncated:{type:"boolean"}},required:["generation","freshness","items","truncated","support_gaps"],title:"SymbolGraphPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},node_id:{type:"string"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["node_id","scope","meta"],title:"CodeNavigationSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,SymbolPrimitiveRecord:bI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeQueryScope:hV,ExactTechnicalTermKindV1:yO,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kind:{anyOf:[{$ref:"#/$defs/ExactTechnicalTermKindV1"},{type:"null"}]},literal:{type:"string"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["literal","scope","meta"],title:"CodeExactOccurrenceSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeOccurrenceRecord:hP,CodeSearchChunkId:hR,ExactOccurrenceRecord:{additionalProperties:!1,properties:{matched_kind:{$ref:"#/$defs/ExactTechnicalTermKindV1"},matched_literal:{type:"string"},occurrence:{$ref:"#/$defs/CodeOccurrenceRecord"}},required:["occurrence","matched_kind","matched_literal"],type:"object"},ExactTechnicalTermKindV1:yO,FileOccurrenceId:gs,SourceSpan:b$,SymbolOccurrenceId:bq},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/ExactOccurrenceRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeFacetDimension:hh,CodeGenerationId:hy,CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{dimension:{$ref:"#/$defs/CodeFacetDimension"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["dimension","scope","meta"],title:"CodeFacetSurfaceRequest",type:"object"},{$defs:{CodeFacetDimension:hh,CodeFacetRecord:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},dimension:{$ref:"#/$defs/CodeFacetDimension"},value:{type:"string"}},required:["dimension","value","count"],type:"object"},CodeGenerationId:hy},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/CodeFacetRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ImplementationSelector:{oneOf:[{properties:{name:{type:"string"},selector:{const:"trait",type:"string"}},required:["selector","name"],type:"object"},{properties:{name:{type:"string"},selector:{const:"method",type:"string"}},required:["selector","name"],type:"object"}]},ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},scope:{$ref:"#/$defs/SymbolGraphScope",default:{path_prefix:null}},selector:{$ref:"#/$defs/ImplementationSelector"}},required:["selector"],title:"CodeImplementationsSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeGraphReadFreshnessV1:hg,ImplementationRecord:{additionalProperties:!1,description:"One implementation match with its exact source: the implementing\nimpl/class block (methods included) for a trait selector, or the function\nbody for a method selector.",properties:{body:{type:"string"},dispatch_from:{description:"Trait or interface node a trait-selector match was reached through.",type:["string","null"]},edge_kind:{type:"string"},symbol:{$ref:"#/$defs/SymbolPrimitiveRecord"}},required:["symbol","edge_kind","body"],type:"object"},PrimitiveSupportGap:_Y,SymbolPrimitiveRecord:bI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Bounded semantic result shared by the compatibility surfaces. Rendering,\ntransport envelopes, and MCP content blocks remain outside this contract.",properties:{freshness:{$ref:"#/$defs/CodeGraphReadFreshnessV1"},generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/ImplementationRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},related_edge_count:{format:"uint64",minimum:0,type:["integer","null"]},support_gaps:{items:{$ref:"#/$defs/PrimitiveSupportGap"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]},truncated:{type:"boolean"}},required:["generation","freshness","items","truncated","support_gaps"],title:"SymbolGraphPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeLexicalField:{description:"Typed code fields accepted by the generation-owned lexical authority.",enum:["symbol_name","qualified_name","path","signature","documentation","body_text","preamble_text","exact_term","subtoken"],type:"string"},CodeLexicalFieldFilter:{additionalProperties:!1,properties:{field:{$ref:"#/$defs/CodeLexicalField"},include:{type:"boolean"}},required:["field","include"],type:"object"},CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Serializable adapter DTO for the request-local phrase query view.\n\nThe callable application request deliberately keeps its sanitized query\nnon-serializable. The owning runtime supplies the exact sanitizer\nrevisions when converting this transport DTO.",properties:{field_filters:{default:[],items:{$ref:"#/$defs/CodeLexicalFieldFilter"},type:"array"},fuzzy_budget:{default:0,format:"uint32",minimum:0,type:"integer"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},phrases:{items:{type:"string"},type:"array"},query:{type:"string"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["query","phrases","scope","meta"],title:"CodePhraseSearchSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeOccurrenceRecord:hP,CodeSearchChunkId:hR,FileOccurrenceId:gs,LexicalOccurrenceRecord:{additionalProperties:!1,properties:{matched_phrases:{items:{type:"string"},type:"array"},matched_terms:{items:{type:"string"},type:"array"},occurrence:{$ref:"#/$defs/CodeOccurrenceRecord"},score_micros:{format:"uint64",minimum:0,type:"integer"}},required:["occurrence","score_micros","matched_phrases","matched_terms"],type:"object"},SourceSpan:b$,SymbolOccurrenceId:bq},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/LexicalOccurrenceRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{is_async:{type:["boolean","null"]},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},params:{default:[],items:{type:"string"},type:"array"},returns:{type:["string","null"]},scope:{$ref:"#/$defs/SymbolGraphScope",default:{path_prefix:null}}},title:"CodeSignatureSearchSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeGraphReadFreshnessV1:hg,PrimitiveSupportGap:_Y,SymbolPrimitiveRecord:bI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Bounded semantic result shared by the compatibility surfaces. Rendering,\ntransport envelopes, and MCP content blocks remain outside this contract.",properties:{freshness:{$ref:"#/$defs/CodeGraphReadFreshnessV1"},generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},related_edge_count:{format:"uint64",minimum:0,type:["integer","null"]},support_gaps:{items:{$ref:"#/$defs/PrimitiveSupportGap"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]},truncated:{type:"boolean"}},required:["generation","freshness","items","truncated","support_gaps"],title:"SymbolGraphPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{lazy_index_ignored_dependencies:{type:"boolean"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},query:{type:"string"},scope:{$ref:"#/$defs/SymbolGraphScope"}},required:["query","scope","lazy_index_ignored_dependencies","meta"],title:"CodeSymbolSearchSurfaceRequest",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,CodeGenerationId:hy,CodeQueryScope:hV,ResultProjection:vP,RetrievalOrder:vx},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{meta:{$ref:"#/$defs/CallableCodeSurfaceMeta"},scope:{$ref:"#/$defs/CodeQueryScope"}},required:["scope","meta"],title:"CodeTimelineSurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeTimelineRecord:{additionalProperties:!1,properties:{file_count:{format:"uint64",minimum:0,type:"integer"},generation:{$ref:"#/$defs/CodeGenerationId"},indexed_at:{$ref:"#/$defs/UtcMicros"},symbol_count:{format:"uint64",minimum:0,type:"integer"}},required:["generation","indexed_at","file_count","symbol_count"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Generation-bound page returned by every callable code query. Coverage,\nomissions, scoring, and terminal state remain in the enclosing\n[`crate::result::RetrievalEvidence`].",properties:{generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/CodeTimelineRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},query_fallback:{description:"Independently hashed exact/lexical/graph subpayload. Callers preserve it\nbyte-for-byte rather than interpreting it, so the public schema admits\nthe canonical JSON it carries without re-declaring its internals."},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation","items"],title:"CodeQueryPage",type:"object"},{$defs:{CallableCodeSurfaceMeta:ho,ResultProjection:vP,RetrievalOrder:vx,SymbolGraphScope:bR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{maximum_depth:{default:5,format:"uint32",minimum:0,type:"integer"},meta:{$ref:"#/$defs/CallableCodeSurfaceMeta",default:{cursor:null,order:"source_position",projection:"evidence"}},node_id:{type:"string"},scope:{$ref:"#/$defs/SymbolGraphScope",default:{path_prefix:null}}},required:["node_id"],title:"CodeTypeHierarchySurfaceRequest",type:"object"},{$defs:{CodeGenerationId:hy,CodeGraphReadFreshnessV1:hg,PrimitiveSupportGap:_Y,SymbolPrimitiveRecord:bI,TypeHierarchyRecord:{additionalProperties:!1,properties:{depth:{format:"uint32",minimum:0,type:"integer"},edge_kind:{type:"string"},parent_node_id:{type:"string"},symbol:{$ref:"#/$defs/SymbolPrimitiveRecord"}},required:["symbol","parent_node_id","edge_kind","depth"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Bounded semantic result shared by the compatibility surfaces. Rendering,\ntransport envelopes, and MCP content blocks remain outside this contract.",properties:{freshness:{$ref:"#/$defs/CodeGraphReadFreshnessV1"},generation:{$ref:"#/$defs/CodeGenerationId"},items:{items:{$ref:"#/$defs/TypeHierarchyRecord"},type:"array"},next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},related_edge_count:{format:"uint64",minimum:0,type:["integer","null"]},support_gaps:{items:{$ref:"#/$defs/PrimitiveSupportGap"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]},truncated:{type:"boolean"}},required:["generation","freshness","items","truncated","support_gaps"],title:"SymbolGraphPage",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{staged_only:{description:"If true, compare pinned HEAD with immutable staged index blobs. The\ndefault compares HEAD with captured working-tree bytes, including\nuntracked files: a staged edit undone in the working tree cancels out.",type:["boolean","null"]}},title:"CommitContextSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,CommitCategoryV1:{description:"The commit category the changed file roles suggest.",enum:["feature/fix (source + tests)","feature/fix/refactor","test","chore/docs/config"],type:"string"},CommitContextSummaryV1:{additionalProperties:!1,properties:{changed_files:{items:{$ref:"#/$defs/CommitFileRoleV1"},type:"array"},comparison:{anyOf:[{$ref:"#/$defs/GitContextComparisonV1"},{type:"null"}]},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},recent_commits:{items:{type:"string"},type:"array"},source_coverage:{anyOf:[{$ref:"#/$defs/GitContextSourceCoverageV1"},{type:"null"}]},suggested_category:{anyOf:[{$ref:"#/$defs/CommitCategoryV1"},{type:"null"}],description:"Absent when the worktree has no changes."},summary:{type:"string"},symbols_by_role:{additionalProperties:!1,properties:{config:{items:{$ref:"#/$defs/CommitSymbolEntryV1"},type:"array"},docs:{items:{$ref:"#/$defs/CommitSymbolEntryV1"},type:"array"},source:{items:{$ref:"#/$defs/CommitSymbolEntryV1"},type:"array"},test:{items:{$ref:"#/$defs/CommitSymbolEntryV1"},type:"array"}},type:"object"}},required:["changed_files","symbols_by_role","recent_commits","summary"],type:"object"},CommitFileRoleV1:{additionalProperties:!1,properties:{comparison:{anyOf:[{$ref:"#/$defs/GitContextFileComparisonV1"},{type:"null"}]},file:{type:"string"},role:{$ref:"#/$defs/GitFileRoleV1"},symbols:{format:"uint",minimum:0,type:"integer"}},required:["file","role","symbols"],type:"object"},CommitSymbolEntryV1:{anyOf:[{$ref:"#/$defs/CommitSymbolV1"},{$ref:"#/$defs/ConfigSummaryV1"}]},CommitSymbolV1:{additionalProperties:!1,properties:{change:{anyOf:[{$ref:"#/$defs/GitDeclarationChangeKindV1"},{type:"null"}]},file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},source_side:{anyOf:[{$ref:"#/$defs/GitContextSourceSideV1"},{type:"null"}]}},required:["name","kind","file","line"],type:"object"},ConfigSummaryKindV1:hT,ConfigSummaryV1:hO,GitChangeKindV1:gh,GitContextComparisonV1:gg,GitContextFileComparisonV1:{additionalProperties:!1,properties:{after_blob:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},before_blob:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},change:{$ref:"#/$defs/GitChangeKindV1"},previous_file:{type:["string","null"]}},required:["change"],type:"object"},GitContextSourceConsistencyV1:{oneOf:[{enum:["immutable_blobs"],type:"string"},{const:"per_file_worktree_capture",description:"Each file is checked around its bounded read; this is not an atomic\nsnapshot of the entire working tree.",type:"string"}]},GitContextSourceCoverageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},consistency:{$ref:"#/$defs/GitContextSourceConsistencyV1"},gaps:{items:{$ref:"#/$defs/GitContextSourceGapV1"},type:"array"},git:{$ref:"#/$defs/GitCoverageV1"}},required:["complete","git","gaps","consistency"],type:"object"},GitContextSourceGapV1:{additionalProperties:!1,properties:{file:{type:"string"},reason:{type:"string"}},required:["file","reason"],type:"object"},GitContextSourceSideV1:{enum:["before","after"],type:"string"},GitCoverageV1:gv,GitDeclarationChangeKindV1:{enum:["added","removed","modified","signature_changed","visibility_changed","renamed","ambiguous_overload"],type:"string"},GitDegradationV1:gb,GitFileRoleV1:gS,GitOidV1:gq,GitToolErrorKindV1:gW,GitToolErrorV1:gM,GitToolFailureV1:gN,GitToolOperationV1:gz,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/CommitContextSummaryV1"},{$ref:"#/$defs/GitToolFailureV1"}],title:"CommitContextResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},node_kind:{description:"Filter by node kind (default: every kind).",type:["string","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"ComplexitySurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComplexityAnalysisV1:hx,ComplexityReportEntryV1:{additionalProperties:!1,properties:{branches:{format:"uint32",minimum:0,type:["integer","null"]},complexity_analysis:{$ref:"#/$defs/ComplexityAnalysisV1"},cyclomatic_complexity:{description:"The counters are `None` when `complexity_analysis` reports the bounded\nwalk did not cover the body.",format:"uint32",minimum:0,type:["integer","null"]},fan_in:{format:"uint64",minimum:0,type:"integer"},fan_out:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},lines:{format:"uint32",minimum:0,type:"integer"},loops:{format:"uint32",minimum:0,type:["integer","null"]},max_nesting:{format:"uint32",minimum:0,type:["integer","null"]},name:{type:"string"},score:{format:"uint64",minimum:0,type:"integer"}},required:["id","name","kind","file","line","lines","complexity_analysis","fan_out","fan_in","score"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{formula:{type:"string"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},note:{type:"string"},ranking:{items:{$ref:"#/$defs/ComplexityReportEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["formula","note","result_count","ranking"],title:"ComplexityReportV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exactly one of `path` or `glob` names the files to query.",properties:{glob:{description:"Glob pattern to match multiple config files (e.g. '**/Cargo.toml').\nMutually exclusive with 'path'.",type:["string","null"]},key:{description:"Dot-separated key path (e.g. 'package.version',\n'dependencies.tokio.version').",type:"string"},path:{description:"Project-relative path to a single config file (e.g. 'Cargo.toml').\nMutually exclusive with 'glob'.",type:["string","null"]}},required:["key"],title:"ConfigSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ConfigKeyFoundV1:{additionalProperties:!1,properties:{file:{type:"string"},key:{type:"string"},line:{description:"The first line whose text starts with the key's leaf segment.",format:"uint32",minimum:0,type:["integer","null"]},value:!0},required:["file","key","value"],type:"object"},ConfigKeyMissingV1:{additionalProperties:!1,description:"`value` is always null and `found` always false; both stay on the wire\nso a missing key reads the same as it always has.",properties:{file:{type:"string"},found:{type:"boolean"},key:{type:"string"},value:{type:"null"}},required:["file","key","value","found"],type:"object"},ConfigMatchV1:{anyOf:[{$ref:"#/$defs/ConfigParseErrorV1"},{$ref:"#/$defs/ConfigKeyMissingV1"},{$ref:"#/$defs/ConfigKeyFoundV1"}],description:"One queried config file: the file's parse error, the key's absence, or the\nkey's value and defining line.\n\nThe variants are distinguished by their exact field sets, so each one\ndenies unknown fields and the most specific shapes are tried first."},ConfigParseErrorV1:{additionalProperties:!1,properties:{error:{type:"string"},file:{type:"string"}},required:["file","error"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{description:"Files where the key was found or that failed to parse.",format:"uint",minimum:0,type:"integer"},matches:{items:{$ref:"#/$defs/ConfigMatchV1"},type:"array"}},required:["match_count","matches"],title:"ConfigResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{default:null,description:"The previous page's `next_cursor`, valid only with the same `limit`.",type:["string","null"]},limit:{format:"uint",minimum:0,type:"integer"}},required:["limit"],title:"ConfigurationAuditRequestV1",type:"object"},{$defs:{ActorId:fb,ConfigurationAuditEvent:{additionalProperties:!1,description:"Append-only audit record. `target_commitment` is event-scoped and cannot be\njoined across audit events; a caller must be separately authorized before\nany canonical target is resolved by the store/application layer.",properties:{actor_id:{$ref:"#/$defs/ActorId"},base_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},event_id:{$ref:"#/$defs/ConfigurationAuditEventId"},event_kind:{$ref:"#/$defs/ConfigurationAuditEventKindV1"},idempotency_key:{anyOf:[{$ref:"#/$defs/ConfigurationIdempotencyKey"},{type:"null"}]},occurred_at:{$ref:"#/$defs/UtcMicros"},operation_digest:{$ref:"#/$defs/ManifestDigest"},receipt_id:{anyOf:[{$ref:"#/$defs/ConfigurationReceiptId"},{type:"null"}]},result_revision_id:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},safe_reason_code:{type:["string","null"]},target_commitment:{$ref:"#/$defs/ManifestDigest"}},required:["event_id","event_kind","actor_id","base_revision_id","operation_digest","target_commitment","occurred_at"],type:"object"},ConfigurationAuditEventId:{description:"Strongly typed canonical identity: `ConfigurationAuditEventId`.",type:"string"},ConfigurationAuditEventKindV1:{enum:["dry_run_created","applied","rejected","expired","activation_failed","rollback_dry_run_created","rollback_applied","recovered"],type:"string"},ConfigurationIdempotencyKey:hE,ConfigurationReceiptId:hW,ConfigurationRevisionId:hM,ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",properties:{events:{items:{$ref:"#/$defs/ConfigurationAuditEvent"},type:"array"},next_cursor:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]}},required:["events"],title:"ConfigurationAuditPage",type:"object"},{$defs:{AccessRuleId:fv,ActorId:fb,AnalyzerEnvironmentVariable:fV,AnalyzerExecutableId:fR,AnalyzerExecutableReferenceV1:fq,AnalyzerLanguageId:fI,AnalyzerLanguageSelectionV1:fx,AnalyzerPrivacyClassV1:fj,AnalyzerResourceLimitsV1:fC,AnalyzerRestartPolicyV1:fT,AnalyzerSettingsV1:fO,AnalyzerStructuredValueV1:fE,AuthorityRef:fM,AutomaticWorktreeGcV1:fF,AutomationBackendV1:fL,AutomationHostModeV1:fU,AutomationSettingsV1:fZ,AutomationTaskSetV1:fQ,AutomationTaskSettingsV1:fX,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CodeIndexWorkerSelectionV1:hw,ConfigurationDirectMutationRequestV1:{oneOf:[{properties:{key:{$ref:"#/$defs/SettingKey"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"},operation:{const:"set",type:"string"},value:{$ref:"#/$defs/ConfigurationValueV1"}},required:["operation","layer","key","value"],type:"object"},{properties:{key:{$ref:"#/$defs/SettingKey"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"},operation:{const:"unset",type:"string"}},required:["operation","layer","key"],type:"object"}]},ConfigurationIdempotencyKey:hE,ConfigurationLayerIdV1:hA,ConfigurationRevisionId:hM,ConfigurationValueV1:hz,ContextScoutConfigurationLimitsV1:hB,ContextScoutConfigurationModeV1:hK,ContextScoutConfigurationStateV1:hJ,ContextScoutConfiguredModelPathV1:hZ,ContextScoutIntentKindV1:h6,ContextScoutIntentSettingsV1:h3,ContextScoutSettingsV1:yn,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,DecisionEngineSettingsV1:yb,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,IntentQuestionSettingsV1:gB,IntentWindowSettingsV1:gK,LcmSummarizerExecutableV1:g9,LcmSummarizerExecutablesV1:g5,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,QueryCollectionId:vd,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RuleEffect:vD,ScopeAccessRule:vG,ScopeAccessSubjectV1:vB,ScopeControlOperationV1:vK,ScopeSourceBinding:v1,SensitiveFilesystemLocatorV1:v4,SettingKey:ba,SourceBindingId:bh,SourceKindV1:b_,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkContentLocationClassV1:$u,WorkEffortClassV1:$y,WorkEgressPolicy:$g,WorkExecutableBindingV1:$b,WorkExecutableCapabilityV1:$$,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExpertiseCategoryV1:$V,WorkExpertiseConsentV1:$R,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkOrdinalBandV1:$U,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteCandidateV1:Sg,WorkRouteExecutionProfileV1:Sv,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"},mutations:{items:{$ref:"#/$defs/ConfigurationDirectMutationRequestV1"},type:"array"}},required:["mutations","expected_revision","idempotency_key"],title:"ConfigurationBatchRequestV1",type:"object"},{$defs:{AccessPolicyDigest:f_,ConfigurationReceiptId:hW,ConfigurationRevisionId:hM,ConfigurationSettlementAuthorityV1:{additionalProperties:!1,description:"Original authorization evidence pinned to a durable configuration effect.\nA retry reauthorizes access separately without replacing these fields.",properties:{policy_digest:{$ref:"#/$defs/AccessPolicyDigest"},policy_epoch:{format:"uint64",minimum:0,type:"integer"},revalidated_at:{$ref:"#/$defs/UtcMicros"}},required:["policy_epoch","policy_digest","revalidated_at"],type:"object"},ConfigurationSnapshotId:hN,ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",properties:{base_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},created_at:{$ref:"#/$defs/UtcMicros"},effective_deadline_at:{$ref:"#/$defs/UtcMicros"},operation_digest:{$ref:"#/$defs/ManifestDigest"},receipt_id:{$ref:"#/$defs/ConfigurationReceiptId"},result_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},settlement_authority:{$ref:"#/$defs/ConfigurationSettlementAuthorityV1"},snapshot_id:{$ref:"#/$defs/ConfigurationSnapshotId"}},required:["receipt_id","base_revision_id","result_revision_id","snapshot_id","operation_digest","settlement_authority","created_at","effective_deadline_at"],title:"ConfigurationMutationReceipt",type:"object"},{$defs:{SettingKey:ba},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{key:{$ref:"#/$defs/SettingKey"}},required:["key"],title:"ConfigurationGetRequestV1",type:"object"},{$defs:{AccessRuleId:fv,ActorId:fb,AnalyzerEnvironmentVariable:fV,AnalyzerExecutableId:fR,AnalyzerExecutableReferenceV1:fq,AnalyzerLanguageId:fI,AnalyzerLanguageSelectionV1:fx,AnalyzerPrivacyClassV1:fj,AnalyzerResourceLimitsV1:fC,AnalyzerRestartPolicyV1:fT,AnalyzerSettingsV1:fO,AnalyzerStructuredValueV1:fE,AuthorityRef:fM,AutomaticWorktreeGcV1:fF,AutomationBackendV1:fL,AutomationHostModeV1:fU,AutomationSettingsV1:fZ,AutomationTaskSetV1:fQ,AutomationTaskSettingsV1:fX,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CandidateDispositionV1:{enum:["winning","overridden","rejected","defaulted"],type:"string"},CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CodeIndexWorkerSelectionV1:hw,ConfigurationCandidateV1:{additionalProperties:!1,description:"Resolution provenance is intentionally distinct from behavior. Moving the\nsame winner between layers can change this material without changing the\neffective behavior digest.",properties:{disposition:{$ref:"#/$defs/CandidateDispositionV1"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"},revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},safe_reason:{type:["string","null"]}},required:["layer","revision_id","disposition"],type:"object"},ConfigurationLayerIdV1:hA,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,ConfigurationValueV1:hz,ContextScoutConfigurationLimitsV1:hB,ContextScoutConfigurationModeV1:hK,ContextScoutConfigurationStateV1:hJ,ContextScoutConfiguredModelPathV1:hZ,ContextScoutIntentKindV1:h6,ContextScoutIntentSettingsV1:h3,ContextScoutSettingsV1:yn,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,DecisionEngineSettingsV1:yb,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,IntentQuestionSettingsV1:gB,IntentWindowSettingsV1:gK,LcmSummarizerExecutableV1:g9,LcmSummarizerExecutablesV1:g5,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,QueryCollectionId:vd,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RuleEffect:vD,ScopeAccessRule:vG,ScopeAccessSubjectV1:vB,ScopeControlOperationV1:vK,ScopeSourceBinding:v1,SensitiveFilesystemLocatorV1:v4,SettingKey:ba,SourceBindingId:bh,SourceKindV1:b_,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkContentLocationClassV1:$u,WorkEffortClassV1:$y,WorkEgressPolicy:$g,WorkExecutableBindingV1:$b,WorkExecutableCapabilityV1:$$,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExpertiseCategoryV1:$V,WorkExpertiseConsentV1:$R,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkOrdinalBandV1:$U,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteCandidateV1:Sg,WorkRouteExecutionProfileV1:Sv,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",properties:{candidates:{items:{$ref:"#/$defs/ConfigurationCandidateV1"},type:"array"},effective_behavior_digest:{$ref:"#/$defs/ManifestDigest"},effective_value:{$ref:"#/$defs/ConfigurationValueV1"},key:{$ref:"#/$defs/SettingKey"},resolution_provenance_digest:{$ref:"#/$defs/ManifestDigest"},revision_id:{$ref:"#/$defs/ConfigurationRevisionId",description:"Current configuration revision accepted by mutation `expected_revision` CAS."},snapshot_id:{$ref:"#/$defs/ConfigurationSnapshotId",description:"Content identity of the fully resolved configuration snapshot."}},required:["key","effective_value","revision_id","snapshot_id","effective_behavior_digest","resolution_provenance_digest","candidates"],title:"ResolvedSetting",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Typed input for the configuration list read through the daemon\ninvocation boundary.",title:"ConfigurationListRequestV1",type:"object"},{$defs:{RestartRequirementV1:{enum:["none","analyzer_restart","daemon_restart"],type:"string"},SettingKey:ba,SettingSensitivityV1:{enum:["public","sensitive"],type:"string"},SettingSummary:{properties:{key:{$ref:"#/$defs/SettingKey"},restart_requirement:{$ref:"#/$defs/RestartRequirementV1"},sensitivity:{$ref:"#/$defs/SettingSensitivityV1"}},required:["key","sensitivity","restart_requirement"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",items:{$ref:"#/$defs/SettingSummary"},title:"Array_of_SettingSummary",type:"array"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,title:"ConfigurationObservedStateRequestV1",type:"object"},{$defs:{ActivationDriftV1:{enum:["current","never_activated","pending_restart","activation_failed"],type:"string"},ComponentConfigurationState:{properties:{activation_error_code:{type:["string","null"]},component:{type:"string"},desired_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},drift:{$ref:"#/$defs/ActivationDriftV1"},last_working_revision_id:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},observed_revision_id:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},restart_required:{type:"boolean"}},required:["component","desired_revision_id","restart_required","drift"],type:"object"},ConfigurationRevisionId:hM},$schema:"https://json-schema.org/draft/2020-12/schema",items:{$ref:"#/$defs/ComponentConfigurationState"},title:"Array_of_ComponentConfigurationState",type:"array"},{$defs:{ChangePlanId:hu,ConfigurationIdempotencyKey:hE,ConfigurationRevisionId:hM,ManifestDigest:_l},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_base_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"},operation_digest:{$ref:"#/$defs/ManifestDigest"},plan_id:{$ref:"#/$defs/ChangePlanId"}},required:["plan_id","expected_base_revision_id","operation_digest","idempotency_key"],title:"ConfigurationProtectedApplyRequestV1",type:"object"},{$defs:{AccessRuleId:fv,ActorId:fb,AuthorityRef:fM,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,ConfigurationRevisionId:hM,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProtectedChange:{description:"The protected configuration operation set. Ordinary scalar mutations are\nintentionally absent; they activate directly after validation.",oneOf:[{properties:{kind:{const:"bind_source",type:"string"},value:{$ref:"#/$defs/ScopeSourceBinding"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"rebind_source",type:"string"},value:{$ref:"#/$defs/ScopeSourceBinding"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"unbind_source",type:"string"},value:{properties:{binding_id:{$ref:"#/$defs/SourceBindingId"}},required:["binding_id"],type:"object"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"upsert_access_rule",type:"string"},value:{$ref:"#/$defs/ScopeAccessRule"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"remove_access_rule",type:"string"},value:{properties:{rule_id:{$ref:"#/$defs/AccessRuleId"}},required:["rule_id"],type:"object"}},required:["kind","value"],type:"object"},{properties:{kind:{const:"replace_work_topology_policy",type:"string"},value:{$ref:"#/$defs/WorkTopologyPolicyV1"}},required:["kind","value"],type:"object"}]},ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RuleEffect:vD,ScopeAccessRule:vG,ScopeAccessSubjectV1:vB,ScopeControlOperationV1:vK,ScopeSourceBinding:v1,SensitiveFilesystemLocatorV1:v4,SourceBindingId:bh,SourceKindV1:b_,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{change:{$ref:"#/$defs/ProtectedChange"},expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"}},required:["change","expected_revision"],title:"ConfigurationProtectedPreviewRequestV1",type:"object"},{$defs:{AccessPolicyDigest:f_,ActorId:fb,ChangePlanId:hu,ConfigurationRevisionId:hM,ManifestDigest:_l,RedactedConfigurationChangeV1:{additionalProperties:!1,properties:{after_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},before_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},operation:{$ref:"#/$defs/ScopeControlOperationV1"},setting_key:{$ref:"#/$defs/SettingKey"}},required:["setting_key","operation"],type:"object"},ScopeControlOperationV1:vK,SettingKey:ba,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Immutable dry-run result. It contains no raw locator, secret, target\nidentity, or plaintext configuration value.",properties:{actor_id:{$ref:"#/$defs/ActorId"},authorization_policy_digest:{$ref:"#/$defs/AccessPolicyDigest"},base_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"},created_at:{$ref:"#/$defs/UtcMicros"},expires_at:{$ref:"#/$defs/UtcMicros"},membership_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},operation_digest:{$ref:"#/$defs/ManifestDigest"},plan_id:{$ref:"#/$defs/ChangePlanId"},policy_epoch:{format:"uint64",minimum:0,type:"integer"},redacted_changes:{items:{$ref:"#/$defs/RedactedConfigurationChangeV1"},type:"array"},resolved_scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["plan_id","actor_id","base_revision_id","operation_digest","resolved_scope_digest","authorization_policy_digest","policy_epoch","expires_at","created_at","redacted_changes"],title:"ProtectedChangePlan",type:"object"},{$defs:{ConfigurationRevisionId:hM,RollbackModeV1:{enum:["all_or_nothing","partial"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{mode:{$ref:"#/$defs/RollbackModeV1"},target_revision_id:{$ref:"#/$defs/ConfigurationRevisionId"}},required:["target_revision_id","mode"],title:"ConfigurationRollbackPreviewRequestV1",type:"object"},{$defs:{AccessRuleId:fv,ActorId:fb,AnalyzerEnvironmentVariable:fV,AnalyzerExecutableId:fR,AnalyzerExecutableReferenceV1:fq,AnalyzerLanguageId:fI,AnalyzerLanguageSelectionV1:fx,AnalyzerPrivacyClassV1:fj,AnalyzerResourceLimitsV1:fC,AnalyzerRestartPolicyV1:fT,AnalyzerSettingsV1:fO,AnalyzerStructuredValueV1:fE,AuthorityRef:fM,AutomaticWorktreeGcV1:fF,AutomationBackendV1:fL,AutomationHostModeV1:fU,AutomationSettingsV1:fZ,AutomationTaskSetV1:fQ,AutomationTaskSettingsV1:fX,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CodeIndexWorkerSelectionV1:hw,ConfigurationIdempotencyKey:hE,ConfigurationLayerIdV1:hA,ConfigurationRevisionId:hM,ConfigurationValueV1:hz,ContextScoutConfigurationLimitsV1:hB,ContextScoutConfigurationModeV1:hK,ContextScoutConfigurationStateV1:hJ,ContextScoutConfiguredModelPathV1:hZ,ContextScoutIntentKindV1:h6,ContextScoutIntentSettingsV1:h3,ContextScoutSettingsV1:yn,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,DecisionEngineSettingsV1:yb,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,IntentQuestionSettingsV1:gB,IntentWindowSettingsV1:gK,LcmSummarizerExecutableV1:g9,LcmSummarizerExecutablesV1:g5,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,QueryCollectionId:vd,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RuleEffect:vD,ScopeAccessRule:vG,ScopeAccessSubjectV1:vB,ScopeControlOperationV1:vK,ScopeSourceBinding:v1,SensitiveFilesystemLocatorV1:v4,SettingKey:ba,SourceBindingId:bh,SourceKindV1:b_,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkContentLocationClassV1:$u,WorkEffortClassV1:$y,WorkEgressPolicy:$g,WorkExecutableBindingV1:$b,WorkExecutableCapabilityV1:$$,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExpertiseCategoryV1:$V,WorkExpertiseConsentV1:$R,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkOrdinalBandV1:$U,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteCandidateV1:Sg,WorkRouteExecutionProfileV1:Sv,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Typed revision-CAS input for a configuration write through the daemon\ninvocation boundary.",properties:{expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"},key:{$ref:"#/$defs/SettingKey"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"},value:{$ref:"#/$defs/ConfigurationValueV1"}},required:["layer","key","value","expected_revision","idempotency_key"],title:"ConfigurationSetRequestV1",type:"object"},{$defs:{ConfigurationIdempotencyKey:hE,ConfigurationLayerIdV1:hA,ConfigurationRevisionId:hM,ProjectId:_4,QueryCollectionId:vd,SettingKey:ba,UserProfileId:bJ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"},key:{$ref:"#/$defs/SettingKey"},layer:{$ref:"#/$defs/ConfigurationLayerIdV1"}},required:["layer","key","expected_revision","idempotency_key"],title:"ConfigurationUnsetRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of literal sites to return (default: 100, max: 1000).",format:"uint32",minimum:0,type:["integer","null"]},struct:{description:"Struct name to search literal sites of (e.g. 'GraphStats', 'Config').",type:"string"}},required:["struct"],title:"ConstructorsSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ConstructorFieldCoverageV1:{description:"Whether a literal site's field lists are complete relative to the\nstruct's graph definition.",enum:["complete","unknown"],type:"string"},ConstructorResolutionReasonV1:{enum:["ambiguous_simple_name","syntax_only_simple_name"],type:"string"},ConstructorResolutionStatusV1:{description:"Syntax alone cannot link same-name types across modules, so every\nresolution is unverified.",enum:["unverified"],type:"string"},ConstructorSiteV1:{additionalProperties:!1,properties:{field_coverage:{$ref:"#/$defs/ConstructorFieldCoverageV1"},fields:{items:{type:"string"},type:"array"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},missing_fields:{items:{type:"string"},type:"array"},update_fields:{items:{type:"string"},type:"array"}},required:["file","line","fields","update_fields","missing_fields","field_coverage"],type:"object"},ConstructorsNotFoundV1:{additionalProperties:!1,properties:{found:{description:"Always `false`: no struct, class, or case class has the name.",type:"boolean"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{format:"uint64",minimum:0,type:"integer"},message:{type:"string"},sites:{items:{$ref:"#/$defs/ConstructorSiteV1"},type:"array"},struct:{type:"string"}},required:["found","struct","message","match_count","sites"],type:"object"},ConstructorsReportV1:{additionalProperties:!1,properties:{candidate_count:{format:"uint64",minimum:0,type:"integer"},expected_fields:{description:"`None` when the name resolves to more than one definition.",items:{type:"string"},type:["array","null"]},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{format:"uint64",minimum:0,type:"integer"},resolution_reason:{$ref:"#/$defs/ConstructorResolutionReasonV1"},resolution_status:{$ref:"#/$defs/ConstructorResolutionStatusV1"},sites:{items:{$ref:"#/$defs/ConstructorSiteV1"},type:"array"},struct:{type:"string"}},required:["struct","candidate_count","resolution_status","resolution_reason","match_count","sites"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/ConstructorsNotFoundV1"},{$ref:"#/$defs/ConstructorsReportV1"}],title:"ConstructorsResultV1"},{$defs:{ContextModeV1:hL},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{budget_tokens:{description:"Cap the ranked sections of the answer at about this many tokens.\nQuotas are fixed shares of the budget. The cut is reported on the result.",format:"uint32",minimum:0,type:["integer","null"]},include_code:{type:["boolean","null"]},include_memory:{type:["boolean","null"]},lexical_anchors:{description:"Exact identifiers or technical terms the answer must be about. Each\nruns as its own lexical route: hits carrying an anchor outrank hits\ncarrying none, exact hits included, every anchor with matches keeps at\nleast its best sites through the lane cap, and `lexical_anchors` in the\nresult reports each anchor's outcome: the sites this result returns\nand, by reason, the admitted sites it could not carry. Bounded and\nvalidated by the retrieval kernel; a\nviolation is a typed request rejection. Identifiers the task names\n(`snake_case`, `camelCase`, `a::b`) are anchored after these.",items:{type:"string"},type:["array","null"]},max_code_blocks:{format:"uint32",minimum:0,type:["integer","null"]},max_nodes:{format:"uint32",minimum:0,type:["integer","null"]},memory_limit:{format:"uint32",minimum:0,type:["integer","null"]},memory_min_trust:{format:"double",type:["number","null"]},mode:{anyOf:[{$ref:"#/$defs/ContextModeV1"},{type:"null"}]},prefer_symbol:{description:"Add a symbol-name lexical route for the identifier-shaped words of the\ntask text.",type:["boolean","null"]},task:{type:"string"}},required:["task"],title:"ContextSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ContextCodeBlockV1:{additionalProperties:!1,properties:{code:{type:"string"},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},node_id:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["node_id","file","start_line","end_line","code"],type:"object"},ContextExtensionPointV1:{additionalProperties:!1,description:"A public trait or interface among the context's selected symbols.",properties:{file:{type:"string"},implementor_count:{format:"uint",minimum:0,type:"integer"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","file","line","implementor_count"],type:"object"},ContextLexicalAnchorV1:hF,ContextModeV1:hL,ContextPlanV1:{additionalProperties:!1,description:"Plan-mode enrichment: where the selected code can be extended and which\ntest files reach it.",properties:{extension_points:{items:{$ref:"#/$defs/ContextExtensionPointV1"},type:"array"},test_files:{description:"Test files calling the selected symbols within two hops; absent when\nno symbol was selected to trace from.",items:{type:"string"},type:["array","null"]}},required:["extension_points"],type:"object"},ContextRelatedOmissionV1:{additionalProperties:!1,description:"Related symbols `context` ranked but did not return.",properties:{omitted:{description:"Ranked related symbols the `max_nodes` cut dropped.",format:"uint",minimum:0,type:"integer"},total:{description:"Distinct related symbols the walk found and ranked.",format:"uint",minimum:0,type:"integer"},total_is_lower_bound:{description:"The neighbor walk stopped at its row limit, so `total` is a lower\nbound.",type:"boolean"}},required:["total","omitted","total_is_lower_bound"],type:"object"},ContextRetrievalPlanV1:{additionalProperties:!1,description:"The retrieval plan `context` executed: which stages ran, what each\nadmitted, and where a budget bounded the answer. Lane-level serving state\nstays in `coverage`.",properties:{code:{$ref:"#/$defs/ContextStageV1",description:"Source bodies for selected symbols, bounded by `max_code_blocks`."},graph:{$ref:"#/$defs/ContextStageV1",description:"Candidates resolved to verified graph symbols."},memory:{$ref:"#/$defs/ContextStageV1",description:"Project memory facts, bounded by `memory_limit`."},related:{$ref:"#/$defs/ContextStageV1",description:"Ranked neighbors of the selected symbols, bounded by `max_nodes`."},search:{$ref:"#/$defs/ContextStageV1",description:"Ranked code-index candidates, bounded by `max_nodes`."}},required:["search","graph","related","code","memory"],type:"object"},ContextRetrievalRouteV1:{description:"Which retrieval route `context` ran.\n\n`name` is the preferred-symbol route. `prose` is the ordinary task\nroute. A caller that omits `prefer_symbol` gets `name` only when the\ntask is one identifier or one `Type.method` / `path::name` token.",enum:["name","prose"],type:"string"},ContextSearchMatchV1:{additionalProperties:!1,properties:{anchor_id:{type:"string"},anchors:{description:"Lexical anchors, the caller's and then the task's identifiers, whose\nroute ranked this match; the anchor receipt counts it as returned.",items:{type:"string"},type:"array"},exact_class:{type:"string"},file:{type:"string"},kind:{type:"string"},name:{type:"string"},qualified_name:{type:"string"},rank:{format:"uint32",minimum:0,type:"integer"},utility_micros:{format:"uint64",minimum:0,type:"integer"}},required:["anchor_id","name","qualified_name","kind","file","exact_class","rank","utility_micros"],type:"object"},ContextStageV1:{description:"What one `context` stage ran with and kept.",oneOf:[{description:"The request did not ask for this stage.",properties:{state:{const:"not_requested",type:"string"}},required:["state"],type:"object"},{description:"A stage this one reads from produced nothing to work on.",properties:{state:{const:"skipped",type:"string"}},required:["state"],type:"object"},{description:"The stage's authority could not answer.",properties:{state:{const:"unavailable",type:"string"}},required:["state"],type:"object"},{description:"The stage admitted `admitted` entries under `budget`. `truncated` is\ntrue when it stopped at that budget, so more entries may exist.",properties:{admitted:{format:"uint32",minimum:0,type:"integer"},budget:{format:"uint32",minimum:0,type:"integer"},state:{const:"ran",type:"string"},truncated:{type:"boolean"}},required:["state","budget","admitted","truncated"],type:"object"}]},FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LexicalAnchorDropReasonV1:_e,LexicalAnchorDropV1:_t,LocatorDigest:_r,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveLaneCompleteV1:_J,PrimitiveLaneStateV1:{enum:["stale","partial","unavailable"],type:"string"},PrimitiveLaneStatusV1:{anyOf:[{$ref:"#/$defs/PrimitiveLaneCompleteV1"},{properties:{generation:{type:["string","null"]},reason:{type:["string","null"]},status:{$ref:"#/$defs/PrimitiveLaneStateV1"}},required:["status"],type:"object"}]},PrimitiveRecallV1:_Q,PrimitiveSearchCoverageV1:{additionalProperties:!1,properties:{exact:{$ref:"#/$defs/PrimitiveLaneStatusV1"},graph:{$ref:"#/$defs/PrimitiveLaneStatusV1"},lexical:{$ref:"#/$defs/PrimitiveLaneStatusV1"},recall:{$ref:"#/$defs/PrimitiveRecallV1"}},required:["exact","lexical","graph","recall"],type:"object"},PrimitiveSearchFreshnessV1:_X,PrimitiveSymbolLocationV1:_1,PrimitiveUnavailableEvidenceV1:_0,PrimitiveUnavailableStatusV1:_2,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,TokenBudgetCutV1:bD,TokenBudgetSectionV1:bF,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{code:{items:{$ref:"#/$defs/ContextCodeBlockV1"},type:"array"},code_generation:{type:["string","null"]},coverage:{$ref:"#/$defs/PrimitiveSearchCoverageV1"},freshness:{$ref:"#/$defs/PrimitiveSearchFreshnessV1",description:"Freshness of the served code generation, derived from the typed lane\ncoverage and the daemon scheduler's worktree state."},lexical_anchors:{description:"Outcome of every caller `lexical_anchors` entry, then of each\nidentifier the task names; empty when there are neither.",items:{$ref:"#/$defs/ContextLexicalAnchorV1"},type:"array"},memory_graph_coverage:{anyOf:[{$ref:"#/$defs/FactSearchGraphCoverageV1"},{type:"null"}]},memory_matches:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},memory_matches_error:{type:["string","null"]},mode:{$ref:"#/$defs/ContextModeV1"},oversized_symbols:{description:"Matched symbols whose declaration is larger than one code block.\nTheir code is withheld rather than served as a partial window.",items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},type:"array"},plan:{anyOf:[{$ref:"#/$defs/ContextPlanV1"},{type:"null"}],description:"Present in plan mode when the verified graph answered."},related_omission:{anyOf:[{$ref:"#/$defs/ContextRelatedOmissionV1"},{type:"null"}],description:"Present when related symbols were left out: by the `max_nodes` cut,\nor because the neighbor walk stopped at its row limit."},related_symbols:{description:"Neighbors of `symbols`, ranked before the `max_nodes` cut: best edge\nkind to a selected symbol (calls, implements, extends, `type_of`,\nreturns, receives, uses, annotates, contains), then total degree\ndescending, then qualified name.",items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},type:"array"},retrieval:{$ref:"#/$defs/ContextRetrievalPlanV1"},route:{$ref:"#/$defs/ContextRetrievalRouteV1"},search_matches:{items:{$ref:"#/$defs/ContextSearchMatchV1"},type:"array"},symbols:{items:{$ref:"#/$defs/PrimitiveSymbolLocationV1"},type:"array"},task:{type:"string"},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."},verified_graph_evidence:{anyOf:[{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"},{type:"null"}]}},required:["task","route","mode","freshness","symbols","related_symbols","code","coverage","memory_matches","retrieval"],title:"ContextResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"}},required:["address"],title:"ContextScoutExactAddressRequestV1",type:"object"},{$defs:{ContextScoutLimitsV1:h9,ContextScoutModelOutcomeV1:h8},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{exhausted:{type:"boolean"},last_estimated_cost_microusd:{format:"uint64",minimum:0,type:["integer","null"]},last_input_tokens:{format:"uint64",minimum:0,type:["integer","null"]},last_model_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutModelOutcomeV1"},{type:"null"}]},last_output_tokens:{format:"uint64",minimum:0,type:["integer","null"]},limits:{$ref:"#/$defs/ContextScoutLimitsV1"}},required:["limits","exhausted"],title:"ContextScoutBudgetResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU,ContextScoutWorkV1:yc},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},idempotency_key:{type:"string"},work:{$ref:"#/$defs/ContextScoutWorkV1"}},required:["address","work","idempotency_key"],title:"ContextScoutCancelRequestV1",type:"object"},{$defs:{ContextScoutStoreOutcomeV1:ya},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{outcome:{$ref:"#/$defs/ContextScoutStoreOutcomeV1"}},required:["outcome"],title:"ContextScoutMutationResultV1",type:"object"},{$defs:{ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutRuntimeModeV1:yr,ContextScoutServiceStateV1:yi},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{configured_model:{anyOf:[{$ref:"#/$defs/ContextScoutModelBackendV1"},{type:"null"}]},configured_model_available:{type:"boolean"},deterministic_available:{type:"boolean"},last_model_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutModelOutcomeV1"},{type:"null"}]},mode:{$ref:"#/$defs/ContextScoutRuntimeModeV1"},state:{$ref:"#/$defs/ContextScoutServiceStateV1"}},required:["state","mode","deterministic_available","configured_model_available"],title:"ContextScoutCapabilityResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU,ContextScoutClaimWindowV1:{enum:["idle_window","on_request"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},idempotency_key:{type:"string"},window:{$ref:"#/$defs/ContextScoutClaimWindowV1"}},required:["address","window","idempotency_key"],title:"ContextScoutClaimRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,ContextScoutAddressV1:hU,ContextScoutCategoryV1:hH,ContextScoutClaimHandleV1:hG,ContextScoutDeliveryWindowV1:hY,ContextScoutEvidenceAvailabilityV1:h1,ContextScoutEvidenceProjectionV1:h0,ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutModelReceiptV1:h7,ContextScoutRouteV1:yt,ContextScoutSessionWindowV1:yo,ContextScoutSuggestionProjectionV1:ys,ContextScoutWorkV1:yc,ManifestDigest:_l,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{claim:{$ref:"#/$defs/ContextScoutClaimHandleV1"},outcome:{const:"claimed",type:"string"},suggestion:{$ref:"#/$defs/ContextScoutSuggestionProjectionV1"}},required:["outcome","claim","suggestion"],type:"object"},{properties:{outcome:{const:"empty",type:"string"}},required:["outcome"],type:"object"}],title:"ContextScoutClaimResultV1"},{$defs:{ContextScoutAddressV1:hU,ContextScoutClaimHandleV1:hG,ContextScoutDeliveryOutcomeV1:hQ,ContextScoutWorkV1:yc,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},claim:{$ref:"#/$defs/ContextScoutClaimHandleV1"},delivered_at:{$ref:"#/$defs/UtcMicros"},idempotency_key:{type:"string"},outcome:{$ref:"#/$defs/ContextScoutDeliveryOutcomeV1"}},required:["address","claim","delivered_at","outcome","idempotency_key"],title:"ContextScoutDeliveryRequestV1",type:"object"},{$defs:{ContextScoutDeliveryOutcomeV1:hQ,ContextScoutDeliveryReceiptV1:hX,ContextScoutStoreOutcomeV1:ya,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{outcome:{$ref:"#/$defs/ContextScoutStoreOutcomeV1"},receipt:{$ref:"#/$defs/ContextScoutDeliveryReceiptV1"}},required:["outcome","receipt"],title:"ContextScoutDeliveryResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},limit:{default:8,format:"uint",minimum:0,type:"integer"}},required:["address"],title:"ContextScoutRecentRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,ContextScoutAddressV1:hU,ContextScoutCategoryV1:hH,ContextScoutDeliveryOutcomeV1:hQ,ContextScoutDeliveryReceiptV1:hX,ContextScoutDeliveryWindowV1:hY,ContextScoutEvidenceAvailabilityV1:h1,ContextScoutEvidenceProjectionV1:h0,ContextScoutFeedbackKindV1:h2,ContextScoutFeedbackV1:h4,ContextScoutLimitsV1:h9,ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutModelReceiptV1:h7,ContextScoutRecentDeliveryV1:ye,ContextScoutRecentResultV1:{additionalProperties:!1,properties:{configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},deliveries:{items:{$ref:"#/$defs/ContextScoutRecentDeliveryV1"},type:"array"},observed_at:{$ref:"#/$defs/UtcMicros"},omitted:{format:"uint",minimum:0,type:"integer"},pending:{items:{$ref:"#/$defs/ContextScoutSuggestionProjectionV1"},type:"array"}},required:["configuration_revision","observed_at","pending","deliveries","omitted"],type:"object"},ContextScoutRouteV1:yt,ContextScoutRuntimeModeV1:yr,ContextScoutServiceStateV1:yi,ContextScoutSessionWindowV1:yo,ContextScoutStatusResultV1:{additionalProperties:!1,properties:{active_suggestions:{format:"uint",minimum:0,type:"integer"},configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},last_delivery_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutDeliveryOutcomeV1"},{type:"null"}]},last_feedback:{anyOf:[{$ref:"#/$defs/ContextScoutFeedbackKindV1"},{type:"null"}]},last_model_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutModelOutcomeV1"},{type:"null"}]},last_model_receipt:{anyOf:[{$ref:"#/$defs/ContextScoutModelReceiptV1"},{type:"null"}]},last_route:{anyOf:[{$ref:"#/$defs/ContextScoutRouteV1"},{type:"null"}]},last_suppression:{anyOf:[{$ref:"#/$defs/ContextScoutSuppressionV1"},{type:"null"}]},limits:{$ref:"#/$defs/ContextScoutLimitsV1"},mode:{$ref:"#/$defs/ContextScoutRuntimeModeV1"},model_path:{anyOf:[{$ref:"#/$defs/ContextScoutModelBackendV1"},{type:"null"}]},state:{$ref:"#/$defs/ContextScoutServiceStateV1"}},required:["configuration_revision","state","mode","limits","active_suggestions"],type:"object"},ContextScoutSuggestionProjectionV1:ys,ContextScoutSuppressionV1:yd,ContextScoutWorkV1:yc,ManifestDigest:_l,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{recent:{$ref:"#/$defs/ContextScoutRecentResultV1"},status:{$ref:"#/$defs/ContextScoutStatusResultV1"}},required:["status","recent"],title:"ContextScoutExplanationResultV1",type:"object"},{$defs:{ContextScoutAddressV1:hU,ContextScoutDeliveryOutcomeV1:hQ,ContextScoutDeliveryReceiptV1:hX,ContextScoutFeedbackKindV1:h2,ContextScoutFeedbackV1:h4,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},feedback:{$ref:"#/$defs/ContextScoutFeedbackV1"},idempotency_key:{type:"string"},receipt:{$ref:"#/$defs/ContextScoutDeliveryReceiptV1"}},required:["address","receipt","feedback","idempotency_key"],title:"ContextScoutFeedbackRequestV1",type:"object"},{$defs:{ConfigurationIdempotencyKey:hE,ConfigurationRevisionId:hM,ContextScoutAddressV1:hU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{address:{$ref:"#/$defs/ContextScoutAddressV1"},expected_revision:{$ref:"#/$defs/ConfigurationRevisionId"},idempotency_key:{$ref:"#/$defs/ConfigurationIdempotencyKey"}},required:["address","expected_revision","idempotency_key"],title:"ContextScoutControlRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,ContextScoutAddressV1:hU,ContextScoutCategoryV1:hH,ContextScoutDeliveryOutcomeV1:hQ,ContextScoutDeliveryReceiptV1:hX,ContextScoutDeliveryWindowV1:hY,ContextScoutEvidenceAvailabilityV1:h1,ContextScoutEvidenceProjectionV1:h0,ContextScoutFeedbackKindV1:h2,ContextScoutFeedbackV1:h4,ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutModelReceiptV1:h7,ContextScoutRecentDeliveryV1:ye,ContextScoutRouteV1:yt,ContextScoutSessionWindowV1:yo,ContextScoutSuggestionProjectionV1:ys,ContextScoutWorkV1:yc,ManifestDigest:_l,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},deliveries:{items:{$ref:"#/$defs/ContextScoutRecentDeliveryV1"},type:"array"},observed_at:{$ref:"#/$defs/UtcMicros"},omitted:{format:"uint",minimum:0,type:"integer"},pending:{items:{$ref:"#/$defs/ContextScoutSuggestionProjectionV1"},type:"array"}},required:["configuration_revision","observed_at","pending","deliveries","omitted"],title:"ContextScoutRecentResultV1",type:"object"},{$defs:{ContextScoutDeliveryOutcomeV1:hQ,ContextScoutFeedbackKindV1:h2,ContextScoutLimitsV1:h9,ContextScoutModelBackendV1:h5,ContextScoutModelOutcomeV1:h8,ContextScoutModelReceiptV1:h7,ContextScoutRouteV1:yt,ContextScoutRuntimeModeV1:yr,ContextScoutServiceStateV1:yi,ContextScoutSuppressionV1:yd},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{active_suggestions:{format:"uint",minimum:0,type:"integer"},configuration_revision:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},maxItems:32,minItems:32,type:"array"},last_delivery_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutDeliveryOutcomeV1"},{type:"null"}]},last_feedback:{anyOf:[{$ref:"#/$defs/ContextScoutFeedbackKindV1"},{type:"null"}]},last_model_outcome:{anyOf:[{$ref:"#/$defs/ContextScoutModelOutcomeV1"},{type:"null"}]},last_model_receipt:{anyOf:[{$ref:"#/$defs/ContextScoutModelReceiptV1"},{type:"null"}]},last_route:{anyOf:[{$ref:"#/$defs/ContextScoutRouteV1"},{type:"null"}]},last_suppression:{anyOf:[{$ref:"#/$defs/ContextScoutSuppressionV1"},{type:"null"}]},limits:{$ref:"#/$defs/ContextScoutLimitsV1"},mode:{$ref:"#/$defs/ContextScoutRuntimeModeV1"},model_path:{anyOf:[{$ref:"#/$defs/ContextScoutModelBackendV1"},{type:"null"}]},state:{$ref:"#/$defs/ContextScoutServiceStateV1"}},required:["configuration_revision","state","mode","limits","active_suggestions"],title:"ContextScoutStatusResultV1",type:"object"},{$defs:{CouplingDirectionV1:yp},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{direction:{anyOf:[{$ref:"#/$defs/CouplingDirectionV1"},{type:"null"}],description:"fan_in: files depended on by the most others. fan_out: files that\ndepend on the most others (default: fan_in)."},limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"CouplingSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,CouplingDirectionV1:yp,CouplingEntryV1:{additionalProperties:!1,properties:{coupled_files:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"}},required:["file","coupled_files"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{direction:{$ref:"#/$defs/CouplingDirectionV1"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ranking:{items:{$ref:"#/$defs/CouplingEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["direction","result_count","ranking"],title:"CouplingResultV1",type:"object"},{$defs:{DashboardActionV1:{description:"What `tracedecay_dashboard` does.",enum:["start","stop"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{action:{anyOf:[{$ref:"#/$defs/DashboardActionV1"},{type:"null"}],description:'Action to perform (default: "start"). "stop" shuts down a previously\nstarted dashboard if any.'},host:{description:'Loopback host address to bind: 127.0.0.1, localhost, or ::1\n(default: "127.0.0.1"). Wildcard, LAN, public IPs, and other\nhostnames are rejected.',type:["string","null"]},port:{description:"Port to listen on; 0 picks an ephemeral port (default: 7341).",format:"uint16",maximum:65535,minimum:0,type:["integer","null"]}},title:"DashboardSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{host:{type:"string"},port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},status:{const:"started",type:"string"},url:{type:"string"}},required:["status","url","host","port"],type:"object"},{additionalProperties:!1,description:"A dashboard that was already bound when `start` was asked again.",properties:{host:{type:"string"},port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},requested_host:{type:"string"},requested_port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},requested_port_honored:{description:"Whether the bound port is the one asked for (always true for 0).",type:"boolean"},status:{const:"already_running",type:"string"},url:{type:"string"}},required:["status","url","host","port","requested_host","requested_port","requested_port_honored"],type:"object"},{additionalProperties:!1,description:"The bound server is shutting down.",properties:{host:{type:"string"},port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},requested_host:{type:"string"},requested_port:{format:"uint16",maximum:65535,minimum:0,type:"integer"},requested_port_honored:{description:"Whether the bound port is the one asked for (always true for 0).",type:"boolean"},status:{const:"stopping",type:"string"},url:{type:"string"}},required:["status","url","host","port","requested_host","requested_port","requested_port_honored"],type:"object"},{additionalProperties:!1,properties:{previous_url:{type:"string"},status:{const:"stopped",type:"string"}},required:["status","previous_url"],type:"object"},{additionalProperties:!1,properties:{status:{const:"not_running",type:"string"}},required:["status"],type:"object"}],title:"DashboardResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_public:{description:"When true, do NOT exclude pub items. Default false.",type:["boolean","null"]},kinds:{description:'Node kinds to check (default: ["function", "method"]).',items:{type:"string"},type:["array","null"]},limit:{description:"Maximum symbols to return (default: 100, max: 1000).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter reported symbols to files under this directory path (e.g.\n'crates/tracedecay-mcp'). Omit for the entire codebase.",type:["string","null"]}},title:"DeadCodeSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DeadCodeSymbolV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},signature:{type:["string","null"]}},required:["id","name","kind","file","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{dead_code_count:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},symbols:{items:{$ref:"#/$defs/DeadCodeSymbolV1"},type:"array"}},required:["dead_code_count","symbols"],title:"DeadCodeResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of chains to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path.",type:["string","null"]}},title:"DependencyDepthSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DependencyDepthChainV1:{additionalProperties:!1,properties:{chain:{items:{type:"string"},type:"array"},depth:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"}},required:["file","depth","chain"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"`ideal_depth` is `ceil(log2(file_count))`.",properties:{chains:{items:{$ref:"#/$defs/DependencyDepthChainV1"},type:"array"},depth_score:{format:"double",type:"number"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ideal_depth:{format:"uint64",minimum:0,type:"integer"},max_depth:{format:"uint64",minimum:0,type:"integer"}},required:["max_depth","ideal_depth","depth_score","chains"],title:"DependencyDepthResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Addresses indexed symbols by node id or by qualified name; the node id\nwins when both are present.",properties:{node_id:{description:"Look up a single node by its ID instead of qualified_name.",type:["string","null"]},qualified_name:{description:"The exact, case-sensitive qualified name to look up. A bare short name\ndoes not match; resolve it with find_exact_symbol first.",type:["string","null"]}},title:"SymbolSelectorSurfaceRequestV1",type:"object"},{$defs:{DeriveAnnotationV1:{additionalProperties:!1,properties:{evidence_class:{$ref:"#/$defs/DeriveEvidenceClassV1"},name:{type:"string"},unavailable_fields:{items:{type:"string"},type:"array"}},required:["name","evidence_class","unavailable_fields"],type:"object"},DeriveEvidenceClassV1:{description:"How a derive name is known: read from the declaration's attributes, not\nfrom macro expansion.",enum:["syntax_exact"],type:"string"},DerivesSymbolV1:{additionalProperties:!1,properties:{derives:{items:{$ref:"#/$defs/DeriveAnnotationV1"},type:"array"},file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"}},required:["node_id","name","qualified_name","kind","file","line","derives"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Derive annotations of every addressed symbol; empty when no symbol matched.",items:{$ref:"#/$defs/DerivesSymbolV1"},title:"DerivesResultV1",type:"array"},{$defs:{DiagnoseSeverityFilterV1:{description:"Compiler severity the diagnose report keeps.",enum:["error","warning","all"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cargo_output:{description:"Raw stderr text from `cargo check` / `cargo clippy` / `rustc`.",type:"string"},include_callers:{description:"Attach up to 5 callers per diagnostic (default: true).",type:["boolean","null"]},max_diagnostics:{description:"Cap on diagnostics in the response (default: 50, at most 500).",format:"uint32",minimum:0,type:["integer","null"]},severity:{anyOf:[{$ref:"#/$defs/DiagnoseSeverityFilterV1"},{type:"null"}],description:"Filter by severity (default: all)."}},required:["cargo_output"],title:"DiagnoseSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DiagnoseItemV1:{additionalProperties:!1,properties:{callers:{description:"Absent when the request turned caller attachment off.",items:{$ref:"#/$defs/DiagnoseSymbolV1"},type:["array","null"]},code:{type:["string","null"]},column:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},message:{type:"string"},node:{anyOf:[{$ref:"#/$defs/DiagnoseSymbolV1"},{type:"null"}]},severity:{$ref:"#/$defs/DiagnoseSeverityV1"}},required:["severity","message","file","line","column"],type:"object"},DiagnosePublicationV1:{description:"Outcome of publishing the parsed diagnostics into the managed store.",oneOf:[{additionalProperties:!1,properties:{reason:{type:"string"},status:{const:"skipped",type:"string"},unresolved:{items:{type:"string"},type:["array","null"]}},required:["status","reason"],type:"object"},{additionalProperties:!1,properties:{cleared:{format:"uint64",minimum:0,type:"integer"},generation:{type:"string"},inserted:{format:"uint64",minimum:0,type:"integer"},publication_revision:{format:"uint64",minimum:0,type:"integer"},rejected:{items:{type:"string"},type:"array"},status:{const:"published",type:"string"},unresolved:{items:{type:"string"},type:"array"}},required:["status","generation","publication_revision","inserted","cleared","unresolved","rejected"],type:"object"},{additionalProperties:!1,properties:{reason:{type:"string"},status:{const:"failed",type:"string"}},required:["status","reason"],type:"object"}]},DiagnoseSeverityV1:{description:"Severity of one parsed compiler diagnostic.",enum:["error","warning","note","help"],type:"string"},DiagnoseSymbolV1:{additionalProperties:!1,description:"The graph symbol a diagnostic line falls in, or one of its callers.",properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},kind:{type:"string"},line:{description:"One-based display line.",format:"uint32",minimum:0,type:"integer"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["node_id","name","kind","qualified_name","file","line","start_line","end_line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{diagnostics:{items:{$ref:"#/$defs/DiagnoseItemV1"},type:"array"},diagnostics_parsed:{format:"uint64",minimum:0,type:"integer"},diagnostics_returned:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},mapped_to_node:{format:"uint64",minimum:0,type:"integer"},published:{$ref:"#/$defs/DiagnosePublicationV1"},truncated:{type:"boolean"},unmapped:{format:"uint64",minimum:0,type:"integer"}},required:["diagnostics_parsed","diagnostics_returned","mapped_to_node","unmapped","truncated","published","diagnostics"],title:"DiagnoseResultV1",type:"object"},{$defs:{DiagnosticsPrimitiveScope:{oneOf:[{enum:["workspace"],type:"string"},{additionalProperties:!1,properties:{package:{type:"string"}},required:["package"],type:"object"},{additionalProperties:!1,properties:{file:{type:"string"}},required:["file"],type:"object"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{default:null,type:["string","null"]},maximum_diagnostics:{format:"uint32",minimum:0,type:"integer"},scope:{$ref:"#/$defs/DiagnosticsPrimitiveScope"}},required:["scope","maximum_diagnostics"],title:"DiagnosticsPrimitiveRequest",type:"object"},{$defs:{CodeGenerationId:hy,CommitId:hq,ComponentVersion:hC,ContentDigest:hD,DiagnosticEvidenceClassV1:{description:"Evidence class for one diagnostic record. Evidence class is part of\ncanonical diagnostic identity.",oneOf:[{const:"observed_current",description:"Directly observed against the exact clean generation it names.",type:"string"},{const:"producer_reported",description:"Reported by the cataloged producer for the exact clean generation.",type:"string"},{const:"derived_structural",description:"Derived from TraceDecay structural/graph analysis of the generation.",type:"string"},{const:"unknown_unsupported",description:"The evidence class cannot be established; the record is retained for\naudit but must not be treated as current truth.",type:"string"}]},DiagnosticPrimitiveRecord:{additionalProperties:!1,properties:{diagnostic:{$ref:"#/$defs/GenerationDiagnosticV1"},logical_path:{type:"string"}},required:["logical_path","diagnostic"],type:"object"},DiagnosticProducerKindV1:{description:"The cataloged producer kinds that may publish durable diagnostics.\nRuntime, storage, migration,\nconfiguration, session, or daemon-health findings without a truthful\nsource range are Doctor or application findings and never become\n`GenerationDiagnosticV1` records.",enum:["upstream_compiler","language_server","tracedecay_structural","tracedecay_graph_integrity","tracedecay_policy","tracedecay_code_health","generation_consistency","authorized_external_analyzer"],type:"string"},DiagnosticProvenanceV1:{additionalProperties:!1,description:"Producer provenance for one diagnostic. Diagnostic identity includes\nproducer provenance: identical findings from the same logical producer and\nrevision collapse; findings from distinct producers remain distinct.",properties:{analyzer_revision:{$ref:"#/$defs/ComponentVersion"},configuration_revision:{$ref:"#/$defs/ComponentVersion"},producer:{$ref:"#/$defs/ProviderId"},producer_kind:{$ref:"#/$defs/DiagnosticProducerKindV1"},sanitization_receipt:{anyOf:[{$ref:"#/$defs/SanitizationReceiptId"},{type:"null"}]}},required:["producer_kind","producer","analyzer_revision","configuration_revision"],type:"object"},DiagnosticRecordStateV1:{description:"Current-vs-stale typing for a durable diagnostic record. Publication is\nversion-monotone: a newer clean generation clears the prior publication\ndeterministically, and stale findings cannot cross snapshots.\nStale and historical records remain queryable through\napplication APIs but are excluded from active publication.",oneOf:[{description:"Current for exactly the clean generation named by the record.",properties:{kind:{const:"current",type:"string"}},required:["kind"],type:"object"},{description:"A clean generation completed and deterministically removed this\nfinding (resolution, deletion, source-revision drift, or content or\ngeneration change).",properties:{cleared_in_generation:{$ref:"#/$defs/CodeGenerationId"},kind:{const:"cleared",type:"string"}},required:["kind","cleared_in_generation"],type:"object"}]},DiagnosticSeverityV1:y$,FileOccurrenceId:gs,GenerationDiagnosticV1:{additionalProperties:!1,description:"One durable, generation-bound diagnostic record. Its diagnostic payload,\nscope, and producer provenance form observation identity; the display\nmessage remains sanitized product data.",properties:{code:{description:"Stable producer diagnostic code (for example `E0308`).",type:"string"},collected_at:{$ref:"#/$defs/UtcMicros",description:"Time the server first accepted this evidence observation. Compiler\noutput does not carry a trustworthy producer capture time, and an exact\nsemantic replay retains the first accepted value."},content_digest:{$ref:"#/$defs/ContentDigest",description:"Content digest of the attached file inside the generation."},diagnostic_anchor:{$ref:"#/$defs/RetrievalAnchorId",description:"Retrieval anchor addressing this record. The code index's\n`GenerationDiagnosticAttachmentV1::diagnostic_anchor` points here."},evidence_class:{$ref:"#/$defs/DiagnosticEvidenceClassV1"},file_occurrence_id:{$ref:"#/$defs/FileOccurrenceId",description:"Canonical file identity the diagnostic attaches to."},generation_id:{$ref:"#/$defs/CodeGenerationId",description:"The immutable clean code-intelligence generation this record is bound\nto. Findings never cross generations."},message:{description:"Sanitized display message; bounded by [`MAX_DIAGNOSTIC_MESSAGE_BYTES`].",type:"string"},message_digest:{$ref:"#/$defs/ManifestDigest",description:"Integrity digest over the sanitized message."},provenance:{$ref:"#/$defs/DiagnosticProvenanceV1"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},repository:{$ref:"#/$defs/RepositoryId"},severity:{$ref:"#/$defs/DiagnosticSeverityV1"},source_revision:{anyOf:[{$ref:"#/$defs/CommitId"},{type:"null"}]},span:{$ref:"#/$defs/SourceSpan",description:"Range encoding inside the sanitized file (byte range; mutable line\nnumbers are never identity)."},state:{$ref:"#/$defs/DiagnosticRecordStateV1",description:"Current-vs-stale typing; publication is version-monotone."},symbol_occurrence_id:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}],description:"Enclosing symbol occurrence, when exact attachment is possible."},worktree:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["diagnostic_anchor","generation_id","repository","file_occurrence_id","content_digest","span","code","severity","message","message_digest","provenance","evidence_class","collected_at","state"],type:"object"},ManifestDigest:_l,ProviderId:vo,RefId:vm,RepositoryId:vb,RetrievalAnchorId:vI,SanitizationReceiptId:{description:"Strongly typed canonical identity: `SanitizationReceiptId`.",type:"string"},SourceSpan:b$,SymbolOccurrenceId:bq,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{clean_generation:{type:"boolean"},diagnostics:{items:{$ref:"#/$defs/DiagnosticPrimitiveRecord"},type:"array"},findings_cleared:{type:"boolean"},generation_id:{$ref:"#/$defs/CodeGenerationId"},next_cursor:{type:["string","null"]}},required:["generation_id","clean_generation","findings_cleared","diagnostics"],title:"DiagnosticsPrimitiveResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{budget_tokens:{description:"Cap the symbol, test, and co-change sections at about this many tokens.",format:"uint32",minimum:0,type:["integer","null"]},depth:{description:"Maximum impact traversal depth (default: 2, at most 10).",format:"uint32",minimum:0,type:["integer","null"]},files:{description:"Files to inspect prospectively. All indexed declarations in these files\nare candidates; this does not select exact Git-changed declarations.",items:{type:"string"},type:"array"}},required:["files"],title:"DiffContextSurfaceRequestV1",type:"object"},{$defs:{CoChangeUnavailableV1:hf,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GitContextComparisonV1:gg,GitContextSymbolV1:g_,GitOidV1:gq,IncompatibleCallSiteV1:{additionalProperties:!1,description:"A call site whose argument count cannot invoke the new parameter list.",properties:{arguments:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","file","line","arguments"],type:"object"},MissingCoChangePartnerV1:_w,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,SignatureEditStatusV1:{description:"How a modified function's parameter list compares with HEAD.",enum:["contract_change"],type:"string"},SignatureEditV1:{additionalProperties:!1,description:"A Rust free function whose parameter count differs from HEAD.",properties:{file:{type:"string"},incompatible:{items:{$ref:"#/$defs/IncompatibleCallSiteV1"},type:"array"},new_parameters:{format:"uint32",minimum:0,type:["integer","null"]},old_parameters:{format:"uint32",minimum:0,type:["integer","null"]},status:{$ref:"#/$defs/SignatureEditStatusV1"},symbol:{type:"string"}},required:["symbol","file","status","incompatible"],type:"object"},TestGateV1:{additionalProperties:!1,description:"Whether tests reach the symbols in a diff's blast radius.\n\n`pass` and exit 0 when every counted symbol is reached. `fail` and exit 4\nname the ones that are not. `incomplete` and exit 0 mean the caller walk\nstopped before that absence is known.",properties:{exit_code:{format:"uint8",maximum:255,minimum:0,type:"integer"},untested:{items:{type:"string"},type:"array"},verdict:{type:"string"}},required:["verdict","exit_code","untested"],type:"object"},TokenBudgetCutV1:bD,TokenBudgetSectionV1:bF},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{affected_tests:{items:{type:"string"},type:"array"},changed_files:{items:{type:"string"},type:"array"},co_change_unavailable:{anyOf:[{$ref:"#/$defs/CoChangeUnavailableV1"},{type:"null"}],description:"Present when Git history could not be mined for co-change partners."},comparison:{anyOf:[{$ref:"#/$defs/GitContextComparisonV1"},{type:"null"}]},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},impact_complete:{description:"False when the impact walk stopped at its depth or budget with callers\nstill unexplored.",type:"boolean"},impacted_symbols:{items:{$ref:"#/$defs/GitContextSymbolV1"},type:"array"},impacted_symbols_count:{format:"uint",minimum:0,type:"integer"},missing_co_change_partners:{description:"Files that usually change with a changed file, per bounded Git\nhistory, but are absent from this change set.",items:{$ref:"#/$defs/MissingCoChangePartnerV1"},type:"array"},modified_symbols:{items:{$ref:"#/$defs/GitContextSymbolV1"},type:"array"},signature_edits:{description:"Rust free functions whose parameter count changed since HEAD, with the\ncall sites that list cannot accept. Omitted when nothing changed.",items:{$ref:"#/$defs/SignatureEditV1"},type:"array"},test_gate:{$ref:"#/$defs/TestGateV1",description:"Symbols in this diff that no test reaches, and the verdict a CLI exits on."},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."}},required:["changed_files","modified_symbols","impacted_symbols_count","impacted_symbols","impact_complete","affected_tests","missing_co_change_partners","test_gate"],title:"DiffContextResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of files in the per-file breakdown, highest node count\nfirst (default: 100, max: 1000). Ignored when summary is true; the\nresponse states total_file_count and omitted_file_count.",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Directory or file path prefix to filter (e.g.\n'src/main/java/com/example'). Omit for entire codebase.",type:["string","null"]},summary:{description:"If true, aggregate counts across all matching files instead of\nper-file breakdown (default: false).",type:["boolean","null"]}},title:"DistributionSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DistributionFileV1:{additionalProperties:!1,properties:{file:{type:"string"},kinds:{items:{$ref:"#/$defs/DistributionKindCountV1"},type:"array"}},required:["file","kinds"],type:"object"},DistributionKindCountV1:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},kind:{type:"string"}},required:["kind","count"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Flattening the tagged view keeps `path_filter` ahead of `mode` on the\nwire; serde cannot deny unknown fields through a flattened member.",oneOf:[{properties:{distribution:{items:{$ref:"#/$defs/DistributionKindCountV1"},type:"array"},mode:{const:"summary",type:"string"},total_kinds:{format:"uint64",minimum:0,type:"integer"}},required:["mode","total_kinds","distribution"],type:"object"},{properties:{file_count:{format:"uint64",minimum:0,type:"integer"},files:{items:{$ref:"#/$defs/DistributionFileV1"},type:"array"},mode:{const:"per_file",type:"string"},omitted_file_count:{format:"uint64",minimum:0,type:"integer"},total_file_count:{format:"uint64",minimum:0,type:"integer"}},required:["mode","file_count","total_file_count","omitted_file_count","files"],type:"object"}],properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},path_filter:{type:["string","null"]}},title:"DistributionResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 50, at most 500).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Directory or file path prefix to filter (e.g. 'src/main'). Omit for\nentire codebase.",type:["string","null"]}},title:"DocCoverageSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DocCoverageFileV1:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},symbols:{items:{$ref:"#/$defs/DocCoverageSymbolV1"},type:"array"}},required:["file","count","symbols"],type:"object"},DocCoverageSymbolV1:{additionalProperties:!1,properties:{id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},signature:{type:["string","null"]}},required:["id","name","kind","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{complete:{type:"boolean"},file_count:{format:"uint64",minimum:0,type:"integer"},files:{items:{$ref:"#/$defs/DocCoverageFileV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},limit:{format:"uint64",minimum:0,type:"integer"},omitted_count:{format:"uint64",minimum:0,type:"integer"},path_filter:{type:["string","null"]},returned_count:{format:"uint64",minimum:0,type:"integer"},total_undocumented:{format:"uint64",minimum:0,type:"integer"}},required:["total_undocumented","returned_count","omitted_count","complete","limit","file_count","files"],title:"DocCoverageResultV1",type:"object"},{$defs:{DsmShapeV1:yw},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{max_files:{description:"Maximum files in matrix format (default: 30, at most 200).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path.",type:["string","null"]},shape:{anyOf:[{$ref:"#/$defs/DsmShapeV1"},{type:"null"}],description:"DSM data shape: stats, clusters, or matrix (default: stats)."}},title:"DsmSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,DsmClusterV1:{additionalProperties:!1,properties:{boundary_edges:{format:"uint64",minimum:0,type:"integer"},directory:{type:"string"},file_count:{format:"uint64",minimum:0,type:"integer"},incoming_edges:{format:"uint64",minimum:0,type:"integer"},internal_edges:{format:"uint64",minimum:0,type:"integer"},outgoing_edges:{format:"uint64",minimum:0,type:"integer"}},required:["directory","file_count","internal_edges","outgoing_edges","incoming_edges","boundary_edges"],type:"object"},DsmMatrixV1:{additionalProperties:!1,properties:{files:{items:{type:"string"},type:"array"},matrix:{items:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},type:"array"},type:"array"},note:{type:"string"}},required:["files","matrix","note"],type:"object"},DsmShapeV1:yw,DsmStatsV1:{additionalProperties:!1,properties:{clusters:{format:"uint64",minimum:0,type:"integer"},density:{format:"double",type:"number"},edges:{format:"uint64",minimum:0,type:"integer"},files:{format:"uint64",minimum:0,type:"integer"},largest_cluster:{format:"uint64",minimum:0,type:"integer"}},required:["files","edges","density","clusters","largest_cluster"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{clusters:{items:{$ref:"#/$defs/DsmClusterV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},matrix:{anyOf:[{$ref:"#/$defs/DsmMatrixV1"},{type:"null"}]},shape:{$ref:"#/$defs/DsmShapeV1"},stats:{$ref:"#/$defs/DsmStatsV1"}},required:["shape","stats","clusters"],title:"DsmResultV1",type:"object"},{$defs:{FactEventId:yz,FactFeedbackActionV1:yD,FactId:yF,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{action:{$ref:"#/$defs/FactFeedbackActionV1"},expected_last_event_id:{anyOf:[{$ref:"#/$defs/FactEventId"},{type:"null"}]},fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},reason:{type:["string","null"]},source_label:{type:["string","null"]}},required:["fact_id","action"],title:"FactFeedbackRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactFeedbackActionV1:yD,FactFeedbackV1:{additionalProperties:!1,properties:{action:{$ref:"#/$defs/FactFeedbackActionV1"},event_id:{$ref:"#/$defs/FactEventId"},fact_id:{$ref:"#/$defs/FactId"},helpful_count:{format:"uint64",minimum:0,type:"integer"},new_trust_millionths:{format:"uint32",minimum:0,type:"integer"},old_trust_millionths:{format:"uint32",minimum:0,type:"integer"},trust_delta_millionths:{format:"int32",type:"integer"},unhelpful_count:{format:"uint64",minimum:0,type:"integer"}},required:["event_id","fact_id","action","old_trust_millionths","new_trust_millionths","trust_delta_millionths","helpful_count","unhelpful_count"],type:"object"},FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},fact:{$ref:"#/$defs/FactProjectionV1"},feedback:{$ref:"#/$defs/FactFeedbackV1"}},required:["fact","feedback","commit"],title:"FactFeedbackResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},content:{type:"string"},entities:{default:[],items:{type:"string"},type:"array"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},metadata:{additionalProperties:!0,type:["object","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},source_label:{type:["string","null"]},tags:{default:[],items:{type:"string"},type:"array"},trust:{format:"double",type:["number","null"]}},required:["content"],title:"FactStoreAddRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactStoreAddCommitV1:{oneOf:[{additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},disposition:{const:"added",type:"string"},fact:{$ref:"#/$defs/FactProjectionV1"}},required:["disposition","fact","commit"],type:"object"},{additionalProperties:!1,properties:{closest_fact_id:{$ref:"#/$defs/FactId"},commit:{$ref:"#/$defs/FactCommitReceiptV1"},disposition:{const:"near_duplicate",type:"string"},fact:{$ref:"#/$defs/FactProjectionV1"},similarity_millionths:{format:"uint32",minimum:0,type:"integer"}},required:["disposition","fact","closest_fact_id","similarity_millionths","commit"],type:"object"},{additionalProperties:!1,properties:{closest_fact_id:{$ref:"#/$defs/FactId"},commit:{$ref:"#/$defs/FactCommitReceiptV1"},disposition:{const:"possible_conflict",type:"string"},fact:{$ref:"#/$defs/FactProjectionV1"},similarity_millionths:{format:"uint32",minimum:0,type:"integer"}},required:["disposition","fact","closest_fact_id","similarity_millionths","commit"],type:"object"}]},FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{outcome:{const:"secret_rejected",type:"string"}},required:["outcome"],type:"object"},{additionalProperties:!1,properties:{closest_fact_id:{$ref:"#/$defs/FactId"},fact:{$ref:"#/$defs/FactProjectionV1"},outcome:{const:"normalized_duplicate",type:"string"}},required:["outcome","fact","closest_fact_id"],type:"object"},{additionalProperties:!1,properties:{outcome:{const:"committed",type:"string"},result:{$ref:"#/$defs/FactStoreAddCommitV1"}},required:["outcome","result"],type:"object"}],title:"FactStoreAddResultV1"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},threshold_millionths:{format:"uint32",minimum:0,type:["integer","null"]}},title:"FactStoreContradictRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactContradictionV1:{additionalProperties:!1,properties:{existing_fact:{$ref:"#/$defs/FactV1"},new_content:{type:"string"},score_millionths:{format:"uint32",minimum:0,type:"integer"},why:{type:["string","null"]}},required:["existing_fact","new_content","score_millionths"],type:"object"},FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{contradictions:{items:{$ref:"#/$defs/FactContradictionV1"},type:"array"},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","contradictions"],title:"FactStoreContradictResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Closed public launcher for the automatic Memory Curator.\n\nRun identity, task selection, operations, proposals, approval, and apply\nauthority are deliberately absent and rejected by `deny_unknown_fields`.",properties:{fact_review_limit:{default:24,format:"uint32",maximum:1e3,minimum:1,type:"integer"},min_confidence_millionths:{default:72e4,format:"uint32",maximum:1e6,minimum:0,type:"integer"}},title:"FactStoreCurateRequestV1",type:"object"},{$defs:{AutomationTaskV1:{description:"Automation capability selected after one registered application admission.",enum:["memory_curator","session_reflector","skill_writer","combined_review","user_job"],type:"string"},FactStoreCurateStateV1:{description:"Lifecycle state a `fact_store_curate` receipt reports.",oneOf:[{const:"started",description:"The run was admitted and continues on the daemon.",type:"string"}]},ManifestDigest:_l,RunId:vF},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Receipt of one admitted automatic curation.\n\nThe curator runs on the daemon after this receipt is returned. Its terminal\nis the automation run ledger record for `run_id`, read with\n`automation_run_view`.",properties:{request_digest:{$ref:"#/$defs/ManifestDigest"},run_id:{$ref:"#/$defs/RunId"},state:{$ref:"#/$defs/FactStoreCurateStateV1"},task:{$ref:"#/$defs/AutomationTaskV1"}},required:["run_id","task","request_digest","state"],title:"FactStoreCurateResultV1",type:"object"},{$defs:{FactId:yF,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["fact_id"],title:"FactStoreGetRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactFeedbackActionV1:yD,FactFeedbackDetailsAvailabilityV1:{enum:["available","redacted","unknown"],type:"string"},FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,TrustHistoryEntryV1:{additionalProperties:!1,properties:{action:{$ref:"#/$defs/FactFeedbackActionV1"},details_availability:{$ref:"#/$defs/FactFeedbackDetailsAvailabilityV1"},event_id:{$ref:"#/$defs/FactEventId"},new_trust_millionths:{format:"uint32",minimum:0,type:"integer"},occurred_at:{$ref:"#/$defs/UtcMicros"},old_trust_millionths:{format:"uint32",minimum:0,type:"integer"},reason:{type:["string","null"]},source_label:{type:["string","null"]}},required:["event_id","occurred_at","action","old_trust_millionths","new_trust_millionths","details_availability"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactProjectionV1"},trust_history:{items:{$ref:"#/$defs/TrustHistoryEntryV1"},type:"array"}},required:["fact","trust_history"],title:"FactStoreGetResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},title:"FactStoreListRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{facts:{items:{$ref:"#/$defs/FactProjectionV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","facts"],title:"FactStoreListResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},entity:{type:"string"},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["entity"],title:"FactStoreProbeRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{graph_coverage:{$ref:"#/$defs/FactSearchGraphCoverageV1"},hits:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","hits","graph_coverage"],title:"FactStoreProbeResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},entities:{items:{type:"string"},minItems:1,type:"array"},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["entities"],title:"FactStoreReasonRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{graph_coverage:{$ref:"#/$defs/FactSearchGraphCoverageV1"},hits:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","hits","graph_coverage"],title:"FactStoreReasonResultV1",type:"object"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},entity:{type:"string"},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["entity"],title:"FactStoreRelatedRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{graph_coverage:{$ref:"#/$defs/FactSearchGraphCoverageV1"},hits:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"}},required:["owner","hits","graph_coverage"],title:"FactStoreRelatedResultV1",type:"object"},{$defs:{FactEventId:yz,FactId:yF,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_last_event_id:{anyOf:[{$ref:"#/$defs/FactEventId"},{type:"null"}]},fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},required:["fact_id"],title:"FactStoreRemoveRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},fact:{$ref:"#/$defs/FactProjectionV1"},outcome:{const:"removed",type:"string"},remaining_fact_count:{format:"uint64",minimum:0,type:"integer"}},required:["outcome","fact","remaining_fact_count","commit"],type:"object"},{additionalProperties:!1,properties:{fact:{$ref:"#/$defs/FactProjectionV1"},outcome:{const:"already_removed",type:"string"},remaining_fact_count:{format:"uint64",minimum:0,type:"integer"}},required:["outcome","fact","remaining_fact_count"],type:"object"}],title:"FactStoreRemoveResultV1"},{$defs:{FactCategoryV1:yA,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{description:"The previous page's `next_after`, valid only with the same parameters.",type:["string","null"]},category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},limit:{format:"uint64",minimum:0,type:["integer","null"]},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},min_trust:{format:"double",type:["number","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},query:{type:"string"}},required:["query"],title:"FactStoreSearchRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitOwnerV1:yM,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactRetrievalTelemetryDegradationV1:{enum:["unavailable","saturated"],type:"string"},FactRetrievalTelemetryV1:{description:"Whether an explicit search recorded retrieval telemetry for its hits.\n\nThe telemetry write is recall bookkeeping, not part of the returned\nevidence: when only that lane is unavailable the search still delivers its\nresult and reports the degradation here instead of refusing the read.",oneOf:[{additionalProperties:!1,description:"The result had no hits, so there was nothing to record.",properties:{kind:{const:"not_applicable",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,description:"The selected store is mounted read-only; recording is never attempted.",properties:{kind:{const:"read_only",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{fact_count:{format:"uint",minimum:0,type:"integer"},kind:{const:"recorded",type:"string"}},required:["kind","fact_count"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"degraded",type:"string"},reason:{$ref:"#/$defs/FactRetrievalTelemetryDegradationV1"}},required:["kind","reason"],type:"object"}]},FactSearchGraphCoverageV1:yG,FactSearchGraphDegradationV1:yB,FactSearchHitV1:yK,FactSearchScoresV1:yJ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Explicit search additionally records retrieval telemetry for its returned\nhits; `retrieval_telemetry` reports whether that recall bookkeeping\nhappened, so a served result can truthfully carry a degraded write lane.",properties:{graph_coverage:{$ref:"#/$defs/FactSearchGraphCoverageV1"},hits:{items:{$ref:"#/$defs/FactSearchHitV1"},type:"array"},next_after:{description:"Opaque continuation, bound to this operation and request.",type:["string","null"]},owner:{$ref:"#/$defs/FactCommitOwnerV1"},retrieval_telemetry:{$ref:"#/$defs/FactRetrievalTelemetryV1"}},required:["owner","hits","graph_coverage","retrieval_telemetry"],title:"FactStoreSearchResultV1",type:"object"},{$defs:{FactEventId:yz,FactId:yF,MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Mark `fact_id` as superseded by `superseded_by`. The old fact leaves the\ndefault retrieval surfaces but stays readable by id through its history;\npayload and trust are never rewritten.",properties:{expected_last_event_id:{anyOf:[{$ref:"#/$defs/FactEventId"},{type:"null"}]},fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},superseded_by:{$ref:"#/$defs/FactId"}},required:["fact_id","superseded_by"],title:"FactStoreSupersedeRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactId:yF,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Outcome of an explicit supersession. `superseded` carries the durable\ncommit receipt of the `Curated { SupersededBy }` lineage event;\n`already_superseded` reports the successor already recorded for the fact.",oneOf:[{additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},fact_id:{$ref:"#/$defs/FactId"},outcome:{const:"superseded",type:"string"},superseded_by:{$ref:"#/$defs/FactId"}},required:["outcome","fact_id","superseded_by","commit"],type:"object"},{additionalProperties:!1,properties:{fact_id:{$ref:"#/$defs/FactId"},outcome:{const:"already_superseded",type:"string"},superseded_by:{$ref:"#/$defs/FactId"}},required:["outcome","fact_id","superseded_by"],type:"object"}],title:"FactStoreSupersedeResultV1"},{$defs:{FactCategoryV1:yA,FactEventId:yz,FactId:yF,FactSourceLabelPatchV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"set",type:"string"},value:{type:"string"}},required:["kind","value"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"clear",type:"string"}},required:["kind"],type:"object"}]},MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{category:{anyOf:[{$ref:"#/$defs/FactCategoryV1"},{type:"null"}]},content:{type:["string","null"]},entities:{items:{type:"string"},type:["array","null"]},expected_last_event_id:{anyOf:[{$ref:"#/$defs/FactEventId"},{type:"null"}]},fact_id:{$ref:"#/$defs/FactId"},memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},metadata:{additionalProperties:!0,type:["object","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},source_label:{anyOf:[{$ref:"#/$defs/FactSourceLabelPatchV1"},{type:"null"}]},tags:{items:{type:"string"},type:["array","null"]},trust:{format:"double",type:["number","null"]}},required:["fact_id"],title:"FactStoreUpdateRequestV1",type:"object"},{$defs:{FactAssertionId:yE,FactCategoryV1:yA,FactCommitDispositionV1:yW,FactCommitOwnerV1:yM,FactCommitReceiptV1:yN,FactEventId:yz,FactId:yF,FactIdentitySourceResultV1:yL,FactPayloadAccessV1:yU,FactProjectionV1:yH,FactStatusV1:yZ,FactTelemetryV1:yQ,FactV1:yX,LocatorDigest:_r,ProjectId:_4,ProvenanceId:vr,RetrievalAnchorId:vI,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{commit:{$ref:"#/$defs/FactCommitReceiptV1"},fact:{$ref:"#/$defs/FactProjectionV1"},trust_delta_millionths:{format:"int32",type:"integer"}},required:["fact","trust_delta_millionths","commit"],title:"FactStoreUpdateResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Explicit advisory-cycle trigger for one document in the admitted project.",properties:{document_uri:{type:"string"}},required:["document_uri"],title:"FeedbackAdvisoryCycleSurfaceRequestV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,DiagnosticSeverityV1:y$,FeedbackAdvisoryCycleWireV1:{additionalProperties:!1,description:"One canonical cycle result plus whether its durable publication committed.\n\n`published` intentionally remains adjacent to the cycle fields on the\nwire: publication is a property of this exact cycle, not of a page or a\nlater lookup.",properties:{advisory_only:{type:"boolean"},advisory_provider_states:{items:{$ref:"#/$defs/FeedbackAdvisoryProviderStateV1"},type:"array"},affected_tests_state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},baseline_states:{items:{$ref:"#/$defs/FeedbackBaselineStateV1"},type:"array"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},content_identity:{anyOf:[{$ref:"#/$defs/FeedbackContentIdentityV1"},{type:"null"}]},cycle_id:{$ref:"#/$defs/FeedbackCycleId"},durability:{$ref:"#/$defs/FeedbackDurabilityV1"},findings:{items:{$ref:"#/$defs/FeedbackFindingV1"},type:"array"},impact:{anyOf:[{$ref:"#/$defs/FeedbackImpactV1"},{type:"null"}]},impact_state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},omitted_findings:{format:"uint64",minimum:0,type:"integer"},policy_digest:{$ref:"#/$defs/ManifestDigest"},provider_states:{items:{$ref:"#/$defs/ProviderEvaluationStateV1"},type:"array"},published:{type:"boolean"},result_id:{$ref:"#/$defs/FeedbackResultId"},returned_findings:{format:"uint64",minimum:0,type:"integer"},scope:{$ref:"#/$defs/FeedbackScopeV1"},termination:{$ref:"#/$defs/FeedbackCycleTerminationV1"},total_findings:{format:"uint64",minimum:0,type:"integer"}},required:["result_id","cycle_id","scope","durability","policy_digest","configuration_digest","termination","provider_states","baseline_states","findings","total_findings","returned_findings","omitted_findings","advisory_only","published"],type:"object"},FeedbackAdvisoryFindingHandleV1:{additionalProperties:!1,description:"One daemon-minted read-handle pair for a finding in the published cycle.",properties:{expansion_handle:{type:["string","null"]},finding_id:{$ref:"#/$defs/FeedbackFindingId"},get_handle:{type:"string"},retrieval_anchor_id:{anyOf:[{$ref:"#/$defs/RetrievalAnchorId"},{type:"null"}]}},required:["finding_id","get_handle"],type:"object"},FeedbackAdvisoryProviderStateV1:yY,FeedbackAdvisoryReadHandlesV1:{additionalProperties:!1,description:"Daemon-minted handles for reads over this exact publication.",properties:{affected_tests_handle:{type:"string"},diagnostics_handle:{type:"string"},impact_handle:{type:"string"},list_handle:{type:"string"}},required:["diagnostics_handle","impact_handle","affected_tests_handle","list_handle"],type:"object"},FeedbackBaselineStateV1:y1,FeedbackContentIdentityV1:y0,FeedbackCycleId:y2,FeedbackCycleTerminationV1:y4,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackDurabilityV1:y5,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingV1:gt,FeedbackImpactStateV1:gr,FeedbackImpactV1:gi,FeedbackResultId:go,FeedbackScopeV1:gn,FeedbackTargetV1:ga,FileOccurrenceId:gs,HostInstanceId:gL,ManifestDigest:_l,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact advisory-cycle payload serialized by the mounted daemon route.",properties:{cycle:{$ref:"#/$defs/FeedbackAdvisoryCycleWireV1"},finding_handles:{items:{$ref:"#/$defs/FeedbackAdvisoryFindingHandleV1"},type:"array"},read_handles:{anyOf:[{$ref:"#/$defs/FeedbackAdvisoryReadHandlesV1"},{type:"null"}]}},required:["cycle","finding_handles"],title:"FeedbackAdvisoryCycleSurfaceResultV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,DiagnosticSeverityV1:y$,FeedbackAdvisoryProviderStateV1:yY,FeedbackBaselineStateV1:y1,FeedbackContentIdentityV1:y0,FeedbackCycleId:y2,FeedbackCycleResultV1:{additionalProperties:!1,description:"One deterministic result for one trigger. The result represents a\nterminal advisory evaluation and contains no next-action execution hook.",properties:{advisory_only:{type:"boolean"},advisory_provider_states:{items:{$ref:"#/$defs/FeedbackAdvisoryProviderStateV1"},type:"array"},affected_tests_state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},baseline_states:{items:{$ref:"#/$defs/FeedbackBaselineStateV1"},type:"array"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},content_identity:{anyOf:[{$ref:"#/$defs/FeedbackContentIdentityV1"},{type:"null"}]},cycle_id:{$ref:"#/$defs/FeedbackCycleId"},durability:{$ref:"#/$defs/FeedbackDurabilityV1"},findings:{items:{$ref:"#/$defs/FeedbackFindingV1"},type:"array"},impact:{anyOf:[{$ref:"#/$defs/FeedbackImpactV1"},{type:"null"}]},impact_state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]},omitted_findings:{format:"uint64",minimum:0,type:"integer"},policy_digest:{$ref:"#/$defs/ManifestDigest"},provider_states:{items:{$ref:"#/$defs/ProviderEvaluationStateV1"},type:"array"},result_id:{$ref:"#/$defs/FeedbackResultId"},returned_findings:{format:"uint64",minimum:0,type:"integer"},scope:{$ref:"#/$defs/FeedbackScopeV1"},termination:{$ref:"#/$defs/FeedbackCycleTerminationV1"},total_findings:{format:"uint64",minimum:0,type:"integer"}},required:["result_id","cycle_id","scope","durability","policy_digest","configuration_digest","termination","provider_states","baseline_states","findings","total_findings","returned_findings","omitted_findings","advisory_only"],type:"object"},FeedbackCycleTerminationV1:y4,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackDurabilityV1:y5,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingV1:gt,FeedbackImpactStateV1:gr,FeedbackImpactV1:gi,FeedbackResultId:go,FeedbackScopeV1:gn,FeedbackTargetV1:ga,FileOccurrenceId:gs,HostInstanceId:gL,ManifestDigest:_l,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cycle:{$ref:"#/$defs/FeedbackCycleResultV1"}},required:["cycle"],title:"FeedbackDiagnosticsReadResultV1",type:"object"},{$defs:{AnchorExpandResult:{additionalProperties:!1,properties:{anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"}},required:["anchors"],type:"object"},CommitId:hq,DiagnosticSeverityV1:y$,FeedbackCycleId:y2,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingReadV1:ge,FeedbackFindingV1:gt,FeedbackResultId:go,FeedbackScopeV1:gn,FileOccurrenceId:gs,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expansion:{$ref:"#/$defs/AnchorExpandResult"},finding:{$ref:"#/$defs/FeedbackFindingReadV1"}},required:["finding","expansion"],title:"FeedbackExpandResultV1",type:"object"},{$defs:{CommitId:hq,DiagnosticSeverityV1:y$,FeedbackCycleId:y2,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingReadV1:ge,FeedbackFindingV1:gt,FeedbackResultId:go,FeedbackScopeV1:gn,FileOccurrenceId:gs,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{finding:{$ref:"#/$defs/FeedbackFindingReadV1"}},required:["finding"],title:"FeedbackGetResultV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,FeedbackContentIdentityV1:y0,FeedbackCycleId:y2,FeedbackImpactStateV1:gr,FeedbackImpactV1:gi,FeedbackResultId:go,FeedbackScopeV1:gn,FeedbackTargetV1:ga,FileOccurrenceId:gs,HostInstanceId:gL,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Canonical impact projection returned by `feedback_impact`.\n\nThe daemon-side projection owner (usecases) re-exports this type; it lives\nhere so the catalog contribution can register its schema body as the single\nRust-owned wire authority. Results project from an authorized completed\ncycle, and the canonical response wire remains consumable by typed SDKs.",properties:{content_identity:{anyOf:[{$ref:"#/$defs/FeedbackContentIdentityV1"},{type:"null"}]},cycle_id:{$ref:"#/$defs/FeedbackCycleId"},impact:{anyOf:[{$ref:"#/$defs/FeedbackImpactV1"},{type:"null"}]},result_id:{$ref:"#/$defs/FeedbackResultId"},scope:{$ref:"#/$defs/FeedbackScopeV1"},state:{anyOf:[{$ref:"#/$defs/FeedbackImpactStateV1"},{type:"null"}]}},required:["result_id","cycle_id","scope"],title:"CanonicalFeedbackImpactProjectionV1",type:"object"},{$defs:{CommitId:hq,DiagnosticSeverityV1:y$,FeedbackCycleId:y2,FeedbackDiagnosticClassificationV1:y6,FeedbackDiagnosticProducerV1:y3,FeedbackDiagnosticProjectionV1:y9,FeedbackFindingId:y8,FeedbackFindingLifecycleV1:y7,FeedbackFindingReadV1:ge,FeedbackFindingV1:gt,FeedbackResultId:go,FeedbackScopeV1:gn,FileOccurrenceId:gs,ProjectId:_4,ProviderEvaluationStateV1:vi,RepositoryId:vb,RetrievalAnchorId:vI,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{findings:{items:{$ref:"#/$defs/FeedbackFindingReadV1"},type:"array"}},required:["findings"],title:"FeedbackListResultV1",type:"object"},{$defs:{UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"}},required:["observed_at"],title:"FeedbackProximityReadRequestV1",type:"object"},{$defs:{AgentInstanceId:f$,CodeGenerationId:hy,CommitId:hq,FeedbackProximityAccessKindV1:{enum:["read","write"],type:"string"},FeedbackProximityCloneHandleV1:{additionalProperties:!1,properties:{retrieval_anchor_ids:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},source_generation:{$ref:"#/$defs/CodeGenerationId"},source_symbol:{$ref:"#/$defs/SymbolOccurrenceId"}},required:["source_generation","source_symbol","retrieval_anchor_ids"],type:"object"},FeedbackProximityConflictDifferenceV1:{additionalProperties:!1,properties:{difference_digest:{$ref:"#/$defs/ManifestDigest"},file:{$ref:"#/$defs/FileOccurrenceId"},span:{$ref:"#/$defs/SourceSpan"}},required:["file","span","difference_digest"],type:"object"},FeedbackProximityConflictHandleV1:{additionalProperties:!1,properties:{common_base_revision:{$ref:"#/$defs/CommitId"},differences:{items:{$ref:"#/$defs/FeedbackProximityConflictDifferenceV1"},type:"array"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},left_head_revision:{$ref:"#/$defs/CommitId"},right_head_revision:{$ref:"#/$defs/CommitId"}},required:["common_base_revision","left_head_revision","right_head_revision","evidence_digest","differences"],type:"object"},FeedbackProximityEncounterV1:{additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/ProximityCoverageV1"},encounter_id:{$ref:"#/$defs/ManifestDigest"},expires_at:{$ref:"#/$defs/UtcMicros"},interval:{$ref:"#/$defs/FeedbackProximityIntervalV1"},observed_at:{$ref:"#/$defs/UtcMicros"},participants:{items:{$ref:"#/$defs/FeedbackProximityParticipantV1"},type:"array"},relation:{$ref:"#/$defs/FeedbackProximityRelationV1"},scope:{$ref:"#/$defs/FeedbackScopeV1"}},required:["encounter_id","scope","interval","participants","relation","observed_at","expires_at","coverage"],type:"object"},FeedbackProximityIntervalV1:{additionalProperties:!1,properties:{end:{$ref:"#/$defs/UtcMicros"},start:{$ref:"#/$defs/UtcMicros"}},required:["start","end"],type:"object"},FeedbackProximityOmissionV1:{enum:["active_session_limit","session_activity_limit","recent_observation_limit","edited_path_limit","encounter_limit","missing_participant_observation","missing_participant_worktree","missing_participant_revision","missing_code_address","clone_coverage_partial","conflict_evidence_unavailable","code_index_revision_mismatch"],type:"string"},FeedbackProximityParticipantV1:{additionalProperties:!1,properties:{access:{$ref:"#/$defs/FeedbackProximityAccessKindV1"},activity:{$ref:"#/$defs/FeedbackProximityIntervalV1"},address:{$ref:"#/$defs/ProximityAddressV1"},agent_id:{$ref:"#/$defs/AgentInstanceId"},branch_ref:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},head_revision:{anyOf:[{$ref:"#/$defs/CommitId"},{type:"null"}]},source:{$ref:"#/$defs/ObservationSourceIdentityV1"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]},worktree_root:{type:"string"}},required:["source","agent_id","worktree_root","access","activity","address"],type:"object"},FeedbackProximityReadPageV1:{additionalProperties:!1,properties:{encounters:{items:{$ref:"#/$defs/FeedbackProximityEncounterV1"},type:"array"},expires_at:{$ref:"#/$defs/UtcMicros"},observed_at:{$ref:"#/$defs/UtcMicros"},scope:{$ref:"#/$defs/FeedbackScopeV1"},source_generation:{$ref:"#/$defs/CodeGenerationId"}},required:["scope","source_generation","observed_at","expires_at","encounters"],type:"object"},FeedbackProximityRelationV1:{oneOf:[{additionalProperties:!1,properties:{relation_kind:{const:"code_neighborhood_candidate",type:"string"},warning_class:{$ref:"#/$defs/ProximityWarningClassV1"}},required:["relation_kind","warning_class"],type:"object"},{additionalProperties:!1,properties:{clone_handle:{$ref:"#/$defs/FeedbackProximityCloneHandleV1"},relation_kind:{const:"shared_code_candidate",type:"string"},warning_class:{$ref:"#/$defs/ProximityWarningClassV1"}},required:["relation_kind","warning_class","clone_handle"],type:"object"},{additionalProperties:!1,properties:{relation_kind:{const:"overlapping_edit",type:"string"},warning_class:{$ref:"#/$defs/ProximityWarningClassV1"}},required:["relation_kind","warning_class"],type:"object"},{additionalProperties:!1,properties:{conflict_handle:{$ref:"#/$defs/FeedbackProximityConflictHandleV1"},relation_kind:{const:"confirmed_conflict",type:"string"}},required:["relation_kind","conflict_handle"],type:"object"}]},FeedbackScopeV1:gn,FileOccurrenceId:gs,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProjectId:_4,ProviderId:vo,ProximityAddressV1:{additionalProperties:!1,description:"A privacy-scoped code address. It identifies the coarse changed-code shape\nbut carries no other actor, session, or private-source content.",properties:{file:{$ref:"#/$defs/FileOccurrenceId"},scope:{$ref:"#/$defs/FeedbackScopeV1"},span:{anyOf:[{$ref:"#/$defs/SourceSpan"},{type:"null"}]},symbol:{anyOf:[{$ref:"#/$defs/SymbolOccurrenceId"},{type:"null"}]}},required:["scope","file"],type:"object"},ProximityCoverageV1:{enum:["complete","partial","stale","unavailable","denied","private"],type:"string"},ProximityWarningClassV1:{enum:["same_file","overlapping_range","same_symbol","same_package","same_crate","neighborhood","shared_caller","shared_dependency","shared_test"],type:"string"},RefId:vm,RepositoryId:vb,RetrievalAnchorId:vI,SessionId:v8,SourceSpan:b$,SymbolOccurrenceId:bq,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{page:{$ref:"#/$defs/FeedbackProximityReadPageV1"},state:{const:"complete",type:"string"}},required:["state","page"],type:"object"},{additionalProperties:!1,properties:{page:{$ref:"#/$defs/FeedbackProximityReadPageV1"},state:{const:"complete_zero",type:"string"}},required:["state","page"],type:"object"},{additionalProperties:!1,properties:{omissions:{items:{$ref:"#/$defs/FeedbackProximityOmissionV1"},type:"array"},page:{$ref:"#/$defs/FeedbackProximityReadPageV1"},state:{const:"partial",type:"string"}},required:["state","page","omissions"],type:"object"},{additionalProperties:!1,properties:{omissions:{items:{$ref:"#/$defs/FeedbackProximityOmissionV1"},type:"array"},page:{$ref:"#/$defs/FeedbackProximityReadPageV1"},state:{const:"stale",type:"string"}},required:["state","page","omissions"],type:"object"},{additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"denied",type:"string"}},required:["state","observed_at"],type:"object"},{additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"},state:{const:"unavailable",type:"string"}},required:["state","observed_at"],type:"object"}],title:"FeedbackProximityReadResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{field:{description:"Field name. Bare name ('last_sync_at') matches across structs;\nqualified form ('GraphStats::last_sync_at') narrows to one struct's\nfield.",type:"string"},limit:{description:"Maximum sites per kind (default: 200, max: 2000).",format:"uint32",minimum:0,type:["integer","null"]},writes_only:{description:"When true, returns only write_sites and omits reads. Default false.",type:["boolean","null"]}},required:["field"],title:"FieldSitesSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,FieldSiteV1:{additionalProperties:!1,properties:{enclosing:{type:["string","null"]},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},snippet:{type:"string"}},required:["file","line","snippet"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"`read_count` and `read_sites` are absent when the request asked for\nwrites only.",properties:{field:{type:"string"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},qualifier:{type:["string","null"]},qualifier_applied:{type:"boolean"},read_count:{format:"uint64",minimum:0,type:["integer","null"]},read_sites:{items:{$ref:"#/$defs/FieldSiteV1"},type:["array","null"]},write_count:{format:"uint64",minimum:0,type:"integer"},write_sites:{items:{$ref:"#/$defs/FieldSiteV1"},type:"array"}},required:["field","qualifier_applied","write_count","write_sites"],title:"FieldSitesResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{file:{type:"string"}},required:["file"],title:"FileDependentsPrimitiveRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{dependent_files:{items:{type:"string"},type:"array"},file:{type:"string"}},required:["file","dependent_files"],title:"FileDependentsPrimitiveResult",type:"object"},{$defs:{FilesLayoutV1:gd},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{layout:{anyOf:[{$ref:"#/$defs/FilesLayoutV1"},{type:"null"}],description:"File listing layout: flat (one per line) or grouped by directory\n(default: grouped)."},path:{description:"Filter to files under this directory path.",type:["string","null"]},pattern:{description:"Filter files matching this glob pattern (e.g. '**/*.rs').",type:["string","null"]}},title:"FilesSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexOmittedSourceV1:hb,CodeIndexOmittedSourcesV1:h$,CodeIndexSourceOmissionReasonV1:hS,CodeIndexStalenessStateV1:hk,FilesLayoutV1:gd,IndexedFileV1:{additionalProperties:!1,properties:{bytes:{format:"uint64",minimum:0,type:"integer"},path:{type:"string"},symbols:{format:"uint64",minimum:0,type:"integer"}},required:["path","symbols","bytes"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:"integer"},files:{items:{$ref:"#/$defs/IndexedFileV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},layout:{$ref:"#/$defs/FilesLayoutV1"},worktree_omitted_sources:{anyOf:[{$ref:"#/$defs/CodeIndexOmittedSourcesV1"},{type:"null"}],description:"Sources the serving snapshot captured for the whole worktree but does\nnot index, unfiltered by `path` or `pattern`."}},required:["count","layout","files"],title:"FilesResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{lazy_index_ignored_dependencies:{description:"Opt in to bounded indexing of ignored dependency entry files when an\nimport hint matches (default: false).",type:["boolean","null"]},limit:{description:"Maximum matches to return (default: 20, max: 200).",format:"uint32",minimum:0,type:["integer","null"]},name:{description:"Exact bare symbol name (no `::`, no glob).",type:"string"}},required:["name"],title:"FindExactSymbolSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,FindExactSymbolMatchV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},qualified_name:{type:"string"},signature:{type:["string","null"]}},required:["id","name","qualified_name","kind","file","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},matches:{items:{$ref:"#/$defs/FindExactSymbolMatchV1"},type:"array"},name:{type:"string"},suggestions:{description:"Nearest indexed bare names when `count` is 0. Empty when the query\nmatched, or when it is not itself a bare identifier.",items:{type:"string"},type:"array"}},required:["name","count","matches"],title:"FindExactSymbolResultV1",type:"object"},{$defs:{GiniMetricV1:gu,GiniScopeV1:gm},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Number of top outliers to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},metric:{anyOf:[{$ref:"#/$defs/GiniMetricV1"},{type:"null"}],description:"Metric to measure inequality for (default: complexity)."},path:{description:"Filter to files under this directory path.",type:["string","null"]},scope:{anyOf:[{$ref:"#/$defs/GiniScopeV1"},{type:"null"}],description:"Aggregate per file or per symbol (default: file)."}},title:"GiniSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GiniMetricV1:gu,GiniOutlierV1:{additionalProperties:!1,properties:{name:{type:"string"},pct_of_max:{format:"double",type:"number"},value:{format:"double",type:"number"}},required:["name","value","pct_of_max"],type:"object"},GiniScopeV1:gm,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},gini:{format:"double",type:"number"},incomplete_complexity_symbols:{description:"Symbols left out because their bounded complexity walk did not cover\nthe body; their counters are lower bounds and measure nothing here.",format:"uint64",minimum:0,type:"integer"},interpretation:{type:"string"},metric:{$ref:"#/$defs/GiniMetricV1"},outliers:{items:{$ref:"#/$defs/GiniOutlierV1"},type:"array"},scope:{$ref:"#/$defs/GiniScopeV1"},total_items:{format:"uint64",minimum:0,type:"integer"}},required:["gini","interpretation","total_items","metric","scope","incomplete_complexity_symbols","outliers"],title:"GiniResultV1",type:"object"},{$defs:{GitIndexPreviewId:gV,ManifestDigest:_l},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Public MCP/CLI request to apply one immutable Git index preview.",properties:{idempotency_key:{type:"string"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/GitIndexPreviewId"}},required:["preview_id","preview_digest","idempotency_key"],title:"GitApplySurfaceRequest",type:"object"},{$defs:{GitIndexPreviewId:gV,GitIndexReceiptId:{description:"Strongly typed canonical identity: `GitIndexReceiptId`.",type:"string"},GitIndexReceiptOutcomeV1:{description:"Terminal outcome a recovery record can prove without re-running a native\nmutation.",enum:["committed","aborted_no_change","needs_inspection"],type:"string"},GitIndexTransactionId:{description:"Strongly typed canonical identity: `GitIndexTransactionId`.",type:"string"},GitIndexTransactionOperationV1:gR,GitOidV1:gq,ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Durable, integrity-protected receipt for one Git index transaction.",properties:{committed_at:{$ref:"#/$defs/UtcMicros"},final_snapshot_captured:{description:"Whether `final_snapshot_digest`, `new_index_tree`, and `new_head` came\nfrom a post-outcome native observation. An unavailable observation is\nvalid only for a terminal outcome that does not claim a commit.",type:"boolean"},final_snapshot_digest:{$ref:"#/$defs/ManifestDigest",description:"Digest of a snapshot that was actually captured after the terminal\nobservation. When `final_snapshot_captured` is false this retains the\nexpected snapshot digest only as a stable schema placeholder; callers\nmust not treat it as an observation."},new_head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},new_index_tree:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},old_head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},old_index_tree:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},old_snapshot_digest:{$ref:"#/$defs/ManifestDigest"},operation:{$ref:"#/$defs/GitIndexTransactionOperationV1"},outcome:{$ref:"#/$defs/GitIndexReceiptOutcomeV1"},preview_id:{$ref:"#/$defs/GitIndexPreviewId"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},receipt_id:{$ref:"#/$defs/GitIndexReceiptId"},selected_hunk_digests:{items:{$ref:"#/$defs/ManifestDigest"},type:"array"},transaction_id:{$ref:"#/$defs/GitIndexTransactionId"}},required:["receipt_id","transaction_id","preview_id","operation","old_snapshot_digest","final_snapshot_digest","final_snapshot_captured","selected_hunk_digests","outcome","committed_at","receipt_digest"],title:"GitIndexTransactionReceiptV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_blame` surface.",properties:{follow_renames:{default:!1,type:"boolean"},max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]},path:{type:"string"}},required:["path"],title:"GitBlameSurfaceRequest",type:"object"},{$defs:{GitBlameAvailabilityV1:{description:"Why blame/line provenance is unavailable for a path.",enum:["available","path_not_tracked","unborn_branch","binary_file"],type:"string"},GitBlameLineV1:{additionalProperties:!1,description:"Line provenance for one final (current) line.",properties:{author:{$ref:"#/$defs/GitCommitIdentityV1"},boundary:{description:"True when the origin commit is a history boundary (e.g. shallow root).",type:"boolean"},commit:{$ref:"#/$defs/GitOidV1"},final_line:{description:"1-based line number in the blamed revision.",format:"uint32",minimum:0,type:"integer"},origin_line:{description:"1-based line number in the origin commit.",format:"uint32",minimum:0,type:"integer"},previous:{anyOf:[{$ref:"#/$defs/GitBlamePreviousV1"},{type:"null"}]}},required:["final_line","origin_line","commit","author","boundary"],type:"object"},GitBlamePreviousV1:{additionalProperties:!1,description:"Rename-following evidence for one blamed line (`previous` record).",properties:{commit:{$ref:"#/$defs/GitOidV1"},path:{type:"string"}},required:["commit","path"],type:"object"},GitBlameV1:{additionalProperties:!1,description:"Typed blame result: per-line provenance plus boundary, rename-following,\nand unavailable states.",properties:{availability:{$ref:"#/$defs/GitBlameAvailabilityV1"},coverage:{$ref:"#/$defs/GitCoverageV1"},lines:{items:{$ref:"#/$defs/GitBlameLineV1"},type:"array"},path:{type:"string"},repository:{$ref:"#/$defs/RepositoryId"}},required:["repository","path","lines","availability","coverage"],type:"object"},GitBlobExpectationV1:gf,GitChangeKindV1:gh,GitCommitIdentityV1:{additionalProperties:!1,description:"Author/committer identity and timestamp evidence for one commit.",properties:{at:{$ref:"#/$defs/UtcMicros"},email:{type:"string"},name:{type:"string"}},required:["name","email","at"],type:"object"},GitCommitMetadataV1:{additionalProperties:!1,description:"Bounded commit metadata. The full message is not retained;\n`message_digest` is its canonical digest evidence.",properties:{author:{$ref:"#/$defs/GitCommitIdentityV1"},commit:{$ref:"#/$defs/GitOidV1"},committer:{$ref:"#/$defs/GitCommitIdentityV1"},message_digest:{$ref:"#/$defs/ManifestDigest"},parents:{items:{$ref:"#/$defs/GitOidV1"},type:"array"},subject:{description:"First line of the commit message, bounded at capture.",type:"string"},tree:{$ref:"#/$defs/GitOidV1"}},required:["commit","tree","parents","author","committer","subject","message_digest"],type:"object"},GitCoverageV1:gv,GitDegradationV1:gb,GitDiffScopeV1:{description:"Diff scope: unstaged worktree changes, staged index changes, or an exact\ncommit range. Range diffs are read-only evidence and carry no index\nrelationship, so they cannot mint an applicable `HunkRefV1`.",oneOf:[{properties:{scope:{const:"working_tree",type:"string"}},required:["scope"],type:"object"},{properties:{scope:{const:"staged",type:"string"}},required:["scope"],type:"object"},{properties:{base:{$ref:"#/$defs/GitOidV1"},head:{$ref:"#/$defs/GitOidV1"},scope:{const:"commit_range",type:"string"}},required:["scope","base","head"],type:"object"}]},GitDiffV1:{additionalProperties:!1,description:"Typed diff result for one scope with explicit coverage.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},files:{items:{$ref:"#/$defs/GitFileDiffV1"},type:"array"},repository:{$ref:"#/$defs/RepositoryId"},scope:{$ref:"#/$defs/GitDiffScopeV1"}},required:["repository","scope","files","coverage"],type:"object"},GitFileDiffV1:{additionalProperties:!1,description:"One file's structured diff record: change kind, modes, blob identities,\nbinary/submodule classification, bounded line totals, and hunks.",properties:{binary:{type:"boolean"},change:{$ref:"#/$defs/GitChangeKindV1"},deletions:{format:"uint32",minimum:0,type:["integer","null"]},hunks:{items:{$ref:"#/$defs/GitHunkV1"},type:"array"},insertions:{description:"Inserted/deleted line totals; absent for binary and submodule records.",format:"uint32",minimum:0,type:["integer","null"]},new_blob:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},new_mode:{anyOf:[{$ref:"#/$defs/GitFileModeV1"},{type:"null"}]},old_blob:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},old_mode:{anyOf:[{$ref:"#/$defs/GitFileModeV1"},{type:"null"}]},original_path:{description:"Source path for a rename or copy.",type:["string","null"]},path:{type:"string"},submodule:{description:"True when the entry is a gitlink (submodule) change.",type:"boolean"}},required:["path","change","binary","submodule","hunks"],type:"object"},GitFileModeV1:g$,GitHeadStateV1:gk,GitHistoryV1:{additionalProperties:!1,description:"Bounded commit history in native traversal order. `truncated` is true\nwhen the capture bound cut the walk; shallow/partial-clone boundaries are\ncoverage degradations, never silently clean.",properties:{commits:{items:{$ref:"#/$defs/GitCommitMetadataV1"},type:"array"},coverage:{$ref:"#/$defs/GitCoverageV1"},repository:{$ref:"#/$defs/RepositoryId"},truncated:{type:"boolean"}},required:["repository","commits","truncated","coverage"],type:"object"},GitHunkPreviewEntryV1:{additionalProperties:!1,description:"One minted hunk selection: the canonical selection digest plus the\n`HunkRef` identity evidence it selects.",properties:{digest:{$ref:"#/$defs/ManifestDigest"},hunk:{$ref:"#/$defs/HunkRefV1"}},required:["digest","hunk"],type:"object"},GitHunkPreviewInputV1:{additionalProperties:!1,description:"Bounded, expiring preview input minted by `git_hunks` from one exact\ndaemon-captured repository snapshot.",properties:{expires_at:{$ref:"#/$defs/UtcMicros"},hunks:{items:{$ref:"#/$defs/GitHunkPreviewEntryV1"},type:"array"},preview_input_id:{$ref:"#/$defs/GitIndexPreviewId"},repository_snapshot_digest:{$ref:"#/$defs/ManifestDigest"}},required:["preview_input_id","repository_snapshot_digest","expires_at","hunks"],type:"object"},GitHunkV1:{additionalProperties:!1,description:"One structured diff hunk. The hunk body is not retained; `patch_digest`\nis the canonical digest of the normalized header plus body lines, which\nis the stable hunk identity evidence.",properties:{new_lines:{format:"uint32",minimum:0,type:"integer"},new_start:{format:"uint32",minimum:0,type:"integer"},old_lines:{format:"uint32",minimum:0,type:"integer"},old_start:{format:"uint32",minimum:0,type:"integer"},patch_digest:{$ref:"#/$defs/ManifestDigest"},section:{description:"Function/section heading from the hunk header when Git emitted one.",type:["string","null"]}},required:["old_start","old_lines","new_start","new_lines","patch_digest"],type:"object"},GitIndexEntryExpectationV1:gP,GitIndexPreviewId:gV,GitOidV1:gq,GitOperationStateV1:gI,GitQueryEnvelopeV1:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitStatusSummaryV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitQueryEnvelopeV12:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitDiffV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitQueryEnvelopeV13:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitHistoryV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitQueryEnvelopeV14:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitBlameV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitQueryEnvelopeV15:{additionalProperties:!1,description:"One typed query result with its merged coverage. `coverage` is the\nadapter-reported coverage plus any query-level degradation (entry-bound\ntruncation); `truncated_by_bound` distinguishes query-level truncation\nfrom adapter-level capture bounds.",properties:{coverage:{$ref:"#/$defs/GitCoverageV1"},truncated_by_bound:{type:"boolean"},value:{$ref:"#/$defs/GitHunkPreviewInputV1"}},required:["value","coverage","truncated_by_bound"],type:"object"},GitStatusSummaryV1:{additionalProperties:!1,description:"Bounded status summary derived from the typed\n[`tracedecay_domain::git::GitStatusV1`]: HEAD and operation state,\nper-class counts, and a bounded sorted sample of changed paths.",properties:{changed_paths:{description:"Sorted, de-duplicated changed paths, truncated at the query entry bound.",items:{type:"string"},type:"array"},conflicted:{format:"uint32",minimum:0,type:"integer"},head:{$ref:"#/$defs/GitHeadStateV1"},ignored:{format:"uint32",minimum:0,type:"integer"},operation:{$ref:"#/$defs/GitOperationStateV1"},repository:{$ref:"#/$defs/RepositoryId"},schema_version:{type:"string"},staged:{format:"uint32",minimum:0,type:"integer"},unstaged:{format:"uint32",minimum:0,type:"integer"},untracked:{format:"uint32",minimum:0,type:"integer"}},required:["repository","head","operation","staged","unstaged","conflicted","untracked","ignored","changed_paths","schema_version"],type:"object"},HunkDirectionV1:gU,HunkRefV1:gH,ManifestDigest:_l,RepositoryId:vb,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Actual payload emitted by each public Git read operation.",oneOf:[{properties:{query:{const:"status",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV1"}},required:["query","result"],type:"object"},{properties:{query:{const:"diff",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV12"}},required:["query","result"],type:"object"},{properties:{query:{const:"history",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV13"}},required:["query","result"],type:"object"},{properties:{query:{const:"blame",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV14"}},required:["query","result"],type:"object"},{properties:{query:{const:"hunks",type:"string"},result:{$ref:"#/$defs/GitQueryEnvelopeV15"}},required:["query","result"],type:"object"}],title:"GitReadResultV1"},{$defs:{GitOidV1:gq,GitSurfaceDiffScopeV1:gA},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_diff` surface.",properties:{base:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},head:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]},scope:{$ref:"#/$defs/GitSurfaceDiffScopeV1",default:"working_tree"}},title:"GitDiffSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_history` surface.",properties:{count:{format:"uint32",minimum:0,type:["integer","null"]},first_parent:{default:!1,type:"boolean"},follow:{default:!1,type:"boolean"},max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]},path:{type:["string","null"]}},title:"GitHistorySurfaceRequest",type:"object"},{$defs:{GitSurfaceDiffScopeV1:gA},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_hunks` surface.\n\nThe daemon captures exact repository state itself and injects the private\npreview binding after capture, so the public wire carries only the diff\nscope (commit ranges cannot mint applicable hunks).",properties:{max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]},scope:{$ref:"#/$defs/GitSurfaceDiffScopeV1",default:"working_tree"}},title:"GitHunksSurfaceRequest",type:"object"},{$defs:{GitIndexPreviewId:gV,GitIndexTransactionOperationV1:gR,ManifestDigest:_l},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Public MCP/CLI request for one daemon-owned Git index preview.",properties:{operation:{$ref:"#/$defs/GitIndexTransactionOperationV1"},preview_input_id:{anyOf:[{$ref:"#/$defs/GitIndexPreviewId"},{type:"null"}],default:null,description:"Hunk preview input minted by `git_hunks`; required for stage/unstage."},selected_hunk_digests:{default:[],description:"Selection digests drawn from the referenced preview input.",items:{$ref:"#/$defs/ManifestDigest"},type:"array"}},required:["operation"],title:"GitPreviewSurfaceRequest",type:"object"},{$defs:{GitBlobExpectationV1:gf,GitCoverageV1:gv,GitDegradationV1:gb,GitFileModeV1:g$,GitHeadStateV1:gk,GitIndexEntryExpectationV1:gP,GitIndexPreviewDispositionV1:{description:"Whether a captured preview may reach the daemon's native apply path.",oneOf:[{properties:{state:{const:"applicable",type:"string"}},required:["state"],type:"object"},{properties:{reason:{$ref:"#/$defs/GitIndexUnsupportedStateV1"},state:{const:"unsupported",type:"string"}},required:["state","reason"],type:"object"}]},GitIndexPreviewId:gV,GitIndexTransactionOperationV1:gR,GitIndexUnsupportedStateV1:{description:"Why a preview is intentionally read-only. A caller must re-preview after\nresolving the condition; no variant grants a relaxed or partial apply.",enum:["bare_repository","detached_head","unborn_branch","index_lock_present","external_git_driver","unmerged_index","intent_to_add","split_index","sparse_index","unreadable_index","conflicted_working_tree","unreadable_working_tree","in_progress_operation","unsupported_object_format","binary_hunk","submodule","symlink","file_mode_only","rename_or_copy","filters_or_end_of_line","partial_hunk_selection"],type:"string"},GitObjectFormatV1:{description:"Repository object format, derived from object-id length.",enum:["sha1","sha256"],type:"string"},GitOidV1:gq,GitOperationStateV1:gI,HunkDirectionV1:gU,HunkRefV1:gH,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RepositoryIndexSnapshotV1:{additionalProperties:!1,properties:{checksum:{$ref:"#/$defs/ManifestDigest"},state:{$ref:"#/$defs/RepositoryIndexStateV1"},tree_id:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},unmerged_stage_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]}},required:["checksum","state"],type:"object"},RepositoryIndexStateV1:{enum:["clean","staged","unmerged","intent_to_add","split","sparse","unreadable"],type:"string"},RepositoryStateSnapshotV1:{additionalProperties:!1,description:"Immutable content-addressed native repository state. Missing/partial\nevidence remains typed by fields and coverage instead of being upgraded to\na guessed clean snapshot.",properties:{adapter_revision:{description:"Revision of the fixed native adapter that interpreted this state.",type:["string","null"]},attributes_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},captured_at:{$ref:"#/$defs/UtcMicros"},configuration_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},coverage:{$ref:"#/$defs/GitCoverageV1"},filesystem_capabilities_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},git_version:{description:"Exact native Git implementation observed by the fixed adapter. A\nread-only partial snapshot may omit this, but omitted native evidence\nis never mutation eligible.",type:["string","null"]},head:{$ref:"#/$defs/GitHeadStateV1"},index:{$ref:"#/$defs/RepositoryIndexSnapshotV1"},object_format:{$ref:"#/$defs/GitObjectFormatV1"},observation_epoch:{format:"uint64",minimum:0,type:"integer"},operation_state:{$ref:"#/$defs/GitOperationStateV1"},project_id:{$ref:"#/$defs/ProjectId"},refs_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}],description:"Digest of the complete native ref namespace at capture time."},repository_id:{$ref:"#/$defs/RepositoryId"},snapshot_id:{type:"string"},sparse_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},submodule_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},working_tree:{$ref:"#/$defs/RepositoryWorkingTreeSnapshotV1"},worktree_id:{anyOf:[{$ref:"#/$defs/WorktreeId"},{type:"null"}]}},required:["snapshot_id","project_id","repository_id","observation_epoch","object_format","head","index","working_tree","operation_state","captured_at","coverage"],type:"object"},RepositoryWorkingTreeSnapshotV1:{additionalProperties:!1,properties:{ignored_collision_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},state:{$ref:"#/$defs/RepositoryWorkingTreeStateV1"},tracked_digest:{$ref:"#/$defs/ManifestDigest"},untracked_name_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]}},required:["state","tracked_digest"],type:"object"},RepositoryWorkingTreeStateV1:{enum:["clean","tracked_dirty","untracked_only","mixed","conflicted","unreadable"],type:"string"},UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Immutable, content-bound preview for one daemon-serialized index\ntransaction. Applicability is only a precondition: the daemon must capture\nand compare the entire snapshot and every contained `HunkRefV1` again\nimmediately before a native mutation.",properties:{candidate_index_tree:{anyOf:[{$ref:"#/$defs/GitOidV1"},{type:"null"}]},created_at:{$ref:"#/$defs/UtcMicros"},disposition:{$ref:"#/$defs/GitIndexPreviewDispositionV1"},expires_at:{$ref:"#/$defs/UtcMicros"},operation:{$ref:"#/$defs/GitIndexTransactionOperationV1"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/GitIndexPreviewId"},repository_snapshot:{$ref:"#/$defs/RepositoryStateSnapshotV1"},repository_snapshot_digest:{$ref:"#/$defs/ManifestDigest"},selected_hunks:{items:{$ref:"#/$defs/HunkRefV1"},type:"array"}},required:["preview_id","operation","repository_snapshot","repository_snapshot_digest","selected_hunks","disposition","created_at","expires_at","preview_digest"],title:"GitIndexPreviewV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Request shape for the public `git_status` surface.",properties:{max_bytes:{format:"uint64",minimum:0,type:["integer","null"]},max_entries:{format:"uint32",minimum:0,type:["integer","null"]}},title:"GitStatusSurfaceRequest",type:"object"},{$defs:{StackDeliveryWatermarkId:bk,StackSignalId:bP},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The public, transport-neutral request for one durable stack signal.",properties:{expected_watermark_id:{anyOf:[{$ref:"#/$defs/StackDeliveryWatermarkId"},{type:"null"}]},signal_id:{anyOf:[{$ref:"#/$defs/StackSignalId"},{type:"null"}]}},title:"GitHubStackSignalExpandSurfaceRequest",type:"object"},{$defs:{BranchStackRevisionId:f8,GitHubStackSignalEvidenceRefV1:{additionalProperties:!1,description:"Bounded evidence for the exact signal the coordinator authorized.\n\nProvider payloads, paths, commit bodies, and delivery recipients remain\nbehind the durable signal evidence rather than copied to this result.",properties:{github_stack_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},kind:{$ref:"#/$defs/StackSignalKindV1"},native_source:{$ref:"#/$defs/GitHubStackSignalNativeSourceV1"},observed_at:{$ref:"#/$defs/UtcMicros"},signal_id:{$ref:"#/$defs/StackSignalId"},stack_revision_digest:{$ref:"#/$defs/ManifestDigest"},stack_revision_id:{$ref:"#/$defs/BranchStackRevisionId"},state_digest:{$ref:"#/$defs/ManifestDigest"},watermark_id:{$ref:"#/$defs/StackDeliveryWatermarkId"}},required:["signal_id","watermark_id","kind","stack_revision_id","stack_revision_digest","state_digest","observed_at","native_source"],type:"object"},GitHubStackSignalExpandUnavailableV1:{description:"Truthful non-success outcomes for signal expansion.\n\n`Concealed` intentionally combines absent and unauthorized signal handles;\nexposing that distinction would turn this operation into a signal probe.",enum:["concealed","stale","native_evidence_unavailable","authority_unmounted","cancelled"],type:"string"},GitHubStackSignalNativePreviewV1:{additionalProperties:!1,description:"Exact branch pair and native preflight that produced the selected signal.",properties:{destination_ref:{$ref:"#/$defs/RefId"},destination_tip:{$ref:"#/$defs/GitOidV1"},direction:{$ref:"#/$defs/NativeIntegrationDirectionV1"},disposition:{$ref:"#/$defs/NativeIntegrationPreviewDispositionV1"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/NativeIntegrationPreviewId"},source_ref:{$ref:"#/$defs/RefId"},source_tip:{$ref:"#/$defs/GitOidV1"}},required:["preview_id","preview_digest","direction","source_ref","destination_ref","source_tip","destination_tip","disposition"],type:"object"},GitHubStackSignalNativeSourceV1:{oneOf:[{properties:{preview:{$ref:"#/$defs/GitHubStackSignalNativePreviewV1"},source:{const:"preflight",type:"string"}},required:["source","preview"],type:"object"},{properties:{preview:{$ref:"#/$defs/GitHubStackSignalNativePreviewV1"},source:{const:"terminal",type:"string"},terminal:{$ref:"#/$defs/GitHubStackSignalNativeTerminalV1"}},required:["source","preview","terminal"],type:"object"}]},GitHubStackSignalNativeTerminalV1:{additionalProperties:!1,properties:{completed_at:{$ref:"#/$defs/UtcMicros"},final_ref_tip:{$ref:"#/$defs/GitOidV1"},outcome:{$ref:"#/$defs/NativeIntegrationTerminalOutcomeV1"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"}},required:["transaction_id","receipt_digest","outcome","final_ref_tip","completed_at"],type:"object"},GitOidV1:gq,ManifestDigest:_l,MechanicalIntegrationModeV1:_p,NativeIntegrationDirectionV1:_R,NativeIntegrationPreviewDispositionV1:_q,NativeIntegrationPreviewId:_I,NativeIntegrationTerminalOutcomeV1:_C,NativeIntegrationTransactionId:_T,NativeIntegrationUnavailabilityV1:_O,RefId:vm,StackDeliveryWatermarkId:bk,StackSignalId:bP,StackSignalKindV1:{description:"Durable classification of one GitHub stack transition.",enum:["dependency_ready","actual_conflict","stack_tip_drift","pull_request_drift","ci_evaluated_commit_drift","integration_committed","integration_needs_inspection"],type:"string"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{evidence:{$ref:"#/$defs/GitHubStackSignalEvidenceRefV1"},outcome:{const:"expanded",type:"string"}},required:["outcome","evidence"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},reason:{$ref:"#/$defs/GitHubStackSignalExpandUnavailableV1"}},required:["outcome","reason"],type:"object"}],title:"GitHubStackSignalExpandSurfaceResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"GodClassSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,GodClassEntryV1:{additionalProperties:!1,properties:{fields:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},methods:{format:"uint64",minimum:0,type:"integer"},name:{type:"string"},total_members:{format:"uint64",minimum:0,type:"integer"}},required:["id","name","kind","file","line","methods","fields","total_members"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ranking:{items:{$ref:"#/$defs/GodClassEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["result_count","ranking"],title:"GodClassResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{case_sensitive:{description:"Match case-sensitively (default: false = case-insensitive).",type:["boolean","null"]},context_lines:{description:"Lines of surrounding context to include per hit (default: 0, max: 3).",format:"uint32",minimum:0,type:["integer","null"]},fixed_strings:{description:"Treat pattern as a literal string instead of a regex (default: false).",type:["boolean","null"]},max_results:{description:"Maximum number of matching lines to return (default: 50, max: 200).",format:"uint32",minimum:0,type:["integer","null"]},path_glob:{description:"Optional glob restricting which files are searched, matched against\nproject-relative paths (e.g. 'src/**/*.rs').",type:["string","null"]},pattern:{description:"Content to search for. Treated as a regular expression unless\nfixed_strings is true.",type:"string"}},required:["pattern"],title:"GrepSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,CoverageCompleteness:yu,CoverageDomainState:ym,EvidenceCoverage:yx,EvidenceDomain:yj,GrepGraphEnrichmentV1:{description:"Whether the verified graph resolved each hit's enclosing symbol. Hits are\nthe lexical answer either way.",oneOf:[{additionalProperties:!1,properties:{enriched:{format:"uint64",minimum:0,type:"integer"},returned:{format:"uint64",minimum:0,type:"integer"},status:{const:"complete",type:"string"}},required:["status","enriched","returned"],type:"object"},{additionalProperties:!1,properties:{detail:{type:"string"},reason_code:{type:"string"},retryable:{type:"boolean"},status:{const:"unavailable",type:"string"}},required:["status","reason_code","retryable","detail"],type:"object"}]},GrepMatchV1:{additionalProperties:!1,properties:{after:{items:{type:"string"},type:"array"},before:{items:{type:"string"},type:"array"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},node_id:{type:["string","null"]},symbol:{description:"The smallest verified graph symbol enclosing the hit.",type:["string","null"]},text:{type:"string"}},required:["file","line","text"],type:"object"},GrepScanOmissionsV1:{additionalProperties:!1,description:"What the bounded scan skipped, by cause; absent when it skipped nothing.",properties:{oversized_files:{description:"Files larger than the interactive scan byte limit.",format:"uint64",minimum:0,type:"integer"},oversized_lines:{description:"Lines longer than the scan line byte limit.",format:"uint64",minimum:0,type:"integer"},unavailable_sources:{description:"Source candidates that could not be read during the scan.",format:"uint64",minimum:0,type:"integer"}},required:["oversized_files","oversized_lines","unavailable_sources"],type:"object"},Omission:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},domain:{$ref:"#/$defs/EvidenceDomain"},reason:{$ref:"#/$defs/OmissionReason"}},required:["domain","count","reason"],type:"object"},OmissionReason:{description:"Safe reason why authorized requested evidence was omitted.",oneOf:[{enum:["budget","redacted","unavailable","unsupported","stale","failed","cancelled","timed_out","conflict"],type:"string"},{const:"macro_body_unparsed",description:"Evidence came from a macro body that was not expanded, so what the\nexpansion defines or calls is not covered.",type:"string"},{const:"import_unmodeled",description:"A caller sits under a `use` whose binding the index could not model\n(a glob in a block or inline module), so whether it calls the target\nis not covered.",type:"string"},{const:"cursor_expired",description:"The continuation cursor can no longer be redeemed (its lifetime ended\nor the snapshot it pages is gone); restart the request without it.",type:"string"},{const:"cursor_foreign",description:"The continuation cursor was issued for another project, worktree, or\nref; redeem it where it was issued.",type:"string"}]},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/EvidenceCoverage"},files_scanned:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},graph_enrichment:{$ref:"#/$defs/GrepGraphEnrichmentV1"},match_count:{format:"uint64",minimum:0,type:"integer"},omissions:{items:{$ref:"#/$defs/Omission"},type:"array"},results:{items:{$ref:"#/$defs/GrepMatchV1"},type:"array"},scan_omissions:{$ref:"#/$defs/GrepScanOmissionsV1"},truncated:{type:"boolean"}},required:["results","match_count","files_scanned","truncated","coverage","omissions","graph_enrichment"],title:"GrepSearchResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{details:{description:"If true, include full dimension breakdown (default: false).",type:["boolean","null"]},path:{description:"Filter to files under this directory path.",type:["string","null"]}},title:"HealthSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,HealthAcyclicityV1:{additionalProperties:!1,properties:{edges_in_cycles:{format:"uint64",minimum:0,type:"integer"},score:{format:"double",type:"number"},source:{type:"string"}},required:["score","edges_in_cycles","source"],type:"object"},HealthCoverageDisciplineV1:{additionalProperties:!1,properties:{score:{format:"double",type:"number"},skip_test_coverage_count:{format:"uint64",minimum:0,type:"integer"},source:{type:"string"},total_fns:{format:"uint64",minimum:0,type:"integer"}},required:["score","skip_test_coverage_count","total_fns","source"],type:"object"},HealthDepthV1:{additionalProperties:!1,properties:{ideal_chain:{format:"uint64",minimum:0,type:"integer"},max_chain:{format:"uint64",minimum:0,type:"integer"},score:{format:"double",type:"number"},source:{type:"string"}},required:["score","max_chain","ideal_chain","source"],type:"object"},HealthDimensionsV1:{additionalProperties:!1,properties:{acyclicity:{$ref:"#/$defs/HealthAcyclicityV1"},coverage_discipline:{$ref:"#/$defs/HealthCoverageDisciplineV1"},depth:{$ref:"#/$defs/HealthDepthV1"},equality:{$ref:"#/$defs/HealthEqualityV1"},modularity:{$ref:"#/$defs/HealthModularityV1"},redundancy:{$ref:"#/$defs/HealthRedundancyV1"}},required:["acyclicity","depth","equality","redundancy","modularity","coverage_discipline"],type:"object"},HealthEqualityV1:{additionalProperties:!1,properties:{gini:{format:"double",type:"number"},incomplete_complexity_symbols:{format:"uint64",minimum:0,type:"integer"},interpretation:{type:"string"},score:{format:"double",type:"number"},source:{type:"string"}},required:["score","gini","interpretation","incomplete_complexity_symbols","source"],type:"object"},HealthModularityV1:{additionalProperties:!1,properties:{components_after_hub_removal:{format:"uint64",minimum:0,type:"integer"},interpretation:{type:"string"},score:{format:"double",type:"number"},source:{type:"string"}},required:["score","interpretation","components_after_hub_removal","source"],type:"object"},HealthRedundancyV1:{additionalProperties:!1,properties:{dead_count:{format:"uint64",minimum:0,type:"integer"},score:{format:"double",type:"number"},source:{type:"string"},total_fns:{format:"uint64",minimum:0,type:"integer"}},required:["score","dead_count","total_fns","source"],type:"object"},HealthWeightsV1:{additionalProperties:!1,properties:{note:{type:"string"}},required:["note"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"`dimensions` and `weights` are present exactly when the request asked for\n`details`.",properties:{dimensions:{anyOf:[{$ref:"#/$defs/HealthDimensionsV1"},{type:"null"}]},files_analyzed:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},panel:{description:"Measured dimension names, worst score first, then\n`no evidence: name (reason), ...` for the dimensions the scope gave\nnothing to measure. An empty scope reads\n`no evidence: 0 files in scope`.",type:"string"},quality_signal:{description:"Geometric mean of the dimensions, scaled to 0-10000. A breakdown of\n`panel`, not a number to maximize. Dimensions that `panel` lists under\n`no evidence:` enter it at their formula value for an empty\nmeasurement, so it does not summarize such a scope: an empty scope\nreads 10000 and one file reads 0.",format:"uint32",minimum:0,type:"integer"},weights:{anyOf:[{$ref:"#/$defs/HealthWeightsV1"},{type:"null"}]}},required:["quality_signal","files_analyzed"],title:"HealthResultV1",type:"object"},{$defs:{PageRequest:_U,ResultProjection:vP,RetrievalOrder:vx,RetrievalRequestMeta:vj,TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{before_cursor:{description:"A prior result's after_cursor. A cursor recorded under another health\ndefinition, or before definitions were recorded, is refused with\n`application.health-delta.definition-mismatch` or\n`application.health-delta.definition-unrecorded`; omit it to record a\nnew baseline.",type:["string","null"]},meta:{$ref:"#/$defs/RetrievalRequestMeta"},path_prefix:{type:["string","null"]}},required:["meta"],title:"HealthDeltaRequest",type:"object"},{$defs:{HealthDeltaCoverageV1:{additionalProperties:!1,properties:{completeness:{description:"`complete` when both points analyzed files, otherwise `unknown`.",type:"string"},denominator:{format:"uint64",minimum:0,type:["integer","null"]},eligible:{description:"Files the `after` point analyzed.",format:"uint64",minimum:0,type:["integer","null"]},visited:{format:"uint64",minimum:0,type:["integer","null"]}},required:["completeness"],type:"object"},HealthDeltaCurrentnessV1:{additionalProperties:!1,properties:{observed_at:{$ref:"#/$defs/UtcMicros"},state:{type:"string"}},required:["state","observed_at"],type:"object"},HealthDeltaPointV1:{additionalProperties:!1,properties:{dimensions:{additionalProperties:{$ref:"#/$defs/HealthDimensionPointV1"},type:"object"},files_analyzed:{format:"uint64",minimum:0,type:"integer"},function_denominator:{format:"uint64",minimum:0,type:"integer"},observed_at:{$ref:"#/$defs/UtcMicros"},quality_signal:{format:"uint32",minimum:0,type:"integer"},watermark:{$ref:"#/$defs/ManifestDigest"}},required:["watermark","observed_at","quality_signal","files_analyzed","function_denominator","dimensions"],type:"object"},HealthDeltaScopeV1:{additionalProperties:!1,properties:{path_prefix:{type:["string","null"]},project_id:{type:["string","null"]},scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest"],type:"object"},HealthDimensionDeltaV1:{additionalProperties:!1,properties:{after_denominator:{format:"uint64",minimum:0,type:["integer","null"]},after_ppm:{format:"uint64",minimum:0,type:"integer"},before_denominator:{format:"uint64",minimum:0,type:["integer","null"]},before_ppm:{format:"uint64",minimum:0,type:"integer"},delta_ppm:{format:"int64",type:"integer"},status:{description:"`improved` or `degraded` when the score moved more than 1000 ppm,\notherwise `unchanged`. `no_evidence` when either point's scope gave\nthe dimension nothing to measure, so its scores are formula values.",type:"string"}},required:["before_ppm","after_ppm","delta_ppm","status"],type:"object"},HealthDimensionPointV1:{additionalProperties:!1,properties:{denominator:{format:"uint64",minimum:0,type:["integer","null"]},score_ppm:{format:"uint64",minimum:0,type:"integer"}},required:["score_ppm"],type:"object"},ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{after:{$ref:"#/$defs/HealthDeltaPointV1"},after_cursor:{type:"string"},before:{$ref:"#/$defs/HealthDeltaPointV1"},before_cursor:{type:"string"},coverage:{$ref:"#/$defs/HealthDeltaCoverageV1"},currentness:{$ref:"#/$defs/HealthDeltaCurrentnessV1"},delta:{format:"int64",type:"integer"},dimensions:{additionalProperties:{$ref:"#/$defs/HealthDimensionDeltaV1"},type:"object"},pass:{description:"True when both points analyzed files and quality_signal did not drop.",type:"boolean"},schema_version:{format:"uint32",minimum:0,type:"integer"},scope:{$ref:"#/$defs/HealthDeltaScopeV1"}},required:["schema_version","scope","before","after","before_cursor","after_cursor","pass","delta","dimensions","coverage","currentness"],title:"HealthDeltaResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The health read takes no parameters: it reports one serving status, with no\npage, projection, or temporal selection to make. The page and deadline\ncontrols every surface supplies travel in the dispatch envelope, not here.",title:"HealthReadRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{status:{type:"string"}},required:["status"],title:"HealthReadResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_pending_payloads:{default:!1,description:"Include staged Hermes skill-write payloads (default: false).",type:"boolean"},include_skill_bodies:{default:!1,description:"Include bounded SKILL.md contents (default: false).",type:"boolean"}},title:"HermesSkillBridgeSurfaceRequestV1",type:"object"},{$defs:{AutomationReadStatusV1:fH,HermesPendingSkillWrite:{properties:{action:{type:["string","null"]},created_at:!0,id:{type:"string"},name:{type:["string","null"]},origin:{type:["string","null"]},payload:!0,source_path:{type:"string"},summary:{type:["string","null"]}},required:["id","source_path"],type:"object"},HermesSkillBridgeContracts:{properties:{discovery_policy:{type:"string"},lifecycle_owner:{type:"string"},mutation_policy:{type:"string"}},required:["lifecycle_owner","mutation_policy","discovery_policy"],type:"object"},HermesSkillBridgeSnapshot:{properties:{agent_home:{type:"string"},archive_count:{format:"uint",minimum:0,type:"integer"},contracts:{$ref:"#/$defs/HermesSkillBridgeContracts"},pending_skill_corrupt_count:{format:"uint",minimum:0,type:"integer"},pending_skill_count:{format:"uint",minimum:0,type:"integer"},pending_skills:{items:{$ref:"#/$defs/HermesPendingSkillWrite"},type:"array"},skill_count:{format:"uint",minimum:0,type:"integer"},skills:{items:{$ref:"#/$defs/HermesSkillSummary"},type:"array"},skills_dir:{type:"string"},usage_record_count:{format:"uint",minimum:0,type:"integer"},usage_records:{additionalProperties:!0,description:"Hermes-owned usage telemetry keyed by skill name, as Hermes wrote it.",type:"object"}},required:["agent_home","skills_dir","skill_count","pending_skill_count","pending_skill_corrupt_count","usage_record_count","archive_count","skills","pending_skills","usage_records","contracts"],type:"object"},HermesSkillSummary:{properties:{body_markdown:{type:["string","null"]},category:{type:["string","null"]},description:{type:["string","null"]},name:{type:"string"},path:{type:"string"},pending_write_ids:{items:{type:"string"},type:"array"},usage:!0},required:["name","path","pending_write_ids"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{bridge:{$ref:"#/$defs/HermesSkillBridgeSnapshot"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","bridge"],title:"HermesSkillBridgeResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,description:"Reset the project's local token counter.",properties:{action:{const:"reset_counter",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,description:"Admit one Hook V2 envelope for the bound project.",properties:{action:{const:"hook_v2_admit",type:"string"},envelope:!0,native_lifecycle:!0,native_session_id:{description:"The host's native session id; it binds only when it hashes to the\nenvelope's protected session.",type:["string","null"]}},required:["action","envelope"],type:"object"},{additionalProperties:!1,description:"Commit a Context Scout delivery receipt for guidance the last\nadmission handed out.",properties:{action:{const:"hook_v2_delivery_receipt",type:"string"},receipt:!0},required:["action","receipt"],type:"object"},{additionalProperties:!1,description:"Acknowledge delivery of an advisory feedback notice.",properties:{action:{const:"hook_v2_feedback_notice_delivery",type:"string"},envelope:!0,feedback_notice:!0},required:["action","envelope","feedback_notice"],type:"object"},{additionalProperties:!1,description:"Land a host transcript in the owning session store.",properties:{action:{const:"ingest_transcript",type:"string"},event_json:{description:"The host's raw hook event, for providers that locate the transcript\nfrom it.",type:["string","null"]},max_new_bytes:{description:"Byte budget for this pass across every scanned source.",format:"uint64",minimum:0,type:["integer","null"]},messages:{description:"One turn the host inlined instead of a source to scan.",items:!0,type:["array","null"]},provider:{type:"string"},session_id:{type:["string","null"]},user_scope:{description:"Land the transcript in the profile's user store instead of the\nproject's.",type:"boolean"}},required:["action","provider","user_scope"],type:"object"},{additionalProperties:!1,description:"Codex `PostCompact` pressure evidence.",properties:{action:{const:"codex_compact",type:"string"},event_json:{type:"string"}},required:["action","event_json"],type:"object"},{additionalProperties:!1,description:"Claude `PostCompact` pressure evidence; `user_scope` routes it to the\nprofile.",properties:{action:{const:"claude_compact",type:"string"},event_json:{type:"string"},user_scope:{type:"boolean"}},required:["action","event_json","user_scope"],type:"object"},{additionalProperties:!1,description:"Cursor `preCompact` pressure evidence.",properties:{action:{const:"cursor_compact",type:"string"},event_json:{type:"string"}},required:["action","event_json"],type:"object"},{additionalProperties:!1,description:"Record a Hermes terminal receipt without a project route.",properties:{action:{const:"hermes_receipt",type:"string"},event:!0},required:["action","event"],type:"object"},{additionalProperties:!1,description:"Admit a native event without a project route into the profile's\nHook V2 ledger.",properties:{action:{const:"hook_v2_profile_admit",type:"string"},admission:!0},required:["action","admission"],type:"object"}],title:"HookRuntimeSurfaceRequestV1"},{$defs:{ContextScoutAddressV1:hU,ContextScoutStoreStatusV1:{enum:["stored","duplicate","superseded","unavailable"],type:"string"},HermesReceiptStatusV1:{oneOf:[{const:"recorded",description:"A terminal receipt was recorded.",type:"string"},{const:"ingested",description:"The turn was marked ingested and no receipt awaits review.",type:"string"},{const:"awaiting_transcript",description:"A receipt awaits a transcript that has not landed yet.",type:"string"}]},HookIngestAdmissionV1:{additionalProperties:!1,description:"The admission authority's verdict on one transcript ingest.",properties:{reason_code:{type:["string","null"]},retryable:{type:"boolean"},status:{description:"The session host-admission status, in its wire spelling.",type:"string"}},required:["status","retryable"],type:"object"},HookOrchestrationAdmissionV1:{description:"Outcome of admitting one hook envelope into the registered orchestrator.",enum:["enqueued","backpressured","unsupported_trigger","unavailable"],type:"string"},HookRuntimeDispositionV1:{description:"How the hook transport should treat a Hook V2 envelope.",oneOf:[{enum:["accepted"],type:"string"},{const:"catchup_required",description:"The published binding no longer authorizes the envelope; the host\nmust catch up before sending again.",type:"string"}]},HookV2RejectionReasonV1:{oneOf:[{const:"admission_identity_conflict",description:"The same event identity previously carried different bytes.",type:"string"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{action:{const:"reset_counter",type:"string"},reset:{type:"boolean"}},required:["action","reset"],type:"object"},{oneOf:[{properties:{context_scout_address:{anyOf:[{$ref:"#/$defs/ContextScoutAddressV1"},{type:"null"}]},disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},feedback_notice:{description:"The advisory `AdvisoryHookLookupNoticeV1` waiting for this\nworktree."},github_stack_signal_available:{type:"boolean"},orchestration:{$ref:"#/$defs/HookOrchestrationAdmissionV1"},ready_guidance:{description:"The hook's `HookReadyGuidanceV1`, when admission claimed one."},status:{const:"accepted",type:"string"}},required:["status","disposition","orchestration","github_stack_signal_available"],type:"object"},{description:"This exact envelope was already admitted; a retry may still receive\nguidance retained before a lost host response.",properties:{context_scout_address:{anyOf:[{$ref:"#/$defs/ContextScoutAddressV1"},{type:"null"}]},disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},ready_guidance:!0,status:{const:"exact_duplicate",type:"string"}},required:["status","disposition"],type:"object"},{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},reason:{anyOf:[{$ref:"#/$defs/HookV2RejectionReasonV1"},{type:"null"}]},status:{const:"rejected",type:"string"}},required:["status","disposition"],type:"object"},{description:"Idempotency could not be recorded, so nothing was admitted.",properties:{status:{const:"backpressured",type:"string"}},required:["status"],type:"object"},{properties:{status:{const:"unavailable",type:"string"}},required:["status"],type:"object"}],properties:{action:{const:"hook_v2_admit",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"hook_v2_delivery_receipt",type:"string"},status:{$ref:"#/$defs/ContextScoutStoreStatusV1"}},required:["action","status"],type:"object"},{oneOf:[{properties:{status:{const:"stored",type:"string"}},required:["status"],type:"object"},{properties:{status:{const:"unavailable",type:"string"}},required:["status"],type:"object"},{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},status:{const:"rejected",type:"string"}},required:["status","disposition"],type:"object"}],properties:{action:{const:"hook_v2_feedback_notice_delivery",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"ingest_transcript",type:"string"},admission:{$ref:"#/$defs/HookIngestAdmissionV1"},bytes_consumed:{format:"uint64",minimum:0,type:["integer","null"]},completed:{description:"False when the byte budget left work for a later pass.",type:"boolean"},cursor_advances:{format:"uint64",minimum:0,type:["integer","null"]},cursor_duplicates:{format:"uint64",minimum:0,type:["integer","null"]},deferred_by_byte_cap:{type:["boolean","null"]},deferred_sources:{format:"uint64",minimum:0,type:["integer","null"]},hint_outcomes:{description:"How emitted hook hints settled against the new project activity."},messages_upserted:{format:"uint64",minimum:0,type:"integer"},observation_duplicates:{format:"uint64",minimum:0,type:["integer","null"]},observations_committed:{format:"uint64",minimum:0,type:["integer","null"]},projection_duplicates:{format:"uint64",minimum:0,type:["integer","null"]},projections_completed:{format:"uint64",minimum:0,type:["integer","null"]},projections_skipped:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:"string"},records_quarantined:{format:"uint64",minimum:0,type:["integer","null"]},records_rejected:{format:"uint64",minimum:0,type:["integer","null"]},source_bytes_scanned:{format:"uint64",minimum:0,type:["integer","null"]},status:{type:"string"},user_scope:{type:"boolean"}},required:["action","provider","user_scope","completed","status","admission","messages_upserted"],type:"object"},{anyOf:[{description:"The LCM authority settled the compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},relation_projection_status:!0,retry_status:{type:["string","null"]},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],type:"object"},{description:"The LCM authority answered without a compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],type:"object"},{description:"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.",properties:{reason:{type:"string"},relation_projection_status:!0,status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids"],type:"object"},{description:"The host event named no session to compact.",properties:{messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"}},required:["status","reason","messages_upserted"],type:"object"}],description:"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.",properties:{action:{const:"codex_compact",type:"string"}},required:["action"],type:"object"},{anyOf:[{description:"The LCM authority settled the compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},relation_projection_status:!0,retry_status:{type:["string","null"]},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],type:"object"},{description:"The LCM authority answered without a compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],type:"object"},{description:"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.",properties:{reason:{type:"string"},relation_projection_status:!0,status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids"],type:"object"},{description:"The host event named no session to compact.",properties:{messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"}},required:["status","reason","messages_upserted"],type:"object"}],description:"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.",properties:{action:{const:"claude_compact",type:"string"}},required:["action"],type:"object"},{anyOf:[{description:"The LCM authority settled the compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},relation_projection_status:!0,retry_status:{type:["string","null"]},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids","relation_projection_status","authority_outcome","committed_state","messages_upserted"],type:"object"},{description:"The LCM authority answered without a compaction.",properties:{authority_outcome:!0,committed_state:!0,messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","authority_outcome","committed_state","summary_nodes_created","summary_node_ids","messages_upserted"],type:"object"},{description:"No compaction ran: the authority is absent, the host supplied nothing\nto compact, or its summaries have no provenance.",properties:{reason:{type:"string"},relation_projection_status:!0,status:{type:"string"},summary_node_ids:{items:{type:"string"},type:"array"},summary_nodes_created:{format:"uint64",minimum:0,type:"integer"}},required:["status","reason","summary_nodes_created","summary_node_ids"],type:"object"},{description:"The host event named no session to compact.",properties:{messages_upserted:{format:"uint64",minimum:0,type:"integer"},reason:{type:"string"},status:{type:"string"}},required:["status","reason","messages_upserted"],type:"object"}],description:"A compaction hook's outcome. Variants are distinguished by the fields\nthey carry.",properties:{action:{const:"cursor_compact",type:"string"}},required:["action"],type:"object"},{additionalProperties:!1,properties:{action:{const:"hermes_receipt",type:"string"},status:{$ref:"#/$defs/HermesReceiptStatusV1"}},required:["action","status"],type:"object"},{oneOf:[{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},status:{const:"accepted",type:"string"}},required:["status","disposition"],type:"object"},{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},status:{const:"exact_duplicate",type:"string"}},required:["status","disposition"],type:"object"},{properties:{disposition:{$ref:"#/$defs/HookRuntimeDispositionV1"},status:{const:"rejected",type:"string"}},required:["status","disposition"],type:"object"},{properties:{status:{const:"unavailable",type:"string"}},required:["status"],type:"object"}],properties:{action:{const:"hook_v2_profile_admit",type:"string"}},required:["action"],type:"object"}],title:"HookRuntimeResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of hotspots to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]}},title:"HotspotsSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,HotspotV1:{additionalProperties:!1,properties:{churn:{description:"Commits touching `file` in the last 90 days. Absent when git history\ncould not be read; `0` means the file had no commits in that window.",format:"uint64",minimum:0,type:["integer","null"]},file:{type:"string"},id:{type:"string"},incoming:{format:"uint64",minimum:0,type:"integer"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},outgoing:{format:"uint64",minimum:0,type:"integer"},total:{format:"uint64",minimum:0,type:"integer"}},required:["id","name","kind","file","line","incoming","outgoing","total"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},hotspot_count:{format:"uint64",minimum:0,type:"integer"},hotspots:{items:{$ref:"#/$defs/HotspotV1"},type:"array"},unavailable_fields:{description:"Names a measurement this result could not make. `churn` means the\nranking is connectivity alone.",items:{type:"string"},type:"array"}},required:["hotspot_count","hotspots"],title:"HotspotsResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{max_depth:{format:"uint32",minimum:0,type:["integer","null"]},node_id:{type:"string"}},required:["node_id"],title:"NodeDepthSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ImpactNodeV1:{additionalProperties:!1,properties:{depth:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line","depth"],type:"object"},ImpactRadiusV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},node_count:{format:"uint",minimum:0,type:"integer"},nodes:{items:{$ref:"#/$defs/ImpactNodeV1"},type:"array"},unavailable_fields:{items:{type:"string"},type:"array"}},required:["node_count","complete","unavailable_fields","nodes"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveNotFoundV1:_Z,PrimitiveSearchFreshnessV1:_X,PrimitiveSymbolLocationV1:_1},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/ImpactRadiusV1"},{$ref:"#/$defs/PrimitiveNotFoundV1"}],title:"ImpactResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"InheritanceDepthSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,InheritanceDepthEntryV1:{additionalProperties:!1,properties:{depth:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line","depth"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},ranking:{items:{$ref:"#/$defs/InheritanceDepthEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["result_count","ranking"],title:"InheritanceDepthResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_insert_at`.",properties:{anchor:{type:"string"},before:{default:!1,type:"boolean"},content:{type:"string"},dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},path:{type:"string"},verify:{default:!1,type:"boolean"}},required:["path","anchor","content"],title:"InsertAtSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_insert_at_symbol`.",properties:{content:{type:"string"},dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},position:{default:"after",type:"string"},symbol:{type:"string"},verify:{default:!1,type:"boolean"}},required:["symbol","content"],title:"InsertAtSymbolSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},node_kind:{description:"Filter by node kind (e.g. 'class', 'method', 'function', 'interface',\n'enum', 'struct').",type:["string","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"LargestSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,LargestEntryV1:{additionalProperties:!1,properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},lines:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["id","name","kind","file","start_line","end_line","lines"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},node_kind_filter:{type:["string","null"]},ranking:{items:{$ref:"#/$defs/LargestEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["result_count","ranking"],title:"LargestResultV1",type:"object"},{$defs:{LcmDescribeTargetV1:{oneOf:[{properties:{kind:{const:"session",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"summary_node",type:"string"},node_id:{type:"string"}},required:["kind","node_id"],type:"object"},{properties:{kind:{const:"external_payload",type:"string"},payload_ref:{type:"string"}},required:["kind","payload_ref"],type:"object"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{provider:{type:"string"},session_id:{type:"string"},target:{anyOf:[{$ref:"#/$defs/LcmDescribeTargetV1"},{type:"null"}]}},required:["provider","session_id"],title:"LcmDescribeRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,CompactLineageEdgeV1:{additionalProperties:!1,properties:{authority:{type:"string"},authorized:{type:"boolean"},kind:{type:"string"},knowledge_at:{format:"int64",type:"integer"},object_anchor_id:{type:"string"},subject_anchor_id:{type:"string"},supporting_anchor_ids:{items:{type:"string"},type:"array"}},required:["kind","subject_anchor_id","object_anchor_id","knowledge_at","authority","authorized","supporting_anchor_ids"],type:"object"},HydrationStateResultV1:gG,LcmContentRangeV1:gQ,LcmDescribeExternalPayloadV1:{additionalProperties:!1,properties:{byte_count:{format:"uint64",minimum:0,type:"integer"},char_count:{format:"uint64",minimum:0,type:"integer"},content_hash:{type:"string"},content_preview:{type:"string"},created_at:{format:"int64",type:"integer"},kind:{type:"string"},message_id:{type:"string"},metadata_json:{type:["string","null"]},payload_ref:{type:"string"},provider:{type:"string"},session_id:{type:"string"}},required:["payload_ref","provider","session_id","message_id","kind","content_hash","byte_count","char_count","created_at","content_preview"],type:"object"},LcmDescribeSourceOverviewV1:{additionalProperties:!1,properties:{expand_hint:{type:["string","null"]},node_id:{type:["string","null"]},role:{type:["string","null"]},source_kind:{type:"string"},source_ref:{$ref:"#/$defs/LcmSourceRefV1"},source_token_count:{format:"int64",type:["integer","null"]},storage_kind:{anyOf:[{$ref:"#/$defs/LcmStorageKindV1"},{type:"null"}]},store_id:{format:"int64",type:["integer","null"]},summary_token_count:{format:"int64",type:["integer","null"]}},required:["source_kind","source_ref"],type:"object"},LcmDescribeSummaryNodeV1:{additionalProperties:!1,properties:{children:{items:{$ref:"#/$defs/LcmDescribeSourceOverviewV1"},type:"array"},conversation_id:{type:"string"},created_at:{format:"int64",type:"integer"},depth:{format:"int64",type:"integer"},expand_hint:{type:["string","null"]},metadata_json:{type:["string","null"]},node_id:{type:"string"},source_count:{format:"uint",minimum:0,type:"integer"},source_time_end:{format:"int64",type:["integer","null"]},source_time_start:{format:"int64",type:["integer","null"]},source_token_count:{format:"int64",type:"integer"},summary_token_count:{format:"int64",type:"integer"}},required:["node_id","conversation_id","depth","summary_token_count","source_token_count","created_at","source_count","children"],type:"object"},LcmDescriptionV1:{additionalProperties:!1,properties:{external_payload:{anyOf:[{$ref:"#/$defs/LcmDescribeExternalPayloadV1"},{type:"null"}]},external_payload_count:{format:"int64",type:"integer"},first_store_id:{format:"int64",type:["integer","null"]},last_store_id:{format:"int64",type:["integer","null"]},provider:{type:"string"},raw_message_count:{format:"int64",type:"integer"},raw_messages:{items:{$ref:"#/$defs/LcmRawMessageOverviewV1"},type:"array"},session_id:{type:"string"},session_token_estimate:{format:"int64",type:["integer","null"]},summary_node:{anyOf:[{$ref:"#/$defs/LcmDescribeSummaryNodeV1"},{type:"null"}]},summary_node_count:{format:"int64",type:"integer"},summary_nodes:{items:{$ref:"#/$defs/LcmSummaryNodeOverviewV1"},type:"array"},target:{type:"string"},unpublished_message_count:{description:"Raw messages the session's active temporal generation has not\npublished; transcript reads cannot page them yet.",format:"int64",type:"integer"}},required:["target","provider","session_id","raw_message_count","unpublished_message_count","summary_node_count","external_payload_count","raw_messages","summary_nodes"],type:"object"},LcmRawMessageOverviewV1:{additionalProperties:!1,properties:{content_preview:{type:"string"},content_range:{$ref:"#/$defs/LcmContentRangeV1"},message_id:{type:"string"},payload_ref:{type:["string","null"]},role:{type:"string"},storage_kind:{$ref:"#/$defs/LcmStorageKindV1"},store_id:{format:"int64",type:"integer"}},required:["message_id","store_id","role","storage_kind","content_preview","content_range"],type:"object"},LcmRetrievalOutcomeV1:g4,LcmSourceRefV1:g6,LcmStorageKindV1:g3,LcmSummaryNodeOverviewV1:{additionalProperties:!1,properties:{conversation_id:{type:"string"},created_at:{format:"int64",type:"integer"},depth:{format:"int64",type:"integer"},node_id:{type:"string"},source_count:{format:"uint",minimum:0,type:"integer"},summary_preview:{type:"string"}},required:["node_id","conversation_id","depth","summary_preview","source_count","created_at"],type:"object"},LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalFreshnessV1:bA,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},description:{anyOf:[{$ref:"#/$defs/LcmDescriptionV1"},{type:"null"}]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},grain:{type:["string","null"]},lineage:{items:{$ref:"#/$defs/CompactLineageEdgeV1"},type:["array","null"]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},retrieval:{anyOf:[{$ref:"#/$defs/LcmRetrievalOutcomeV1"},{type:"null"}]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},session_id:{type:["string","null"]},state:{anyOf:[{$ref:"#/$defs/HydrationStateResultV1"},{type:"null"}]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status"],title:"LcmDescribeResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,title:"LcmDoctorRequestV1",type:"object"},{$defs:{LcmAuthorityOutcomeV1:gZ,LcmConvergenceStateV1:gX,LcmConvergenceV1:gY,LcmDoctorFindingKindV1:{enum:["trigger_audit_drift","occurrence_fts_corruption","summary_fts_corruption","missing_anchor","missing_receipt","invalid_generation","multi_active_generation","cursor_chain_absent","cursor_key_absent","ownership_drift","stuck_refresh","stuck_binding","stuck_progress","stuck_receipt","migration_gap","compatibility_drift","relation_graph_unavailable","relation_graph_corruption","relation_graph_cycle","stale_summary_closure"],type:"string"},LcmDoctorFindingV1:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},kind:{$ref:"#/$defs/LcmDoctorFindingKindV1"}},required:["kind","count"],type:"object"},LcmDoctorHealthStatusV1:{enum:["complete","partial","unavailable","locked"],type:"string"},LcmDoctorHealthV1:{additionalProperties:!1,properties:{findings:{items:{$ref:"#/$defs/LcmDoctorFindingV1"},type:"array"},reason:{type:["string","null"]},status:{$ref:"#/$defs/LcmDoctorHealthStatusV1"}},required:["status","findings"],type:"object"},LcmDoctorProjectionStateV1:g1,LcmDoctorProjectionV1:g0,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{authority_outcome:{$ref:"#/$defs/LcmAuthorityOutcomeV1"},health:{anyOf:[{$ref:"#/$defs/LcmDoctorHealthV1"},{type:"null"}]},projection:{anyOf:[{$ref:"#/$defs/LcmDoctorProjectionV1"},{type:"null"}],description:"Absent when the diagnosed store has no refresh worker (profile mounts)."},reason:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"}},required:["status","authority_outcome"],title:"LcmDoctorResultV1",type:"object"},{$defs:{LcmExpandTargetV1:{oneOf:[{properties:{kind:{const:"canonical_occurrence",type:"string"},message_id:{type:"string"}},required:["kind","message_id"],type:"object"},{properties:{kind:{const:"raw_message",type:"string"},store_id:{format:"uint64",minimum:0,type:"integer"}},required:["kind","store_id"],type:"object"},{properties:{kind:{const:"summary_node",type:"string"},node_id:{type:"string"}},required:["kind","node_id"],type:"object"},{properties:{kind:{const:"external_payload",type:"string"},payload_ref:{type:"string"}},required:["kind","payload_ref"],type:"object"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{content_limit:{format:"uint64",minimum:0,type:["integer","null"]},content_offset:{format:"uint64",minimum:0,type:["integer","null"]},cursor:{type:["string","null"]},provider:{type:"string"},session_id:{type:"string"},source_limit:{format:"uint64",minimum:0,type:["integer","null"]},target:{$ref:"#/$defs/LcmExpandTargetV1"}},required:["provider","session_id","target"],title:"LcmExpandRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,HydrationStateResultV1:gG,LcmContentRangeV1:gQ,LcmExpandedSourceV1:{additionalProperties:!1,properties:{content:{type:"string"},content_range:{anyOf:[{$ref:"#/$defs/LcmContentRangeV1"},{type:"null"}]},content_truncated:{type:"boolean"},raw_message:{anyOf:[{$ref:"#/$defs/LcmRawMessageV1"},{type:"null"}]},raw_message_metadata:{anyOf:[{$ref:"#/$defs/LcmRawMessageMetadataV1"},{type:"null"}]},source_ref:{$ref:"#/$defs/LcmSourceRefV1"},state:{$ref:"#/$defs/HydrationStateResultV1"},summary_node:{anyOf:[{$ref:"#/$defs/LcmSummaryNodeV1"},{type:"null"}]}},required:["source_ref","state","content","content_truncated"],type:"object"},LcmExpansionV1:{additionalProperties:!1,properties:{content:{type:"string"},content_range:{$ref:"#/$defs/LcmContentRangeV1"},from_current_session:{type:["boolean","null"]},kind:{type:"string"},payload_ref:{type:["string","null"]},raw_message:{anyOf:[{$ref:"#/$defs/LcmRawMessageV1"},{type:"null"}]},raw_message_metadata:{anyOf:[{$ref:"#/$defs/LcmRawMessageMetadataV1"},{type:"null"}]},source_pagination:{anyOf:[{$ref:"#/$defs/LcmSourcePaginationV1"},{type:"null"}]},summary_node:{anyOf:[{$ref:"#/$defs/LcmSummaryNodeV1"},{type:"null"}]},summary_sources:{items:{$ref:"#/$defs/LcmExpandedSourceV1"},type:"array"}},required:["kind","content","content_range","summary_sources"],type:"object"},LcmRawMessageMetadataV1:{additionalProperties:!1,properties:{content_hash:{type:"string"},message_id:{type:"string"},metadata_json:{type:["string","null"]},ordinal:{format:"int64",type:"integer"},payload_ref:{type:["string","null"]},provider:{type:"string"},role:{type:"string"},session_id:{type:"string"},storage_kind:{$ref:"#/$defs/LcmStorageKindV1"},store_id:{format:"int64",type:"integer"},timestamp:{format:"int64",type:["integer","null"]}},required:["provider","message_id","session_id","store_id","role","ordinal","content_hash","storage_kind"],type:"object"},LcmRawMessageV1:g2,LcmRetrievalOutcomeV1:g4,LcmSourcePaginationV1:{additionalProperties:!1,properties:{has_more:{type:"boolean"},remaining_sources:{format:"uint",minimum:0,type:"integer"},returned_sources:{format:"uint",minimum:0,type:"integer"},source_limit:{format:"uint",minimum:0,type:"integer"},total_sources:{format:"uint",minimum:0,type:"integer"}},required:["source_limit","returned_sources","total_sources","has_more","remaining_sources"],type:"object"},LcmSourceRefV1:g6,LcmStorageKindV1:g3,LcmSummaryNodeV1:g8,LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalFreshnessV1:bA,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},expansion:{anyOf:[{$ref:"#/$defs/LcmExpansionV1"},{type:"null"}]},grain:{type:["string","null"]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},retrieval:{anyOf:[{$ref:"#/$defs/LcmRetrievalOutcomeV1"},{type:"null"}]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},session_id:{type:["string","null"]},state:{anyOf:[{$ref:"#/$defs/HydrationStateResultV1"},{type:"null"}]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status"],title:"LcmExpandResultV1",type:"object"},{$defs:{LcmNodeIdV1:{anyOf:[{type:"string"},{format:"uint64",minimum:0,type:"integer"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{context_max_tokens:{format:"uint64",minimum:0,type:["integer","null"]},cursor:{type:["string","null"]},max_results:{format:"uint64",minimum:0,type:["integer","null"]},max_tokens:{format:"uint64",minimum:0,type:["integer","null"]},node_ids:{items:{$ref:"#/$defs/LcmNodeIdV1"},type:["array","null"]},prompt:{type:"string"},provider:{type:"string"},query:{type:["string","null"]},session_id:{type:"string"}},required:["provider","session_id","prompt"],title:"LcmExpandQueryRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,HydrationStateResultV1:gG,LcmContentRangeV1:gQ,LcmExpandQueryBudgetV1:{additionalProperties:!1,properties:{requested_max_chars:{format:"uint",minimum:0,type:"integer"},used_chars:{format:"uint",minimum:0,type:"integer"}},required:["requested_max_chars","used_chars"],type:"object"},LcmExpandQueryContextBlockV1:{additionalProperties:!1,properties:{content:{type:"string"},content_range:{$ref:"#/$defs/LcmContentRangeV1"},kind:{type:"string"},node_id:{type:["string","null"]},raw_message:{anyOf:[{$ref:"#/$defs/LcmRawMessageV1"},{type:"null"}]},source_ref:{anyOf:[{$ref:"#/$defs/LcmSourceRefV1"},{type:"null"}]},summary_node:{anyOf:[{$ref:"#/$defs/LcmSummaryNodeV1"},{type:"null"}]}},required:["kind","content","content_range"],type:"object"},LcmExpandQueryMatchV1:{additionalProperties:!1,properties:{kind:{type:"string"},node_id:{type:["string","null"]},snippet:{type:"string"},store_id:{format:"int64",type:["integer","null"]}},required:["kind","snippet"],type:"object"},LcmExpandQueryPaginationV1:{additionalProperties:!1,properties:{has_more:{type:"boolean"},kind:{type:"string"},next_content_offset:{format:"uint64",minimum:0,type:["integer","null"]},node_id:{type:["string","null"]},source_ref:{anyOf:[{$ref:"#/$defs/LcmSourceRefV1"},{type:"null"}]},state:{anyOf:[{$ref:"#/$defs/HydrationStateResultV1"},{type:"null"}]}},required:["kind","has_more"],type:"object"},LcmExpandQuerySynthesisPromptV1:{additionalProperties:!1,properties:{system:{type:"string"},user:{type:"string"},user_prompt_truncated_for_mcp:{type:["boolean","null"]}},required:["system","user"],type:"object"},LcmRawMessageV1:g2,LcmSourceRefV1:g6,LcmStorageKindV1:g3,LcmSummaryNodeV1:g8,LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{answer:{type:["string","null"]},capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},context_blocks:{items:{$ref:"#/$defs/LcmExpandQueryContextBlockV1"},type:"array"},context_budget:{anyOf:[{$ref:"#/$defs/LcmExpandQueryBudgetV1"},{type:"null"}]},context_max_tokens:{format:"uint",minimum:0,type:["integer","null"]},context_pagination:{items:{$ref:"#/$defs/LcmExpandQueryPaginationV1"},type:["array","null"]},context_truncated:{type:["boolean","null"]},contract_truncated:{type:["boolean","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},matches:{items:{$ref:"#/$defs/LcmExpandQueryMatchV1"},type:["array","null"]},max_tokens:{format:"uint",minimum:0,type:["integer","null"]},mcp_response_truncated:{type:["boolean","null"]},mcp_truncation_reason:{type:["string","null"]},needs_synthesis:{type:["boolean","null"]},node_ids:{items:{type:"string"},type:["array","null"]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},prompt:{type:["string","null"]},prompt_truncated_for_mcp:{type:["boolean","null"]},provider:{type:["string","null"]},query:{type:["string","null"]},query_truncated_for_mcp:{type:["boolean","null"]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},session_id:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},synthesis_prompt:{anyOf:[{$ref:"#/$defs/LcmExpandQuerySynthesisPromptV1"},{type:"null"}]},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status","context_blocks"],title:"LcmExpandQueryResultV1",type:"object"},{$defs:{LcmGrepSortV1:{enum:["recency","relevance","hybrid"],type:"string"},LcmRoleV1:{enum:["system","user","assistant","tool","unknown"],type:"string"},LcmSearchScopeV1:{enum:["current","session","all"],type:"string"},MessageRelationshipScopeV1:_m,MessageTypeFilterV1:_f,RetainedTimeFilterV1:vq,TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{branch:{type:["string","null"]},commit:{type:["string","null"]},cursor:{type:["string","null"]},end_time:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},include_summaries:{type:["boolean","null"]},limit:{format:"uint64",minimum:0,type:["integer","null"]},message_type:{anyOf:[{$ref:"#/$defs/MessageTypeFilterV1"},{type:"null"}]},provider:{type:["string","null"]},query:{type:"string"},relationship_scope:{anyOf:[{$ref:"#/$defs/MessageRelationshipScopeV1"},{type:"null"}]},role:{anyOf:[{$ref:"#/$defs/LcmRoleV1"},{type:"null"}]},scope:{anyOf:[{$ref:"#/$defs/LcmSearchScopeV1"},{type:"null"}]},session_id:{type:["string","null"]},sort:{anyOf:[{$ref:"#/$defs/LcmGrepSortV1"},{type:"null"}]},source:{type:["string","null"]},start_time:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},temporal_mode:{anyOf:[{$ref:"#/$defs/TemporalModeV1"},{type:"null"}]},worktree:{type:["string","null"]}},required:["query"],title:"LcmGrepRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,HydrationStateResultV1:gG,LcmGrepHitV1:{additionalProperties:!1,properties:{kind:{type:"string"},message_id:{type:["string","null"]},node_id:{type:["string","null"]},provider:{type:"string"},role:{type:["string","null"]},score:{format:"double",type:"number"},session_id:{type:"string"},snippet:{type:"string"},store_id:{format:"int64",type:["integer","null"]}},required:["kind","provider","session_id","snippet","score"],type:"object"},LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},count:{format:"uint",minimum:0,type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},hits:{items:{$ref:"#/$defs/LcmGrepHitV1"},type:"array"},message_type:{type:["string","null"]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},query:{type:["string","null"]},relationship_scope:{type:["string","null"]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},sort:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status","hits"],title:"LcmGrepResultV1",type:"object"},{$defs:{TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{content_limit:{format:"uint64",minimum:0,type:["integer","null"]},content_offset:{format:"uint64",minimum:0,type:["integer","null"]},cursor:{type:["string","null"]},end_time:{format:"uint64",minimum:0,type:["integer","null"]},limit:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},role:{type:["string","null"]},roles:{items:{type:"string"},type:["array","null"]},session_id:{type:"string"},start_time:{format:"uint64",minimum:0,type:["integer","null"]},temporal_mode:{anyOf:[{$ref:"#/$defs/TemporalModeV1"},{type:"null"}]}},required:["session_id"],title:"LcmLoadSessionRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,HydrationStateResultV1:gG,LcmContentRangeV1:gQ,LcmMessageV1:{additionalProperties:!1,properties:{content:{type:"string"},content_hash:{type:["string","null"]},content_range:{$ref:"#/$defs/LcmContentRangeV1"},message_id:{type:"string"},metadata_json:{type:["string","null"]},ordinal:{format:"int64",type:"integer"},payload_ref:{type:["string","null"]},provider:{type:"string"},role:{type:"string"},session_id:{type:"string"},storage_kind:{$ref:"#/$defs/LcmStorageKindV1"},store_id:{format:"int64",type:["integer","null"]},timestamp:{format:"int64",type:["integer","null"]}},required:["provider","message_id","session_id","role","ordinal","content","content_range","storage_kind"],type:"object"},LcmStorageKindV1:g3,LcmTemporalFieldsV1:g7,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{capped_sessions:{additionalProperties:{format:"uint",minimum:0,type:"integer"},type:["object","null"]},content_limit:{format:"uint",minimum:0,type:["integer","null"]},content_limit_clamped_from:{format:"uint",minimum:0,type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},messages:{items:{$ref:"#/$defs/LcmMessageV1"},type:"array"},omitted:{format:"uint64",minimum:0,type:["integer","null"]},provider:{type:["string","null"]},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},session_id:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},temporal:{anyOf:[{$ref:"#/$defs/LcmTemporalFieldsV1"},{type:"null"}]}},required:["status","messages"],title:"LcmLoadSessionResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{deep:{type:["boolean","null"]},provider:{type:["string","null"]},session_id:{type:["string","null"]}},title:"LcmStatusRequestV1",type:"object"},{$defs:{LcmAuthorityOutcomeV1:gZ,LcmConfigStatusV1:{additionalProperties:!1,properties:{compression_boundary_cooldown_seconds:{format:"int64",type:"integer"},fresh_tail_count:{format:"uint",minimum:0,type:"integer"},summary_fan_in:{format:"uint",minimum:0,type:"integer"}},required:["fresh_tail_count","summary_fan_in","compression_boundary_cooldown_seconds"],type:"object"},LcmConvergenceStateV1:gX,LcmConvergenceV1:gY,LcmDagDepthStatusV1:{additionalProperties:!1,properties:{count:{format:"int64",type:"integer"},source_tokens:{format:"int64",type:"integer"},tokens:{format:"int64",type:"integer"}},required:["count","tokens","source_tokens"],type:"object"},LcmDagStatusV1:{additionalProperties:!1,properties:{compression_ratio:{type:"string"},depths:{additionalProperties:{$ref:"#/$defs/LcmDagDepthStatusV1"},type:"object"},total_nodes:{format:"int64",type:"integer"},total_source_tokens:{format:"int64",type:"integer"},total_tokens:{format:"int64",type:"integer"}},required:["total_nodes","total_tokens","total_source_tokens","compression_ratio","depths"],type:"object"},LcmDoctorProjectionStateV1:g1,LcmDoctorProjectionV1:g0,LcmLifecycleStatusV1:{additionalProperties:!1,properties:{current_frontier_store_id:{format:"int64",type:["integer","null"]},current_session_id:{type:["string","null"]},frontier_count:{format:"int64",type:"integer"},last_finalized_frontier_store_id:{format:"int64",type:["integer","null"]},last_finalized_session_id:{type:["string","null"]},lifecycle_state_count:{format:"int64",type:"integer"},maintenance_debt_count:{format:"int64",type:"integer"}},required:["lifecycle_state_count","frontier_count","maintenance_debt_count"],type:"object"},LcmPayloadCoverageStateV1:{enum:["complete","partial"],type:"string"},LcmPayloadCoverageV1:{additionalProperties:!1,properties:{reason:{type:["string","null"]},scanned_files:{format:"int64",type:"integer"},scanned_metadata_refs:{format:"int64",type:"integer"},state:{$ref:"#/$defs/LcmPayloadCoverageStateV1"}},required:["state","scanned_metadata_refs","scanned_files"],type:"object"},LcmPayloadGcStatusV1:{additionalProperties:!1,properties:{grace_seconds:{format:"int64",type:"integer"},last_gc_at:{format:"int64",type:["integer","null"]},last_gc_duration_ms:{format:"uint64",minimum:0,type:["integer","null"]},last_gc_error:{type:["string","null"]},last_gc_status:{type:["string","null"]},last_reaped_bytes:{format:"uint64",minimum:0,type:["integer","null"]},last_reaped_refs:{format:"int64",type:["integer","null"]},next_run_eligible_at:{format:"int64",type:["integer","null"]},reap_missing_metadata_after_seconds:{format:"int64",type:"integer"}},required:["grace_seconds","reap_missing_metadata_after_seconds"],type:"object"},LcmPayloadStatusV1:{additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/LcmPayloadCoverageV1"},externalized_count:{format:"int64",type:"integer"},gc_candidate_count:{format:"int64",type:"integer"},integrity_mismatch_count:{format:"int64",type:["integer","null"]},missing_count:{format:"int64",type:"integer"},missing_placeholder_file_count:{format:"int64",type:"integer"},missing_placeholder_metadata_count:{format:"int64",type:"integer"},orphan_file_bytes:{format:"uint64",minimum:0,type:"integer"},orphan_file_count:{format:"int64",type:"integer"},placeholder_ref_count:{format:"int64",type:"integer"},reclaimable_bytes:{format:"uint64",minimum:0,type:"integer"},reclaimable_bytes_after_grace:{format:"uint64",minimum:0,type:"integer"},referenced_bytes:{format:"uint64",minimum:0,type:"integer"},referenced_count:{format:"int64",type:"integer"},root_contained:{type:"boolean"},tombstoned_count:{format:"int64",type:"integer"},total_bytes:{format:"uint64",minimum:0,type:"integer"},unreferenced_count:{format:"int64",type:"integer"}},required:["coverage","externalized_count","missing_count","unreferenced_count","placeholder_ref_count","missing_placeholder_metadata_count","missing_placeholder_file_count","gc_candidate_count","root_contained","orphan_file_count","tombstoned_count","referenced_count","total_bytes","referenced_bytes","orphan_file_bytes","reclaimable_bytes","reclaimable_bytes_after_grace"],type:"object"},LcmRedactionStatusV1:{additionalProperties:!1,properties:{enabled:{type:"boolean"},lossy_records:{format:"int64",type:"integer"}},required:["enabled","lossy_records"],type:"object"},LcmStatusV1:{additionalProperties:!1,properties:{config:{$ref:"#/$defs/LcmConfigStatusV1"},dag:{$ref:"#/$defs/LcmDagStatusV1"},external_payload_count:{format:"int64",type:"integer"},lifecycle:{$ref:"#/$defs/LcmLifecycleStatusV1"},maintenance_debt_count:{format:"int64",type:"integer"},missing_payload_count:{format:"int64",type:"integer"},payload:{$ref:"#/$defs/LcmPayloadStatusV1"},payload_gc:{$ref:"#/$defs/LcmPayloadGcStatusV1"},raw_message_count:{format:"int64",type:"integer"},redaction:{$ref:"#/$defs/LcmRedactionStatusV1"},schema_version:{format:"int64",type:"integer"},store:{$ref:"#/$defs/LcmStoreStatusV1"},summary_convergence:{$ref:"#/$defs/LcmSummaryConvergenceStatusV1"},summary_node_count:{format:"int64",type:"integer"},unreferenced_payload_count:{format:"int64",type:"integer"}},required:["schema_version","raw_message_count","summary_node_count","external_payload_count","missing_payload_count","unreferenced_payload_count","maintenance_debt_count","store","dag","config","payload","payload_gc","lifecycle","summary_convergence","redaction"],type:"object"},LcmStoreStatusV1:{additionalProperties:!1,properties:{estimated_tokens:{format:"int64",type:"integer"},messages:{format:"int64",type:"integer"},token_estimate:{$ref:"#/$defs/LcmStoreTokenCoverageV1"}},required:["messages","estimated_tokens","token_estimate"],type:"object"},LcmStoreTokenCoverageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},next_after_store_id:{format:"int64",type:["integer","null"]},scanned_messages:{format:"int64",type:"integer"}},required:["complete","scanned_messages"],type:"object"},LcmSummaryConvergenceReasonV1:{additionalProperties:!1,properties:{reason:{type:"string"},session_count:{format:"int64",type:"integer"},state:{$ref:"#/$defs/LcmSummaryConvergenceStateV1"}},required:["state","reason","session_count"],type:"object"},LcmSummaryConvergenceStateV1:{enum:["pending","retryable","current","unavailable","permanent"],type:"string"},LcmSummaryConvergenceStatusV1:{additionalProperties:!1,description:"Retained-session summary convergence queue: disjoint per-state session\ncounts and the reasons parked or failed sessions record.",properties:{current_session_count:{format:"int64",type:"integer"},pending_session_count:{format:"int64",type:"integer"},permanent_session_count:{format:"int64",type:"integer"},reasons:{items:{$ref:"#/$defs/LcmSummaryConvergenceReasonV1"},type:"array"},retryable_session_count:{format:"int64",type:"integer"},unavailable_session_count:{format:"int64",type:"integer"}},required:["pending_session_count","retryable_session_count","current_session_count","unavailable_session_count","permanent_session_count","reasons"],type:"object"},RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{authority_outcome:{anyOf:[{$ref:"#/$defs/LcmAuthorityOutcomeV1"},{type:"null"}]},deep:{type:["boolean","null"]},lcm:{anyOf:[{$ref:"#/$defs/LcmStatusV1"},{type:"null"}]},message:{type:["string","null"]},projection:{anyOf:[{$ref:"#/$defs/LcmDoctorProjectionV1"},{type:"null"}],description:"The store's refresh-worker serving and convergence state. Absent when\nno refresh worker serves the store."},provider:{type:["string","null"]},reason:{type:["string","null"]},session_id:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"}},required:["status"],title:"LcmStatusResultV1",type:"object"},{$defs:{MemoryScopeV1:_u,ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{memory_scope:{anyOf:[{$ref:"#/$defs/MemoryScopeV1"},{type:"null"}]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]}},title:"MemoryStatusRequestV1",type:"object"},{$defs:{FactCommitOwnerV1:yM,MemoryAlgebraV1:{additionalProperties:!1,properties:{estimated_capacity:{description:"Heuristic D / ln(D) count of bound items one vector can superpose\nbefore cosine similarity degrades. Each fact has its own vector, so\nthis is neither a limit on stored facts nor a recall guarantee.",format:"uint64",minimum:0,type:"integer"},hrr_dim:{description:"Width of each encoded vector.",format:"uint64",minimum:0,type:"integer"},name:{description:"Vector algebra the fact encodings use. Current daemons report `map_c`;\nearlier releases reported `amari_fhrr` for the same encoding.",type:"string"}},required:["name","hrr_dim","estimated_capacity"],type:"object"},MemoryFeedbackFunnelV1:{additionalProperties:!1,properties:{access_count_total:{format:"uint64",minimum:0,type:"integer"},feedback_total:{format:"uint64",minimum:0,type:"integer"},rated_fact_count:{format:"uint64",minimum:0,type:"integer"},retrieval_count_total:{format:"uint64",minimum:0,type:"integer"},retrieved_fact_count:{format:"uint64",minimum:0,type:"integer"},seen_to_feedback_ratio:{format:"uint64",minimum:0,type:["integer","null"]}},required:["retrieval_count_total","access_count_total","retrieved_fact_count","rated_fact_count","feedback_total"],type:"object"},MemoryStatusV1:{additionalProperties:!1,properties:{algebra:{$ref:"#/$defs/MemoryAlgebraV1"},below_default_recall_threshold_count:{format:"uint64",minimum:0,type:"integer"},entity_count:{format:"uint64",minimum:0,type:"integer"},fact_count:{format:"uint64",minimum:0,type:"integer"},feedback_funnel:{$ref:"#/$defs/MemoryFeedbackFunnelV1"},helpful_count:{format:"uint64",minimum:0,type:"integer"},owner:{$ref:"#/$defs/FactCommitOwnerV1"},trust_025_050_count:{format:"uint64",minimum:0,type:"integer"},trust_050_075_count:{format:"uint64",minimum:0,type:"integer"},trust_075_100_count:{format:"uint64",minimum:0,type:"integer"},trust_0_025_count:{format:"uint64",minimum:0,type:"integer"},unhelpful_count:{format:"uint64",minimum:0,type:"integer"}},required:["owner","fact_count","entity_count","algebra","trust_0_025_count","trust_025_050_count","trust_050_075_count","trust_075_100_count","below_default_recall_threshold_count","helpful_count","unhelpful_count","feedback_funnel"],type:"object"},ProjectId:_4},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{memory:{$ref:"#/$defs/MemoryStatusV1"}},required:["memory"],title:"MemoryStatusResultV1",type:"object"},{$defs:{MessageRelationshipScopeV1:_m,MessageTypeFilterV1:_f,ProjectId:_4,RetainedTimeFilterV1:vq},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_message_search`.",properties:{branch:{type:["string","null"]},commit:{type:["string","null"]},cursor:{type:["string","null"]},goals:{default:!1,type:"boolean"},include_subagents:{type:["boolean","null"]},limit:{format:"uint64",minimum:0,type:["integer","null"]},message_type:{anyOf:[{$ref:"#/$defs/MessageTypeFilterV1"},{type:"null"}]},parent_session_id:{type:["string","null"]},project_key:{type:["string","null"]},project_selector:{additionalProperties:!1,description:'Exact registered-project selector. Reads and fact effects run against the\nselected project.\n\nInlined so every request schema advertises the closed selector contract\n(`required: ["project_id"]`, no additional properties) directly on its\n`project_selector` property instead of behind a `$defs` reference, matching\nthe selector shape the MCP dispatch policy promises for selector-accepting\ntools.',properties:{project_id:{$ref:"#/$defs/ProjectId"}},required:["project_id"],type:["object","null"]},provider:{type:["string","null"]},query:{type:["string","null"]},require_fresh:{description:"Freshness precondition: stale or partial coverage returns\n`refresh_required` instead of stored evidence. The read never refreshes.",type:["boolean","null"]},scope:{anyOf:[{$ref:"#/$defs/MessageRelationshipScopeV1"},{type:"null"}]},since:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},until:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},workflow_agent:{type:["string","null"]},workflow_run:{type:["string","null"]},worktree:{type:["string","null"]}},title:"MessageSearchRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,GitScopeV1:gE,HydrationStateResultV1:gG,MessageSearchHitV1:{additionalProperties:!1,properties:{message:{$ref:"#/$defs/SessionMessageV1"},project_id:{type:["string","null"]},root:{type:["string","null"]},score:{format:"double",type:"number"},session:{$ref:"#/$defs/SessionRecordV1"}},required:["session","message","score"],type:"object"},RetainedErrorV1:vV,RetainedNextActionV1:{additionalProperties:!1,properties:{action:{type:"string"},kind:{type:"string"},reason:{type:"string"},tool:{type:"string"}},required:["kind","tool","action","reason"],type:"object"},RetainedOutcomeStatusV1:vR,RetrievalWorkerStatusV1:vT,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionMessageV1:{additionalProperties:!1,properties:{kind:{type:["string","null"]},message_id:{type:"string"},metadata_json:{type:["string","null"]},model:{type:["string","null"]},ordinal:{format:"int64",type:"integer"},provider:{type:"string"},role:{type:"string"},session_id:{type:"string"},source_offset:{format:"int64",type:["integer","null"]},source_path:{type:["string","null"]},text:{type:"string"},timestamp:{format:"int64",type:["integer","null"]},tool_names:{type:["string","null"]}},required:["provider","message_id","session_id","role","ordinal","text"],type:"object"},SessionRecordV1:{additionalProperties:!1,properties:{agent_id:{type:["string","null"]},ended_at:{format:"int64",type:["integer","null"]},is_subagent:{type:"boolean"},metadata_json:{type:["string","null"]},parent_session_id:{type:["string","null"]},parent_tool_use_id:{type:["string","null"]},project_key:{type:"string"},project_path:{type:"string"},provider:{type:"string"},session_id:{type:"string"},started_at:{format:"int64",type:["integer","null"]},title:{type:["string","null"]},transcript_path:{type:["string","null"]}},required:["provider","session_id","project_key","project_path","is_subagent"],type:"object"},SessionSourceCoverageV1:bn,TemporalCoverageOmissionV1:{oneOf:[{properties:{detail:{type:"string"},kind:{const:"root_continuation_unavailable",type:"string"},strict_population:{$ref:"#/$defs/TemporalPopulationCountV1"}},required:["kind","strict_population","detail"],type:"object"}]},TemporalCoverageV1:bO,TemporalExplanationV1:bE,TemporalFreshnessV1:bA,TemporalMetadataV1:{additionalProperties:!1,properties:{anchors:{items:{type:"string"},type:"array"},coverage:{$ref:"#/$defs/TemporalCoverageV1"},coverage_omissions:{items:{$ref:"#/$defs/TemporalCoverageOmissionV1"},type:"array"},explanations:{items:{$ref:"#/$defs/TemporalExplanationV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/TemporalFreshnessV1"},{type:"null"}]},next_cursor:{type:["string","null"]},omissions:{items:{$ref:"#/$defs/TemporalOmissionV1"},type:"array"},source_coverage:{items:{$ref:"#/$defs/SessionSourceCoverageV1"},type:"array"},watermarks:{$ref:"#/$defs/TemporalWatermarksV1"}},required:["anchors","watermarks","coverage","explanations"],type:"object"},TemporalModeV1:bW,TemporalOmissionV1:bM,TemporalPopulationCountV1:{oneOf:[{properties:{count:{format:"uint64",minimum:0,type:"integer"},kind:{const:"exact",type:"string"}},required:["kind","count"],type:"object"},{properties:{count:{format:"uint64",minimum:0,type:"integer"},kind:{const:"at_least",type:"string"}},required:["kind","count"],type:"object"}]},TemporalWatermarksV1:bN,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},git_filter:{anyOf:[{$ref:"#/$defs/GitScopeV1"},{type:"null"}]},git_filter_applied:{type:["boolean","null"]},goals:{type:"boolean"},include_subagents:{type:"boolean"},message:{type:["string","null"]},message_type:{type:"string"},next_action:{anyOf:[{$ref:"#/$defs/RetainedNextActionV1"},{type:"null"}]},omitted:{format:"uint64",minimum:0,type:["integer","null"]},outcome:{$ref:"#/$defs/RetainedOutcomeStatusV1"},parent_session_id:{type:["string","null"]},project_key:{type:["string","null"]},provider:{type:"string"},query:{type:["string","null"]},refresh_required:{type:"boolean"},requested_provider:{type:["string","null"]},require_fresh:{type:"boolean"},results:{items:{$ref:"#/$defs/MessageSearchHitV1"},type:["array","null"]},scope:{type:"string"},service_status:{anyOf:[{$ref:"#/$defs/RetrievalWorkerStatusV1"},{type:"null"}]},since:{format:"int64",type:["integer","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},store_scope:{type:["string","null"]},temporal:{anyOf:[{$ref:"#/$defs/TemporalMetadataV1"},{type:"null"}]},until:{format:"int64",type:["integer","null"]},workflow_agent:{type:["string","null"]},workflow_filter_applied:{type:["boolean","null"]},workflow_run:{type:["string","null"]},workflow_run_parent_session:{type:["string","null"]}},required:["require_fresh","goals","include_subagents","message_type","outcome","provider","refresh_required","scope","status"],title:"MessageSearchResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{path:{type:"string"}},required:["path"],title:"ModuleApiPrimitiveRequest",type:"object"},{$defs:{SymbolPrimitiveRecord:bI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{path:{type:"string"},symbols:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"}},required:["path","symbols"],title:"ModuleApiPrimitiveResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_move_symbol`.",properties:{dest_file:{type:"string"},dry_run:{default:!0,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},symbol:{type:"string"}},required:["symbol","dest_file"],title:"MoveSymbolSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_multi_str_replace`.",properties:{dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},path:{type:"string"},replacements:{description:"Ordered `[old, new]` pairs, matching the existing MCP tool wire form.",items:{maxItems:2,minItems:2,prefixItems:[{type:"string"},{type:"string"}],type:"array"},type:"array"},verify:{default:!1,type:"boolean"}},required:["path","replacements"],title:"MultiStrReplaceSurfaceRequestV1",type:"object"},{$defs:{NativeIntegrationTransactionId:_T},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{transaction_id:{$ref:"#/$defs/NativeIntegrationTransactionId"}},required:["transaction_id"],title:"NativeIntegrationStatusSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{node_id:{type:"string"}},required:["node_id"],title:"NodeSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComplexityAnalysisV1:hx,NodeDetailsV1:{additionalProperties:!1,properties:{branches:{description:"Exact counters; `None`, and listed in `unavailable_fields`, when\n`complexity_analysis` reports the bounded walk did not cover the body.",format:"uint32",minimum:0,type:["integer","null"]},complexity_analysis:{$ref:"#/$defs/ComplexityAnalysisV1"},cost_to_expand:{$ref:"#/$defs/NodeExpansionCostV1"},cyclomatic_complexity:{format:"uint32",minimum:0,type:["integer","null"]},derives:{items:{type:"string"},type:"array"},docstring:{type:["string","null"]},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},id:{type:"string"},is_async:{type:"boolean"},kind:{type:"string"},loops:{format:"uint32",minimum:0,type:["integer","null"]},max_nesting:{format:"uint32",minimum:0,type:["integer","null"]},name:{type:"string"},qualified_name:{type:"string"},signature:{type:["string","null"]},start_line:{format:"uint32",minimum:0,type:"integer"},unavailable_fields:{items:{type:"string"},type:"array"},visibility:{type:"string"}},required:["id","name","kind","qualified_name","file","start_line","end_line","is_async","derives","visibility","complexity_analysis","cost_to_expand","unavailable_fields"],type:"object"},NodeExpansionCostV1:_A,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveNotFoundV1:_Z,PrimitiveSearchFreshnessV1:_X,PrimitiveSymbolLocationV1:_1},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/NodeDetailsV1"},{$ref:"#/$defs/PrimitiveNotFoundV1"}],title:"NodeResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One project-scoped horizon for the canonical Observatory and Costs models.",properties:{window_days:{default:14,format:"uint16",maximum:365,minimum:1,type:"integer"}},title:"ObservatoryReadRequestV1",type:"object"},{$defs:{AnalyticsModeReadModelV1:fk,AnalyticsModeV1:fw,ComparisonDispositionV1:hI,CostsReadModelV1:yl,CoverageStateV1:yf,LatencyDistributionReadModelV1:gJ,MetricCalibrationV1:_h,MetricCohortV1:_y,MetricCoverageV1:_g,MetricEvidenceClassV1:__,MetricProvenanceV1:_v,MetricSourceV1:_b,MetricTemporalV1:_$,MetricUncertaintyV1:_S,MetricValueV1:_k,ObservabilityHorizonV1:_W,ObservatoryReadModelV1:_N,PerformanceComparisonReadModelV1:_H,ProviderLatencyReadModelV1:vn,RejectedArgumentAnalyticsV1:vh,RejectedArgumentErrorClassV1:vy,RejectedArgumentGroupV1:vg,RejectedArgumentNameV1:v_,RejectedArgumentSurfaceV1:vv},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Canonical project-scoped observability and costs read models.",properties:{costs:{$ref:"#/$defs/CostsReadModelV1"},observatory:{$ref:"#/$defs/ObservatoryReadModelV1"}},required:["observatory","costs"],title:"ObservatoryReadResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kinds:{items:{type:"string"},type:["array","null"]},limit:{format:"uint32",minimum:0,type:["integer","null"]},source_dir:{type:"string"}},required:["source_dir"],title:"PortOrderSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PortCycleAnchorV1:{additionalProperties:!1,properties:{file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},rationale:{type:["string","null"]}},required:["name","file","line"],type:"object"},PortCycleFileV1:{additionalProperties:!1,properties:{file:{type:"string"},members_in_cycle:{format:"uint",minimum:0,type:"integer"}},required:["file","members_in_cycle"],type:"object"},PortCycleSymbolV1:{additionalProperties:!1,properties:{file:{type:"string"},in_cycle_in_degree:{format:"uint",minimum:0,type:"integer"},in_cycle_out_degree:{format:"uint",minimum:0,type:"integer"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","file","line","in_cycle_out_degree","in_cycle_in_degree"],type:"object"},PortCycleV1:{additionalProperties:!1,properties:{break_point_candidate:{anyOf:[{$ref:"#/$defs/PortCycleAnchorV1"},{type:"null"}]},entry_point:{anyOf:[{$ref:"#/$defs/PortCycleAnchorV1"},{type:"null"}]},files:{items:{$ref:"#/$defs/PortCycleFileV1"},type:"array"},note:{type:"string"},size:{format:"uint",minimum:0,type:"integer"},symbols:{items:{$ref:"#/$defs/PortCycleSymbolV1"},type:"array"}},required:["size","files","symbols","note"],type:"object"},PortOrderLevelV1:{additionalProperties:!1,properties:{description:{type:"string"},level:{format:"uint",minimum:0,type:"integer"},symbols:{items:{$ref:"#/$defs/PortOrderSymbolV1"},type:"array"}},required:["level","description","symbols"],type:"object"},PortOrderSymbolV1:{additionalProperties:!1,properties:{depends_on:{items:{type:"string"},type:["array","null"]},file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","file","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cycles:{items:{$ref:"#/$defs/PortCycleV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},levels:{items:{$ref:"#/$defs/PortOrderLevelV1"},type:"array"},returned:{format:"uint",minimum:0,type:"integer"},source_dir:{type:"string"},total_symbols:{format:"uint",minimum:0,type:"integer"}},required:["source_dir","total_symbols","returned","levels","cycles"],title:"PortOrderResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kinds:{items:{type:"string"},type:["array","null"]},source_dir:{type:"string"},target_dir:{type:"string"}},required:["source_dir","target_dir"],title:"PortStatusSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PortMatchedSymbolV1:{additionalProperties:!1,properties:{name:{type:"string"},source_file:{type:"string"},source_kind:{type:"string"},target_file:{type:"string"},target_kind:{type:"string"}},required:["name","source_kind","target_kind","source_file","target_file"],type:"object"},PortTargetOnlySymbolV1:{additionalProperties:!1,properties:{file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","file","line"],type:"object"},PortUnmatchedSymbolV1:{additionalProperties:!1,properties:{kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["name","kind","line"],type:"object"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage_percent:{format:"double",type:"number"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},matched:{format:"uint",minimum:0,type:"integer"},matched_symbols:{items:{$ref:"#/$defs/PortMatchedSymbolV1"},type:"array"},source_count:{format:"uint",minimum:0,type:"integer"},source_dir:{type:"string"},target_count:{format:"uint",minimum:0,type:"integer"},target_dir:{type:"string"},target_only:{format:"uint",minimum:0,type:"integer"},target_only_symbols:{items:{$ref:"#/$defs/PortTargetOnlySymbolV1"},type:"array"},unmatched:{format:"uint",minimum:0,type:"integer"},unmatched_by_file:{additionalProperties:{items:{$ref:"#/$defs/PortUnmatchedSymbolV1"},type:"array"},type:"object"}},required:["source_dir","target_dir","source_count","target_count","matched","unmatched","target_only","coverage_percent","unmatched_by_file","matched_symbols","target_only_symbols"],title:"PortStatusResultV1",type:"object"},{$defs:{PrContextViewV1:_G},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{base_ref:{description:"Base branch or ref (default: the matching retained PR base, otherwise\nthe detected repository default branch). A short branch name selects the descendant of its\nlocal and origin tracking tips; use an explicit ref when they diverge.",type:["string","null"]},budget_tokens:{description:"Approximate whole-result JSON token budget for the brief (default: 4000).\nIn symbols view, budgets the existing symbol, test, and module sections.",format:"uint32",minimum:0,type:["integer","null"]},cursor:{description:"Authenticated continuation cursor; accepted only with view `symbols`.",type:["string","null"]},head_ref:{description:"Head branch or ref (default: 'HEAD'). Accepts local branches,\nremote-tracking refs such as origin/topic, full refs, and Git revision\nexpressions.",type:["string","null"]},maximum_symbols:{description:"Maximum symbols returned on a symbols-view page (default: 200, clamped to 1-500).",format:"uint32",minimum:0,type:["integer","null"]},pull_request:{description:"Select a retained PR number for this checkout when several are known.",format:"uint64",minimum:0,type:["integer","null"]},refresh_github:{default:!1,description:"Explicitly refresh the configured matching GitHub PR within the caller\ndeadline. By default, read retained authorized evidence. CI stays retained.",type:"boolean"},view:{$ref:"#/$defs/PrContextViewV1",default:"brief",description:"Compact PR briefing by default; `symbols` requests exact symbol pages."}},title:"PrContextSurfaceRequestV1",type:"object"},{$defs:{CoChangeUnavailableV1:hf,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ConfigSummaryKindV1:hT,ConfigSummaryV1:hO,GitCommitSubjectV1:{additionalProperties:!1,properties:{hash:{type:"string"},subject:{type:"string"}},required:["hash","subject"],type:"object"},GitComparedSymbolV1:gy,GitContextSymbolV1:g_,GitFileChangeStatusV1:{enum:["added","deleted","modified"],type:"string"},GitFileChangeV1:{additionalProperties:!1,properties:{path:{type:"string"},status:{$ref:"#/$defs/GitFileChangeStatusV1"}},required:["path","status"],type:"object"},GitFileRoleV1:gS,GitReadCompleteV1:gj,GitReadPartialV1:gC,GitReadUnavailableV1:gT,GitToolErrorKindV1:gW,GitToolErrorV1:gM,GitToolFailureV1:gN,GitToolOperationV1:gz,MissingCoChangePartnerV1:_w,PrAnalysisCoverageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},direct_call_edges_admitted:{format:"uint",minimum:0,type:"integer"},impact_bytes_admitted:{format:"uint",minimum:0,type:"integer"},impact_nodes_admitted:{format:"uint",minimum:0,type:"integer"},impact_nodes_returned:{format:"uint",minimum:0,type:"integer"},impact_partial:{type:"boolean"},seed_symbols_analyzed:{format:"uint",minimum:0,type:"integer"},symbols_complete:{type:"boolean"},symbols_returned:{format:"uint",minimum:0,type:"integer"}},required:["seed_symbols_analyzed","symbols_returned","symbols_complete","impact_nodes_admitted","impact_nodes_returned","direct_call_edges_admitted","impact_bytes_admitted","impact_partial","complete"],type:"object"},PrContextAreaV1:{additionalProperties:!1,properties:{additions:{format:"uint64",minimum:0,type:"integer"},area:{type:"string"},deletions:{format:"uint64",minimum:0,type:"integer"},files:{format:"uint",minimum:0,type:"integer"}},required:["area","files","additions","deletions"],type:"object"},PrContextBriefBudgetV1:{additionalProperties:!1,properties:{areas_omitted:{format:"uint",minimum:0,type:"integer"},checks_omitted:{format:"uint",minimum:0,type:"integer"},commits_omitted:{format:"uint",minimum:0,type:"integer"},discussions_omitted:{format:"uint",minimum:0,type:"integer"},entry_points_omitted:{format:"uint",minimum:0,type:"integer"},estimated_tokens:{description:"Whole-result JSON byte estimate, divided by four; not a tokenizer count.",format:"uint32",minimum:0,type:"integer"},files_omitted:{format:"uint",minimum:0,type:"integer"},impact_omitted:{format:"uint",minimum:0,type:"integer"},over_budget:{type:"boolean"},quality_omitted:{format:"uint",minimum:0,type:"integer"},requested_tokens:{format:"uint32",minimum:0,type:"integer"}},required:["requested_tokens","estimated_tokens","over_budget","files_omitted","entry_points_omitted","discussions_omitted","checks_omitted","impact_omitted","commits_omitted","areas_omitted","quality_omitted"],type:"object"},PrContextBriefV1:{additionalProperties:!1,properties:{additions:{format:"uint64",minimum:0,type:"integer"},areas:{items:{$ref:"#/$defs/PrContextAreaV1"},type:"array"},base:{type:"string"},base_oid:{type:"string"},budget:{$ref:"#/$defs/PrContextBriefBudgetV1"},changes:{items:{$ref:"#/$defs/PrContextFileV1"},type:"array"},commits:{items:{$ref:"#/$defs/GitCommitSubjectV1"},type:"array"},deletions:{format:"uint64",minimum:0,type:"integer"},entry_points:{description:"Prioritized places to begin reading the change, with exact revisions.",items:{$ref:"#/$defs/PrContextEntryPointV1"},type:"array"},files_changed:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}]},graph_analysis:{$ref:"#/$defs/PrContextSourceV1"},head:{type:"string"},head_oid:{type:"string"},hosted:{$ref:"#/$defs/PrContextHostedV1"},impact:{items:{$ref:"#/$defs/PrContextImpactV1"},type:"array"},merge_base:{type:"string"},next_steps:{items:{type:"string"},type:"array"},quality:{items:{$ref:"#/$defs/PrContextQualityV1"},type:"array"},source_analysis:{$ref:"#/$defs/PrContextSourceV1"},view:{$ref:"#/$defs/PrContextViewV1"}},required:["view","base","head","base_oid","head_oid","merge_base","files_changed","additions","deletions","commits","hosted","areas","changes","entry_points","impact","quality","source_analysis","graph_analysis","next_steps","budget"],type:"object"},PrContextCheckV1:{additionalProperties:!1,properties:{conclusion:{type:["string","null"]},evidence_anchor:{type:"string"},failed_step:{type:["string","null"]},head:{type:"string"},locations:{items:{$ref:"#/$defs/PrContextLocationV1"},type:"array"},matches_head:{type:"boolean"},name:{type:"string"},observed_at:{format:"int64",type:"integer"},status:{type:"string"},workflow:{type:"string"}},required:["name","workflow","status","head","matches_head","observed_at","evidence_anchor","locations"],type:"object"},PrContextCompleteV1:{additionalProperties:!1,properties:{added:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},affected_tests:{items:{type:"string"},type:"array"},affected_tests_coverage:{$ref:"#/$defs/PrSelectionCoverageV1"},analysis_coverage:{$ref:"#/$defs/PrAnalysisCoverageV1"},base:{type:"string"},base_oid:{type:"string"},changes:{items:{$ref:"#/$defs/GitFileChangeV1"},type:"array"},co_change_unavailable:{anyOf:[{$ref:"#/$defs/CoChangeUnavailableV1"},{type:"null"}],description:"Present when Git history could not be mined for co-change partners."},commits:{items:{$ref:"#/$defs/GitCommitSubjectV1"},type:"array"},files_changed:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},graph_generation:{type:"string"},head:{type:"string"},head_oid:{type:"string"},impacted_modules:{items:{type:"string"},type:"array"},impacted_modules_coverage:{$ref:"#/$defs/PrSelectionCoverageV1"},merge_base:{type:"string"},missing_co_change_partners:{description:"Files that usually change with a changed file, per bounded Git\nhistory, but are absent from this change set.",items:{$ref:"#/$defs/MissingCoChangePartnerV1"},type:"array"},modified:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},next_cursor:{type:["string","null"]},removed:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},status:{$ref:"#/$defs/GitReadCompleteV1"},symbol_changes_coverage:{$ref:"#/$defs/PrSymbolChangesCompleteV1"},symbol_page:{$ref:"#/$defs/PrSymbolPageV1"},symbols_added:{format:"uint",minimum:0,type:"integer"},symbols_modified:{format:"uint",minimum:0,type:"integer"},symbols_removed:{format:"uint",minimum:0,type:"integer"},test_files_changed:{items:{type:"string"},type:"array"},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."}},required:["status","base","head","base_oid","head_oid","merge_base","graph_generation","commits","files_changed","changes","missing_co_change_partners","symbols_added","symbols_removed","symbols_modified","added","removed","modified","symbol_changes_coverage","symbol_page","analysis_coverage","test_files_changed","affected_tests","affected_tests_coverage","impacted_modules","impacted_modules_coverage"],type:"object"},PrContextDiscussionV1:{additionalProperties:!1,properties:{author:{description:"Provider login when retained; an opaque author anchor is not a login.",type:["string","null"]},body_anchor:{type:["string","null"]},event_at:{description:"Provider activity time in UTC microseconds: comment update/creation or\nreview submission. Absent when not retained or not parseable.",format:"int64",type:["integer","null"]},file:{type:["string","null"]},id:{type:"string"},kind:{type:"string"},lifecycle:{type:"string"},line:{format:"uint64",minimum:0,type:["integer","null"]},matches_head:{type:"boolean"},observed_at:{format:"int64",type:"integer"},review_state:{type:"string"},text:{type:["string","null"]},text_truncated:{type:"boolean"},thread_id:{type:["string","null"]},url:{type:["string","null"]}},required:["id","kind","lifecycle","review_state","text_truncated","observed_at","matches_head"],type:"object"},PrContextEntryPointV1:{additionalProperties:!1,properties:{after_excerpt:{anyOf:[{$ref:"#/$defs/PrContextExcerptV1"},{type:"null"}]},after_signature:{type:["string","null"]},after_signature_truncated:{default:!1,type:"boolean"},before_excerpt:{anyOf:[{$ref:"#/$defs/PrContextExcerptV1"},{type:"null"}]},before_signature:{type:["string","null"]},before_signature_truncated:{default:!1,type:"boolean"},change:{type:"string"},location:{$ref:"#/$defs/PrContextLocationV1"},node_id:{description:"Exact-head graph occurrence accepted by source_body and impact.\nAbsent when graph provenance or declaration matching is unavailable.",type:["string","null"]},reason:{type:"string"},revision:{type:"string"},symbol:{type:"string"}},required:["location","revision","symbol","change","reason"],type:"object"},PrContextExcerptV1:{additionalProperties:!1,properties:{location:{$ref:"#/$defs/PrContextLocationV1"},revision:{type:"string"},text:{type:"string"},truncated:{description:"True when this is only an excerpt of the declaration.",type:"boolean"}},required:["revision","location","text","truncated"],type:"object"},PrContextFileV1:{additionalProperties:!1,properties:{additions:{format:"uint32",minimum:0,type:["integer","null"]},change:{type:"string"},deletions:{format:"uint32",minimum:0,type:["integer","null"]},file:{type:"string"},previous_file:{type:["string","null"]},role:{$ref:"#/$defs/GitFileRoleV1"}},required:["file","change","role"],type:"object"},PrContextGraphPendingV1:{additionalProperties:!1,description:"The git comparison while the verified graph generation is still warming.",properties:{added:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},affected_tests:{items:{type:"string"},type:"array"},affected_tests_coverage:{$ref:"#/$defs/PrSelectionCoverageV1"},analysis_coverage:{$ref:"#/$defs/PrAnalysisCoverageV1"},base:{type:"string"},base_oid:{type:"string"},changes:{items:{$ref:"#/$defs/GitFileChangeV1"},type:"array"},co_change_unavailable:{anyOf:[{$ref:"#/$defs/CoChangeUnavailableV1"},{type:"null"}],description:"Present when Git history could not be mined for co-change partners."},commits:{items:{$ref:"#/$defs/GitCommitSubjectV1"},type:"array"},files_changed:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},graph_generation:{description:"No verified generation was admitted.",type:["string","null"]},head:{type:"string"},head_oid:{type:"string"},impacted_modules:{items:{type:"string"},type:"array"},impacted_modules_coverage:{$ref:"#/$defs/PrSelectionCoverageV1"},merge_base:{type:"string"},message:{type:"string"},missing_co_change_partners:{description:"Files that usually change with a changed file, per bounded Git\nhistory, but are absent from this change set.",items:{$ref:"#/$defs/MissingCoChangePartnerV1"},type:"array"},modified:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},next_cursor:{type:["string","null"]},status:{$ref:"#/$defs/GitReadPartialV1"},symbol_page:{$ref:"#/$defs/PrSymbolPageV1"},symbols_added:{format:"uint",minimum:0,type:"integer"},symbols_modified:{format:"uint",minimum:0,type:"integer"},test_files_changed:{items:{type:"string"},type:"array"},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."},verified_graph_evidence:{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"}},required:["status","message","base","head","base_oid","head_oid","merge_base","commits","files_changed","changes","missing_co_change_partners","symbols_added","symbols_modified","added","modified","symbol_page","analysis_coverage","test_files_changed","affected_tests","affected_tests_coverage","impacted_modules","impacted_modules_coverage","verified_graph_evidence"],type:"object"},PrContextHostedV1:{additionalProperties:!1,properties:{checks:{items:{$ref:"#/$defs/PrContextCheckV1"},type:"array"},checks_total:{format:"uint",minimum:0,type:"integer"},ci_source:{$ref:"#/$defs/PrContextSourceV1"},discussions:{items:{$ref:"#/$defs/PrContextDiscussionV1"},type:"array"},discussions_total:{format:"uint",minimum:0,type:"integer"},pull_request:{anyOf:[{$ref:"#/$defs/PrContextPullRequestV1"},{type:"null"}]},required_checks_known:{description:"A retained CI inventory is not an enumeration of required checks.",type:"boolean"},source:{$ref:"#/$defs/PrContextSourceV1"}},required:["source","ci_source","discussions","checks","discussions_total","checks_total","required_checks_known"],type:"object"},PrContextImpactV1:{additionalProperties:!1,properties:{changed_symbol:{type:"string"},consumer:{type:"string"},consumer_changed:{description:"Whether the consumer's file is in the PR diff; this does not imply\nthat the consumer declaration itself changed.",type:"boolean"},location:{$ref:"#/$defs/PrContextLocationV1"},node_id:{description:"Exact-head consumer occurrence accepted by source_body and impact.",type:["string","null"]},relation:{type:"string"}},required:["changed_symbol","consumer","location","relation","consumer_changed"],type:"object"},PrContextLocationV1:{additionalProperties:!1,properties:{end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"}},required:["file","line","end_line"],type:"object"},PrContextPullRequestV1:{additionalProperties:!1,properties:{description:{description:"Sanitized retained description, when the provider supplied it.",type:["string","null"]},description_truncated:{type:"boolean"},draft:{type:"boolean"},matches_head:{type:"boolean"},number:{format:"uint64",minimum:0,type:"integer"},observed_at:{format:"int64",type:"integer"},observed_head:{type:"string"},state:{type:"string"},title:{type:"string"}},required:["number","title","state","draft","description_truncated","observed_head","observed_at","matches_head"],type:"object"},PrContextQualityV1:{additionalProperties:!1,properties:{observation:{type:"string"},signal:{type:"string"}},required:["signal","observation"],type:"object"},PrContextSourceStateV1:{enum:["ready","partial","stale","unavailable","not_published","denied","not_mounted","ambiguous","not_found"],type:"string"},PrContextSourceV1:{additionalProperties:!1,properties:{detail:{type:"string"},state:{$ref:"#/$defs/PrContextSourceStateV1"}},required:["state","detail"],type:"object"},PrContextSymbolsUnavailableV1:{additionalProperties:!1,description:"The git comparison while exact base/head symbol comparison is unavailable\nor does not describe the verified graph's head generation.",properties:{added:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},base:{type:"string"},base_oid:{type:"string"},changes:{items:{$ref:"#/$defs/GitFileChangeV1"},type:"array"},co_change_unavailable:{anyOf:[{$ref:"#/$defs/CoChangeUnavailableV1"},{type:"null"}],description:"Present when Git history could not be mined for co-change partners."},commits:{items:{$ref:"#/$defs/GitCommitSubjectV1"},type:"array"},files_changed:{format:"uint",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},graph_generation:{type:"string"},head:{type:"string"},head_oid:{type:"string"},merge_base:{type:"string"},message:{type:"string"},missing_co_change_partners:{description:"Files that usually change with a changed file, per bounded Git\nhistory, but are absent from this change set.",items:{$ref:"#/$defs/MissingCoChangePartnerV1"},type:"array"},modified:{items:{$ref:"#/$defs/PrSymbolEntryV1"},type:"array"},next_cursor:{type:["string","null"]},removed:{items:{$ref:"#/$defs/GitComparedSymbolV1"},type:"array"},status:{$ref:"#/$defs/GitReadPartialV1"},symbol_changes_coverage:{$ref:"#/$defs/SymbolChangesUnavailableV1"},symbols_added:{format:"uint",minimum:0,type:"integer"},symbols_modified:{format:"uint",minimum:0,type:"integer"},symbols_removed:{format:"uint",minimum:0,type:"integer"},token_budget:{anyOf:[{$ref:"#/$defs/TokenBudgetCutV1"},{type:"null"}],description:"Budget accounting when the request supplies `budget_tokens`."}},required:["status","message","base","head","base_oid","head_oid","merge_base","graph_generation","commits","files_changed","changes","missing_co_change_partners","symbols_added","symbols_removed","symbols_modified","added","removed","modified","symbol_changes_coverage"],type:"object"},PrContextViewV1:_G,PrCoverageSelectionV1:{enum:["unavailable","deterministic_bounded_prefix"],type:"string"},PrSelectionCoverageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},selection:{$ref:"#/$defs/PrCoverageSelectionV1"}},required:["complete","selection"],type:"object"},PrSymbolChangesCompleteV1:{additionalProperties:!1,properties:{base_generation:{type:"string"},head_generation:{type:"string"},status:{$ref:"#/$defs/GitReadCompleteV1"}},required:["status","base_generation","head_generation"],type:"object"},PrSymbolEntryV1:{anyOf:[{$ref:"#/$defs/GitContextSymbolV1"},{$ref:"#/$defs/ConfigSummaryV1"}]},PrSymbolPageV1:{additionalProperties:!1,properties:{complete:{type:"boolean"},continuation_available:{type:"boolean"},has_more:{type:"boolean"},limit:{format:"uint",minimum:0,type:"integer"},returned:{format:"uint",minimum:0,type:"integer"},selection:{$ref:"#/$defs/PrSymbolSelectionV1"}},required:["limit","returned","has_more","complete","selection","continuation_available"],type:"object"},PrSymbolSelectionV1:{enum:["unavailable","stable_prefix"],type:"string"},PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,PrimitiveUnavailableEvidenceV1:_0,PrimitiveUnavailableStatusV1:_2,SymbolChangesUnavailableV1:bV,TokenBudgetCutV1:bD,TokenBudgetSectionV1:bF},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/PrContextBriefV1"},{$ref:"#/$defs/PrContextCompleteV1"},{$ref:"#/$defs/PrContextSymbolsUnavailableV1"},{$ref:"#/$defs/PrContextGraphPendingV1"},{$ref:"#/$defs/GitToolFailureV1"}],title:"PrContextResultV1"},{$defs:{BranchStackEdgeV1:f3,BranchStackId:f9,BranchStackNodeV1:f5,BranchStackRevisionId:f8,BranchStackRevisionV1:f7,BranchStackSourceV1:he,CommitId:hq,ManifestDigest:_l,MechanicalIntegrationModeV1:_p,NativeIntegrationDirectionV1:_R,NativeIntegrationSealedStackSnapshotV1:_x,NativeIntegrationSelectionBindingV1:_j,ProjectId:_4,RefId:vm,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,StackNodeId:bw,WorktreeId:SB,WorktreeInventoryEpoch:SK,WorktreeInventorySnapshotId:SJ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Read-only preflight over one frozen snapshot identity.\n\n`preferred_mode` selects only one of the three fixed mechanical encodings.\nIt cannot change topology, commit order, or the commit set.",properties:{preferred_mode:{anyOf:[{$ref:"#/$defs/MechanicalIntegrationModeV1"},{type:"null"}],default:null},snapshot:{$ref:"#/$defs/NativeIntegrationSealedStackSnapshotV1"}},required:["snapshot"],title:"NativeIntegrationPreflightSurfaceRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{path:{description:"Project path or registered alias to resolve.",type:["string","null"]},project_selector:{additionalProperties:!1,default:null,description:"Registered project id to inspect. Omit to use path or the active\nproject.",properties:{project_id:{description:"Registered project id to query.",type:"string"}},required:["project_id"],type:"object"}},title:"ProjectContextSurfaceRequestV1",type:"object"},{$defs:{PublicCodeProject:va},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One registered project's context, or the registry's typed miss.",oneOf:[{additionalProperties:!1,properties:{aliases:{description:"Alias rows exactly as the registry serializes them.",items:!0,type:"array"},is_active:{type:"boolean"},project:{$ref:"#/$defs/PublicCodeProject"},registry_path:{type:"string"},status:{const:"ok",type:"string"},stores:{description:"Store rows exactly as the registry serializes them.",items:!0,type:"array"}},required:["status","is_active","registry_path","project","aliases","stores"],type:"object"},{additionalProperties:!1,description:"The registry answered and no registered project matches the selector.",properties:{aliases:{items:!0,type:"array"},project:{type:"null"},registry_path:{type:"string"},status:{const:"not_found",type:"string"},stores:{items:!0,type:"array"}},required:["status","registry_path","project","aliases","stores"],type:"object"}],title:"ProjectContextResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum projects to return (default: 25, max: 100).",format:"uint",minimum:0,type:["integer","null"]}},title:"ProjectListSurfaceRequestV1",type:"object"},{$defs:{ProjectRegistryEntry:_6,ProjectRegistrySummary:_3,ProjectRepoGroup:_9,PublicCodeProject:va},$schema:"https://json-schema.org/draft/2020-12/schema",description:"A bounded page of the profile's registered projects.",oneOf:[{additionalProperties:!1,properties:{limit:{format:"uint",minimum:0,type:"integer"},project_tree:{items:{$ref:"#/$defs/ProjectRepoGroup"},type:"array"},projects:{items:{$ref:"#/$defs/PublicCodeProject"},type:"array"},query:{type:["string","null"]},registry_path:{type:"string"},status:{const:"ok",type:"string"},summary:{$ref:"#/$defs/ProjectRegistrySummary"},title:{type:"string"},truncated:{type:"boolean"}},required:["status","title","registry_path","limit","truncated","summary","project_tree","projects"],type:"object"}],title:"ProjectRegistryListingResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum projects to return (default: 10, max: 50).",format:"uint",minimum:0,type:["integer","null"]},query:{description:"Case-insensitive substring query over registry project metadata.",type:"string"}},required:["query"],title:"ProjectSearchSurfaceRequestV1",type:"object"},{$defs:{PageRequest:_U},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{page:{$ref:"#/$defs/PageRequest"},qualified_name:{type:"string"}},required:["qualified_name","page"],title:"QualifiedNamePrimitiveRequest",type:"object"},{$defs:{SymbolPrimitiveRecord:bI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{next_cursor:{description:"Opaque resume token; its bounded string is the public wire form.",type:["string","null"]},symbols:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["symbols"],title:"QualifiedNamePrimitiveResult",type:"object"},{$defs:{RankDirectionV1:vc,RankEdgeKindV1:vl},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{direction:{anyOf:[{$ref:"#/$defs/RankDirectionV1"},{type:"null"}],description:"Edge direction: 'incoming' ranks targets (default, e.g.\nmost-implemented interface), 'outgoing' ranks sources (e.g. class that\nimplements the most interfaces)."},edge_kind:{$ref:"#/$defs/RankEdgeKindV1",description:"The relationship type to rank by (e.g. 'implements' to find\nmost-implemented interfaces)."},limit:{description:"Maximum number of results to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},node_kind:{description:"Optional filter for node kind (e.g. 'interface', 'class', 'trait',\n'function', 'method').",type:["string","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},required:["edge_kind"],title:"RankSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RankDirectionV1:vc,RankEdgeKindV1:vl,RankEntryV1:{additionalProperties:!1,properties:{count:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line","count"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{direction:{$ref:"#/$defs/RankDirectionV1"},edge_kind:{$ref:"#/$defs/RankEdgeKindV1"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},node_kind_filter:{type:["string","null"]},ranking:{items:{$ref:"#/$defs/RankEntryV1"},type:"array"},result_count:{format:"uint64",minimum:0,type:"integer"}},required:["edge_kind","direction","result_count","ranking"],title:"RankResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{limit:{description:"Maximum number of cycles to return (default: 10, at most 100).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path (e.g. 'src/main/java').",type:["string","null"]}},title:"RecursionSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RecursionCycleV1:{additionalProperties:!1,description:"One call cycle; `chain` repeats its first symbol at the end.",properties:{chain:{items:{$ref:"#/$defs/RecursionSymbolV1"},type:"array"},length:{format:"uint64",minimum:0,type:"integer"}},required:["length","chain"],type:"object"},RecursionSymbolV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","kind","file","line"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cycle_count:{format:"uint64",minimum:0,type:"integer"},cycles:{items:{$ref:"#/$defs/RecursionCycleV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."}},required:["cycle_count","cycles"],title:"RecursionResultV1",type:"object"},{$defs:{CommitId:hq,ProjectId:_4,ProviderId:vo,RedundancyScopeV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"repository",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"path",type:"string"},path:{type:"string"}},required:["kind","path"],type:"object"},{additionalProperties:!1,properties:{changed_paths:{items:{type:"string"},type:"array"},head_commit_id:{$ref:"#/$defs/CommitId"},kind:{const:"pull_request",type:"string"},provider:{$ref:"#/$defs/ProviderId"},pull_request_id:{type:"string"}},required:["kind","provider","pull_request_id","head_commit_id","changed_paths"],type:"object"}]},RepositoryId:vb,SimilarMatchClassV1:bc},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{type:["string","null"]},family_limit:{description:"Preferred family page size, 1 through 100.",format:"uint32",maximum:100,minimum:1,type:"integer"},include_generated_paths:{type:"boolean"},match_classes:{items:{$ref:"#/$defs/SimilarMatchClassV1"},type:"array"},member_limit:{description:"Members listed per family, at least 2.",format:"uint32",minimum:2,type:"integer"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},scope:{$ref:"#/$defs/RedundancyScopeV1"},work_limit:{description:"Clone-index work budget for this page, 3 through 10000. A page that\nexhausts it reports partial coverage.",format:"uint32",maximum:1e4,minimum:3,type:"integer"}},required:["project_id","repository_id","match_classes","scope","include_generated_paths","family_limit","member_limit","work_limit"],title:"RedundancySurfaceRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ManifestDigest:_l,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,ProjectId:_4,RedundancyCoverageV1:{oneOf:[{additionalProperties:!1,properties:{examined_families:{format:"uint",minimum:0,type:"integer"},examined_members:{format:"uint",minimum:0,type:"integer"},status:{const:"complete",type:"string"}},required:["status","examined_families","examined_members"],type:"object"},{additionalProperties:!1,properties:{examined_families:{format:"uint",minimum:0,type:"integer"},examined_members:{format:"uint",minimum:0,type:"integer"},reason:{$ref:"#/$defs/RedundancyPartialReasonV1"},status:{const:"partial",type:"string"}},required:["status","reason","examined_families","examined_members"],type:"object"}]},RedundancyFamilyV1:{additionalProperties:!1,properties:{family:{$ref:"#/$defs/SimilarFamilyV1"},generated_members:{items:{$ref:"#/$defs/SymbolOccurrenceId"},type:"array"},reviewable_source_bytes:{format:"uint64",minimum:0,type:"integer"},total_member_count:{format:"uint",minimum:0,type:"integer"}},required:["family","total_member_count","reviewable_source_bytes","generated_members"],type:"object"},RedundancyPartialReasonV1:{enum:["family_limit","work_limit"],type:"string"},RedundancyRankingV1:{enum:["reviewable_source_bytes"],type:"string"},RepositoryId:vb,SimilarFamilyV1:bd,SimilarMatchClassV1:bc,SimilarOccurrenceV1:bl,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/RedundancyCoverageV1"},families:{items:{$ref:"#/$defs/RedundancyFamilyV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},next_cursor:{type:["string","null"]},ranked_by:{$ref:"#/$defs/RedundancyRankingV1"},source_generation:{$ref:"#/$defs/CodeGenerationId"}},required:["source_generation","ranked_by","families","coverage"],title:"RedundancyResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,title:"RemoteStatusSurfaceRequestV1",type:"object"},{$defs:{AuthorityEpoch:{description:"Monotonic epoch of the writer authority for a shard.",format:"uint64",minimum:0,type:"integer"},BrainId:f1,BrainNodeId:{description:"Strongly typed canonical identity: `BrainNodeId`.",type:"string"},CurrentRemoteAuthorityStateV1:{description:"Truthful authority lookup state. Missing evidence is never represented as\nan available authority or a successful empty response.",oneOf:[{properties:{state:{const:"available",type:"string"},value:{$ref:"#/$defs/CurrentRemoteAuthorityV1"}},required:["state","value"],type:"object"},{properties:{state:{const:"partial",type:"string"},value:{properties:{known_fence:{anyOf:[{$ref:"#/$defs/RemoteWriterFenceV1"},{type:"null"}]},missing:{items:{$ref:"#/$defs/RemoteAuthorityUnavailableReasonV1"},type:"array",uniqueItems:!0},observed_at:{$ref:"#/$defs/UtcMicros"}},required:["missing","observed_at"],type:"object"}},required:["state","value"],type:"object"},{properties:{state:{const:"unavailable",type:"string"},value:{properties:{observed_at:{$ref:"#/$defs/UtcMicros"},reason:{$ref:"#/$defs/RemoteAuthorityUnavailableReasonV1"}},required:["reason","observed_at"],type:"object"}},required:["state","value"],type:"object"}]},CurrentRemoteAuthorityV1:{additionalProperties:!1,description:"Authenticated current authority for a mutable shard.",properties:{credential_revision:{description:"Revision of the authority node's current enrollment credential.",format:"uint64",minimum:0,type:"integer"},fence:{$ref:"#/$defs/RemoteWriterFenceV1"},observed_at:{$ref:"#/$defs/UtcMicros"}},required:["fence","credential_revision","observed_at"],type:"object"},DoctorCoverageCompletenessV1:yk,ProjectionGenerationId:_5,RemoteAuthorityUnavailableReasonV1:{oneOf:[{enum:["registry_unavailable","placement_unknown","authority_unreachable","authority_authentication_failed","caller_authentication_failed","enrollment_expired","enrollment_revoked","insufficient_capability","scope_mismatch","fence_unverified","protocol_incompatible"],type:"string"},{const:"writer_authority_unpublished",description:"The RemoteNode store has never had a writer authority published for\nthis Brain, so no capture, replay, query, or failover can bind to one.",type:"string"}]},RemoteListenerReadV1:{enum:["serving","disabled","degraded"],type:"string"},RemoteOperationalReadinessV1:{enum:["unconfigured","partial","ready","recovery_required"],type:"string"},RemoteOperationalStatusV1:{additionalProperties:!1,properties:{authority:{$ref:"#/$defs/CurrentRemoteAuthorityStateV1"},enrollment_configured:{type:"boolean"},failover_in_progress:{type:"boolean"},observed_at:{$ref:"#/$defs/UtcMicros"},readiness:{$ref:"#/$defs/RemoteOperationalReadinessV1"},recovery_required:{type:"boolean"},replay_coverage_complete:{type:"boolean"},spool:{$ref:"#/$defs/RemoteSpoolOperationalStatusV1"}},required:["readiness","enrollment_configured","authority","spool","replay_coverage_complete","failover_in_progress","recovery_required","observed_at"],type:"object"},RemoteSpoolOperationalStatusV1:{additionalProperties:!1,properties:{has_sequence_gap:{type:"boolean"},pending_count:{format:"uint64",minimum:0,type:"integer"},quarantined_count:{format:"uint64",minimum:0,type:"integer"}},required:["pending_count","quarantined_count","has_sequence_gap"],type:"object"},RemoteWriterFenceV1:{additionalProperties:!1,description:"The complete single-writer identity for one mutable shard.",properties:{authority_epoch:{$ref:"#/$defs/AuthorityEpoch"},authority_node_id:{$ref:"#/$defs/BrainNodeId"},brain_id:{$ref:"#/$defs/BrainId"},generation_id:{$ref:"#/$defs/ProjectionGenerationId"},placement_revision:{format:"uint64",minimum:0,type:"integer"},shard_id:{$ref:"#/$defs/ShardId"}},required:["brain_id","shard_id","generation_id","placement_revision","authority_epoch","authority_node_id"],type:"object"},ShardId:{description:"Strongly typed canonical identity: `ShardId`.",type:"string"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Typed read of the Remote Brain operational plane as observed from the\nmounted daemon authorities. Every operator surface (Doctor, CLI, MCP,\ndashboard) reads this one shape; `Unavailable` is reserved for a genuinely\nunmounted or unreadable authority, never a rendering shortcut.",oneOf:[{properties:{coverage:{$ref:"#/$defs/DoctorCoverageCompletenessV1"},kind:{const:"observed",type:"string"},listener:{$ref:"#/$defs/RemoteListenerReadV1"},status:{$ref:"#/$defs/RemoteOperationalStatusV1"}},required:["kind","listener","status","coverage"],type:"object"},{properties:{kind:{const:"unconfigured",type:"string"}},required:["kind"],type:"object"},{properties:{kind:{const:"unavailable",type:"string"}},required:["kind"],type:"object"}],title:"RemoteOperationalStatusReadV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{new_name:{type:["string","null"]},node_id:{type:"string"}},required:["node_id"],title:"RenamePreviewPrimitiveRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveNotFoundV1:_Z,PrimitiveSearchFreshnessV1:_X,PrimitiveSymbolLocationV1:_1,RenamePreviewNodeV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},qualified_name:{type:"string"},snippet:{type:["string","null"]}},required:["id","name","qualified_name","kind","file","line"],type:"object"},RenamePreviewPrimitiveResultV1:{additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},new_name:{type:["string","null"]},node:{$ref:"#/$defs/RenamePreviewNodeV1"},note:{type:"string"},read_only:{type:"boolean"},reference_count:{format:"uint",minimum:0,type:"integer"},references:{items:{$ref:"#/$defs/RenamePreviewReferenceV1"},type:"array"},symbol:{type:"string"},text_only_matches:{items:{$ref:"#/$defs/RenamePreviewTextOnlyMatchV1"},type:"array"}},required:["read_only","note","symbol","node","reference_count","references","text_only_matches"],type:"object"},RenamePreviewReferenceV1:{additionalProperties:!1,properties:{edge_kind:{type:"string"},file:{type:"string"},from_kind:{type:"string"},from_name:{type:"string"},from_node_id:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},snippet:{type:["string","null"]}},required:["from_node_id","from_name","from_kind","edge_kind","file","line"],type:"object"},RenamePreviewTextOnlyMatchV1:{additionalProperties:!1,properties:{file:{type:"string"},note:{type:"string"},text_only_count:{format:"uint",minimum:0,type:"integer"}},required:["file","text_only_count","note"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/RenamePreviewPrimitiveResultV1"},{$ref:"#/$defs/PrimitiveNotFoundV1"}],title:"RenamePreviewPrimitiveOutcomeV1"},{$defs:{ManifestDigest:_l,RenamePreviewAcceptanceV1:{additionalProperties:!1,description:"Exact preview material an apply must echo. Preview calls omit this value;\napply rejects any mismatch before publishing a file.",properties:{graph_revision:{$ref:"#/$defs/ManifestDigest"},plan_digest:{$ref:"#/$defs/ManifestDigest"},preview_digest:{$ref:"#/$defs/ManifestDigest"},preview_id:{$ref:"#/$defs/ManifestDigest"},repository_revision:{default:null,type:["string","null"]}},required:["preview_id","preview_digest","plan_digest","graph_revision"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_rename_symbol`.\n\nThe five identity fields consume the preview's exact symbol identity; the\nflattened control consumes its exact candidate-state digest.",properties:{accepted_preview:{anyOf:[{$ref:"#/$defs/RenamePreviewAcceptanceV1"},{type:"null"}],description:"Exact output identity from the accepted dry-run preview. Required when\n`dry_run=false` and omitted when computing a preview."},dry_run:{default:!0,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},file:{type:"string"},idempotency_key:{type:["string","null"]},kind:{type:"string"},new_name:{type:"string"},node_id:{description:"Canonical `SymbolOccurrenceId` returned by `tracedecay_rename_preview`.",type:"string"},old_name:{type:"string"},qualified_name:{type:"string"},verify:{default:!0,type:"boolean"}},required:["node_id","qualified_name","kind","file","old_name","new_name"],title:"RenameSymbolSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_replace_symbol`.",properties:{dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},new_source:{type:"string"},symbol:{type:"string"},verify:{default:!1,type:"boolean"}},required:["symbol","new_source"],title:"ReplaceSymbolSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{handle:{description:"The required `handle` argument copied exactly from a truncated MCP\nresponse envelope.",type:"string"},max_chars:{description:"Maximum characters requested for this page. Values above the safe\nresponse-frame budget are clamped.",format:"uint64",minimum:1,type:["integer","null"]},offset:{default:0,description:"Character offset into the immutable stored response (default: 0). Use\nthe prior page's next_offset.",format:"uint64",minimum:0,type:["integer","null"]}},required:["handle"],title:"RetrieveSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,RetrieveHandleExpiredV1:{additionalProperties:!1,description:"The record expired and was removed.",properties:{content:{description:"Always null: the expired content was removed.",type:["string","null"]},created_at:{format:"int64",type:"integer"},expired:{description:"Always `true`.",type:"boolean"},expires_at:{format:"int64",type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},handle:{type:"string"},message:{type:"string"},reason_code:{type:"string"},retry_instruction:{type:"string"},retryable:{type:"boolean"}},required:["handle","expired","reason_code","message","retryable","retry_instruction","created_at","expires_at"],type:"object"},RetrieveHandleMissingV1:{additionalProperties:!1,description:"No record exists under the handle in this project's store.",properties:{content:{description:"Always null: nothing is stored under the handle.",type:["string","null"]},expired:{description:"Always null: an absent record has no expiry to report.",type:["boolean","null"]},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},handle:{type:"string"},message:{type:"string"},reason_code:{type:"string"},retry_instruction:{type:"string"},retryable:{type:"boolean"}},required:["handle","reason_code","message","retryable","retry_instruction"],type:"object"},RetrievedPageV1:{additionalProperties:!1,description:"One page of the stored response, sized so its response frame fits the\nresponse budget.",properties:{content:{type:"string"},created_at:{format:"int64",type:"integer"},expired:{description:"Always `false`: a page is only served from a live record.",type:"boolean"},expires_at:{format:"int64",type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},handle:{type:"string"},has_more:{type:"boolean"},next_offset:{description:"Where the next page starts; absent on the last page.",format:"uint64",minimum:0,type:["integer","null"]},offset:{format:"uint64",minimum:0,type:"integer"},original_chars:{format:"uint64",minimum:0,type:"integer"},total_chars:{format:"uint64",minimum:0,type:"integer"}},required:["handle","expired","original_chars","total_chars","offset","has_more","created_at","expires_at","content"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/RetrievedPageV1"},{$ref:"#/$defs/RetrieveHandleMissingV1"},{$ref:"#/$defs/RetrieveHandleExpiredV1"}],description:"What a retrieve found under the handle.",title:"RetrieveResultV1"},{$defs:{TestProfileV1:{description:"The cargo profile an affected-test run builds with.",enum:["debug","release"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{changed_paths:{description:"Explicit manifest of project-relative file paths used to compute\naffected tests.",items:{type:"string"},type:"array"},max_tests:{description:"Cap on tests dispatched in a single invocation, 1 through 500\n(default: 100).",format:"uint64",maximum:500,minimum:1,type:["integer","null"]},profile:{anyOf:[{$ref:"#/$defs/TestProfileV1"},{type:"null"}],description:"Cargo profile (default: debug)."},timeout_secs:{description:"Maximum wall time in seconds before the cargo subprocess is killed,\n1 through 300 (default: 300).",format:"uint64",maximum:300,minimum:1,type:["integer","null"]}},required:["changed_paths"],title:"RunAffectedTestsSurfaceRequestV1",type:"object"},{$defs:{AffectedTestErrorV1:{additionalProperties:!1,description:"Why a run failed or was refused.",properties:{kind:{type:"string"},message:{type:"string"},operation:{type:"string"}},required:["kind","operation","message"],type:"object"},AffectedTestOutcomeV1:{additionalProperties:!1,description:"One observed libtest outcome.",properties:{covers_source_ids:{description:"Graph symbols this test was selected to cover.",items:{type:"string"},type:"array"},passed:{type:"boolean"},test:{type:"string"}},required:["test","passed","covers_source_ids"],type:"object"},AffectedTestRunV1:{additionalProperties:!1,description:"A dispatched run, completed or failed, with what it observed.",properties:{dispatched_tests:{items:{type:"string"},type:"array"},error:{anyOf:[{$ref:"#/$defs/AffectedTestErrorV1"},{type:"null"}],description:"Present when the run did not complete."},exit_code:{format:"int32",type:["integer","null"]},failed:{format:"uint64",minimum:0,type:"integer"},ignored:{description:"Dispatched tests libtest reported as ignored.",format:"uint64",minimum:0,type:"integer"},passed:{format:"uint64",minimum:0,type:"integer"},results:{items:{$ref:"#/$defs/AffectedTestOutcomeV1"},type:"array"},stderr_tail:{type:"string"},stdout_tail:{type:"string"},terminal:{$ref:"#/$defs/ManagedTestTerminalV1"},total_observed:{format:"uint64",minimum:0,type:"integer"},truncated:{description:"More affected tests existed than `max_tests` admitted.",type:"boolean"}},required:["passed","failed","ignored","total_observed","dispatched_tests","truncated","results","stderr_tail","stdout_tail","terminal"],type:"object"},AffectedTestsNotRunV1:{additionalProperties:!1,description:"No test was dispatched: nothing covers the change, or the request was\nrefused before a run began.",properties:{error:{anyOf:[{$ref:"#/$defs/AffectedTestErrorV1"},{type:"null"}]},failed:{description:"Always 0.",format:"uint64",minimum:0,type:"integer"},note:{type:["string","null"]},passed:{description:"Always 0.",format:"uint64",minimum:0,type:"integer"},results:{description:"Always empty.",items:{$ref:"#/$defs/AffectedTestOutcomeV1"},type:"array"}},required:["passed","failed","results"],type:"object"},CancellationObservation:hn,CancellationStage:ha,Deadline:yv,ManagedTestTerminalV1:{additionalProperties:!1,description:"The managed test-run operation the run was recorded under.",properties:{operation_id:{type:"string"},receipt:{$ref:"#/$defs/OperationReceipt"},result_tool:{description:"The tool that reads the recorded results back.",type:"string"},session_id:{description:"The requesting session the run is recorded against; null when the\nrequest carried no session.",type:["string","null"]}},required:["operation_id","result_tool","receipt"],type:"object"},OperationBudgetUsage:_D,OperationReceipt:_F,OperationTermination:_L,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/AffectedTestRunV1"},{$ref:"#/$defs/AffectedTestsNotRunV1"}],title:"RunAffectedTestsResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{authority_audit:{default:!1,description:"Run the exhaustive observation-authority audit and include\nauthority_audit_ok (true = audit ran and passed, false = audit ran and\nfailed, null = audit did not run or finish), authority_audit_reason\n(typed: authority_invariant_failed, authority_store_unavailable,\nauthority_store_missing, authority_audit_not_run,\nauthority_audit_budget_exceeded), and\nauthority_audit_error (observed detail) in database telemetry. Also\nincludes session-temporal health. Default false.",type:"boolean"},doctor_report:{default:!1,description:"Include the daemon-owned canonical Doctor report and typed per-table\ngrowth evidence. Default false.",type:"boolean"},session_ingest_health:{default:!1,description:"Include Cursor transcript-ingest health from the daemon-retained\nproject session authority. Default false.",type:"boolean"},session_temporal_health:{default:!1,description:"Include session-temporal health without the authority audit. Default\nfalse.",type:"boolean"},startup_health:{default:!1,description:"Ask a connection's first request for only the daemon-mounted database\nintegrity telemetry, for post-update startup validation; the daemon\ncore answers that probe before a project owner exists, and a project\nowner's snapshot already carries the same telemetry. Default false.",type:"boolean"}},title:"RuntimeSurfaceRequestV1",type:"object"},{$defs:{DoctorCoverageCompletenessV1:yk,DoctorCoverageStatementV1:{description:"A bounded, human-readable coverage statement plus its completeness.",properties:{completeness:{$ref:"#/$defs/DoctorCoverageCompletenessV1"},statement:{type:"string"}},required:["completeness","statement"],type:"object"},DoctorEvidenceRefV1:{description:"A typed reference to one piece of evidence Doctor composed into a finding.\n\nThe `family` records which audited input surface produced the evidence, so\na finding may cross-cite evidence from more than one family without losing\nprovenance.",properties:{family:{$ref:"#/$defs/DoctorFindingFamilyV1"},reference:{$ref:"#/$defs/DoctorEvidenceReferenceV1"}},required:["family","reference"],type:"object"},DoctorEvidenceReferenceV1:{description:"Durable, non-disclosing reference to one owning-authority evidence\nrecord (for example a `FeedbackFindingId`, configuration revision, or\nruntime read coverage anchor). Doctor stores the reference only; the\nowning authority remains the single source of the record.",type:"string"},DoctorEvidenceStateV1:{description:"Exact Doctor evidence states.\n\nMissing, partial, or unknown truth never becomes healthy or clean. Only\n[`DoctorEvidenceStateV1::HealthyCompleteCoverage`] asserts a healthy result,\nand only when its finding carries complete coverage (see\n[`DoctorFindingV1::new`]).",oneOf:[{const:"unsupported",description:"The owning authority does not support this evidence on this platform.",type:"string"},{const:"absent",description:"The evidence source is supported but produced nothing.",type:"string"},{const:"stale",description:"The evidence exists but is behind the current generation/watermark.",type:"string"},{const:"degraded",description:"The evidence proves a degraded but observed condition.",type:"string"},{const:"partial",description:"Only part of the evidence was observed.",type:"string"},{const:"unknown",description:"The evidence state could not be determined.",type:"string"},{const:"denied",description:"Authorization to read the evidence was denied.",type:"string"},{const:"healthy_complete_coverage",description:"The evidence proves a healthy condition with complete coverage.",type:"string"}]},DoctorFamilyConsultationV1:{description:"Whether a family was consulted from an observed source or is unavailable.",oneOf:[{description:"A source produced observed evidence for this family.",properties:{status:{const:"consulted",type:"string"}},required:["status"],type:"object"},{description:"Complete family coverage was unavailable. Storage may still carry\nfindings from resolved producers when an independent producer failed.",properties:{reason:{$ref:"#/$defs/DoctorFamilyUnavailableReasonV1"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},DoctorFamilyCoverageV1:{description:"The consultation status of one finding family within a report.",properties:{consultation:{$ref:"#/$defs/DoctorFamilyConsultationV1"},family:{$ref:"#/$defs/DoctorFindingFamilyV1"}},required:["family","consultation"],type:"object"},DoctorFamilyUnavailableReasonV1:{description:"Why complete coverage of a finding family was unavailable.",oneOf:[{const:"unwired",description:"No source port is wired for this family in this composition.",type:"string"},{const:"unsupported",description:"The source is unsupported on this build/platform.",type:"string"},{const:"absent",description:"The source is supported but produced nothing.",type:"string"},{const:"denied",description:"The source read was denied.",type:"string"},{const:"unknown",description:"The source state could not be determined.",type:"string"},{const:"unavailable",description:"The source could not be reached. Named separately from `Unknown`: the\nsource is identified and its unreachability is an observation, not an\nundetermined state.",type:"string"},{const:"reset_required",description:"The source must be rebuilt before it can be read again.",type:"string"},{const:"corrupt",description:"The source was read and found corrupt.",type:"string"}]},DoctorFindingFamilyV1:{description:"Stable Doctor finding families.\n\nThe initial list covers advisory findings from\nBrain, Explorer, Loom, Code, and Observatory, plus the daemon\ncore doctor checks (graph quick-check, temporal health, configuration\ndrift, code-index mount state, session ingest).\nEach family maps to one audited typed input surface. The set is kept small\nand honest; new families are added through a future versioned enum rather\nthan by widening the meaning of an existing variant.",oneOf:[{const:"advisory",description:"advisory/scout findings (GitHub review, CI localization,\nproximity, context scout): `crate::advisory` / domain feedback.",type:"string"},{const:"configuration",description:"Desired-versus-effective configuration and compatibility drift from\n`ProjectConfigurationRuntime` / `ConfigurationControlPlane`.",type:"string"},{const:"storage_runtime",description:"Store, graph, and temporal runtime health plus migration coverage\n(`RuntimeReadOperationV1` health family, `StoreRuntimeClientLease`).",type:"string"},{const:"storage",description:"Storage retention, size, and efficiency over canonical observability\nread models. Distinct from [`Self::StorageRuntime`] health: this\nfamily surfaces over-budget stores, identity-drift orphans, incident\ndebris, and retention backlog. The typed\nsubclass vocabulary is [`DoctorStorageFindingKindV1`].",type:"string"},{const:"language_server",description:"Language-server / analyzer engine status from the LSP gateway's\n`AnalyzerState`.",type:"string"},{const:"code_index",description:"Code index mount state (mounted, indexing, stale, unmounted,\nincompatible, parked).",type:"string"},{const:"observability",description:"Denominator-safe measurement and telemetry health from analytics,\naccounting read models, and session ingest.",type:"string"},{const:"memory",description:"Retained daemon memory as the resident-memory inventory reports it:\nRSS against the admission limit and pressure line, and each retained\nowner's bytes.",type:"string"}]},DoctorFindingV1:{description:"One canonical Doctor finding.\n\nA finding pins its diagnosis `family`, its evidence `state`, the typed\nevidence it composed, and a coverage statement. Construction enforces the\ninvariants that keep unknown/partial evidence from collapsing into a\nhealthy or clean result.",properties:{coverage:{$ref:"#/$defs/DoctorCoverageStatementV1"},evidence:{items:{$ref:"#/$defs/DoctorEvidenceRefV1"},type:"array"},family:{$ref:"#/$defs/DoctorFindingFamilyV1"},state:{$ref:"#/$defs/DoctorEvidenceStateV1"}},required:["family","state","evidence","coverage"],type:"object"},DoctorReportCoverageV1:{description:"The report-wide coverage statement: which families were consulted versus\nunavailable, plus an overall completeness and a bounded human statement.",properties:{completeness:{$ref:"#/$defs/DoctorCoverageCompletenessV1"},families:{items:{$ref:"#/$defs/DoctorFamilyCoverageV1"},type:"array"},statement:{$ref:"#/$defs/DoctorCoverageStatementV1"}},required:["families","completeness","statement"],type:"object"},DoctorReportEntryV1:{description:"One entry in a Doctor report: a canonical finding plus, for the storage\nfamily, its typed subclass. The subclass is present only for storage findings\n(a non-storage entry never carries one).",properties:{finding:{$ref:"#/$defs/DoctorFindingV1"},storage_kind:{anyOf:[{$ref:"#/$defs/DoctorStorageFindingKindV1"},{type:"null"}]}},required:["finding"],type:"object"},DoctorReportV1:{description:"One composed Doctor report.\n\nThe report carries one or more entries per family (findings are never merged\nby label) plus a coverage statement that enumerates every family consulted\nversus unavailable. Severity (the finding's evidence state) and evidence\nquality (coverage completeness) are kept as separate dimensions: a degraded\nfinding with complete coverage does not weaken report completeness, and only\ngenuinely complete coverage with every finding healthy makes the whole report\nassert health.",properties:{coverage:{$ref:"#/$defs/DoctorReportCoverageV1"},entries:{items:{$ref:"#/$defs/DoctorReportEntryV1"},type:"array"}},required:["entries","coverage"],type:"object"},DoctorStorageFindingKindV1:{description:"Typed subclasses of the [`DoctorFindingFamilyV1::Storage`] finding family.\n\nThe storage family never reports a silent overage: each subclass names one\nobservable retention/size condition Doctor surfaces over canonical size\nobservability read models. The set is closed and grows only through a future\nversioned enum, never by widening an existing subclass.",oneOf:[{const:"over_budget_store",description:"A store exceeds its owner-configured soft size budget.",type:"string"},{const:"orphan_store",description:"A store whose project identity no longer resolves to a live repository\nroot (identity-drift orphan), reported with age and size.",type:"string"},{const:"incident_debris_present",description:"Recovery/corruption artifacts are present beside a store and awaiting\ndeletion.",type:"string"},{const:"retention_backlog",description:"Retention-eligible rows or stores are past their window and awaiting\noffload/collection.",type:"string"},{const:"table_growth",description:"Per-table SQLite payload growth observed between two retained\nwatermarks, including baseline and unavailable measurement states.",type:"string"},{const:"schema_convergence_incomplete",description:"A store whose background schema convergence (the authority-invariant\naudit and projection retry re-arming that follow admission) has not\ncompleted: it is still pending, still running, or stopped on a failure.\nThe daemon serves meanwhile, so this is the surface that says which\nstore has not converged and why.",type:"string"},{const:"wal_checkpoint_pinned",description:"A store whose WAL checkpoint cannot restart the log because a reader\nstill holds a read slot past the checkpoint fence: a wedged reader of\nthis daemon or another process, named in the evidence. Writes run\nuntil the WAL reaches its ceiling, then wait.",type:"string"}]},LanguageServerAnalyzerStateV1:{description:"State of one analyzer as the daemon owner holds it.\n\n`Inactive` is the one state the aggregate never takes: the language has no\nfiles in the project, so Doctor does not grade it, but `lsp servers` still\nlists it from this same read so both surfaces share one authority.",enum:["ready","available","refreshing","disabled","unavailable","crashed","inactive"],type:"string"},LanguageServerAnalyzerV1:{description:"Live state of one analyzer the daemon resolved for the current project.\n\n`LanguageServerStateV1` is the aggregate the finding is graded on; this is\nthe per-analyzer evidence behind it, so an operator learns *which*\nexecutable is missing and how to install it, resolved by the daemon\nprocess (the only PATH that matters, since the daemon spawns analyzers)\nrather than by whichever shell ran the CLI.",properties:{command:{description:"The configured executable, after any operator command override.",type:"string"},detail:{description:"The owner's last recorded error for this analyzer, when one exists.",type:["string","null"]},executable_found:{description:"Whether the daemon process finds `command` on its own PATH. For an\nactive analyzer `state` is the finer verdict (a rustup proxy whose\ntoolchain lacks the component is found yet `Unavailable`); for an\ninactive one this is the only availability evidence.",type:"boolean"},install:{description:"The first install command the adapter advertises, when one exists.",type:["string","null"]},language:{description:"Adapter language (`typescript`, `rust`, …).",type:"string"},state:{$ref:"#/$defs/LanguageServerAnalyzerStateV1"}},required:["language","command","state","executable_found"],type:"object"},LanguageServerReadV1:{description:"One live read from the daemon language-server/analyzer owner.",oneOf:[{description:"The owner observed all project-active analyzer states.",properties:{analyzers:{default:[],description:"Every analyzer the owner resolved, active or not; the aggregate\n`state` covers the active ones only.",items:{$ref:"#/$defs/LanguageServerAnalyzerV1"},type:"array"},coverage:{$ref:"#/$defs/DoctorCoverageCompletenessV1"},kind:{const:"observed",type:"string"},state:{$ref:"#/$defs/LanguageServerStateV1"}},required:["kind","state","coverage"],type:"object"},{description:"Language-server inspection is unsupported on this build/platform.",properties:{kind:{const:"unsupported",type:"string"}},required:["kind"],type:"object"},{description:"No project-active analyzer is configured. The owner's inactive\nanalyzers are still carried so `lsp servers` can list them.",properties:{analyzers:{default:[],items:{$ref:"#/$defs/LanguageServerAnalyzerV1"},type:"array"},kind:{const:"absent",type:"string"}},required:["kind"],type:"object"},{description:"Authorization to inspect analyzer state was denied.",properties:{kind:{const:"denied",type:"string"}},required:["kind"],type:"object"},{description:"Analyzer state could not be determined.",properties:{kind:{const:"unknown",type:"string"}},required:["kind"],type:"object"}]},LanguageServerStateV1:{description:"Aggregate state of the project-active language-server analyzers.",oneOf:[{const:"ready",description:"Every active analyzer is ready.",type:"string"},{const:"available",description:"At least one analyzer is installed but has not produced a ready snapshot.",type:"string"},{const:"refreshing",description:"At least one analyzer is currently refreshing/indexing.",type:"string"},{const:"disabled",description:"At least one project analyzer is disabled.",type:"string"},{const:"unavailable",description:"At least one project analyzer executable is unavailable.",type:"string"},{const:"crashed",description:"At least one analyzer process crashed.",type:"string"}]},RuntimeDoctorReportV1:{description:"The daemon's canonical Doctor report as this route could read it.",oneOf:[{additionalProperties:!1,properties:{kind:{const:"observed",type:"string"},language_servers:{$ref:"#/$defs/LanguageServerReadV1"},report:{$ref:"#/$defs/DoctorReportV1"},schema_convergences:{items:{$ref:"#/$defs/SchemaConvergenceFindingV1"},type:"array"},table_growth_evidence:{items:{$ref:"#/$defs/TableGrowthDoctorEvidenceV1"},type:"array"}},required:["kind","report","table_growth_evidence","schema_convergences","language_servers"],type:"object"},{additionalProperties:!1,description:"The reader is mounted and the read failed.",properties:{kind:{const:"unknown",type:"string"},language_servers:{$ref:"#/$defs/LanguageServerReadV1"},schema_convergences:{items:{$ref:"#/$defs/SchemaConvergenceFindingV1"},type:"array"},table_growth_evidence:{items:{$ref:"#/$defs/TableGrowthDoctorEvidenceV1"},type:"array"}},required:["kind","table_growth_evidence","schema_convergences","language_servers"],type:"object"},{additionalProperties:!1,description:"No Doctor reader is mounted on this route.",properties:{kind:{const:"unsupported",type:"string"},language_servers:{$ref:"#/$defs/LanguageServerReadV1"},schema_convergences:{items:{$ref:"#/$defs/SchemaConvergenceFindingV1"},type:"array"},table_growth_evidence:{items:{$ref:"#/$defs/TableGrowthDoctorEvidenceV1"},type:"array"}},required:["kind","table_growth_evidence","schema_convergences","language_servers"],type:"object"}]},SchemaConvergenceFindingV1:vL,SchemaConvergenceStageV1:vU,SchemaConvergenceStateV1:vH,StorageByteSizeV1:{description:"A byte size measurement. A newtype keeps sizes from being confused with\ncounts, ratios, or timestamps in the read models and producers.",format:"uint64",minimum:0,type:"integer"},StoreKeyV1:{description:"Logical name of one owner-profile store (for example `sessions.db`,\n`graph.db`, or `projects/proj_x`). Never an absolute on-disk path.",type:"string"},TableGrowthDoctorEvidenceV1:{description:"Contract-independent evidence ready to wrap in a future `TableGrowth`\nStorage finding once that generated-contract variant is available.",oneOf:[{properties:{current_bytes:{$ref:"#/$defs/StorageByteSizeV1"},current_observed_at:{$ref:"#/$defs/UtcMicros"},growth_bytes:{$ref:"#/$defs/StorageByteSizeV1"},kind:{const:"significant_growth",type:"string"},previous_bytes:{$ref:"#/$defs/StorageByteSizeV1"},previous_observed_at:{$ref:"#/$defs/UtcMicros"},store:{$ref:"#/$defs/StoreKeyV1"},table:{$ref:"#/$defs/TableNameV1"}},required:["kind","store","table","previous_bytes","current_bytes","growth_bytes","previous_observed_at","current_observed_at"],type:"object"},{properties:{kind:{const:"baseline_established",type:"string"},observed_at:{$ref:"#/$defs/UtcMicros"},store:{$ref:"#/$defs/StoreKeyV1"},tables_observed:{format:"uint64",minimum:0,type:"integer"}},required:["kind","store","observed_at","tables_observed"],type:"object"},{properties:{current_bytes:{$ref:"#/$defs/StorageByteSizeV1"},kind:{const:"table_baseline_pending",type:"string"},observed_at:{$ref:"#/$defs/UtcMicros"},store:{$ref:"#/$defs/StoreKeyV1"},table:{$ref:"#/$defs/TableNameV1"}},required:["kind","store","table","current_bytes","observed_at"],type:"object"},{properties:{kind:{const:"unsupported",type:"string"},store:{$ref:"#/$defs/StoreKeyV1"}},required:["kind","store"],type:"object"},{properties:{kind:{const:"denied",type:"string"},store:{$ref:"#/$defs/StoreKeyV1"}},required:["kind","store"],type:"object"},{properties:{kind:{const:"unknown",type:"string"},reason:{$ref:"#/$defs/TableGrowthUnavailableReasonV1"},store:{$ref:"#/$defs/StoreKeyV1"}},required:["kind","store","reason"],type:"object"}]},TableGrowthUnavailableReasonV1:{description:"Why a per-table payload-growth measurement is unavailable.",oneOf:[{const:"not_yet_measured",description:"No maintenance pass has measured this store yet.",type:"string"},{const:"reader_unavailable",description:"No reader could be leased within the measurement's wait.",type:"string"},{const:"deadline_exceeded",description:"The `dbstat` walk was interrupted by its deadline.",type:"string"},{const:"cancelled",description:"The `dbstat` walk was cancelled.",type:"string"},{const:"storage_corrupt",description:"The store reported corruption.",type:"string"},{const:"storage_infrastructure",description:"The store failed with an infrastructure error.",type:"string"},{const:"storage_other",description:"The store failed for another reason.",type:"string"},{const:"invalid_table_name",description:"`dbstat` named a table that is not a valid table identifier.",type:"string"},{const:"clock_regressed",description:"The previous watermark is later than the current measurement.",type:"string"},{const:"exceeds_measurement_budget",description:"The store is larger than the `dbstat` walk can cover within its\ndeadline.",type:"string"}]},TableNameV1:{description:"A physical table name inside a store, used for per-table growth telemetry.",type:"string"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Process, database, and session-observation telemetry for the running\ndaemon, with the sections the request opted into.",properties:{captured_at:{description:"Unix epoch seconds.",format:"uint64",minimum:0,type:"integer"},cursor_session_ingest:!0,cursor_session_placeholder_paths:{items:{type:"string"},type:["array","null"]},database:{description:"Store telemetry, with the authority-audit verdict when it ran."},doctor_report:{anyOf:[{$ref:"#/$defs/RuntimeDoctorReportV1"},{type:"null"}]},host_os:{type:"string"},process:{description:"Cached process sample."},session_temporal_health:!0,tracedecay_version:{type:"string"}},required:["captured_at","tracedecay_version","host_os","process","database"],title:"RuntimeResultV1",type:"object"},{$defs:{SearchLexicalAliasV1:{additionalProperties:!1,description:"One named query-time vocabulary alias.",properties:{alternative:{maxLength:128,type:"string"},strict_query:{maxLength:128,type:"string"}},required:["strict_query","alternative"],type:"object"},SearchLexicalFieldFilterV1:{additionalProperties:!1,properties:{field:{$ref:"#/$defs/SearchLexicalFieldV1"},include:{type:"boolean"}},required:["field","include"],type:"object"},SearchLexicalFieldV1:{description:"A lexical posting field a search may include or exclude.",enum:["symbol_name","qualified_name","path","signature","documentation","body_text","preamble_text","exact_term","subtoken"],type:"string"},SearchLexicalProximityV1:{additionalProperties:!1,description:"Ordered terms that must occur in one field within `maximum_gap`\nintervening tokens of each other.",properties:{maximum_gap:{format:"uint32",maximum:8,minimum:0,type:"integer"},terms:{items:{type:"string"},maxItems:8,minItems:2,type:"array"}},required:["terms","maximum_gap"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{description:"Authenticated opaque continuation returned as next_cursor. Repeat the same query and lexical options with it.",type:["string","null"]},lazy_index_ignored_dependencies:{description:"Opt in to bounded indexing of ignored dependency entry files when an import hint matches (default: false).",type:["boolean","null"]},lexical_aliases:{description:"Named query-time vocabulary aliases. The strict query always ranks first. Alias-only hits follow it with the strict query, alternative, and configured-vocabulary reason disclosed.",items:{$ref:"#/$defs/SearchLexicalAliasV1"},maxItems:8,type:["array","null"]},lexical_anchors:{description:"Exact identifiers or technical terms (e.g. 'reserve_stock', 'Foo::bar', 'E0308') that the answer must be about. Each is ranked through the lexical lane as its own route: a hit carrying an anchor outranks every hit that carries none, exact hits included, every anchor with matches keeps at least its best sites through the lane cap, and `lexical_anchors` in the response reports each anchor's outcome (`matched` rows, `admitted` sites this response returns, `dropped` admitted sites it could not carry with the reason, `unmatched`, or `not_served`). Ranked retrieval, not exhaustive grep (use tracedecay_grep for that). Each result names the routes that ranked it. At most 8 anchors, each one whitespace-free term of at most 128 bytes, no repeats.",items:{type:"string"},maxItems:8,type:["array","null"]},lexical_field_filters:{description:"Include or exclude lexical symbol_name, qualified_name, path, signature, documentation, body_text, preamble_text, exact_term, or subtoken fields.",items:{$ref:"#/$defs/SearchLexicalFieldFilterV1"},maxItems:9,type:["array","null"]},lexical_phrases:{description:"Exact lexical phrases to rank through n-gram candidate pruning.",items:{type:"string"},maxItems:4,type:["array","null"]},lexical_proximities:{description:"Ordered lexical terms that must occur within the bounded intervening-token gap.",items:{$ref:"#/$defs/SearchLexicalProximityV1"},maxItems:4,type:["array","null"]},limit:{description:"Maximum number of results to return (default: 10)",format:"uint64",minimum:0,type:["integer","null"]},prefer_symbol:{description:"Add a lexical route restricted to symbol-name matches for the identifier-shaped words of the query. Omitted, it runs when the query is name-shaped (at least half its content words are identifiers such as 'getUserById' or 'Foo::bar'); true forces it, false suppresses it. `query_route` in the response reports the decision and its margin. Query words such as class/struct/function/find/explain are ignored; 'Foo::bar' and 'Foo.bar' contribute 'bar'.",type:["boolean","null"]},query:{description:"Search query string to match against symbol names",type:"string"}},required:["query"],title:"SearchSurfaceRequestV1",type:"object"},{$defs:{ApplicationProblemDetailV1:fA,CalibrationProfileId:hi,CandidateContribution:hs,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComponentRevision:hj,ContextLexicalAnchorV1:hF,DaemonServiceUnitObservationV1:y_,DiagnosticsSearchedTsconfigV1:yS,EvidenceRole:yC,ExactClass:yT,FileOccurrenceId:gs,FixedPointScore:gc,FreshnessCompatibilityV1:gl,FusedCandidate:gp,LexicalAnchorDropReasonV1:_e,LexicalAnchorDropV1:_t,LogicalCopyClusterId:_i,LogicalEvidenceId:_o,OccurrenceProvenance:_z,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveLaneCompleteV1:_J,PrimitiveRecallV1:_Q,PrimitiveSearchFreshnessV1:_X,PrimitiveUnavailableEvidenceV1:_0,PrimitiveUnavailableStatusV1:_2,RankingDecision:vp,RankingDecisionKind:vu,RepositoryId:vb,RetrievalAnchorId:vI,RetrievalSourceRoleV1:vC,RetrieverKind:vO,ScoreDomainId:v2,SearchCompleteV1:{additionalProperties:!1,properties:{code_generation:{type:"string"},coverage:{$ref:"#/$defs/SearchCoverageV1"},external_import_hint:{anyOf:[{$ref:"#/$defs/SearchExternalImportHintV1"},{type:"null"}]},freshness:{$ref:"#/$defs/PrimitiveSearchFreshnessV1",description:"Freshness of the served code generation, derived from the typed lane\ncoverage and the daemon scheduler's worktree state."},lexical_anchors:{description:"Outcome of every caller `lexical_anchors` entry, beside the routes.",items:{$ref:"#/$defs/ContextLexicalAnchorV1"},type:["array","null"]},lexical_routes:{description:"Every lexical route fused into this page; present only when a route\nbeyond the strict query ran or ranked a result.",items:{$ref:"#/$defs/SearchLexicalRouteV1"},type:["array","null"]},next_cursor:{description:"Authenticated continuation for the next page; null on the last page.",type:["string","null"]},query_fallback_digest:{type:"string"},query_route:{anyOf:[{$ref:"#/$defs/SearchQueryRouteV1"},{type:"null"}],description:"Which lane the query's shape selected, and its margin."},results:{items:{$ref:"#/$defs/SearchResultRowV1"},type:"array"},scope_prefix:{description:"The session's scope prefix. Ranked candidates carry no file path, so\nthe scope is reported and not applied.",type:["string","null"]},scope_prefix_applied:{type:["boolean","null"]},verified_graph_evidence:{anyOf:[{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"},{type:"null"}]}},required:["freshness","code_generation","query_fallback_digest","coverage","results"],type:"object"},SearchCoverageV1:{additionalProperties:!1,description:"Per-lane recall of one search, so a full-recall answer is told apart from\none produced while a lane was down.",properties:{exact:{$ref:"#/$defs/SearchLaneStatusV1"},graph:{$ref:"#/$defs/SearchLaneStatusV1"},lexical:{$ref:"#/$defs/SearchLaneStatusV1"},recall:{$ref:"#/$defs/PrimitiveRecallV1"}},required:["exact","lexical","graph","recall"],type:"object"},SearchDisplayUnavailableV1:{description:"Why a ranked candidate's display metadata was not hydrated: the answering\ngeneration no longer matches the request (`stale`), its record is\nincompatible or does not bind the candidate (`incompatible`, `invalid`),\nthe read failed (`internal`), the hydration budget was spent\n(`budget_exceeded`), or the request was cancelled (`cancelled`).",enum:["stale","incompatible","invalid","internal","budget_exceeded","cancelled"],type:"string"},SearchExternalImportCandidatesV1:{additionalProperties:!1,properties:{candidates:{items:{$ref:"#/$defs/SearchExternalImportV1"},type:"array"},evidence:{type:"string"},message:{type:"string"},resolution_status:{type:"string"},suggested_action:{type:"string"}},required:["message","evidence","resolution_status","candidates","suggested_action"],type:"object"},SearchExternalImportHintV1:{anyOf:[{$ref:"#/$defs/SearchExternalImportCandidatesV1"},{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"}],description:"Advisory evidence that a sparse search matched external-module imports,\nor why that evidence could not be read."},SearchExternalImportV1:{additionalProperties:!1,properties:{import_file:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},module:{type:"string"},symbol:{description:"The imported name; null for a whole-module import.",type:["string","null"]}},required:["module","import_file","line"],type:"object"},SearchLaneStateV1:{description:"A lane that did not serve the current complete generation. A partial\nlane names its generation and reason when it has them, null otherwise.",oneOf:[{additionalProperties:!1,properties:{generation:{type:"string"},status:{const:"stale",type:"string"}},required:["status","generation"],type:"object"},{additionalProperties:!1,properties:{generation:{type:["string","null"]},reason:{type:["string","null"]},status:{const:"partial",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{reason:{type:"string"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},SearchLaneStatusV1:{anyOf:[{$ref:"#/$defs/PrimitiveLaneCompleteV1"},{$ref:"#/$defs/SearchLaneStateV1"}]},SearchLexicalAlternativeReasonV1:{description:"Why the lexical lane tried a configured alternative.",enum:["configured_vocabulary_alias"],type:"string"},SearchLexicalRouteV1:{description:"One lexical route fused into the page, with its display label.",oneOf:[{additionalProperties:!1,description:"The caller's strict lexical query.",properties:{label:{type:"string"},route:{const:"query",type:"string"}},required:["route","label"],type:"object"},{additionalProperties:!1,description:"One caller-supplied exact identifier or term.",properties:{anchor:{type:"string"},label:{type:"string"},route:{const:"anchor",type:"string"}},required:["route","anchor","label"],type:"object"},{additionalProperties:!1,description:"Identifier-shaped tokens of the query, restricted to symbol names.",properties:{label:{type:"string"},route:{const:"preferred_symbol",type:"string"},tokens:{items:{type:"string"},type:"array"}},required:["route","tokens","label"],type:"object"},{additionalProperties:!1,description:"Identifier and path components recovered from the strict query.",properties:{label:{type:"string"},route:{const:"identifier_split",type:"string"},strict_query:{type:"string"},terms:{items:{type:"string"},type:"array"}},required:["route","strict_query","terms","label"],type:"object"},{additionalProperties:!1,description:"A configured query-time vocabulary alternative.",properties:{alternative:{type:"string"},label:{type:"string"},reason:{$ref:"#/$defs/SearchLexicalAlternativeReasonV1"},route:{const:"alias",type:"string"},strict_query:{type:"string"}},required:["route","strict_query","alternative","reason","label"],type:"object"}]},SearchQueryRouteDeciderV1:{description:"Who chose the query route: the query-shape gate or the caller's\n`prefer_symbol`.",enum:["query_shape","caller"],type:"string"},SearchQueryRouteKindV1:{description:"Which lexical lane the query's shape selected.",oneOf:[{const:"name",description:"The symbol-name route ran beside the strict query.",type:"string"},{const:"prose",description:"The strict query ran without the symbol-name route.",type:"string"}]},SearchQueryRouteV1:{additionalProperties:!1,description:"The query-shape routing decision behind a page.",properties:{decided_by:{$ref:"#/$defs/SearchQueryRouteDeciderV1"},margin:{description:"Distance from the name gate in [-0.5, 0.5]: the share of the query's\ncontent words that are identifier-shaped, minus one half. The gate\nselects `name` at or above 0. Reported when the caller decided too.\nIt describes query shape only and is not an answerability signal.",format:"double",type:"number"},route:{$ref:"#/$defs/SearchQueryRouteKindV1"}},required:["route","margin","decided_by"],type:"object"},SearchResultDisplayV1:{additionalProperties:!1,properties:{kind:{type:"string"},name:{type:"string"},path:{type:"string"},qualified_name:{type:"string"}},required:["name","qualified_name","kind","path"],type:"object"},SearchResultRowV1:{additionalProperties:!1,description:"One ranked candidate with its generation-bound display metadata.",properties:{candidate:{$ref:"#/$defs/FusedCandidate"},display:{anyOf:[{$ref:"#/$defs/SearchResultDisplayV1"},{type:"null"}]},display_unavailable:{anyOf:[{$ref:"#/$defs/SearchDisplayUnavailableV1"},{type:"null"}],description:"Why `display` is absent from this ranked candidate."},final_ordinal:{format:"uint32",minimum:0,type:"integer"},lexical_routes:{description:"The lexical routes that ranked this candidate.",items:{$ref:"#/$defs/SearchRouteMatchV1"},type:["array","null"]},node_id:{description:"The graph symbol to read with `tracedecay_source_body`.",type:["string","null"]}},required:["candidate","final_ordinal"],type:"object"},SearchRouteMatchV1:{additionalProperties:!1,description:"One route that ranked a candidate, named by its route label.",properties:{matched_terms:{items:{type:"string"},type:"array"},route:{type:"string"},score_micros:{format:"uint64",minimum:0,type:"integer"},spelling_variants:{items:{$ref:"#/$defs/SearchSpellingVariantV1"},type:"array"}},required:["route","score_micros","matched_terms"],type:"object"},SearchSpellingVariantV1:{additionalProperties:!1,properties:{alternative:{type:"string"},query:{type:"string"}},required:["query","alternative"],type:"object"},SearchUnavailableV1:{additionalProperties:!1,properties:{code_generation:{type:["string","null"]},coverage:{$ref:"#/$defs/SearchCoverageV1"},detail:{anyOf:[{$ref:"#/$defs/ApplicationProblemDetailV1"},{type:"null"}],description:"Present when indexing is parked: its cause, remedy, and wake retry."},freshness:{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},query_fallback_digest:{description:"Always null: no fallback subpayload was produced.",type:["string","null"]},reason:{type:"string"},results:{description:"Always empty: no generation answered.",items:{$ref:"#/$defs/SearchResultRowV1"},type:"array"},status:{$ref:"#/$defs/PrimitiveUnavailableStatusV1"},verified_graph_evidence:{anyOf:[{$ref:"#/$defs/PrimitiveUnavailableEvidenceV1"},{type:"null"}]}},required:["freshness","results","status","reason","coverage"],type:"object"},SessionOrThreadId:v7,SourceFreshness:by,SourceInstanceKey:bg,SourceNamespace:bv,SourceOccurrenceId:bb,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/SearchCompleteV1"},{$ref:"#/$defs/SearchUnavailableV1"}],description:"What a search served: a ranked page, or the typed reason no generation\ncould answer.",title:"SearchResultV1"},{$defs:{PageRequest:_U,ResultProjection:vP,RetrievalOrder:vx,RetrievalRequestMeta:vj,SessionId:v8,TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{meta:{$ref:"#/$defs/RetrievalRequestMeta"},session_id:{$ref:"#/$defs/SessionId"}},required:["session_id","meta"],title:"SessionLookupRequest",type:"object"},{$defs:{RetrievalAnchorId:vI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"}},required:["anchors"],title:"SessionLookupResult",type:"object"},{$defs:{SessionRefreshFrontierV1:{additionalProperties:!1,properties:{committed_through:{format:"uint64",minimum:0,type:"integer"},observed_through:{format:"uint64",minimum:0,type:"integer"}},required:["observed_through","committed_through"],type:"object"},SessionRefreshGrainV1:{enum:["occurrence","logical_message","turn","session","thread","agent","summary"],type:"string"},SessionRefreshScopeV1:{description:"Session-store owner one refresh is bound to.\n\nThe caller selects the already-mounted project or profile authority. Exact\nprofile, project, repository, worktree, branch, store, and root identities\nstay daemon-owned and are resolved from that authority during admission.",oneOf:[{additionalProperties:!1,properties:{kind:{const:"project",type:"string"}},required:["kind"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"profile",type:"string"}},required:["kind"],type:"object"}]},SessionRefreshSessionV1:{additionalProperties:!1,properties:{id:{type:"string"}},required:["id"],type:"object"},SessionRefreshSourceV1:{additionalProperties:!1,properties:{scope:{type:"string"}},required:["scope"],type:"object"},SessionRefreshTargetV1:{additionalProperties:!1,properties:{frontier:{$ref:"#/$defs/SessionRefreshFrontierV1"},grain:{$ref:"#/$defs/SessionRefreshGrainV1"},temporal_mode:{$ref:"#/$defs/TemporalModeV1"}},required:["temporal_mode","grain","frontier"],type:"object"},TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact route-selected session-refresh request body.\n\nEach current route selects the action itself; `scope` selects the mounted\nsession-store owner. Project-scoped requests are served under project-open\nadmission, profile-scoped requests by the authenticated profile authority.",properties:{handle:{type:["string","null"]},scope:{$ref:"#/$defs/SessionRefreshScopeV1"},session:{$ref:"#/$defs/SessionRefreshSessionV1"},source:{$ref:"#/$defs/SessionRefreshSourceV1"},target:{$ref:"#/$defs/SessionRefreshTargetV1"}},required:["scope","session","source","target"],title:"SessionRefreshActionRequestV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionRefreshFrontierResultV1:be,SessionRefreshProgressV1:bt,SessionRefreshReceiptV1:br,SessionRefreshTerminalStateResultV1:bi,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalModeV1:bW,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{accepted_at:{format:"int64",type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},handle:{type:["string","null"]},operation_id:{type:["string","null"]},outcome:{$ref:"#/$defs/RetainedOutcomeStatusV1"},progress:{anyOf:[{$ref:"#/$defs/SessionRefreshProgressV1"},{type:"null"}]},receipt:{anyOf:[{$ref:"#/$defs/SessionRefreshReceiptV1"},{type:"null"}]},scope:{type:"string"},tool:{type:"string"}},required:["outcome","scope","tool"],title:"SessionRefreshBeginResultV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionRefreshFrontierResultV1:be,SessionRefreshProgressV1:bt,SessionRefreshReceiptV1:br,SessionRefreshTerminalStateResultV1:bi,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalModeV1:bW,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{accepted_at:{format:"int64",type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},handle:{type:["string","null"]},operation_id:{type:["string","null"]},outcome:{$ref:"#/$defs/RetainedOutcomeStatusV1"},progress:{anyOf:[{$ref:"#/$defs/SessionRefreshProgressV1"},{type:"null"}]},receipt:{anyOf:[{$ref:"#/$defs/SessionRefreshReceiptV1"},{type:"null"}]},scope:{type:"string"},tool:{type:"string"}},required:["outcome","scope","tool"],title:"SessionRefreshCancelResultV1",type:"object"},{$defs:{ClosedUtcIntervalV1:hm,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,SessionCoverageIntervalV1:v6,SessionCoverageReasonV1:v3,SessionCoverageRequestV1:v9,SessionCoverageStateV1:v5,SessionRefreshFrontierResultV1:be,SessionRefreshProgressV1:bt,SessionRefreshReceiptV1:br,SessionRefreshTerminalStateResultV1:bi,SessionSourceCoverageV1:bn,TemporalCoverageV1:bO,TemporalModeV1:bW,UtcMicros:bZ,ValidCoverageIntervalV1:bQ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},outcome:{$ref:"#/$defs/RetainedOutcomeStatusV1"},progress:{anyOf:[{$ref:"#/$defs/SessionRefreshProgressV1"},{type:"null"}]},receipt:{anyOf:[{$ref:"#/$defs/SessionRefreshReceiptV1"},{type:"null"}]},scope:{type:"string"},tool:{type:"string"}},required:["outcome","scope","tool"],title:"SessionRefreshStatusResultV1",type:"object"},{$defs:{RetainedTimeFilterV1:vq,SessionGitRefV1:{enum:["branch","worktree","commit"],type:"string"},SessionGitRelationV1:{enum:["produced","observed","all"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{git_ref:{$ref:"#/$defs/SessionGitRefV1"},limit:{format:"uint64",minimum:0,type:["integer","null"]},relation:{anyOf:[{$ref:"#/$defs/SessionGitRelationV1"},{type:"null"}]},since:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},until:{anyOf:[{$ref:"#/$defs/RetainedTimeFilterV1"},{type:"null"}]},value:{type:"string"}},required:["git_ref","value"],title:"SessionsForRequestV1",type:"object"},{$defs:{CorrelationIndexCountModeV1:{enum:["presence_only"],type:"string"},CorrelationIndexV1:{additionalProperties:!1,properties:{backfill_watermark:{format:"int64",type:["integer","null"]},commit_count:{format:"uint64",minimum:0,type:["integer","null"]},commits_present:{type:"boolean"},count_mode:{$ref:"#/$defs/CorrelationIndexCountModeV1"},generation:{type:["string","null"]},projection_available:{type:"boolean"},source_watermark:{type:["string","null"]},span_count:{format:"uint64",minimum:0,type:["integer","null"]},spans_present:{type:"boolean"}},required:["projection_available","spans_present","commits_present","count_mode"],type:"object"},RetainedOutcomeStatusV1:vR,SessionCorrelationHitV1:{additionalProperties:!1,properties:{branch:{type:["string","null"]},commit_sha:{type:["string","null"]},committed_at:{format:"int64",type:["integer","null"]},confidence:{format:"int64",type:["integer","null"]},event_count:{format:"int64",type:"integer"},evidence:{type:["string","null"]},evidence_message_id:{type:["string","null"]},first_ts:{format:"int64",type:["integer","null"]},last_ts:{format:"int64",type:["integer","null"]},provider:{type:"string"},relation:{type:["string","null"]},session_id:{type:"string"},sources:{items:{type:"string"},type:"array"},span_count:{format:"int64",type:"integer"},span_overlap_kind:{type:["string","null"]},worktree:{type:["string","null"]}},required:["provider","session_id","event_count","span_count","sources"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:"integer"},git_ref:{type:["string","null"]},index:{anyOf:[{$ref:"#/$defs/CorrelationIndexV1"},{type:"null"}]},index_empty:{type:["boolean","null"]},message:{type:["string","null"]},observed_count:{format:"uint",minimum:0,type:["integer","null"]},observed_sessions:{items:{$ref:"#/$defs/SessionCorrelationHitV1"},type:["array","null"]},problem_code:{type:["string","null"]},relation:{type:["string","null"]},results:{items:{$ref:"#/$defs/SessionCorrelationHitV1"},type:"array"},since:{format:"int64",type:["integer","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"},until:{format:"int64",type:["integer","null"]},value:{type:["string","null"]}},required:["count","results","status"],title:"SessionsForResultV1",type:"object"},{$defs:{NodeExpansionCostV1:_A,SymbolSignatureV1:{additionalProperties:!1,properties:{cost_to_expand:{$ref:"#/$defs/NodeExpansionCostV1"},docstring:{type:["string","null"]},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},is_async:{type:"boolean"},kind:{type:"string"},name:{type:"string"},node_id:{type:"string"},qualified_name:{type:"string"},signature:{type:["string","null"]},start_line:{format:"uint32",minimum:0,type:"integer"},unavailable_fields:{items:{type:"string"},type:"array"},visibility:{type:"string"}},required:["node_id","name","qualified_name","kind","visibility","is_async","file","start_line","end_line","cost_to_expand","unavailable_fields"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",items:{$ref:"#/$defs/SymbolSignatureV1"},title:"Array_of_SymbolSignatureV1",type:"array"},{$defs:{ProjectId:_4,RepositoryId:vb,SimilarMatchClassV1:bc,SimilarTargetV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"symbol_occurrence",type:"string"},symbol_occurrence_id:{$ref:"#/$defs/SymbolOccurrenceId"}},required:["kind","symbol_occurrence_id"],type:"object"},{additionalProperties:!1,properties:{kind:{const:"source_range",type:"string"},path:{type:"string"},span:{$ref:"#/$defs/SourceSpan"}},required:["kind","path","span"],type:"object"}]},SourceSpan:b$,SymbolOccurrenceId:bq},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{type:["string","null"]},match_classes:{items:{$ref:"#/$defs/SimilarMatchClassV1"},type:"array"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},result_limit:{description:"Preferred result page size.",format:"uint32",minimum:0,type:"integer"},target:{$ref:"#/$defs/SimilarTargetV1"},work_limit:{format:"uint32",minimum:0,type:"integer"}},required:["project_id","repository_id","target","match_classes","result_limit","work_limit"],title:"SimilarSurfaceRequestV1",type:"object"},{$defs:{CodeGenerationId:hy,CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ManifestDigest:_l,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,ProjectId:_4,RepositoryId:vb,SimilarCoverageV1:{oneOf:[{additionalProperties:!1,properties:{status:{const:"complete",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{status:{const:"partial",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,properties:{minimum_tokens:{format:"uint32",minimum:0,type:"integer"},status:{const:"excluded_too_small",type:"string"}},required:["status","minimum_tokens"],type:"object"},{additionalProperties:!1,properties:{maximum_bytes:{format:"uint64",minimum:0,type:"integer"},maximum_tokens:{format:"uint32",minimum:0,type:"integer"},status:{const:"excluded_too_large",type:"string"}},required:["status","maximum_tokens","maximum_bytes"],type:"object"},{additionalProperties:!1,properties:{status:{const:"excluded_incomplete_tokenization",type:"string"}},required:["status"],type:"object"}]},SimilarFamilyV1:bd,SimilarMatchClassV1:bc,SimilarOccurrenceV1:bl,SourceSpan:b$,SymbolOccurrenceId:bq,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/SimilarCoverageV1"},families:{items:{$ref:"#/$defs/SimilarFamilyV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},source:{$ref:"#/$defs/SimilarOccurrenceV1"},source_generation:{$ref:"#/$defs/CodeGenerationId"}},required:["source","families","source_generation","coverage"],title:"SimilarResultV1",type:"object"},{$defs:{ManagedSkillState:_c},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_body:{default:!1,description:"If true, include each skill's body_markdown in the list response\n(default: false).",type:"boolean"},state:{anyOf:[{$ref:"#/$defs/ManagedSkillState"},{type:"null"}],description:"Optional managed-skill lifecycle state filter."}},title:"SkillListSurfaceRequestV1",type:"object"},{$defs:{AutomationReadStatusV1:fH,ManagedSkillMaterializationScope:_n,ManagedSkillMetadata:_a,ManagedSkillProvenance:_s,ManagedSkillSource:_d,ManagedSkillState:_c,SkillImprovementRecommendation:bp,SkillInstallTarget:bu,SkillListEntryV1:{additionalProperties:!1,properties:{body_markdown:{description:"Present only when the request asked for bodies.",type:["string","null"]},improvement_recommendation:{anyOf:[{$ref:"#/$defs/SkillImprovementRecommendation"},{type:"null"}]},metadata:{$ref:"#/$defs/ManagedSkillMetadata"},stale_recommendation:{anyOf:[{$ref:"#/$defs/SkillStaleRecommendation"},{type:"null"}]},support_file_count:{format:"uint",minimum:0,type:"integer"},support_file_paths:{items:{type:"string"},type:"array"},usage_summary:{$ref:"#/$defs/SkillUsageRecord"}},required:["metadata","support_file_count","support_file_paths","usage_summary"],type:"object"},SkillStaleRecommendation:bm,SkillUsageRecord:bf},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{count:{format:"uint",minimum:0,type:"integer"},profile_root:{type:"string"},skills:{items:{$ref:"#/$defs/SkillListEntryV1"},type:"array"},status:{$ref:"#/$defs/AutomationReadStatusV1"}},required:["status","profile_root","count","skills"],title:"SkillListResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{id:{description:"Managed skill id to read.",type:"string"},include_support_files:{default:!1,description:"Include support-file byte payloads. Default false; the response still\nlists each path and byte length.",type:"boolean"}},required:["id"],title:"SkillViewSurfaceRequestV1",type:"object"},{$defs:{AutomationReadStatusV1:fH,ManagedSkill:{properties:{body_markdown:{type:"string"},metadata:{$ref:"#/$defs/ManagedSkillMetadata"},support_files:{items:{$ref:"#/$defs/ManagedSupportFile"},type:"array"}},required:["metadata","body_markdown","support_files"],type:"object"},ManagedSkillMaterializationScope:_n,ManagedSkillMetadata:_a,ManagedSkillProvenance:_s,ManagedSkillSource:_d,ManagedSkillState:_c,ManagedSupportFile:{properties:{bytes:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},type:"array"},path:{type:"string"}},required:["path","bytes"],type:"object"},SkillImprovementRecommendation:bp,SkillInstallTarget:bu,SkillStaleRecommendation:bm,SkillSupportFileSummaryV1:{additionalProperties:!1,properties:{byte_len:{format:"uint",minimum:0,type:"integer"},path:{type:"string"}},required:["path","byte_len"],type:"object"},SkillUsageRecord:bf},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{improvement_recommendation:{anyOf:[{$ref:"#/$defs/SkillImprovementRecommendation"},{type:"null"}]},profile_root:{type:"string"},skill:{$ref:"#/$defs/ManagedSkill",description:"The skill package; `support_files` is empty unless the request\nincluded them."},stale_recommendation:{anyOf:[{$ref:"#/$defs/SkillStaleRecommendation"},{type:"null"}]},status:{$ref:"#/$defs/AutomationReadStatusV1"},support_file_summaries:{items:{$ref:"#/$defs/SkillSupportFileSummaryV1"},type:"array"},support_files_included:{type:"boolean"},usage_summary:{$ref:"#/$defs/SkillUsageRecord"}},required:["status","profile_root","skill","usage_summary","support_files_included","support_file_summaries"],title:"SkillViewResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{node_id:{type:"string"}},required:["node_id"],title:"SourceBodyPrimitiveRequest",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{body:{type:"string"},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},node_id:{type:"string"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["node_id","file","start_line","end_line","body"],title:"SourceBodyPrimitiveResult",type:"object"},{$defs:{ManifestDigest:_l,UseCaseId:bK},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",oneOf:[{additionalProperties:!1,description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",properties:{attempt_idempotency_key:{type:"string"},confirm:{default:!1,type:"boolean"},disposition:{const:"inspect",type:"string"},effect_id:{type:"string"},idempotency_key:{type:"string"},input_digest:{type:"string"},original_operation:{$ref:"#/$defs/UseCaseId"}},required:["original_operation","effect_id","idempotency_key","attempt_idempotency_key","input_digest","disposition"],type:"object"},{additionalProperties:!1,description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",properties:{attempt_idempotency_key:{type:"string"},committed_state:{$ref:"#/$defs/ManifestDigest"},confirm:{default:!1,type:"boolean"},disposition:{const:"confirm_committed",type:"string"},effect_id:{type:"string"},idempotency_key:{type:"string"},input_digest:{type:"string"},original_operation:{$ref:"#/$defs/UseCaseId"}},required:["original_operation","effect_id","idempotency_key","attempt_idempotency_key","input_digest","disposition","committed_state"],type:"object"},{additionalProperties:!1,description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",properties:{attempt_idempotency_key:{type:"string"},confirm:{default:!1,type:"boolean"},disposition:{const:"confirm_unchanged",type:"string"},effect_id:{type:"string"},idempotency_key:{type:"string"},input_digest:{type:"string"},original_operation:{$ref:"#/$defs/UseCaseId"}},required:["original_operation","effect_id","idempotency_key","attempt_idempotency_key","input_digest","disposition"],type:"object"},{additionalProperties:!1,description:"Exact public input accepted by `tracedecay_source_edit_reconcile`.",properties:{attempt_idempotency_key:{type:"string"},confirm:{default:!1,type:"boolean"},disposition:{const:"acknowledge_partial",type:"string"},effect_id:{type:"string"},idempotency_key:{type:"string"},input_digest:{type:"string"},observed_state:{$ref:"#/$defs/ManifestDigest"},original_operation:{$ref:"#/$defs/UseCaseId"}},required:["original_operation","effect_id","idempotency_key","attempt_idempotency_key","input_digest","disposition","observed_state"],type:"object"}],title:"SourceEditReconcileSurfaceRequestV1",type:"object"},{$defs:{FileOccurrenceId:gs,GitOidV1:gq,PageRequest:_U,ResultProjection:vP,RetrievalOrder:vx,RetrievalRequestMeta:vj,SourceSpan:b$,TemporalModeV1:bW,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{additionalProperties:!1,description:"Read an exact byte span from the current indexed file occurrence.",properties:{file:{$ref:"#/$defs/FileOccurrenceId",description:"Canonical file occurrence from `code_exact_occurrence` at\n`items[].occurrence.file`; a logical path is not a file occurrence identity."},meta:{$ref:"#/$defs/RetrievalRequestMeta"},span:{$ref:"#/$defs/SourceSpan"}},required:["file","span","meta"],type:"object"},{additionalProperties:!1,description:"Read a bounded range of whole lines from an immutable Git revision.",properties:{end_line:{description:"One-based last line, inclusive. Large ranges are clipped with `next_line`.",format:"uint32",minimum:0,type:"integer"},file:{description:"Canonical repository-relative path in that revision.",type:"string"},revision:{$ref:"#/$defs/GitOidV1",description:"Full lowercase commit OID; mutable names and abbreviations are refused."},start_line:{description:"One-based first line, inclusive.",format:"uint32",minimum:0,type:"integer"}},required:["revision","file","start_line","end_line"],type:"object"}],title:"SourceLinesRequest"},{$defs:{GitOidV1:gq,RetrievalAnchorId:vI,SourceReference:{additionalProperties:!1,properties:{anchor:{$ref:"#/$defs/RetrievalAnchorId"},span:{$ref:"#/$defs/SourceSpan"}},required:["anchor","span"],type:"object"},SourceSpan:b$},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{additionalProperties:!1,properties:{body:{type:["string","null"]},file:{type:["string","null"]},references:{items:{$ref:"#/$defs/SourceReference"},type:"array"}},required:["references"],type:"object"},{additionalProperties:!1,properties:{blob_oid:{$ref:"#/$defs/GitOidV1"},body:{type:"string"},end_line:{format:"uint32",minimum:0,type:"integer"},file:{type:"string"},next_line:{description:"First unread line within the requested range. Keep the original\nrevision, file, and requested end line when continuing.",format:"uint32",minimum:0,type:["integer","null"]},revision:{$ref:"#/$defs/GitOidV1"},span:{$ref:"#/$defs/SourceSpan"},start_line:{format:"uint32",minimum:0,type:"integer"}},required:["file","revision","blob_oid","start_line","end_line","span","body"],type:"object"}],title:"SourceLinesResult"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{file:{type:"string"}},required:["file"],title:"SourceOutlinePrimitiveRequest",type:"object"},{$defs:{SymbolPrimitiveRecord:bI},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{file:{type:"string"},symbols:{items:{$ref:"#/$defs/SymbolPrimitiveRecord"},type:"array"}},required:["file","symbols"],title:"SourceOutlinePrimitiveResult",type:"object"},{$defs:{BranchStackEdgeV1:f3,BranchStackId:f9,BranchStackNodeV1:f5,BranchStackRevisionId:f8,CommitId:hq,ManifestDigest:_l,NativeIntegrationDirectionV1:_R,NativeIntegrationSelectionDeclarationV1:{description:"Explicit caller declaration for one native-integration selection.\n\nDeclared stacks contain the visible nodes and edges, while the daemon\nderives canonical order and the revision digest through the domain\nconstructor. Callers cannot submit either derived field.",oneOf:[{additionalProperties:!1,properties:{binding:{additionalProperties:!1,properties:{destination_node_id:{$ref:"#/$defs/StackNodeId"},direction:{$ref:"#/$defs/NativeIntegrationDirectionV1"},edges:{items:{$ref:"#/$defs/BranchStackEdgeV1"},type:"array"},nodes:{items:{$ref:"#/$defs/BranchStackNodeV1"},type:"array"},revision_id:{$ref:"#/$defs/BranchStackRevisionId"},source_node_id:{$ref:"#/$defs/StackNodeId"},stack_id:{$ref:"#/$defs/BranchStackId"}},required:["stack_id","revision_id","nodes","edges","source_node_id","destination_node_id","direction"],type:"object"},kind:{const:"declared_stack_edge",type:"string"}},required:["kind","binding"],type:"object"},{additionalProperties:!1,properties:{binding:{additionalProperties:!1,properties:{destination_ref:{$ref:"#/$defs/RefId"},proposal_digest:{$ref:"#/$defs/ManifestDigest"},source_ref:{$ref:"#/$defs/RefId"}},required:["proposal_digest","source_ref","destination_ref"],type:"object"},kind:{const:"independent_branch",type:"string"}},required:["kind","binding"],type:"object"}]},ProjectId:_4,RefId:vm,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,StackNodeId:bw,WorktreeId:SB,WorktreeInventoryEpoch:SK,WorktreeInventorySnapshotId:SJ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact caller-supplied identity frozen by `stack_snapshot`.\n\nThis proof binds the exact authorized `ProjectId`, `RepositoryId`, source\nand destination worktree/ref identity, frozen inventory, scope/grant/policy\nrevisions, and one declared-edge or independent-branch selection. Paths,\nfree-form SHA values, branch display names, and provider topology remain\nunrepresentable.",properties:{authorized_scope_set_digest:{$ref:"#/$defs/ManifestDigest"},authorized_scope_set_id:{$ref:"#/$defs/ScopeSetId"},authorized_scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},destination:{$ref:"#/$defs/ResolvedScope"},grant_digest:{$ref:"#/$defs/ManifestDigest"},inventory_epoch:{$ref:"#/$defs/WorktreeInventoryEpoch"},inventory_snapshot_id:{$ref:"#/$defs/WorktreeInventorySnapshotId"},policy_digest:{$ref:"#/$defs/ManifestDigest"},selection:{$ref:"#/$defs/NativeIntegrationSelectionDeclarationV1"},source:{$ref:"#/$defs/ResolvedScope"}},required:["source","destination","authorized_scope_set_id","authorized_scope_set_revision","authorized_scope_set_digest","inventory_snapshot_id","inventory_epoch","selection","grant_digest","policy_digest"],title:"NativeIntegrationStackSnapshotSurfaceRequest",type:"object"},{$defs:{CodeIndexReadinessTargetV1:{description:"The readiness a status caller can wait for.",oneOf:[{const:"fresh",description:"A sealed complete generation serves exact and lexical reads for the\ncurrent source: `code_index_freshness.status` is `current`.",type:"string"},{const:"ready",description:"`fresh`, and the generation's native code graph also serves.",type:"string"},{const:"graph_ready",description:"A published generation's native code graph serves and no convergence\npark is set, whatever the source freshness. Waiting for it never\nsweeps the source, so it cannot arm the reconcile it would observe.",type:"string"}]},CodeIndexReadinessWaitV1:{additionalProperties:!1,description:"`tracedecay_status` `wait_for`: hold the status read until the worktree\nreaches `state`, for at most the caller's `timeout_ms`.",properties:{state:{$ref:"#/$defs/CodeIndexReadinessTargetV1"},timeout_ms:{format:"uint64",minimum:0,type:"integer"}},required:["state","timeout_ms"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{admission_only:{default:!1,description:"Report only that the project route is admitted, reading no graph,\nindex, or session state. Default false.",type:"boolean"},include_branch_diagnostics:{default:!1,description:"Full tracked-branch diagnostic list. Default false.",type:"boolean"},include_session_ingest:{default:!1,description:"Session-ingest health. Default false.",type:"boolean"},include_staleness:{default:!1,description:"Git staleness object. Default false.",type:"boolean"},include_storage_health:{default:!1,description:"Storage-health snapshot. Default false.",type:"boolean"},wait_for:{anyOf:[{$ref:"#/$defs/CodeIndexReadinessWaitV1"},{type:"null"}],description:"Hold the status read until the code index reaches `state` (`fresh`:\nstatus `current`; `ready`: also native graph serving; `graph_ready`: a\npublished generation's native graph serves, whatever the freshness),\nfor at most `timeout_ms`. The payload's `wait` reports `reached`,\n`timed_out` with `last_state`, or `unavailable` with `reason`."}},title:"StatusSurfaceRequestV1",type:"object"},{$defs:{CodeCloneIndexBudgetsV1:{description:"Fixed automatic clone-discovery limits.",properties:{minimum_body_tokens:{format:"uint64",minimum:0,type:"integer"}},required:["minimum_body_tokens"],type:"object"},CodeCloneIndexCoverageV1:{description:"Coverage retained by one clone-index artifact or in-progress successor.\n\nCounts are `None` until the clone artifact has observed the corresponding\ndenominator. A complete empty repository reports `Some(0)`, which keeps a\ndesigned zero distinct from unavailable coverage.",properties:{conservative_normalized_bodies:{description:"Eligible bodies with a conservative exact posting.",format:"uint64",minimum:0,type:["integer","null"]},eligible_source_bodies:{description:"Source bodies admitted for automatic clone discovery.",format:"uint64",minimum:0,type:["integer","null"]},exact_postings:{description:"Conservative and rename-normalized exact posting rows.",format:"uint64",minimum:0,type:["integer","null"]},excluded_incomplete_tokenization_bodies:{description:"Bodies excluded because conservative tokenization was incomplete.",format:"uint64",minimum:0,type:["integer","null"]},excluded_too_large_bodies:{description:"Bodies excluded because they exceed the automatic-discovery token maximum.",format:"uint64",minimum:0,type:["integer","null"]},excluded_too_small_bodies:{description:"Bodies excluded because they are below the automatic-discovery minimum.",format:"uint64",minimum:0,type:["integer","null"]},payloads_reused:{description:"Current payload occurrences reused from the preceding generation.",format:"uint64",minimum:0,type:["integer","null"]},rename_normalized_bodies:{description:"Eligible bodies with a complete rename-normalized exact posting.",format:"uint64",minimum:0,type:["integer","null"]},rename_partial_bodies:{description:"Eligible bodies whose rename normalization is partial.",format:"uint64",minimum:0,type:["integer","null"]},rename_unsupported_bodies:{description:"Eligible bodies whose language has no rename normalization.",format:"uint64",minimum:0,type:["integer","null"]},source_bodies:{description:"Clone body occurrences observed in the sealed lexical source.",format:"uint64",minimum:0,type:["integer","null"]},unique_payloads:{description:"Distinct content-addressed payloads retained by the artifact.",format:"uint64",minimum:0,type:["integer","null"]}},type:"object"},CodeCloneIndexObservationV1:{description:"Generation-pinned clone-index evidence shared by non-error readiness states.",properties:{artifact_format_revision:{format:"uint32",minimum:0,type:["integer","null"]},budgets:{$ref:"#/$defs/CodeCloneIndexBudgetsV1"},conservative_normalization_revision:{format:"uint16",maximum:65535,minimum:0,type:"integer"},coverage:{$ref:"#/$defs/CodeCloneIndexCoverageV1"},generation_id:{type:"string"},rename_normalization_revision:{format:"uint16",maximum:65535,minimum:0,type:"integer"},resources:{$ref:"#/$defs/CodeCloneIndexResourcesV1"},source_revision:{type:["string","null"]}},required:["generation_id","conservative_normalization_revision","rename_normalization_revision","coverage","budgets","resources"],type:"object"},CodeCloneIndexResourcesV1:{description:"Measured resources and update accounting for one clone-index generation.",properties:{bytes_on_disk:{description:"Durable artifact bytes.",format:"uint64",minimum:0,type:["integer","null"]},changed_symbol_update_micros:{description:"Latest observed source-edit arrival through clone-ready publication.",format:"uint64",minimum:0,type:["integer","null"]},peak_scratch_memory_bytes:{description:"Largest measured clone-row serialization scratch during the build.",format:"uint64",minimum:0,type:["integer","null"]},stale_invalidations:{description:"Prior clone payload bindings invalidated by the latest publication.",format:"uint64",minimum:0,type:["integer","null"]}},type:"object"},CodeCloneIndexStatusV1:{description:"Clone readiness, independent from lexical and graph serving.",oneOf:[{description:"The sealed lexical artifact or its clone rows cannot be read.",properties:{reason:{type:"string"},state:{const:"unavailable",type:"string"}},required:["state","reason"],type:"object"},{description:"Some clone evidence is readable, but required postings are missing.",properties:{observation:{$ref:"#/$defs/CodeCloneIndexObservationV1"},omission_reasons:{items:{type:"string"},type:"array"},state:{const:"partial",type:"string"}},required:["state","observation","omission_reasons"],type:"object"},{description:"Required exact postings cover every eligible body.",properties:{observation:{$ref:"#/$defs/CodeCloneIndexObservationV1"},state:{const:"ready",type:"string"}},required:["state","observation"],type:"object"},{description:"The artifact is readable but belongs to a superseded source generation.",properties:{observation:{$ref:"#/$defs/CodeCloneIndexObservationV1"},reason:{type:"string"},state:{const:"stale",type:"string"}},required:["state","observation","reason"],type:"object"}]},CodeGraphServingReadinessV1:{description:"Interactive graph-serving state for the latest sealed generation.\n\nA sealed generation can expose truthful census statistics before its graph\nprojection is ready to serve queries, so readiness is reported separately.",oneOf:[{description:"No graph-serving authority exists for this worktree or generation.",properties:{reason:{type:"string"},state:{const:"unavailable",type:"string"}},required:["state","reason"],type:"object"},{description:"The sealed generation exists, but graph activation has not completed.",properties:{state:{const:"pending",type:"string"}},required:["state"],type:"object"},{description:"Graph activation completed without a serving projection.",properties:{reason:{type:"string"},state:{const:"refused",type:"string"}},required:["state","reason"],type:"object"},{description:"The verified graph projection is installed, but the engine or catalog\nits reads need is not resident: it is still being built, or it was\nreleased for memory. Graph reads answer the retryable warming state\nand restore it.",properties:{reason:{type:"string"},state:{const:"warming",type:"string"}},required:["state","reason"],type:"object"},{description:"The verified graph projection is installed for interactive reads.",properties:{state:{const:"ready",type:"string"}},required:["state"],type:"object"}]},CodeIndexBuildBlockedReasonV1:h_,CodeIndexBuildPhaseV1:{description:"The durable build phase whose committed boundary the dashboard is reading.\n\nA phase is not inferred from scheduler state. The mounted registry publishes\nthe exact phase that owns the active generation.",oneOf:[{enum:["source_scan","relational_preparation","bulk_commit","index_build","verification","ready"],type:"string"},{const:"graph_publication",description:"Text serving is built and the pass that sealed the generation is\nstill publishing its native graph.",type:"string"}]},CodeIndexBuildProgressV1:{description:"The latest committed progress boundary for one active code-index generation.\n\nEvery count is scoped to `generation_id`. The snapshot never includes a\nstaged page: work is reported only after the batch that owns it commits.",properties:{blocked_reason:{anyOf:[{$ref:"#/$defs/CodeIndexBuildBlockedReasonV1"},{type:"null"}],description:"Reason the active generation cannot currently advance, when known."},committed_chunks:{description:"Search chunks committed to the artifact database.",format:"uint64",minimum:0,type:"integer"},committed_imports:{description:"Import evidence rows committed to the artifact database.",format:"uint64",minimum:0,type:"integer"},committed_pages:{description:"Source pages committed to the artifact database.",format:"uint64",minimum:0,type:"integer"},committed_payload_bytes:{description:"Payload bytes committed to the artifact database.",format:"uint64",minimum:0,type:"integer"},completed_files:{description:"Authenticated sealed-source file boundary completed by committed work.",format:"uint64",minimum:0,type:"integer"},completed_lexical_units:{description:"Authenticated lexical-span boundary completed by committed work, in the\nsealed source's own advance unit.\n\nThe unit is the source's, not this surface's: a sealed-layout source\nadvances over the files-array byte span, while a published or\npartitioned source advances over file ordinals because its file records\nare not a contiguous byte range at all. Both are monotone and share the\ndenominator below, so completion and the derived estimate are truthful;\nnaming them bytes was not, and a consumer that multiplied this by an\naverage file size was wrong by orders of magnitude (issue #1205).",format:"uint64",minimum:0,type:"integer"},current_batch_pages:{description:"Source pages in the batch currently being processed.",format:"uint64",minimum:0,type:"integer"},current_batch_payload_bytes:{description:"Sealed payload bytes in the batch currently being processed.",format:"uint64",minimum:0,type:"integer"},daemon_incarnation:{description:"Durable daemon-authority epoch that produced this snapshot.\n\nThis orders snapshots across daemon restarts without relying on wall\nclock time.",format:"uint64",minimum:0,type:"integer"},elapsed_micros:{description:"Monotonic elapsed time for this process's active generation build.",format:"uint64",minimum:0,type:"integer"},estimated_remaining_seconds:{description:"Estimated remaining build duration, absent without a truthful rate.",format:"uint64",minimum:0,type:["integer","null"]},files_per_second:{description:"Rolling committed-file throughput, absent until it is established.",format:"double",type:["number","null"]},generation_id:{description:"Exact generation receiving the committed build work.",type:"string"},last_commit_latency_micros:{description:"Duration of the last committed SQLite batch, when one exists.",format:"uint64",minimum:0,type:["integer","null"]},last_progress_micros:{description:"Unix-epoch timestamp of the last durable progress publication.",format:"int64",type:"integer"},lexical_units_per_second:{description:"Rolling committed lexical-span throughput in units per second, absent\nuntil it is established. Not a byte rate; see\n[`Self::completed_lexical_units`].",format:"double",type:["number","null"]},phase:{$ref:"#/$defs/CodeIndexBuildPhaseV1",description:"Durable pipeline phase that published this snapshot."},producer_incarnation:{description:"Registry-minted scheduler incarnation within one daemon.\n\nA worktree retirement/remount creates a new value. `progress_epoch` is\ncomparable only when both incarnation fields match.",format:"uint64",minimum:0,type:"integer"},progress_epoch:{description:"Monotonic publication epoch for replacing delayed progress reads.",format:"uint64",minimum:0,type:"integer"},sealed_source_digest:{description:"Identity of the sealed source whose authenticated bounds define progress.",type:"string"},total_files:{description:"Authenticated sealed-source file bound for this generation.",format:"uint64",minimum:0,type:"integer"},total_lexical_units:{description:"Authenticated lexical-span bound for this generation, in the same unit\nas [`Self::completed_lexical_units`].",format:"uint64",minimum:0,type:"integer"}},required:["generation_id","daemon_incarnation","producer_incarnation","progress_epoch","sealed_source_digest","phase","committed_pages","committed_chunks","committed_imports","committed_payload_bytes","completed_files","total_files","completed_lexical_units","total_lexical_units","current_batch_pages","current_batch_payload_bytes","elapsed_micros","last_progress_micros"],type:"object"},CodeIndexConvergenceParkedV1:hv,CodeIndexFreshnessCoverageV1:{description:"Coverage of one freshness read. Distinct from [`CodeIndexStalenessStateV1`]:\na generation can be fresh and still omit hook-hint counts, or unverified\nwhile the ladder would otherwise say ready.\n\n`Unobserved` is only the constructed default. A projected read never emits\nit, so an absent observation cannot be mistaken for `complete`.",oneOf:[{enum:["unobserved","complete","partial_refresh_in_progress","partial_artifact_restore","partial_source_verification","partial_unverified_restore","partial_hook_hint_overflow"],type:"string"},{const:"partial_omitted_sources",description:"The sealed generation is fresh for every source it can index, and\n[`CodeIndexWorktreeFreshnessV1::omitted_sources`] names the sources it\ncannot. Waiting cannot change it.",type:"string"}]},CodeIndexGenerationRecoveryServingV1:{description:"Serving disposition of an incompatible generation during recovery.",enum:["preserved","refused"],type:"string"},CodeIndexGenerationRecoveryV1:{description:"Recovery state for a durable generation sealed under a different production\nowner configuration.",properties:{incompatibilities:{description:"Stable owner-input reason codes reported by the code-index authority.",items:{type:"string"},type:"array"},incompatible_generation_id:{description:"Generation retired from incremental reuse.",type:"string"},serving:{$ref:"#/$defs/CodeIndexGenerationRecoveryServingV1",description:"Whether the prior generation may continue serving while its replacement\nbuilds under the current configuration."}},required:["incompatible_generation_id","incompatibilities","serving"],type:"object"},CodeIndexNativeGraphPhaseV1:{description:"Native graph writer progress is independent of text-artifact commit counts.\nEncoded rows are physical work, never a durable page. Stage-page commits\nand installed + digest-verified compact segments are durable work.",enum:["compact_encoding","stage_page_commit","compact_segment_verified"],type:"string"},CodeIndexNativeGraphProgressV1:{properties:{active:{type:"boolean"},attempt_sequence:{format:"uint64",minimum:0,type:"integer"},committed_compact_bytes:{format:"uint64",minimum:0,type:"integer"},committed_compact_segments:{format:"uint64",minimum:0,type:"integer"},committed_stage_bytes:{format:"uint64",minimum:0,type:"integer"},committed_stage_mutations:{format:"uint64",minimum:0,type:"integer"},committed_stage_pages:{format:"uint64",minimum:0,type:"integer"},daemon_incarnation:{format:"uint64",minimum:0,type:"integer"},encoded_entities:{format:"uint64",minimum:0,type:"integer"},encoded_relations:{format:"uint64",minimum:0,type:"integer"},generation_id:{type:"string"},last_progress_micros:{description:"The time of the last actual native writer callback, not a status read.",format:"int64",type:["integer","null"]},phase:{anyOf:[{$ref:"#/$defs/CodeIndexNativeGraphPhaseV1"},{type:"null"}]},producer_incarnation:{format:"uint64",minimum:0,type:"integer"},progress_epoch:{format:"uint64",minimum:0,type:"integer"},sealed_graph_digest:{type:"string"},total_entities:{format:"uint64",minimum:0,type:["integer","null"]},total_relations:{format:"uint64",minimum:0,type:["integer","null"]}},required:["generation_id","sealed_graph_digest","daemon_incarnation","producer_incarnation","attempt_sequence","progress_epoch","encoded_entities","encoded_relations","committed_stage_pages","committed_stage_mutations","committed_stage_bytes","committed_compact_segments","committed_compact_bytes","active"],type:"object"},CodeIndexOmittedSourceV1:hb,CodeIndexOmittedSourcesV1:h$,CodeIndexPresealAttemptProgressV1:{description:"Independently owned attempt work, not committed text or graph pages.",properties:{active:{type:"boolean"},attempt_sequence:{format:"uint64",minimum:0,type:"integer"},completed_items:{format:"uint64",minimum:0,type:"integer"},daemon_incarnation:{format:"uint64",minimum:0,type:"integer"},last_progress_micros:{description:"No timestamp is invented before actual work or by status polling.",format:"int64",type:["integer","null"]},phase:{$ref:"#/$defs/CodeIndexPresealWorkPhaseV1"},producer_incarnation:{format:"uint64",minimum:0,type:"integer"},progress_epoch:{format:"uint64",minimum:0,type:"integer"},total_items:{format:"uint64",minimum:0,type:["integer","null"]}},required:["daemon_incarnation","producer_incarnation","attempt_sequence","progress_epoch","phase","completed_items","active"],type:"object"},CodeIndexPresealWorkPhaseV1:{description:"Observed capture, parse, and source-reference resolution before sealing.",enum:["capture","parse_evidence","resolution"],type:"string"},CodeIndexReadinessWaitOutcomeV1:{description:"How a `wait_for` status read ended. The status payload beside it is read\nafter the wait ends.",oneOf:[{properties:{outcome:{const:"reached",type:"string"}},required:["outcome"],type:"object"},{description:"The caller's budget elapsed; `last_state` is the last observed\n`code_index_freshness.status`.",properties:{last_state:{type:"string"},outcome:{const:"timed_out",type:"string"}},required:["outcome","last_state"],type:"object"},{description:"Waiting cannot reach the target: no scheduler is mounted, graph\nserving was refused, convergence is parked, or the request ended.",properties:{outcome:{const:"unavailable",type:"string"},reason:{type:"string"}},required:["outcome","reason"],type:"object"}]},CodeIndexRestoreProgressV1:{description:"Bounded authentication work required to restore one immutable lexical\nartifact as a serving reader.\n\nThe unit is a fixed restore check, not bytes or build work. Completed\nchecks are published only after they pass. `authenticated_remaining` is\nalways `authenticated_total - authenticated_completed`, so a caller can\ndistinguish bounded cold restore from an unbounded rebuild.",properties:{artifact_digest:{description:"Whole-file content address from the durable artifact descriptor.",type:"string"},authenticated_completed:{description:"Successfully completed authentication checks.",format:"uint64",minimum:0,type:"integer"},authenticated_remaining:{description:"Checks that have not completed yet.",format:"uint64",minimum:0,type:"integer"},authenticated_total:{description:"Fixed number of authentication checks for this restore.",format:"uint64",minimum:0,type:"integer"},generation_id:{description:"Generation whose lexical serving seat is being restored.",type:"string"}},required:["generation_id","artifact_digest","authenticated_completed","authenticated_total","authenticated_remaining"],type:"object"},CodeIndexSourceOmissionReasonV1:hS,CodeIndexStalenessStateV1:hk,CodeIndexWorktreeFreshnessV1:{description:"Freshness/generation state for one mounted worktree.\n\n`Deserialize` is part of the wire contract: the CLI status command decodes\nexactly this type back out of the daemon's `tracedecay_status` response,\nkeeping one authority for the freshness shape.",properties:{clone_index:{anyOf:[{$ref:"#/$defs/CodeCloneIndexStatusV1"},{type:"null"}],description:"Clone readiness from the same sealed lexical artifact."},code_graph_serving:{anyOf:[{$ref:"#/$defs/CodeGraphServingReadinessV1"},{type:"null"}],description:"Whether that generation's verified graph projection can serve reads."},coverage:{$ref:"#/$defs/CodeIndexFreshnessCoverageV1",description:"Whether this read covers the complete mounted scheduler state."},generation_recovery:{anyOf:[{$ref:"#/$defs/CodeIndexGenerationRecoveryV1"},{type:"null"}],description:"One-shot owner-configuration recovery currently replacing an\nincompatible durable generation."},hook_hint_count:{description:"Pending hook-hint count, when cheaply available.",format:"uint64",minimum:0,type:["integer","null"]},last_reconcile_micros:{description:"Last reconcile observation time (microseconds since the Unix epoch).",format:"int64",type:["integer","null"]},latest_generation_id:{description:"Latest sealed generation identity, when a complete generation exists.",type:["string","null"]},native_graph_progress:{anyOf:[{$ref:"#/$defs/CodeIndexNativeGraphProgressV1"},{type:"null"}]},omitted_sources:{anyOf:[{$ref:"#/$defs/CodeIndexOmittedSourcesV1"},{type:"null"}],description:"Sources the serving snapshot captured but does not index, when any."},parked:{anyOf:[{$ref:"#/$defs/CodeIndexConvergenceParkedV1"},{type:"null"}],description:"Deterministic contract violation currently parking background\nconvergence, when one is observed. `staleness_state` reads `parked`\nwhile this is set and no generation serves."},preseal_attempt:{anyOf:[{$ref:"#/$defs/CodeIndexPresealAttemptProgressV1"},{type:"null"}]},progress:{anyOf:[{$ref:"#/$defs/CodeIndexBuildProgressV1"},{type:"null"}],description:"Latest committed progress for the active generation, if one is mounted."},rebuild_in_flight:{description:"Whether the exact scheduler route owns a reconcile pass or has a\npending wake. A stale seated generation with this false is stalled,\nnot in a routine rebuild window.",type:"boolean"},repository_id:{description:"Stable repository identity resolved by the scheduler.",type:["string","null"]},restore_progress:{anyOf:[{$ref:"#/$defs/CodeIndexRestoreProgressV1"},{type:"null"}],description:"Bounded immutable-artifact restore work currently in flight. This is\nseparate from build progress because restore commits no index data."},sealed_at_micros:{description:"Time the complete generation was durably sealed.",format:"int64",type:["integer","null"]},snapshot_content_identity:{description:"Content identity of the complete source snapshot.",type:["string","null"]},source_reference:{description:"Exact source reference captured by the sealed generation.",type:["string","null"]},source_revision:{description:"Exact source revision captured by the sealed generation.",type:["string","null"]},staleness_state:{anyOf:[{$ref:"#/$defs/CodeIndexStalenessStateV1"},{type:"null"}],description:"Staleness-ladder state from the last scheduler execution. `fresh` means\nthe scheduler most recently observed a fresh source; the status read\ndoes not probe the worktree to revalidate that observation."},worktree_id:{description:"Stable worktree identity resolved by the scheduler.",type:["string","null"]},worktree_root:{description:"Display path of the mounted worktree root.",type:"string"}},required:["worktree_root","rebuild_in_flight","coverage"],type:"object"},LcmConvergenceStateV1:gX,LcmConvergenceV1:gY,LcmDoctorProjectionStateV1:g1,LcmDoctorProjectionV1:g0,NativeHostIdentityV1:{enum:["claude_code","cursor_desktop","cursor_cloud","codex","hermes","kiro","cline","roo_code","kilo","kimi_code","open_code","pi","factory_droid"],type:"string"},ProjectStatusV1:{additionalProperties:!1,properties:{active_branch:{type:["string","null"]},branch_diagnostics:!0,branch_drifted:{type:["boolean","null"]},branch_mismatch:{anyOf:[{$ref:"#/$defs/StatusBranchMismatchV1"},{type:"null"}]},branch_resolution:{type:["string","null"]},branch_warnings:{items:{type:"string"},type:["array","null"]},code_index_freshness:{$ref:"#/$defs/StatusCodeIndexFreshnessV1"},code_index_freshness_warning:{type:["string","null"]},current_branch:{type:["string","null"]},git_staleness:{anyOf:[{$ref:"#/$defs/StatusGitStalenessV1"},{type:"null"}]},github_source:{description:"The checkout's GitHub source as its advisory owner observed it."},graph_statistics:{description:"The exact-scope sealed-generation census."},hook_replay:{$ref:"#/$defs/StatusHookReplayV1",description:"The daemon's drain of this project's hook spools, as its last sweep\nleft it."},live_branch:{type:["string","null"]},memory:{$ref:"#/$defs/StatusMemoryV1"},parent_branch:{type:["string","null"]},project_root:{type:"string"},reset_required_stores:{description:"Registered stores this binary serves only as a typed reset-required\nrefusal, each with the command that resets it.",items:{$ref:"#/$defs/StoreResetRequiredV1"},type:"array"},retrieval_serving:{anyOf:[{$ref:"#/$defs/StatusRetrievalServingV1"},{type:"null"}],description:"Whether exact-scope retrieval can serve, when the census authority is\nattached."},schema_convergence:{$ref:"#/$defs/StatusSchemaConvergenceV1"},scope_prefix:{type:["string","null"]},server:{description:"The serving MCP server's request counters."},serving_branch:{type:["string","null"]},session_git_evidence:{$ref:"#/$defs/StatusSessionGitEvidenceV1",description:"The session↔Git evidence `tracedecay_sessions_for` and the\nbranch/commit session filters read."},session_history_catch_up:!0,session_ingest:!0,session_projection:{$ref:"#/$defs/LcmDoctorProjectionV1",description:"The project session projection's serving state, the same reading\n`tracedecay_lcm_doctor` reports."},storage_health:!0,tracked_branch_count:{format:"uint",minimum:0,type:["integer","null"]},wait:{anyOf:[{$ref:"#/$defs/CodeIndexReadinessWaitOutcomeV1"},{type:"null"}]}},required:["project_root","graph_statistics","memory","schema_convergence","reset_required_stores","code_index_freshness","github_source","session_projection","session_git_evidence","hook_replay"],type:"object"},ResidentMemoryHolderReadV1:{description:"One worktree holding a retained owner's memory, and what it holds: a\ngeneration id, or an LSP session id.",properties:{holding:{type:"string"},worktree_id:{type:"string"}},required:["worktree_id","holding"],type:"object"},RetrievalWorkerStatusV1:vT,SchemaConvergenceFindingV1:vL,SchemaConvergenceStageV1:vU,SchemaConvergenceStateV1:vH,StatusAdmissionV1:{additionalProperties:!1,properties:{project_admitted:{type:"boolean"},project_root:{type:"string"},scope_prefix:{type:["string","null"]},server:{description:"The serving MCP server's request counters."}},required:["project_admitted","project_root"],type:"object"},StatusBranchMismatchV1:{additionalProperties:!1,properties:{git_branch:{type:["string","null"]},indexed_branch:{type:["string","null"]},serving_branch:{type:["string","null"]}},type:"object"},StatusCodeIndexFreshnessV1:{description:"The code-index freshness of the served worktree, labeled the way readiness\nwaits report their last state.",oneOf:[{additionalProperties:!1,properties:{status:{const:"current",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,properties:{status:{const:"stale",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,properties:{status:{const:"restoring",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,properties:{status:{const:"warming",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,properties:{status:{const:"parked",type:"string"},worktree:{$ref:"#/$defs/CodeIndexWorktreeFreshnessV1"}},required:["status","worktree"],type:"object"},{additionalProperties:!1,description:"The last code-index mount failed; explicit reconciliation can retry it.",properties:{message:{type:"string"},remediation:{type:"string"},status:{const:"mount_failed",type:"string"}},required:["status","message","remediation"],type:"object"},{additionalProperties:!1,properties:{reason:{type:"string"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},StatusGitStalenessUnavailableV1:{oneOf:[{const:"no_sealed_generation",description:"No complete generation has sealed for the worktree yet.",type:"string"},{const:"sealed_generation_has_no_commit",description:"The sealed generation captured no commit, as in an unborn repository.",type:"string"},{const:"git_head_unreadable",description:"The worktree's checked-out commit could not be read.",type:"string"}]},StatusGitStalenessV1:{description:"The sealed generation's Git watermark, the commit its source snapshot was\ncaptured from, against the worktree's checked-out commit.",oneOf:[{additionalProperties:!1,description:"HEAD is the commit the sealed generation was built from.",properties:{status:{const:"current",type:"string"},watermark:{type:"string"}},required:["status","watermark"],type:"object"},{additionalProperties:!1,description:"HEAD has moved off the commit the sealed generation was built from.",properties:{head:{type:"string"},status:{const:"stale",type:"string"},watermark:{type:"string"}},required:["status","watermark","head"],type:"object"},{additionalProperties:!1,description:"No watermark or no HEAD to compare it with.",properties:{reason:{$ref:"#/$defs/StatusGitStalenessUnavailableV1"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},StatusHookReplayFailureV1:{additionalProperties:!1,description:"One hook spool the last replay sweep could not drain.",properties:{cause:{type:"string"},host:{$ref:"#/$defs/NativeHostIdentityV1"},spool:{$ref:"#/$defs/StatusHookReplaySpoolV1"}},required:["host","spool","cause"],type:"object"},StatusHookReplaySpoolV1:{oneOf:[{const:"records",description:"The host's spooled hook events.",type:"string"},{const:"delivery_receipts",description:"The host's hook delivery receipts.",type:"string"},{const:"pending_work",description:"The producer work the host's admission ledger still owes.",type:"string"}]},StatusHookReplayV1:{description:"The daemon's hook spool drain for one project.",oneOf:[{additionalProperties:!1,description:"No replay consumer drains this project's hook spools in this daemon.",properties:{status:{const:"unowned",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,description:"The replay consumer has not finished its first sweep.",properties:{status:{const:"starting",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,description:"The last sweep drained every hook spool it found.",properties:{status:{const:"drained",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,description:"The spools drained, but producer work they admitted waits for the\nproject's hook orchestrator to mount. The work stays owed and runs\nonce it does; nothing has failed.",properties:{status:{const:"waiting",type:"string"},waiting:{items:{$ref:"#/$defs/StatusHookReplayFailureV1"},type:"array"}},required:["status","waiting"],type:"object"},{additionalProperties:!1,description:"The last sweep could not drain these spools. Their records stay\ndurable and the next sweep retries them.",properties:{failures:{items:{$ref:"#/$defs/StatusHookReplayFailureV1"},type:"array"},status:{const:"failed",type:"string"}},required:["status","failures"],type:"object"}]},StatusMemoryOwnerV1:{additionalProperties:!1,properties:{bytes:{format:"uint64",minimum:0,type:["integer","null"]},content_digest:{type:["string","null"]},holders:{items:{$ref:"#/$defs/ResidentMemoryHolderReadV1"},type:"array"},idle_seconds:{format:"uint64",minimum:0,type:"integer"},kind:{type:"string"},measured:{type:"boolean"},project_id:{type:"string"},protected:{type:"boolean"}},required:["project_id","kind","holders","measured","idle_seconds","protected"],type:"object"},StatusMemoryPressureV1:{enum:["unobserved","nominal","over_budget"],type:"string"},StatusMemoryReservationV1:{additionalProperties:!1,properties:{bytes:{format:"uint64",minimum:0,type:"integer"},component:{type:"string"}},required:["component","bytes"],type:"object"},StatusMemoryV1:{additionalProperties:!1,description:"The daemon's memory admission and resident accounting as one project sees it.",properties:{high_watermark_bytes:{format:"uint64",minimum:0,type:"integer"},idle_window_seconds:{format:"uint64",minimum:0,type:"integer"},limit_bytes:{format:"uint64",minimum:0,type:"integer"},low_watermark_bytes:{format:"uint64",minimum:0,type:"integer"},owners:{description:"This project's retained owners; other projects' belong to the\ndaemon-wide Doctor inventory.",items:{$ref:"#/$defs/StatusMemoryOwnerV1"},type:"array"},psi_some_avg10:{format:"double",type:["number","null"]},reservations:{description:"`reserved_bytes` per component, largest first.",items:{$ref:"#/$defs/StatusMemoryReservationV1"},type:"array"},reserved_bytes:{description:"Bytes admitted work has reserved daemon-wide: the admission model of\nin-flight builds and decodes, not a measurement.",format:"uint64",minimum:0,type:"integer"},resident_bytes:{description:"Observed admission occupancy: anonymous/shared process pages plus swap,\nconstrained by shared cgroup headroom. This is not raw process RSS.",format:"uint64",minimum:0,type:["integer","null"]},retained_bytes:{format:"uint64",minimum:0,type:"integer"},shed_order:{items:{type:"string"},type:"array"},status:{$ref:"#/$defs/StatusMemoryPressureV1"},unattributed_bytes:{description:"Raw process RSS from the last successful canonical sample minus the\ndaemon-wide measured `retained_bytes`, saturating at zero. Unlike\n`resident_bytes`, this excludes swap and shared cgroup pressure. Work in\nflight, runtime allocations, SQLite page caches, and allocator-held pages\ncan contribute. `None` until a resident sample has been published.",format:"uint64",minimum:0,type:["integer","null"]},unmeasured_owners:{format:"uint",minimum:0,type:"integer"}},required:["status","limit_bytes","high_watermark_bytes","low_watermark_bytes","idle_window_seconds","shed_order","retained_bytes","unmeasured_owners","reserved_bytes","reservations","owners"],type:"object"},StatusRetrievalServingV1:{oneOf:[{additionalProperties:!1,description:"A sealed complete generation serves the exact worktree. The ages tell a\nroutine rebuild window from a wedged route.",properties:{condition:{anyOf:[{$ref:"#/$defs/StatusServingConditionV1"},{type:"null"}]},freshness:{$ref:"#/$defs/StatusServingFreshnessV1"},last_reconcile_age_seconds:{format:"int64",type:["integer","null"]},seated_generation_age_seconds:{format:"int64",type:["integer","null"]},status:{const:"serving",type:"string"}},required:["status","freshness"],type:"object"},{additionalProperties:!1,description:"The census answered and nothing is servable yet.",properties:{reason:{type:"string"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},StatusSchemaConvergenceStateV1:{enum:["completed","in_progress","retrying","degraded"],type:"string"},StatusSchemaConvergenceV1:{additionalProperties:!1,properties:{findings:{items:{$ref:"#/$defs/SchemaConvergenceFindingV1"},type:"array"},status:{$ref:"#/$defs/StatusSchemaConvergenceStateV1"}},required:["status","findings"],type:"object"},StatusServingConditionV1:{enum:["artifact_restore","source_verification","rebuilding","stalled"],type:"string"},StatusServingFreshnessV1:{enum:["current","restoring","last_complete_stale","unknown"],type:"string"},StatusSessionGitEvidenceUnavailableV1:{oneOf:[{const:"session_store_denied",description:"This request holds no project session store.",type:"string"},{const:"read_failed",description:"The session store refused the evidence read.",type:"string"}]},StatusSessionGitEvidenceV1:{description:"The project's session↔Git evidence generation.",oneOf:[{additionalProperties:!1,description:"A convergence pass installed this generation.",properties:{backfill_watermark:{format:"int64",type:["integer","null"]},commit_count:{format:"uint64",minimum:0,type:"integer"},generation:{type:"string"},source_watermark:{type:"string"},span_count:{format:"uint64",minimum:0,type:"integer"},status:{const:"recorded",type:"string"}},required:["status","generation","source_watermark","span_count","commit_count"],type:"object"},{additionalProperties:!1,description:"No convergence pass has written evidence for this project yet.",properties:{backfill_watermark:{format:"int64",type:["integer","null"]},status:{const:"unrecorded",type:"string"}},required:["status"],type:"object"},{additionalProperties:!1,description:"The evidence could not be read.",properties:{message:{type:["string","null"]},reason:{$ref:"#/$defs/StatusSessionGitEvidenceUnavailableV1"},status:{const:"unavailable",type:"string"}},required:["status","reason"],type:"object"}]},StoreResetRequiredV1:{description:"A persisted store the daemon keeps mounted in a typed reset-required state\ninstead of refusing to serve: every read against it returns the typed\nrefusal, stores that admit keep serving, and `remedy` is the exact command\nthe operator runs to reset it.",properties:{authority:{type:"string"},found_version:{format:"int64",type:["integer","null"]},reason:{type:"string"},remedy:{type:"string"},required_version:{format:"int64",type:["integer","null"]},store:{type:"string"}},required:["store","authority","reason","remedy"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/StatusAdmissionV1"},{$ref:"#/$defs/ProjectStatusV1"}],description:"`tracedecay_status` for an `admission_only` read, or the project's status.",title:"StatusResultV1"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_details:{default:!1,type:"boolean"}},title:"StorageStatusPrimitiveRequest",type:"object"},{$defs:{StorageStatusHistoryPointV1:{additionalProperties:!1,properties:{database_bytes:{format:"uint64",minimum:0,type:"integer"},observed_at:{format:"int64",type:"integer"}},required:["observed_at","database_bytes"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{database_bytes:{format:"uint64",minimum:0,type:["integer","null"]},details:{items:{type:"string"},type:"array"},freelist_pages:{default:null,format:"uint64",minimum:0,type:["integer","null"]},history:{default:[],items:{$ref:"#/$defs/StorageStatusHistoryPointV1"},type:"array"},history_coverage:{default:null,type:["string","null"]},page_count:{default:null,format:"uint64",minimum:0,type:["integer","null"]},page_size_bytes:{default:null,format:"uint32",minimum:0,type:["integer","null"]},project_id:{default:null,type:["string","null"]},read_only:{type:"boolean"},status:{type:"string"},store_path:{default:null,type:["string","null"]}},required:["status","read_only","details"],title:"StorageStatusPrimitiveResult",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact public input accepted by `tracedecay_str_replace`.",properties:{dry_run:{default:!1,type:"boolean"},expected_state:{description:"Exact `preview_digest`/`expected_state` returned by the dry run. Apply\nre-resolves the typed plan and rejects any candidate-state drift.",type:["string","null"]},idempotency_key:{type:["string","null"]},new_str:{type:"string"},old_str:{type:"string"},path:{type:"string"},verify:{default:!1,type:"boolean"}},required:["path","old_str","new_str"],title:"StrReplaceSurfaceRequestV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{file:{description:"Source file path to find test coverage for.",type:["string","null"]},node_id:{description:"Specific node ID to find test coverage for (alternative to file).",type:["string","null"]}},title:"TestMapSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,TestMapSourceCoverageV1:{additionalProperties:!1,properties:{source_file:{type:"string"},source_id:{type:"string"},source_line:{format:"uint32",minimum:0,type:"integer"},source_name:{type:"string"},tests:{items:{$ref:"#/$defs/TestMapTestV1"},type:"array"}},required:["source_name","source_id","source_file","source_line","tests"],type:"object"},TestMapTestV1:{additionalProperties:!1,properties:{attribution_depth:{format:"uint32",minimum:0,type:"integer"},test_file:{type:"string"},test_line:{format:"uint32",minimum:0,type:"integer"},test_name:{type:"string"}},required:["test_name","test_file","test_line","attribution_depth"],type:"object"},TestMapUncoveredV1:{additionalProperties:!1,properties:{file:{type:"string"},id:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"}},required:["id","name","file","line"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{coverage:{items:{$ref:"#/$defs/TestMapSourceCoverageV1"},type:"array"},covered_symbols:{format:"uint64",minimum:0,type:"integer"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},test_files:{items:{type:"string"},type:"array"},uncovered:{items:{$ref:"#/$defs/TestMapUncoveredV1"},type:"array"},uncovered_symbols:{format:"uint64",minimum:0,type:"integer"}},required:["covered_symbols","uncovered_symbols","test_files","coverage","uncovered"],title:"TestMapResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The admitted project selects the retained managed test run, so this exact\nrequest intentionally carries no caller-selectable scope or identity.",title:"TestResultsSurfaceRequestV1",type:"object"},{$defs:{CancellationObservation:hn,CancellationStage:ha,CodeGenerationId:hy,CommitId:hq,Deadline:yv,OperationBudgetUsage:_D,OperationReceipt:_F,OperationTermination:_L,TestResultProjectionV1:{additionalProperties:!1,description:"One result emitted by the daemon-managed test-run authority.",properties:{passed:{type:"boolean"},test:{type:"string"}},required:["test","passed"],type:"object"},UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Exact retained managed-test-run projection returned by `test_results`.\n\nThe daemon resolves the admitted project, reads its newest durable managed\nrun, and verifies that the run's head and code generation are current\nbefore it serializes this payload. `result_offset` and `available_results`\nretain the authoritative page position. The outcome fields (`finished_at`,\n`exit_code`, the counts, `termination`, `receipt`) are present only after\nthe managed run terminates.",properties:{available_results:{format:"uint64",minimum:0,type:"integer"},code_generation_id:{anyOf:[{$ref:"#/$defs/CodeGenerationId"},{type:"null"}]},completed:{format:"uint64",minimum:0,type:"integer"},exit_code:{format:"int32",type:["integer","null"]},failed:{format:"uint64",minimum:0,type:["integer","null"]},finished_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},head_commit_id:{anyOf:[{$ref:"#/$defs/CommitId"},{type:"null"}]},ignored:{format:"uint64",minimum:0,type:["integer","null"]},operation_id:{type:"string"},passed:{format:"uint64",minimum:0,type:["integer","null"]},receipt:{anyOf:[{$ref:"#/$defs/OperationReceipt"},{type:"null"}]},result_offset:{format:"uint64",minimum:0,type:"integer"},results:{items:{$ref:"#/$defs/TestResultProjectionV1"},type:"array"},session_id:{description:"The session the run was requested by; null when the request named none.",type:["string","null"]},started_at:{$ref:"#/$defs/UtcMicros"},termination:{anyOf:[{$ref:"#/$defs/OperationTermination"},{type:"null"}]},total:{format:"uint64",minimum:0,type:["integer","null"]}},required:["operation_id","started_at","results","completed","result_offset","available_results"],title:"TestResultsResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{include_tested:{description:"Include already-tested functions in results (default: false).",type:["boolean","null"]},limit:{description:"Maximum number of results to return (default: 20, at most 200).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory path.",type:["string","null"]}},title:"TestRiskSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,ComplexityAnalysisV1:hx,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,TestAttributionMethodV1:{description:"How a source symbol's static test evidence was attributed.",enum:["none","direct_unit","closure"],type:"string"},TestRiskAttributionSummaryV1:{additionalProperties:!1,properties:{cli_entry_attributed:{format:"uint64",minimum:0,type:"integer"},closure_attributed:{format:"uint64",minimum:0,type:"integer"},depth:{format:"uint64",minimum:0,type:"integer"},direct_unit_attributed:{format:"uint64",minimum:0,type:"integer"},public_api_attributed:{format:"uint64",minimum:0,type:"integer"},total_attributed:{format:"uint64",minimum:0,type:"integer"},trait_resolved_attributed:{format:"uint64",minimum:0,type:"integer"}},required:["depth","direct_unit_attributed","closure_attributed","trait_resolved_attributed","public_api_attributed","cli_entry_attributed","total_attributed"],type:"object"},TestRiskBucketSummaryV1:{additionalProperties:!1,properties:{attributed:{format:"uint64",minimum:0,type:"integer"},excluded:{format:"uint64",minimum:0,type:"integer"},orphan_entry:{format:"uint64",minimum:0,type:"integer"},reachable_unattributed:{format:"uint64",minimum:0,type:"integer"}},required:["attributed","reachable_unattributed","orphan_entry","excluded"],type:"object"},TestRiskConfidenceV1:{description:"What the reported coverage percentage bounds.",enum:["static_lower_bound"],type:"string"},TestRiskEntryV1:{additionalProperties:!1,properties:{attribution_depth:{format:"uint64",minimum:0,type:["integer","null"]},attribution_method:{$ref:"#/$defs/TestAttributionMethodV1"},churn:{format:"uint64",minimum:0,type:"integer"},complexity:{description:"`None` when `complexity_analysis` reports the bounded walk did not\ncover the body; `risk` then weighs the lower-bound counters.",format:"uint32",minimum:0,type:["integer","null"]},complexity_analysis:{$ref:"#/$defs/ComplexityAnalysisV1"},fan_in:{format:"uint64",minimum:0,type:"integer"},file:{type:"string"},has_test:{type:"boolean"},id:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},name:{type:"string"},risk:{format:"double",type:"number"}},required:["id","name","file","line","complexity_analysis","fan_in","has_test","attribution_method","risk","churn"],type:"object"},TestRiskSummaryV1:{additionalProperties:!1,properties:{attribution:{$ref:"#/$defs/TestRiskAttributionSummaryV1"},buckets:{$ref:"#/$defs/TestRiskBucketSummaryV1"},confidence:{$ref:"#/$defs/TestRiskConfidenceV1"},confidence_note:{type:"string"},coverage_pct:{format:"double",type:"number"},skipped:{format:"uint64",minimum:0,type:"integer"},tested:{format:"uint64",minimum:0,type:"integer"},top_risk_unattributed:{type:"string"},top_risk_untested:{type:"string"},total_functions:{format:"uint64",minimum:0,type:"integer"}},required:["total_functions","tested","skipped","coverage_pct","top_risk_untested","top_risk_unattributed","attribution","buckets","confidence","confidence_note"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},risks:{items:{$ref:"#/$defs/TestRiskEntryV1"},type:"array"},summary:{$ref:"#/$defs/TestRiskSummaryV1"}},required:["risks","summary"],title:"TestRiskResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{kinds:{items:{type:"string"},type:["array","null"]},limit:{format:"uint32",minimum:0,type:["integer","null"]},path:{type:["string","null"]}},title:"TodosSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,TodoMarkerV1:{additionalProperties:!1,properties:{enclosing:{type:["string","null"]},file:{type:"string"},kind:{type:"string"},line:{format:"uint32",minimum:0,type:"integer"},text:{type:"string"}},required:["kind","file","line","text"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{by_kind:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},type:"object"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},markers:{items:{$ref:"#/$defs/TodoMarkerV1"},type:"array"},match_count:{format:"uint",minimum:0,type:"integer"}},required:["match_count","by_kind","markers"],title:"TodosResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{ecosystem:{description:"Filter findings to one ecosystem ('rust' or 'typescript'). Every\necosystem section is still reported, so the scope of the answer stays\nvisible.",type:["string","null"]},limit:{description:"Maximum unmounted files to return (default: 200, max: 2000). The\nresponse always states the true total and how many rows were omitted.",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter findings to files under this directory path (e.g. 'src/daemon').\nThe whole project is still walked, reachability is not a per-directory\nquestion.",type:["string","null"]}},title:"UnmountedFilesSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,UnmountedEcosystemStatusV1:{description:"Whether an ecosystem was audited, absent, or recognised but unmodelled.",enum:["audited","partial","not_present","unsupported"],type:"string"},UnmountedEcosystemV1:{additionalProperties:!1,properties:{blind_spots:{items:{type:"string"},type:"array"},ecosystem:{type:"string"},entry_point_count:{format:"uint64",minimum:0,type:"integer"},excluded_path_globs:{items:{type:"string"},type:"array"},mounted_file_count:{format:"uint64",minimum:0,type:"integer"},note:{type:["string","null"]},package_count:{format:"uint64",minimum:0,type:"integer"},scanned_file_count:{format:"uint64",minimum:0,type:"integer"},status:{$ref:"#/$defs/UnmountedEcosystemStatusV1"},unclaimed_file_count:{format:"uint64",minimum:0,type:"integer"},unmounted_file_count:{format:"uint64",minimum:0,type:"integer"},verdict:{type:"string"}},required:["ecosystem","status","package_count","entry_point_count","scanned_file_count","mounted_file_count","unclaimed_file_count","unmounted_file_count","verdict","blind_spots","excluded_path_globs"],type:"object"},UnmountedFileV1:{additionalProperties:!1,properties:{ecosystem:{type:"string"},file:{type:"string"},manifest:{type:"string"},nearest_mounted_parent:{type:["string","null"]},package:{type:"string"},suggested_declaration:{type:["string","null"]}},required:["file","ecosystem","package","manifest"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{complete:{type:"boolean"},ecosystem:{type:["string","null"]},ecosystems:{items:{$ref:"#/$defs/UnmountedEcosystemV1"},type:"array"},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},limit:{format:"uint64",minimum:0,type:"integer"},omitted_count:{format:"uint64",minimum:0,type:"integer"},path:{type:["string","null"]},returned_count:{format:"uint64",minimum:0,type:"integer"},unmounted:{items:{$ref:"#/$defs/UnmountedFileV1"},type:"array"},unmounted_file_count:{format:"uint64",minimum:0,type:"integer"}},required:["unmounted_file_count","returned_count","omitted_count","complete","ecosystems","limit","unmounted"],title:"UnmountedFilesResultV1",type:"object"},{$defs:{UnsafePatternKindV1:bB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{exclude_tests:{description:"When true, skips files whose path looks like a test (default: false).",type:["boolean","null"]},kinds:{description:"Subset of patterns to search. Default (or an empty list): every kind.",items:{$ref:"#/$defs/UnsafePatternKindV1"},type:["array","null"]},limit:{description:"Maximum number of matches to return (default: 200, max: 2000).",format:"uint32",minimum:0,type:["integer","null"]},path:{description:"Filter to files under this directory (relative to project root).",type:["string","null"]}},title:"UnsafePatternsSurfaceRequestV1",type:"object"},{$defs:{CodeIndexBuildBlockedReasonV1:h_,CodeIndexConvergenceParkedV1:hv,CodeIndexStalenessStateV1:hk,CoverageCompleteness:yu,PrimitiveFreshnessStateV1:_B,PrimitiveIndexingStateV1:_K,PrimitiveSearchFreshnessV1:_X,UnsafePatternFileOmissionV1:{additionalProperties:!1,description:"One scanned file whose sites are not reported as verified matches.",properties:{cause:{$ref:"#/$defs/UnsafePatternOmissionCauseV1"},file:{type:"string"},reason:{$ref:"#/$defs/UnsafePatternOmissionReasonV1"},withheld_match_count:{description:"Sites of the requested kinds found in the file and withheld.",format:"uint64",minimum:0,type:"integer"}},required:["file","reason","cause","withheld_match_count"],type:"object"},UnsafePatternKindV1:bB,UnsafePatternMatchV1:{additionalProperties:!1,properties:{enclosing:{type:["string","null"]},file:{type:"string"},in_test:{type:"boolean"},kind:{$ref:"#/$defs/UnsafePatternKindV1"},line:{format:"uint32",minimum:0,type:"integer"},snippet:{type:"string"}},required:["kind","file","line","snippet","in_test"],type:"object"},UnsafePatternOmissionCauseV1:{description:"What prevented the file from being classified.",oneOf:[{const:"syntax_errors",description:"The Rust grammar parsed the file with error nodes. Valid Rust it only\npartly parses (heavy `macro_rules!`) lands here.",type:"string"}]},UnsafePatternOmissionReasonV1:{description:"Why a file's risky-pattern sites are withheld from the verified result.",oneOf:[{const:"test_scope_unclassified",description:"Whether a site is test-only cannot be decided for this file.",type:"string"}]}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{by_kind:{additionalProperties:{format:"uint64",minimum:0,type:"integer"},description:"Match count per pattern kind, keyed by its wire spelling.",type:"object"},coverage:{$ref:"#/$defs/CoverageCompleteness",description:"`partial` exactly when `omissions` names a file whose sites are withheld."},freshness:{anyOf:[{$ref:"#/$defs/PrimitiveSearchFreshnessV1"},{type:"null"}],description:"The worktree verdict a served graph read opens with."},match_count:{format:"uint64",minimum:0,type:"integer"},matches:{items:{$ref:"#/$defs/UnsafePatternMatchV1"},type:"array"},omissions:{items:{$ref:"#/$defs/UnsafePatternFileOmissionV1"},type:"array"}},required:["match_count","by_kind","matches","coverage","omissions"],title:"UnsafePatternsResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{agent_label:{type:["string","null"]},branch:{type:["string","null"]},commit:{type:["string","null"]},limit:{format:"uint64",minimum:0,type:["integer","null"]},run_id:{type:["string","null"]},session_id:{type:["string","null"]},worktree:{type:["string","null"]}},title:"WorkflowsRequestV1",type:"object"},{$defs:{GitScopeV1:gE,RetainedErrorV1:vV,RetainedOutcomeStatusV1:vR,WorkflowAgentV1:{additionalProperties:!1,properties:{agent_id:{type:"string"},agent_label:{type:"string"},agent_session_id:{type:["string","null"]},ended_ts:{format:"int64",type:["integer","null"]},model:{type:["string","null"]},phase:{type:["string","null"]},run_id:{type:"string"},started_ts:{format:"int64",type:["integer","null"]},status:{$ref:"#/$defs/WorkflowStatusV1"},tokens:{format:"int64",type:"integer"},transcript_path:{type:["string","null"]}},required:["run_id","agent_label","agent_id","status"],type:"object"},WorkflowCoverageV1:{enum:["complete","conclusive","bounded_prefix"],type:"string"},WorkflowQueryModeV1:{enum:["session","git_scope","run","agent"],type:"string"},WorkflowRunV1:{additionalProperties:!1,properties:{agent_count:{format:"int64",type:"integer"},description:{type:["string","null"]},ended_ts:{format:"int64",type:["integer","null"]},name:{type:["string","null"]},parent_session_id:{type:"string"},phase_json:{type:["string","null"]},result_summary:{type:["string","null"]},run_id:{type:"string"},started_ts:{format:"int64",type:["integer","null"]},status:{$ref:"#/$defs/WorkflowStatusV1"}},required:["run_id","parent_session_id","status"],type:"object"},WorkflowStatusV1:{enum:["running","completed","failed","unknown"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{agent:{anyOf:[{$ref:"#/$defs/WorkflowAgentV1"},{type:"null"}]},agent_count:{format:"int64",type:["integer","null"]},agent_label:{type:["string","null"]},agents:{items:{$ref:"#/$defs/WorkflowAgentV1"},type:["array","null"]},agents_complete:{type:["boolean","null"]},agents_coverage:{anyOf:[{$ref:"#/$defs/WorkflowCoverageV1"},{type:"null"}]},agents_returned:{format:"uint",minimum:0,type:["integer","null"]},count:{format:"uint",minimum:0,type:["integer","null"]},error:{anyOf:[{$ref:"#/$defs/RetainedErrorV1"},{type:"null"}]},found:{type:["boolean","null"]},git_filter:{anyOf:[{$ref:"#/$defs/GitScopeV1"},{type:"null"}]},lookup_complete:{type:["boolean","null"]},lookup_coverage:{anyOf:[{$ref:"#/$defs/WorkflowCoverageV1"},{type:"null"}]},message:{type:["string","null"]},mode:{anyOf:[{$ref:"#/$defs/WorkflowQueryModeV1"},{type:"null"}]},run:{anyOf:[{$ref:"#/$defs/WorkflowRunV1"},{type:"null"}]},run_id:{type:["string","null"]},runs:{items:{$ref:"#/$defs/WorkflowRunV1"},type:["array","null"]},session_id:{type:["string","null"]},status:{$ref:"#/$defs/RetainedOutcomeStatusV1"}},required:["status"],title:"WorkflowsResultV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Confirmation names the exact inspection digest, not a worktree id alone.",properties:{inspection_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target","inspection_digest"],title:"WorktreeCleanupConfirmRequestV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target"],title:"WorktreeCleanupInspectRequestV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target","confirmation_digest"],title:"WorktreeCleanupReconcileRequestV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,UtcMicros:bZ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Removal carries both proofs so a stale confirmation cannot be replayed\nagainst another inspection of the same opaque worktree identity.",properties:{confirmation_digest:{$ref:"#/$defs/ManifestDigest"},confirmed_at:{$ref:"#/$defs/UtcMicros"},inspection_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target","inspection_digest","confirmed_at","confirmation_digest"],title:"WorktreeCleanupRemoveRequestV1",type:"object"},{$defs:{ManifestDigest:_l,NativeWorktreeTargetV1:_E,ProjectId:_4,RepositoryId:vb,ScopeSetId:vX,ScopeSetRevision:vY,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"},target:{$ref:"#/$defs/NativeWorktreeTargetV1"}},required:["scope_set_id","scope_set_revision","scope_set_digest","target"],title:"WorktreeInventoryRequestV1",type:"object"},{$defs:{ActorId:fb,TaskId:bT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Issues a short-lived, version-bound task-opening token.\n\nIdentity, scope, authority revisions, issuance time, and expiry are all\nsupplied by the admitted daemon request. The caller supplies only the\nbearer, destination session, exact task version, and enrolled recipient\nprincipal it intends to authorize.",properties:{recipient_actor_id:{$ref:"#/$defs/ActorId"},session_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"},token:{type:"string"},version:{format:"uint64",minimum:0,type:"integer"}},required:["token","session_id","task_id","version","recipient_actor_id"],title:"IssueTaskHandoffRequestV1",type:"object"},{$defs:{ManifestDigest:_l,TaskId:bT,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Flat public receipt for a committed task-handoff issue.\n\nThe complete binding remains inside the daemon authority. Publishing only\nthese exact identifiers avoids turning mutable grant and policy internals\ninto a second public wire authority.",properties:{expires_at:{$ref:"#/$defs/UtcMicros"},issued_at:{$ref:"#/$defs/UtcMicros"},issued_request_id:{type:"string"},session_id:{type:"string"},task_id:{$ref:"#/$defs/TaskId"},token_digest:{$ref:"#/$defs/ManifestDigest"},version:{format:"uint64",minimum:0,type:"integer"}},required:["token_digest","issued_request_id","session_id","task_id","version","issued_at","expires_at"],title:"IssueTaskHandoffResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:'Enumerates the handoff tokens this caller could redeem in one session.\n\nThe two `open_*` operations redeem a bearer the caller already holds; they\ncannot answer "what has been handed to me and not yet taken up". This one\ncan, and it does so without any bearer: the request carries no token, and\nthe result carries only digests.',properties:{session_id:{type:"string"}},required:["session_id"],title:"ListTaskHandoffsRequestV1",type:"object"},{$defs:{FeedbackFindingId:y8,HandoffOpenKindV1:{enum:["investigation","task"],type:"string"},HandoffOpenTargetV1:{oneOf:[{properties:{finding_id:{$ref:"#/$defs/FeedbackFindingId"},kind:{const:"investigation",type:"string"},owner_version_digest:{$ref:"#/$defs/ManifestDigest"}},required:["kind","finding_id","owner_version_digest"],type:"object"},{properties:{kind:{const:"task",type:"string"},owner_version_digest:{$ref:"#/$defs/ManifestDigest"},task_id:{$ref:"#/$defs/TaskId"},version:{format:"uint64",minimum:0,type:"integer"}},required:["kind","task_id","version","owner_version_digest"],type:"object"}]},ListedTaskHandoffV1:{additionalProperties:!1,description:"One handoff token, projected for public reading.\n\nMirrors [`IssueTaskHandoffResultV1`]'s doctrine: the complete binding stays\ninside the daemon authority, and only these identifiers cross the wire. No\nbearer secret exists to leak here. The authority never stored one, and the\nissuer's grant identity and policy digests stay concealed.",properties:{consumed_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}],description:"Set only when `state` is `consumed`."},expires_at:{$ref:"#/$defs/UtcMicros"},issued_at:{$ref:"#/$defs/UtcMicros"},issued_request_id:{type:"string"},kind:{$ref:"#/$defs/HandoffOpenKindV1"},session_id:{type:"string"},state:{$ref:"#/$defs/TaskHandoffTokenStateV1"},target:{$ref:"#/$defs/HandoffOpenTargetV1"},token_digest:{$ref:"#/$defs/ManifestDigest"}},required:["token_digest","issued_request_id","session_id","kind","target","issued_at","expires_at","state"],type:"object"},ManifestDigest:_l,TaskHandoffTokenStateV1:{description:"Where one enumerated token stands at the observed instant.",oneOf:[{const:"open",description:"Not yet redeemed, and not yet expired: the live frontier.",type:"string"},{const:"consumed",description:"Redeemed. Single-use, so it can never be redeemed again.",type:"string"},{const:"expired",description:"Its window closed with no redemption. A dropped handoff, which is\nexactly the fact a frontier exists to surface.",type:"string"}]},TaskId:bT,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The handoff-token frontier for one session.",properties:{consumed_count:{format:"uint32",minimum:0,type:"integer"},expired_count:{format:"uint32",minimum:0,type:"integer"},handoffs:{items:{$ref:"#/$defs/ListedTaskHandoffV1"},type:"array"},observed_at:{$ref:"#/$defs/UtcMicros",description:"The instant the states below were decided at. Without it, `open` and\n`expired` are claims with no clock behind them."},open_count:{format:"uint32",minimum:0,type:"integer"},truncated:{description:"True when the enumeration ceiling was reached, so the counts describe a\nprefix of the frontier rather than all of it.",type:"boolean"}},required:["observed_at","handoffs","open_count","consumed_count","expired_count","truncated"],title:"ListTaskHandoffsResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{session_id:{type:"string"},token:{type:"string"}},required:["token","session_id"],title:"OpenInvestigationHandoffRequestV1",type:"object"},{$defs:{FeedbackFindingId:y8,HandoffOpenReceiptV1:gD,InvestigationHandoffSurfaceV1:{additionalProperties:!1,properties:{finding_id:{$ref:"#/$defs/FeedbackFindingId"},owner_version_digest:{$ref:"#/$defs/ManifestDigest"}},required:["finding_id","owner_version_digest"],type:"object"},ManifestDigest:_l,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{receipt:{$ref:"#/$defs/HandoffOpenReceiptV1"},surface:{$ref:"#/$defs/InvestigationHandoffSurfaceV1"}},required:["surface","receipt"],title:"OpenInvestigationHandoffResultV1",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{session_id:{type:"string"},token:{type:"string"}},required:["token","session_id"],title:"OpenTaskHandoffRequestV1",type:"object"},{$defs:{HandoffOpenReceiptV1:gD,ManifestDigest:_l,TaskHandoffSurfaceV1:{additionalProperties:!1,properties:{task_id:{$ref:"#/$defs/TaskId"},version:{format:"uint64",minimum:0,type:"integer"}},required:["task_id","version"],type:"object"},TaskId:bT,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{receipt:{$ref:"#/$defs/HandoffOpenReceiptV1"},surface:{$ref:"#/$defs/TaskHandoffSurfaceV1"}},required:["surface","receipt"],title:"OpenTaskHandoffResultV1",type:"object"},{$defs:{ManifestDigest:_l,MultiRootContinuationV1:_P,MultiRootOperationV1:{description:"Closed federated read families. The family is typed while its existing\noperation-specific request remains the canonical JSON payload owned by that\napplication surface.",oneOf:[{properties:{kind:{const:"work",type:"string"},request:!0},required:["kind","request"],type:"object"},{properties:{kind:{const:"git",type:"string"},request:!0},required:["kind","request"],type:"object"},{properties:{kind:{const:"feedback",type:"string"},request:!0},required:["kind","request"],type:"object"},{properties:{kind:{const:"impact",type:"string"},request:!0},required:["kind","request"],type:"object"},{properties:{kind:{const:"query",type:"string"},request:!0},required:["kind","request"],type:"object"}]},RootGenerationV1:vM,RootScopeOutcomeV1_for_Nullable_RootGenerationV1:vN,RootScopeOutcomeV1_for_Nullable_string:vz,ScopeOutcome_for_Nullable_RootGenerationV1:vJ,ScopeOutcome_for_Nullable_string:vZ,ScopePartialReasonV1:vQ,ScopeSetId:vX,ScopeSetRevision:vY,ScopeUnavailableReasonV1:v0},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"External federated request bound to one persisted scope-set revision and\ndigest. Query/order digests and root generations are server-derived.",properties:{continuation:{anyOf:[{$ref:"#/$defs/MultiRootContinuationV1"},{type:"null"}]},operation:{$ref:"#/$defs/MultiRootOperationV1"},page:{format:"uint64",minimum:0,type:"integer"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"}},required:["scope_set_id","scope_set_revision","scope_set_digest","operation","page"],title:"MultiRootExecuteRequestV1",type:"object"},{$defs:{ManifestDigest:_l,MultiRootContinuationV1:_P,RootGenerationV1:vM,RootScopeOutcomeV1_for_Array_of_AnyValue:{additionalProperties:!1,description:"One typed outcome pinned to the digest of an exact resolved root.",properties:{outcome:{$ref:"#/$defs/ScopeOutcome_for_Array_of_AnyValue"},scope_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope_digest","outcome"],type:"object"},RootScopeOutcomeV1_for_Nullable_RootGenerationV1:vN,RootScopeOutcomeV1_for_Nullable_string:vz,ScopeOutcome_for_Array_of_AnyValue:{description:"Truthful outcome for one authorized root or an aggregate over roots.\n\n`Denied` and `Unavailable` carry no value and therefore cannot be confused\nwith a successful empty result.",oneOf:[{properties:{outcome:{const:"exact",type:"string"},value:{items:!0,type:"array"}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"partial",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopePartialReasonV1"},value:{items:!0,type:"array"}},required:["value","reason"],type:"object"}},required:["outcome","value"],type:"object"},{properties:{outcome:{const:"denied",type:"string"}},required:["outcome"],type:"object"},{properties:{outcome:{const:"unavailable",type:"string"},value:{properties:{reason:{$ref:"#/$defs/ScopeUnavailableReasonV1"}},required:["reason"],type:"object"}},required:["outcome","value"],type:"object"}]},ScopeOutcome_for_Nullable_RootGenerationV1:vJ,ScopeOutcome_for_Nullable_string:vZ,ScopePartialReasonV1:vQ,ScopeSetId:vX,ScopeSetRevision:vY,ScopeUnavailableReasonV1:v0},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Federated page preserving each root outcome and aggregate partial truth.",properties:{aggregate:{$ref:"#/$defs/ScopeOutcome_for_Array_of_AnyValue"},continuation:{anyOf:[{$ref:"#/$defs/MultiRootContinuationV1"},{type:"null"}]},roots:{items:{$ref:"#/$defs/RootScopeOutcomeV1_for_Array_of_AnyValue"},type:"array"},scope_set_digest:{$ref:"#/$defs/ManifestDigest"},scope_set_id:{$ref:"#/$defs/ScopeSetId"},scope_set_revision:{$ref:"#/$defs/ScopeSetRevision"}},required:["scope_set_id","scope_set_revision","scope_set_digest","roots","aggregate"],title:"MultiRootQueryPageV1_for_AnyValue",type:"object"},{$defs:{ProjectId:_4,RegisteredRootSelectorV1:{additionalProperties:!1,description:"Exact registered-root selector accepted by scope-set CAS.",properties:{project_id:{$ref:"#/$defs/ProjectId"},root:{type:"string"}},required:["project_id","root"],type:"object"},ScopeSetId:vX,ScopeSetRevision:vY},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Canonical external selector for creating or updating an authorized scope\nset. Every member names one exact registered root; project-only selection\ncannot silently widen to an active or first-mounted graph.",properties:{expected_revision:{anyOf:[{$ref:"#/$defs/ScopeSetRevision"},{type:"null"}]},roots:{items:{$ref:"#/$defs/RegisteredRootSelectorV1"},type:"array"},scope_set_id:{$ref:"#/$defs/ScopeSetId"}},required:["scope_set_id","roots"],title:"MultiRootScopeSetCasRequestV1",type:"object"},{$defs:{ActorId:fb,AuthorizedRoot:fN,AuthorizedScopeSet:fz,BrainId:f1,ManifestDigest:_l,MultiRootScopeSetCasStatusV1:{enum:["applied","conflict"],type:"string"},ProjectId:_4,RefId:vm,RegisteredRootLocatorV1:vf,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,SharedProfileStoreLocatorV1:bs,UserProfileId:bJ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope_set:{anyOf:[{$ref:"#/$defs/AuthorizedScopeSet"},{type:"null"}]},status:{$ref:"#/$defs/MultiRootScopeSetCasStatusV1"}},required:["status"],title:"MultiRootScopeSetCasResultV1",type:"object"},{$defs:{ScopeSetId:vX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{scope_set_id:{$ref:"#/$defs/ScopeSetId"}},required:["scope_set_id"],title:"MultiRootScopeSetReadRequestV1",type:"object"},{$defs:{ActorId:fb,AuthorizedRoot:fN,AuthorizedScopeSet:fz,BrainId:f1,ManifestDigest:_l,ProjectId:_4,RefId:vm,RegisteredRootLocatorV1:vf,RepositoryId:vb,ResolvedScope:vw,ScopeSetId:vX,ScopeSetRevision:vY,SharedProfileStoreLocatorV1:bs,UserProfileId:bJ,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",anyOf:[{$ref:"#/$defs/AuthorizedScopeSet"},{type:"null"}],title:"Nullable_AuthorizedScopeSet"},{$defs:{AcceptWorkProposalDispositionV1:{description:"The accept-proposal operation can commit acceptance only.",enum:["accepted"],type:"string"},CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkCommandId:$p,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/AcceptWorkProposalDispositionV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal","disposition","mutation"],title:"AcceptWorkProposalRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,BrainId:f1,CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,SourceStoreId:bS,TaskEvidenceLinkV1:bj,TaskId:bT,UserProfileId:bJ,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkGraphChangeV1:$j,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductEventPayloadV1:$1,WorkProductEventV1:$0,WorkProductGraphV1:$4,WorkProductProfileScopeV1:$9,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{event:{$ref:"#/$defs/WorkProductEventV1"},replayed:{type:"boolean"},verified_graph_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["event","verified_graph_version","replayed"],title:"WorkProductMutationReceiptV1",type:"object"},{$defs:{AttemptId:fW,CoverageStateV1:yf,DuplicateEffectOutcomeV1:yP,DuplicateEffortKindV1:yV,ProjectionGenerationId:_5,QuantityEvidenceClassV1:vs,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkDuplicateAdjudicationEvidenceV1:$m,WorkDuplicateAdjudicationQuantitiesV1:$f,WorkTopologyGenerationRefV1:SE},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},evidence:{$ref:"#/$defs/WorkDuplicateAdjudicationEvidenceV1"},expected_revision:{format:"uint64",minimum:0,type:["integer","null"]},first_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},occurred_at:{$ref:"#/$defs/UtcMicros"},quantities:{$ref:"#/$defs/WorkDuplicateAdjudicationQuantitiesV1"},reason:{type:"string"},second_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},verdict:{$ref:"#/$defs/DuplicateEffortKindV1"}},required:["first_attempt","second_attempt","evidence","verdict","quantities","reason","command_id","occurred_at"],title:"WorkDuplicateAdjudicationCommandV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,CoverageStateV1:yf,DuplicateEffectOutcomeV1:yP,DuplicateEffortKindV1:yV,ManifestDigest:_l,ProjectionGenerationId:_5,QuantityEvidenceClassV1:vs,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkDuplicateAdjudicationCommandV1:{additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},evidence:{$ref:"#/$defs/WorkDuplicateAdjudicationEvidenceV1"},expected_revision:{format:"uint64",minimum:0,type:["integer","null"]},first_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},occurred_at:{$ref:"#/$defs/UtcMicros"},quantities:{$ref:"#/$defs/WorkDuplicateAdjudicationQuantitiesV1"},reason:{type:"string"},second_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},verdict:{$ref:"#/$defs/DuplicateEffortKindV1"}},required:["first_attempt","second_attempt","evidence","verdict","quantities","reason","command_id","occurred_at"],type:"object"},WorkDuplicateAdjudicationEvidenceV1:$m,WorkDuplicateAdjudicationQuantitiesV1:$f,WorkDuplicateAdjudicationReceiptV1:{additionalProperties:!1,properties:{actor_id:{$ref:"#/$defs/ActorId"},adjudication_ref:{$ref:"#/$defs/ManifestDigest"},canonical_input_digest:{$ref:"#/$defs/ManifestDigest"},command:{$ref:"#/$defs/WorkDuplicateAdjudicationCommandV1"},revision:{format:"uint64",minimum:0,type:"integer"}},required:["command","revision","actor_id","canonical_input_digest","adjudication_ref"],type:"object"},WorkTopologyGenerationRefV1:SE},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{outcome:{const:"appended",type:"string"},receipt:{$ref:"#/$defs/WorkDuplicateAdjudicationReceiptV1"}},required:["outcome","receipt"],type:"object"},{properties:{outcome:{const:"replayed",type:"string"},receipt:{$ref:"#/$defs/WorkDuplicateAdjudicationReceiptV1"}},required:["outcome","receipt"],type:"object"}],title:"WorkDuplicateAdjudicationAppendOutcomeV1"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,WorkAttemptIdentityV1:b6,WorkCommandId:$p},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{adjudication_id:{type:"string"},attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},command_id:{$ref:"#/$defs/WorkCommandId"},detection_horizon_micros:{format:"uint64",minimum:0,type:"integer"},expected_revision:{format:"uint64",minimum:0,type:["integer","null"]}},required:["adjudication_id","attempt","detection_horizon_micros","command_id"],title:"AdjudicateWorkLeakCommandV1",type:"object"},{$defs:{AdjudicateWorkLeakCommandV1:{additionalProperties:!1,properties:{adjudication_id:{type:"string"},attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},command_id:{$ref:"#/$defs/WorkCommandId"},detection_horizon_micros:{format:"uint64",minimum:0,type:"integer"},expected_revision:{format:"uint64",minimum:0,type:["integer","null"]}},required:["adjudication_id","attempt","detection_horizon_micros","command_id"],title:"AdjudicateWorkLeakCommandV1",type:"object"},AttemptId:fW,CoverageStateV1:yf,LeakOwnerClassV1:{enum:["work","workflow","git","delivery","unknown"],type:"string"},ManifestDigest:_l,RunId:vF,TaskId:bT,UtcMicros:bZ,VerifiedWorkLeakEvidenceV1:{additionalProperties:!1,description:"Exact result of one scan by the canonical lease/process/effect/placement/\ndelivery evidence owner. Evidence references are opaque local anchors;\ntheir owning records remain behind normal authorization.",properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},coverage:{$ref:"#/$defs/CoverageStateV1"},detection_horizon_micros:{format:"uint64",minimum:0,type:"integer"},evidence_refs:{items:{type:"string"},type:"array"},kind:{$ref:"#/$defs/WorkExecutionLeakKindV1"},owner_class:{$ref:"#/$defs/LeakOwnerClassV1"},recovery:{$ref:"#/$defs/WorkExecutionLeakRecoveryV1"},scan_completed_at:{$ref:"#/$defs/UtcMicros"},scan_started_at:{$ref:"#/$defs/UtcMicros"}},required:["attempt","kind","recovery","owner_class","coverage","detection_horizon_micros","scan_started_at","scan_completed_at","evidence_refs"],type:"object"},WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkExecutionLeakKindV1:{enum:["lease_after_terminal","attempt_without_live_owner","effect_unknown_past_deadline","missing_worktree_binding","unbounded_delivery","none","unknown"],type:"string"},WorkExecutionLeakRecoveryV1:{enum:["not_required","pending","recovered","failed","unknown"],type:"string"},WorkLeakAdjudicationReceiptV1:{additionalProperties:!1,properties:{canonical_input_digest:{$ref:"#/$defs/ManifestDigest"},command:{$ref:"#/$defs/AdjudicateWorkLeakCommandV1"},evidence:{$ref:"#/$defs/VerifiedWorkLeakEvidenceV1"},revision:{format:"uint64",minimum:0,type:"integer"},scan_deadline:{$ref:"#/$defs/UtcMicros",description:"Daemon/request-owned deadline that bounded the source scan."}},required:["command","revision","evidence","scan_deadline","canonical_input_digest"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{outcome:{const:"appended",type:"string"},receipt:{$ref:"#/$defs/WorkLeakAdjudicationReceiptV1"}},required:["outcome","receipt"],type:"object"},{properties:{outcome:{const:"replayed",type:"string"},receipt:{$ref:"#/$defs/WorkLeakAdjudicationReceiptV1"}},required:["outcome","receipt"],type:"object"}],title:"WorkLeakAdjudicationOutcomeV1"},{$defs:{CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RetrievalAnchorId:vI,SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkCommandId:$p,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","based_on_version","mutation"],title:"AdmitWorkExecutionRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,AutomaticWorktreeGcV1:fF,BrainId:f1,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CatalogGenerationId:hp,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,RetrievalAnchorId:vI,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,SourceStoreId:bS,TaskEvidenceLinkV1:bj,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UserProfileId:bJ,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkApprovalPolicy:b1,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkGraphChangeV1:$j,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductEventPayloadV1:$1,WorkProductEventV1:$0,WorkProductGraphV1:$4,WorkProductMutationReceiptV1:$3,WorkProductProfileScopeV1:$9,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkSandboxPolicy:Sw,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTopologyPolicyV1:SA,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Execution admission together with the immutable provider snapshot licensed\nby the accepted proposal and current configuration authority.",properties:{execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},mutation:{$ref:"#/$defs/WorkProductMutationReceiptV1"}},required:["mutation","execution_snapshot"],title:"AdmittedWorkExecutionV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementKindV1:$B,WorkPlacementTargetV1:$J},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{occurred_at:{$ref:"#/$defs/UtcMicros"},retention_eligible_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}],default:null,description:"When retention makes this placement eligible for a fresh cleanup\npreflight. Eligibility is not delete authority."},run_id:{$ref:"#/$defs/RunId"},target:{$ref:"#/$defs/WorkPlacementTargetV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","target","occurred_at"],title:"AdmitWorkPlacementCommand",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementStateV1:$K,WorkPlacementTargetV1:$J},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One run's durable placement relation.",properties:{authority_version:{format:"uint64",minimum:0,type:"integer"},blockers:{items:{$ref:"#/$defs/WorkPlacementBlockerV1"},type:"array",uniqueItems:!0},identity:{$ref:"#/$defs/WorkPlacementIdentityV1"},retention_eligible_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}],description:"When retention makes this placement *eligible* for a fresh cleanup\npreflight. Eligibility is not delete authority."},state:{$ref:"#/$defs/WorkPlacementStateV1"},target:{$ref:"#/$defs/WorkPlacementTargetV1"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["identity","target","state","authority_version","transitioned_at","blockers"],title:"WorkPlacementV1",type:"object"},{$defs:{CommitId:hq,RefId:vm,WorkEffectStateV1:$h,WorkJobBaseV1:{additionalProperties:!1,description:"The source revision every attempt in the job starts from.",properties:{commit:{$ref:"#/$defs/CommitId"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]}},required:["commit"],type:"object"},WorkJobKeyV1:$z,WorkJobNameV1:{description:"A job name: `[a-z0-9-]`, 1 to 48 bytes. Identities derive from it.",type:"string"},WorkJobSynthesisV1:{additionalProperties:!1,properties:{instructions:{type:"string"},output_name:{$ref:"#/$defs/WorkflowOutputName"},task:{$ref:"#/$defs/WorkJobKeyV1",description:"The synthesis attempt runs under this task's run and execution snapshot."}},required:["task","output_name","instructions"],type:"object"},WorkJobTaskV1:{additionalProperties:!1,properties:{instructions:{type:"string"},key:{$ref:"#/$defs/WorkJobKeyV1"},placement:{$ref:"#/$defs/WorkPlacementTargetV1"},title:{type:"string"}},required:["key","title","instructions","placement"],type:"object"},WorkPlacementKindV1:$B,WorkPlacementTargetV1:$J,WorkflowOutputName:SD},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One guided job: the tasks to run in parallel, where each runs, and the\nsynthesis that reviews them.",properties:{base:{$ref:"#/$defs/WorkJobBaseV1"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},job:{$ref:"#/$defs/WorkJobNameV1"},synthesis:{$ref:"#/$defs/WorkJobSynthesisV1"},tasks:{items:{$ref:"#/$defs/WorkJobTaskV1"},type:"array"},title:{type:"string"}},required:["job","title","base","effect_state","tasks","synthesis"],title:"AdvanceWorkJobRequestV1",type:"object"},{$defs:{ActorId:fb,AdmittedWorkExecutionV1:{additionalProperties:!1,description:"Execution admission together with the immutable provider snapshot licensed\nby the accepted proposal and current configuration authority.",properties:{execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},mutation:{$ref:"#/$defs/WorkProductMutationReceiptV1"}},required:["mutation","execution_snapshot"],type:"object"},ApplicationExecutionFailureClassV1:{description:"Stable non-retryable class for an admitted execution failure.",enum:["denied","malformed_output","permanent"],type:"string"},ApplicationProblemDetailV1:fA,ApplicationProblemKind:{description:"Stable problem-code taxonomy for request failures and admitted terminals.",enum:["invalid_request","not_found_or_not_authorized","conflict","partial_effect","stale","unsupported","unavailable","execution_failed","reset_required","saturated","cancelled","timed_out"],type:"string"},ApplicationProblemRecord:{additionalProperties:!1,description:"Stable application problem record shared verbatim by every adapter.",properties:{cancellation_stage:{$ref:"#/$defs/RequiredNullable3"},code:{type:"string"},committed_receipt:{$ref:"#/$defs/RequiredNullable2",description:"A committed effect is present only for an admitted partial effect.\nThe nullable field is always serialized: omitting it would create a\ncompatibility/default path that could hide a missing receipt."},coverage:{anyOf:[{$ref:"#/$defs/EvidenceCoverage"},{type:"null"}]},detail:{$ref:"#/$defs/RequiredNullable",description:"The structured facts `message` is rendered from, when the problem has\nany. Always serialized so a client never mistakes an omitted detail\nfor a problem without one."},details:{items:{$ref:"#/$defs/SafeDiagnostic"},type:"array"},diagnostic:{anyOf:[{$ref:"#/$defs/SafeDiagnostic"},{type:"null"}]},execution_failure_classification:{$ref:"#/$defs/RequiredNullable5"},kind:{$ref:"#/$defs/ApplicationProblemKind"},legal_actions:{items:{$ref:"#/$defs/LegalAction"},type:"array"},message:{type:"string"},owning_layer:{$ref:"#/$defs/ProblemOwningLayer"},request_id:{type:"string"},retry:{$ref:"#/$defs/RetryDirective"},retry_after_millis:{format:"uint64",minimum:0,type:["integer","null"]},retry_scope:{anyOf:[{$ref:"#/$defs/RetryScope"},{type:"null"}]},retryable:{type:"boolean"},revision:{format:"uint32",minimum:0,type:"integer"},terminality:{$ref:"#/$defs/ProblemTerminality"},trace_id:{type:"string"},unavailable_classification:{$ref:"#/$defs/RequiredNullable4"}},required:["revision","kind","code","message","detail","committed_receipt","owning_layer","terminality","retryable","retry","cancellation_stage","unavailable_classification","execution_failure_classification","request_id","trace_id","details","legal_actions"],type:"object"},ApplicationUnavailableClassV1:{description:"Stable reason an application authority is unavailable.",enum:["authority","backend_unavailable","backend_disconnected","backend_retryable"],type:"string"},AttemptId:fW,AutomaticWorktreeGcV1:fF,BrainId:f1,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CancellationStage:ha,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CatalogGenerationId:hp,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CoverageCompleteness:yu,CoverageDomainState:ym,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,DaemonServiceUnitObservationV1:y_,DiagnosticsSearchedTsconfigV1:yS,EffectClass:yR,EffectReceipt:yq,EffectTermination:yI,EvidenceCoverage:yx,EvidenceDomain:yj,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LegalAction:{description:"Bounded action an adapter may offer without inferring executable authority.",enum:["correct_request","reauthorize","refresh","retry","reconcile","reset","restart_without_cursor","contact_administrator"],type:"string"},LocatorDigest:_r,ManifestDigest:_l,ProblemOwningLayer:{description:"Layer that owns resolving the problem rather than merely presenting it.",enum:["adapter","application","runtime","port"],type:"string"},ProblemTerminality:{description:"Whether the problem occurred before admission or is an admitted terminal.",enum:["pre_admission","admitted_terminal"],type:"string"},ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,RequiredNullable:{anyOf:[{$ref:"#/$defs/ApplicationProblemDetailV1"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},RequiredNullable2:{anyOf:[{$ref:"#/$defs/EffectReceipt"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},RequiredNullable3:{anyOf:[{$ref:"#/$defs/CancellationStage"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},RequiredNullable4:{anyOf:[{$ref:"#/$defs/ApplicationUnavailableClassV1"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},RequiredNullable5:{anyOf:[{$ref:"#/$defs/ApplicationExecutionFailureClassV1"},{type:"null"}],description:"Unlike `Option<T>`, this wrapper distinguishes an explicit JSON `null`\nfrom an omitted field. New terminal-state fields must be present on every\nrecord so a missing committed receipt cannot be mistaken for `None`."},ResolvedScope:vw,RetrievalAnchorId:vI,RetryDirective:{description:"Safe adapter-independent retry instruction. Adapters preserve it verbatim.",enum:["never","same_request","after_delay","after_revalidate","after_reconcile"],type:"string"},RetryScope:{description:"Request identity boundary within which a retry remains valid.",enum:["same_request","same_operation","fresh_request"],type:"string"},ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SafeDiagnostic:{additionalProperties:!1,description:"Sanitized detail that may cross the application boundary.",properties:{code:{type:"string"},message:{type:"string"}},required:["code","message"],type:"object"},SensitiveFilesystemLocatorV1:v4,SourceStoreId:bS,TaskEvidenceLinkV1:bj,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UseCaseId:bK,UserProfileId:bJ,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkCommandId:$p,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkGraphChangeV1:$j,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkJobIdentitiesV1:{additionalProperties:!1,properties:{operation:{$ref:"#/$defs/WorkflowOperationRef"},synthesis:{$ref:"#/$defs/WorkAttemptIdentityV1"},tasks:{items:{$ref:"#/$defs/WorkJobTaskIdentitiesV1"},type:"array"}},required:["operation","tasks","synthesis"],type:"object"},WorkJobKeyV1:$z,WorkJobStateV1:{oneOf:[{additionalProperties:!1,description:"The call's deadline floor arrived with work left; call again now.",properties:{state:{const:"advancing",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"Nothing can move until providers, routing, or capacity progress.",properties:{on:{items:{$ref:"#/$defs/WorkJobWaitV1"},type:"array"},state:{const:"waiting",type:"string"}},required:["state","on"],type:"object"},{additionalProperties:!1,description:"The chain stopped at `step`. `problem` is the record the step's own\noperation produced, or a guided refusal naming the job-level cause.",properties:{problem:{$ref:"#/$defs/ApplicationProblemRecord"},state:{const:"refused",type:"string"},step:{$ref:"#/$defs/WorkJobStepV1"}},required:["state","step","problem"],type:"object"},{additionalProperties:!1,properties:{sources:{items:{$ref:"#/$defs/WorkAttemptV1"},type:"array"},state:{const:"completed",type:"string"},synthesis:{$ref:"#/$defs/WorkAttemptV1"}},required:["state","sources","synthesis"],type:"object"}]},WorkJobStepRecordV1:{additionalProperties:!1,description:"A step this call executed, with its operation's own effect receipt.",properties:{receipt:{$ref:"#/$defs/EffectReceipt"},request_id:{type:"string"},result:{$ref:"#/$defs/WorkJobStepResultV1"},step:{$ref:"#/$defs/WorkJobStepV1"}},required:["step","request_id","receipt","result"],type:"object"},WorkJobStepResultV1:{description:"Every arm is an existing Work operation's own output.",oneOf:[{properties:{result:{const:"graph",type:"string"},value:{$ref:"#/$defs/WorkProductMutationReceiptV1"}},required:["result","value"],type:"object"},{properties:{result:{const:"execution",type:"string"},value:{$ref:"#/$defs/AdmittedWorkExecutionV1"}},required:["result","value"],type:"object"},{properties:{result:{const:"placement",type:"string"},value:{$ref:"#/$defs/WorkPlacementV1"}},required:["result","value"],type:"object"},{properties:{result:{const:"attempt",type:"string"},value:{$ref:"#/$defs/WorkAttemptV1"}},required:["result","value"],type:"object"},{properties:{result:{const:"synthesis",type:"string"},value:{$ref:"#/$defs/WorkSynthesisAttemptV1"}},required:["result","value"],type:"object"}]},WorkJobStepV1:{description:"One existing Work operation the guided job runs. There is deliberately no\narm that advances a job, so a step can never recurse into the guided path.",oneOf:[{additionalProperties:!1,properties:{step:{const:"create_task",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"accept_proposal",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"admit_execution",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"admit_placement",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"start_source",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"},{additionalProperties:!1,properties:{step:{const:"await_sources",type:"string"}},required:["step"],type:"object"},{additionalProperties:!1,properties:{step:{const:"synthesize",type:"string"}},required:["step"],type:"object"},{additionalProperties:!1,properties:{step:{const:"await_synthesis",type:"string"}},required:["step"],type:"object"},{additionalProperties:!1,properties:{step:{const:"release_placement",type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"}},required:["step","task"],type:"object"}]},WorkJobTaskIdentitiesV1:{additionalProperties:!1,properties:{key:{$ref:"#/$defs/WorkJobKeyV1"},proposal_id:{$ref:"#/$defs/ProposalId"},source:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["key","proposal_id","source"],type:"object"},WorkJobWaitV1:{oneOf:[{additionalProperties:!1,description:"The proposal route abstained, as it does while routing warms.",properties:{reason:{type:"string"},task:{$ref:"#/$defs/WorkJobKeyV1"},wait:{const:"proposal_route",type:"string"}},required:["wait","task","reason"],type:"object"},{additionalProperties:!1,properties:{identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"},wait:{const:"attempt",type:"string"}},required:["wait","identity","state"],type:"object"},{additionalProperties:!1,description:"The registered topology has no free attempt slot for this task.",properties:{problem:{$ref:"#/$defs/ApplicationProblemRecord"},task:{$ref:"#/$defs/WorkJobKeyV1"},wait:{const:"capacity",type:"string"}},required:["wait","task","problem"],type:"object"}]},WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkMilestoneV1:$L,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementStateV1:$K,WorkPlacementTargetV1:$J,WorkPlacementV1:$Z,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductEventPayloadV1:$1,WorkProductEventV1:$0,WorkProductGraphV1:$4,WorkProductMutationReceiptV1:$3,WorkProductProfileScopeV1:$9,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRestartReasonV1:Sm,WorkRouteDecisionV1:S_,WorkSandboxPolicy:Sw,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkSynthesisAttemptV1:{description:"The typed outcome of a synthesis request: an admitted attempt, or the\nsealed unsynthesized set when synthesis could not truthfully begin.",oneOf:[{additionalProperties:!1,description:"The admitted synthesis attempt and everything it is accountable to.",properties:{attempt:{$ref:"#/$defs/WorkAttemptV1",description:"The leased (or idempotently replayed) synthesis attempt."},draft:{$ref:"#/$defs/WorkflowSynthesisDraft",description:"The citation obligation, complete by construction: the draft cites\nevery citable source digest and is verified downstream by\n[`crate::workflow_synthesis::verify_workflow_synthesis_draft`]."},groups:{description:"Disagreement structure over the succeeded sources.",items:{$ref:"#/$defs/WorkSynthesisEvidenceGroupV1"},type:"array"},source_set:{$ref:"#/$defs/WorkSynthesisSourceSetV1",description:"The sealed source envelopes the attempt was admitted against."},synthesis:{const:"admitted",type:"string"},uncited:{description:"Sources preserved without citations: failures, unknowns, and\nartifact-less successes, in the caller's requested order.",items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"}},required:["synthesis","attempt","source_set","groups","draft","uncited"],type:"object"},{properties:{refusal:{$ref:"#/$defs/WorkSynthesisRefusalV1"},sources:{$ref:"#/$defs/WorkSynthesisSourceSetV1"},synthesis:{const:"unsynthesized",type:"string"}},required:["synthesis","sources","refusal"],type:"object"}]},WorkSynthesisEvidenceGroupV1:Sq,WorkSynthesisRefusalV1:SI,WorkSynthesisSourceEnvelopeV1:Sx,WorkSynthesisSourceOutcomeV1:Sj,WorkSynthesisSourceSetV1:SC,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowSynthesisDraft:SH,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"What one call did and where the job now stands.",properties:{job:{$ref:"#/$defs/WorkJobIdentitiesV1",description:"The derived identities, so the advanced operations can target them."},performed:{description:"Only the steps this call executed, in order.",items:{$ref:"#/$defs/WorkJobStepRecordV1"},type:"array"},state:{$ref:"#/$defs/WorkJobStateV1"}},required:["job","performed","state"],title:"AdvanceWorkJobResultV1",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{attempt_id:{$ref:"#/$defs/AttemptId"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","attempt_id"],title:"WorkAttemptStatusRequestV1",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkSandboxPolicy:Sw,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",properties:{actual_route:{anyOf:[{$ref:"#/$defs/WorkProviderRouteV1"},{type:"null"}]},artifacts:{items:{$ref:"#/$defs/WorkArtifactRefV1"},type:"array"},cancellation:{$ref:"#/$defs/WorkCancellationStateV1"},execution:{$ref:"#/$defs/WorkExecutionEnvelopeV1"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},lease:{$ref:"#/$defs/WorkLeaseFenceV1"},progress:{anyOf:[{$ref:"#/$defs/WorkAttemptProgressV1"},{type:"null"}]},projection_binding:{$ref:"#/$defs/WorkAttemptProjectionBindingV1"},recovery:{$ref:"#/$defs/WorkRecoveryStateV1"},requested_route:{$ref:"#/$defs/WorkProviderRouteV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"},terminal:{anyOf:[{$ref:"#/$defs/WorkTerminalEvidenceV1"},{type:"null"}]}},required:["identity","projection_binding","execution","lease","state","artifacts","cancellation","recovery","requested_route"],title:"WorkAttemptV1",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkCancellationRequestId:$d},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{attempt_id:{$ref:"#/$defs/AttemptId"},occurred_at:{$ref:"#/$defs/UtcMicros"},request_id:{$ref:"#/$defs/WorkCancellationRequestId"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","attempt_id","request_id","occurred_at"],title:"CancelWorkAttemptCommand",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{new_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"},observed_at:{$ref:"#/$defs/UtcMicros"},old_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","old_version","new_version","observed_at"],title:"WorkProposalComparisonRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProposalId:_8,ProviderId:vo,RetrievalAnchorId:vI,RunId:vF,TaskEvidenceLinkV1:bj,TaskId:bT,UtcMicros:bZ,VerifiedWorkEvidenceRootV1:{additionalProperties:!1,properties:{item:{$ref:"#/$defs/WorkItemV1"},links:{items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},proposal_decisions:{items:{$ref:"#/$defs/WorkProposalDecisionV1"},type:"array"},relation_replan_decisions:{items:{$ref:"#/$defs/WorkRelationReplanDecisionV1"},type:"array"},relations:{items:{$ref:"#/$defs/WorkProductRelationV1"},type:"array"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["verified_version","item","relations","proposal_decisions","relation_replan_decisions","links"],type:"object"},VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkItemInputV1:$M,WorkItemV1:$N,WorkProductRelationV1:$5,WorkProposalComparisonEffectV1:{oneOf:[{const:"advisory_only",description:"Comparison is evidence only. There is no apply edge from this result.",type:"string"}]},WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{added_evidence:{items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},added_relations:{items:{$ref:"#/$defs/WorkProductRelationV1"},type:"array"},effect:{$ref:"#/$defs/WorkProposalComparisonEffectV1"},item_changed:{type:"boolean"},new:{$ref:"#/$defs/VerifiedWorkEvidenceRootV1"},old:{$ref:"#/$defs/VerifiedWorkEvidenceRootV1"},removed_evidence:{items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},removed_relations:{items:{$ref:"#/$defs/WorkProductRelationV1"},type:"array"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","old","new","added_relations","removed_relations","added_evidence","removed_evidence","item_changed","effect"],title:"WorkProposalComparisonV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{initiative:{$ref:"#/$defs/WorkInitiativeV1"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},plan:{$ref:"#/$defs/WorkPlanV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","initiative","plan","milestone","item","mutation"],title:"CreateWorkTaskRequestV1",type:"object"},{$defs:{WorkAttemptListCursorV1:b9},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{cursor:{anyOf:[{$ref:"#/$defs/WorkAttemptListCursorV1"},{type:"null"}],default:null},page_size:{format:"uint32",minimum:0,type:"integer"}},required:["page_size"],title:"WorkAttemptListRequestV1",type:"object"},{$defs:{AttemptId:fW,ManifestDigest:_l,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkAttemptListCoverageV1:b3,WorkAttemptListCursorV1:b9,WorkAttemptStateV1:$t,WorkEffectStateV1:$h,WorkExecutionSpanV1:{additionalProperties:!1,properties:{admitted_projection_sequence:{description:"Durable Work projection sequence under which execution was admitted.",format:"uint64",minimum:0,type:"integer"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},ended_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},started_at:{$ref:"#/$defs/UtcMicros"},state:{$ref:"#/$defs/WorkAttemptStateV1"},terminal_evidence_digest:{anyOf:[{$ref:"#/$defs/ManifestDigest"},{type:"null"}]},wall_micros:{description:"Present only when both owner instants form a valid non-negative span.",format:"uint64",minimum:0,type:["integer","null"]}},required:["identity","admitted_projection_sequence","state","effect_state","started_at"],type:"object"},WorkExecutionTimingCoverageV1:{oneOf:[{additionalProperties:!1,properties:{coverage:{const:"complete",type:"string"}},required:["coverage"],type:"object"},{additionalProperties:!1,properties:{coverage:{const:"partial",type:"string"},invalid_terminal_span:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},missing_dispatch:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"}},required:["coverage","missing_dispatch","invalid_terminal_span"],type:"object"}]},WorkObservedExecutionOrderBasisV1:{enum:["terminal_observed_at_then_admitted_projection_sequence_then_attempt_identity"],type:"string"},WorkObservedExecutionV1:{additionalProperties:!1,properties:{admitted_projection_sequence:{format:"uint64",minimum:0,type:"integer"},evidence_digest:{$ref:"#/$defs/ManifestDigest"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},observed_at:{$ref:"#/$defs/UtcMicros"},ordinal:{description:"One-based order assigned after sorting the durable terminal instants.",format:"uint32",minimum:0,type:"integer"},state:{$ref:"#/$defs/WorkAttemptStateV1"}},required:["ordinal","identity","admitted_projection_sequence","observed_at","state","evidence_digest"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,properties:{attempt_coverage:{$ref:"#/$defs/WorkAttemptListCoverageV1"},observed_order:{items:{$ref:"#/$defs/WorkObservedExecutionV1"},type:"array"},order_basis:{$ref:"#/$defs/WorkObservedExecutionOrderBasisV1"},spans:{items:{$ref:"#/$defs/WorkExecutionSpanV1"},type:"array"},state:{const:"listed",type:"string"},timing_coverage:{$ref:"#/$defs/WorkExecutionTimingCoverageV1"}},required:["state","spans","observed_order","order_basis","attempt_coverage","timing_coverage"],type:"object"}],title:"WorkExecutionHistoryV1"},{$defs:{ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkExpertiseCategoryV1:$V,WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{evidence_not_before:{$ref:"#/$defs/UtcMicros",description:"Evidence before this owner-supplied horizon is excluded as stale."},expertise_categories:{description:"Categories for which the returned context will be used ephemerally.",items:{$ref:"#/$defs/WorkExpertiseCategoryV1"},type:"array",uniqueItems:!0},limit:{format:"uint32",minimum:0,type:"integer"},observed_at:{$ref:"#/$defs/UtcMicros"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["selection","task_id","verified_version","evidence_not_before","expertise_categories","limit","observed_at"],title:"WorkExperienceRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProposalId:_8,ProviderId:vo,RetrievalAnchorId:vI,RunId:vF,SessionId:v8,TaskEvidenceLinkV1:bj,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptEvidenceRecordV1:b4,WorkAttemptIdentityV1:b6,WorkAttemptProviderOutcomeV1:b7,WorkAttemptReceiptV1:$e,WorkAttemptStreamChannelV1:$r,WorkAttemptStreamSummaryV1:$i,WorkExperienceApplicabilityV1:{enum:["same_accepted_route","same_milestone"],type:"string"},WorkExperienceCandidateV1:{additionalProperties:!1,properties:{applicability:{description:"Separate declared applicability facts. This is intentionally not a\nscore and candidates remain in canonical TaskId order.",items:{$ref:"#/$defs/WorkExperienceApplicabilityV1"},type:"array",uniqueItems:!0},attempt_receipts:{description:"Exact receipts for accepted successful attempts whose sealed provider\nevidence and declared artifacts establish reusable observed work. The\nidentity is also the canonical `work_retrieve_evidence` drill target.",items:{$ref:"#/$defs/WorkAttemptReceiptV1"},type:"array"},evidence:{description:"Exact anchored evidence establishing that this is observed experience.",items:{$ref:"#/$defs/TaskEvidenceLinkV1"},type:"array"},item:{$ref:"#/$defs/WorkItemV1"}},required:["item","evidence","attempt_receipts","applicability"],type:"object"},WorkExperienceCoverageV1:{oneOf:[{additionalProperties:!1,properties:{coverage:{const:"unavailable",type:"string"}},required:["coverage"],type:"object"},{additionalProperties:!1,properties:{applicable:{format:"uint32",minimum:0,type:"integer"},coverage:{const:"complete",type:"string"},returned:{format:"uint32",minimum:0,type:"integer"},stale_excluded:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned","applicable","stale_excluded"],type:"object"},{additionalProperties:!1,properties:{applicable:{format:"uint32",minimum:0,type:"integer"},coverage:{const:"partial",type:"string"},omitted_by_limit:{format:"uint32",minimum:0,type:"integer"},returned:{format:"uint32",minimum:0,type:"integer"},stale_excluded:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned","applicable","stale_excluded","omitted_by_limit"],type:"object"}]},WorkExpertiseAuthorizationV1:{oneOf:[{additionalProperties:!1,properties:{availability:{const:"available",type:"string"},categories:{items:{$ref:"#/$defs/WorkExpertiseCategoryV1"},type:"array",uniqueItems:!0},durability:{$ref:"#/$defs/WorkExpertiseContextDurabilityV1"},expires_at:{$ref:"#/$defs/UtcMicros"},pin:{$ref:"#/$defs/WorkExpertiseConsentPinV1"}},required:["availability","categories","expires_at","pin","durability"],type:"object"},{additionalProperties:!1,properties:{availability:{const:"unavailable",type:"string"},legal_actions:{items:{$ref:"#/$defs/WorkExpertiseLegalActionV1"},type:"array",uniqueItems:!0},pin:{$ref:"#/$defs/WorkExpertiseConsentPinV1"},reasons:{items:{$ref:"#/$defs/WorkExpertiseUnavailableReasonV1"},type:"array",uniqueItems:!0}},required:["availability","reasons","legal_actions","pin"],type:"object"}]},WorkExpertiseCategoryV1:$V,WorkExpertiseConsentPinV1:{additionalProperties:!1,properties:{configuration_digest:{$ref:"#/$defs/ManifestDigest"},configuration_revision:{$ref:"#/$defs/ConfigurationRevisionId"},configuration_snapshot:{$ref:"#/$defs/ConfigurationSnapshotId"},provenance_digest:{$ref:"#/$defs/ManifestDigest"}},required:["configuration_revision","configuration_snapshot","configuration_digest","provenance_digest"],type:"object"},WorkExpertiseContextDurabilityV1:{oneOf:[{const:"ephemeral_only",description:"Context is returned for this read only and cannot establish evidence,\nrouting, proposal acceptance, execution admission, or completion.",type:"string"}]},WorkExpertiseLegalActionV1:{enum:["grant_user_consent","grant_project_consent","renew_user_consent","renew_project_consent","allow_requested_categories"],type:"string"},WorkExpertiseUnavailableReasonV1:{enum:["user_consent_disabled","project_consent_disabled","user_consent_not_yet_effective","project_consent_not_yet_effective","user_consent_expired","project_consent_expired","requested_category_not_allowed"],type:"string"},WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkItemInputV1:$M,WorkItemV1:$N,WorkProviderAvailabilityV1:So,WorkProviderBackendV1:Sn,WorkProviderFallbackRecordV1:Sa,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{candidates:{items:{$ref:"#/$defs/WorkExperienceCandidateV1"},type:"array"},coverage:{$ref:"#/$defs/WorkExperienceCoverageV1"},evidence_not_before:{$ref:"#/$defs/UtcMicros"},expertise:{$ref:"#/$defs/WorkExpertiseAuthorizationV1"},observed_at:{$ref:"#/$defs/UtcMicros"},task_id:{$ref:"#/$defs/TaskId"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["task_id","verified_version","evidence_not_before","observed_at","expertise","candidates","coverage"],title:"WorkExperienceV1",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,ProposalId:_8,RepositoryId:vb,TaskId:bT,UtcMicros:bZ,WorkEvidenceFrontierV1:$v,WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Read-only proposal generation over one exact current product graph.",properties:{live_git_evidence:{anyOf:[{$ref:"#/$defs/WorkEvidenceFrontierV1"},{type:"null"}],default:null},occurred_at:{$ref:"#/$defs/UtcMicros"},proposal_id:{$ref:"#/$defs/ProposalId"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","proposal_id","occurred_at"],title:"GenerateProposalRequest",type:"object"},{$defs:{ConfigurationRevisionId:hM,ManifestDigest:_l,PolicyIdentifierV1:{description:"A bounded, canonical identifier owned by the policy input schema.\n\nIt represents immutable references only; it is never a path, display\nlabel, provider account, branch name, or native object identifier.",type:"string"},ProposalId:_8,ProviderId:vo,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkCalibratedSizingV1:{additionalProperties:!1,description:"Calibrated sizing. Emitted ONLY when support >= floor. Every field is\nnamed separately (Plan 06); `support_floor` carries the governing floor\ninto the record.",properties:{band:{$ref:"#/$defs/WorkOrdinalBandV1",description:"The sizing band itself: the stronger of the route's declared effort and\nthe derived shape magnitude, widened when the cohort error is high."},cohort:{description:"Identity of the cohort the sizing was calibrated over: the top-ranked\nroute id. Sizing from one cohort is never reused for another.",type:"string"},drift_valid:{description:"False when the cohort contains incomparable or stale observations, so a\nconsumer can refuse a sizing that drifted rather than silently trust it.",type:"boolean"},error:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Observed adverse-outcome band over the cohort. An ordinal band, never a\nrate and never a probability."},horizon:{$ref:"#/$defs/UtcMicros",description:"Latest comparable observation in the cohort. Nothing after\n`evaluated_at` contributes, so the horizon never runs ahead of the input."},support:{description:"Count of comparable in-cohort outcomes backing this sizing.",format:"uint32",minimum:0,type:"integer"},support_floor:{description:"The floor that governed this emission, carried so replay shows which\nfloor applied rather than assuming the current constant.",format:"uint32",minimum:0,type:"integer"}},required:["cohort","horizon","support","support_floor","error","drift_valid","band"],type:"object"},WorkCalibrationEvidenceV1:{additionalProperties:!1,description:"Raw calibration values and their exact decision provenance.\n\nNo rate, probability, or composite score is derived here. Consumers see\nthe authority-supplied outcome rows, categorical uncertainty, and exact\ndenominator counts that produced the proposal's existing calibrated sizing.",properties:{cohort_route:{type:["string","null"]},comparable_outcomes:{format:"uint32",minimum:0,type:"integer"},eligible_route_count:{format:"uint32",minimum:0,type:"integer"},incomparable_outcomes:{format:"uint32",minimum:0,type:"integer"},provenance:{$ref:"#/$defs/WorkCalibrationProvenanceV1"},raw_outcomes:{items:{$ref:"#/$defs/WorkPriorOutcomeV1"},type:"array"},routes_with_outcomes:{format:"uint32",minimum:0,type:"integer"},uncertainty:{$ref:"#/$defs/WorkCalibrationUncertaintyV1"}},required:["raw_outcomes","eligible_route_count","routes_with_outcomes","comparable_outcomes","incomparable_outcomes","uncertainty","provenance"],type:"object"},WorkCalibrationProvenanceV1:{additionalProperties:!1,properties:{configuration_digest:{$ref:"#/$defs/ManifestDigest"},configuration_revision:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},evaluated_at:{$ref:"#/$defs/UtcMicros"},evaluator_id:{type:"string"},evaluator_revision:{format:"uint64",minimum:0,type:"integer"},input_digest:{$ref:"#/$defs/ManifestDigest"},local_evidence:{anyOf:[{$ref:"#/$defs/WorkEvidenceFrontierV1"},{type:"null"}]}},required:["evaluator_id","evaluator_revision","input_digest","configuration_digest","evaluated_at"],type:"object"},WorkCalibrationUncertaintyV1:{enum:["supported","sparse","stale","incomparable"],type:"string"},WorkDecompositionProposalV1:{additionalProperties:!1,description:"A one-level decomposition proposal. Never recursive: a deeper split is a\nseparate sequenced capability, not something this evaluator may invent.",properties:{candidates:{description:"The proposed sketches, ordinal ascending from 0.",items:{$ref:"#/$defs/WorkSubtaskSketchV1"},type:"array"},rationale:{description:"Why the proposal was emitted, in the same ordered reason vocabulary the\ndecision uses.",items:{$ref:"#/$defs/WorkProposalReasonV1"},type:"array"}},required:["candidates","rationale"],type:"object"},WorkEvidenceFrontierV1:$v,WorkFrontierComparisonV1:{description:"Recorded relation between the two supplied frontiers. `Incomparable` means\nat least one side was absent; it is not collapsed into agreement.",enum:["agree","disagree","incomparable"],type:"string"},WorkOrdinalBandV1:$U,WorkPriorOutcomeV1:{additionalProperties:!1,description:"Cohort denominator. APPLICATION-supplied, never worker-supplied.\n\nA worker cannot widen its own calibration cohort, so a route cannot earn\ncalibrated sizing by reporting its own successes.",properties:{accepted:{description:"Whether the produced work was accepted.",type:"boolean"},escaped_defect:{description:"Whether a defect escaped review.",type:"boolean"},observed_at:{$ref:"#/$defs/UtcMicros",description:"When the outcome was observed. Outcomes later than `evaluated_at` are\nINCOMPARABLE and are excluded from support rather than trusted."},rework:{description:"Whether the accepted work required rework.",type:"boolean"},route_id:{description:"The route this outcome belongs to. May name a retired route; only\noutcomes matching the top-ranked route form the sizing cohort.",type:"string"},terminal:{$ref:"#/$defs/WorkPriorTerminalV1",description:"How the attempt terminated."}},required:["route_id","accepted","rework","escaped_defect","terminal","observed_at"],type:"object"},WorkPriorTerminalV1:{description:"How a prior attempt on a route ended. Recorded, never inferred.",enum:["succeeded","failed","timed_out","cancelled"],type:"string"},WorkProposalActionV1:{description:"The explicit command the decision recommends next. A recommendation never\nexecutes; each action names a separate version-checked application command.",enum:["proceed_to_acceptance","hold_for_dependencies","admit_execution","replan"],type:"string"},WorkProposalDecisionV1:{additionalProperties:!1,description:"One explained, replayable work-loop decision.",properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},configuration_revision:{anyOf:[{$ref:"#/$defs/ConfigurationRevisionId"},{type:"null"}]},decomposition:{anyOf:[{$ref:"#/$defs/WorkDecompositionProposalV1"},{type:"null"}],description:"One-level decomposition sketch, present only when more than one\ndependency is unresolved."},deterministic_fallback:{description:"True when the recommendation is the declared deterministic baseline\nselected because the evidence cannot support a stronger claim.",type:"boolean"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},evaluator_id:{$ref:"#/$defs/PolicyIdentifierV1"},evaluator_revision:{format:"uint64",minimum:0,type:"integer"},frontier_comparison:{$ref:"#/$defs/WorkFrontierComparisonV1"},input_digest:{$ref:"#/$defs/ManifestDigest"},live_git_evidence:{anyOf:[{$ref:"#/$defs/WorkEvidenceFrontierV1"},{type:"null"}],description:"The live Git frontier, returned exactly as supplied."},local_evidence:{anyOf:[{$ref:"#/$defs/WorkEvidenceFrontierV1"},{type:"null"}],description:"The local code/session frontier, returned exactly as supplied."},ordered_reason_codes:{items:{$ref:"#/$defs/WorkProposalReasonV1"},type:"array"},policy_digest:{$ref:"#/$defs/ManifestDigest"},policy_revision:{format:"uint64",minimum:0,type:"integer"},recommended_action:{anyOf:[{$ref:"#/$defs/WorkProposalActionV1"},{type:"null"}]},route_plan:{anyOf:[{$ref:"#/$defs/WorkRoutePlanV1"},{type:"null"}],description:"The explained route plan. Present on every evaluation that reached the\ngates, including the one that found no eligible route."},shape:{anyOf:[{$ref:"#/$defs/WorkTaskShapeV1"},{type:"null"}],description:"Derived task shape. Absent on the invalid, cancelled, and deadline\nshort-circuits, where no planner claim is licensed."},sizing:{anyOf:[{$ref:"#/$defs/WorkCalibratedSizingV1"},{type:"null"}],description:"Calibrated sizing, present only when in-cohort support reached the\ngoverning floor. Absence is a recorded fact, never a fabricated estimate."},task_id:{$ref:"#/$defs/TaskId"}},required:["evaluator_id","evaluator_revision","input_digest","task_id","based_on_version","policy_revision","policy_digest","configuration_digest","disposition","deterministic_fallback","ordered_reason_codes","frontier_comparison"],type:"object"},WorkProposalDispositionV1:{description:"Exactly one disposition per decision.",enum:["allow","deny","abstain","indeterminate"],type:"string"},WorkProposalReasonV1:{enum:["invalid_request","request_cancelled","deadline_exceeded","frontier_agreement","frontier_disagreement","frontier_incomparable","task_accepted","runtime_coverage_partial","runtime_coverage_unavailable","terminal_evidence_observed","execution_in_flight","proposal_accepted","dependencies_unresolved","ready","insufficient_calibration_support","route_budget_exceeded","route_content_location_refused","route_evidence_sparse","route_evidence_stale","human_override_applied","no_eligible_routes","deterministic_baseline_selected"],type:"string"},WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRankedRouteV1:{additionalProperties:!1,description:"Ranked route. Dimensions stay SEPARATE. No scalar score field is permitted here.",properties:{autonomy:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Autonomy fitness, echoed unmerged."},correctness:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Correctness fitness, echoed so the ranking can be audited without the input."},cost:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Cost fitness, oriented so `Highest` is best-fitting."},evidence_quality:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Evidence-quality fitness, echoed unmerged."},latency:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Latency fitness, oriented so `Highest` is best-fitting."},rank:{description:"Position in the ranking, ascending from 1.",format:"uint32",minimum:0,type:"integer"},route_id:{description:"The ranked route's identity.",type:"string"},sensitive_data_fitness:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Sensitive-data fitness, echoed unmerged."}},required:["rank","route_id","correctness","sensitive_data_fitness","latency","cost","autonomy","evidence_quality"],type:"object"},WorkRouteDecisionV1:S_,WorkRouteExclusionV1:{additionalProperties:!1,description:"One refused route and the single reason that refused it. Exclusion is\nrecorded rather than silent so a missing route is always explained.",properties:{reason:{$ref:"#/$defs/WorkProposalReasonV1",description:"The first limit the route failed, in the declared exclusion order."},route_id:{description:"The refused route's identity.",type:"string"}},required:["route_id","reason"],type:"object"},WorkRoutePlanV1:{additionalProperties:!1,description:"The explained route plan for one decision. Recommends; never dispatches.",properties:{coverage:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Fraction-free ordinal coverage of the cohort evidence over the ranked set."},deterministic_baseline:{description:"The declared deterministic baseline, selected when evidence cannot support a\nstronger claim. Always names a route that survived exclusion, or None when none did.",type:["string","null"]},exclusions:{description:"Every refused route with its reason, in supplied order.",items:{$ref:"#/$defs/WorkRouteExclusionV1"},type:"array"},human_override_applied:{description:"True only when a recorded human override named a route that survived\nexclusion. An excluded or unknown override leaves ranking untouched.",type:"boolean"},ranked:{description:"Surviving routes in total, deterministic order, rank ascending from 1.",items:{$ref:"#/$defs/WorkRankedRouteV1"},type:"array"},uncertainty:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Widens on sparse / stale / incomparable evidence."}},required:["ranked","exclusions","coverage","uncertainty","human_override_applied"],type:"object"},WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkSubtaskSketchV1:{additionalProperties:!1,description:"One level only (Q3). Read-only sketch; accepting it stays a separate version-checked command.",properties:{ordinal:{description:"Position in the proposal, ascending from 0. Stable across replays of the\nsame input.",format:"uint32",minimum:0,type:"integer"},shape:{$ref:"#/$defs/WorkTaskShapeKindV1",description:"Kind the sketch would carry if it were accepted as its own task."},summary:{description:"What the sketch covers, phrased from the declared counts alone.",type:"string"}},required:["ordinal","summary","shape"],type:"object"},WorkTaskShapeKindV1:{description:"Kind of work the snapshot facts describe. Derived only from facts already in\nthe input; `Unclassified` when those facts do not distinguish a kind.",enum:["investigation","change","synthesis","unclassified"],type:"string"},WorkTaskShapeV1:{additionalProperties:!1,description:"The derived shape of the task: what kind of work it is and how large the\ndeclared dependency and evidence counts make it.",properties:{band:{$ref:"#/$defs/WorkOrdinalBandV1",description:"Magnitude band derived from the declared dependency and evidence counts."},kind:{$ref:"#/$defs/WorkTaskShapeKindV1",description:"Kind derived from the gate booleans and counts. No new discovery."}},required:["kind","band"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"A canonical product proposal and the exact verified graph that licensed it.\n\n`proposal` can be moved directly into a `DecideWorkProposalRequestV1`;\ncallers use `verified_graph_version` to construct that mutation's CAS pin.",properties:{calibration:{$ref:"#/$defs/WorkCalibrationEvidenceV1"},decision:{$ref:"#/$defs/WorkProposalDecisionV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},verified_graph_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["proposal","verified_graph_version","decision","calibration"],title:"GeneratedWorkProposal",type:"object"},{$defs:{WorkAttemptListCursorV1:b9},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One authority-scoped artifact hydration request, paged like the attempt\nlist and pinned to the same verified topology generation.",properties:{cursor:{anyOf:[{$ref:"#/$defs/WorkAttemptListCursorV1"},{type:"null"}],default:null},page_size:{format:"uint32",minimum:0,type:"integer"}},required:["page_size"],title:"WorkArtifactHydrationRequestV1",type:"object"},{$defs:{AttemptId:fW,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProviderId:vo,RunId:vF,SessionId:v8,TaskId:bT,UtcMicros:bZ,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptArtifactsV1:{additionalProperties:!1,description:"The artifacts and evidence one attempt declared.",properties:{artifacts:{description:"Every artifact reference the attempt declared, in its canonical\nstored order. References carry digest and byte length; bytes are\nnever part of this read.",items:{$ref:"#/$defs/WorkArtifactRefV1"},type:"array"},evidence:{$ref:"#/$defs/WorkAttemptEvidenceStateV1"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["identity","artifacts","evidence"],type:"object"},WorkAttemptEvidenceRecordV1:b4,WorkAttemptEvidenceStateV1:{description:"Whether an attempt's terminal evidence has been sealed. An attempt that\nhas not reported an outcome yet is a typed state, not a missing record.",oneOf:[{additionalProperties:!1,description:"The attempt has not sealed terminal evidence yet.",properties:{state:{const:"pending",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The sealed terminal evidence record, exactly as it was written.",properties:{record:{$ref:"#/$defs/WorkAttemptEvidenceRecordV1"},state:{const:"sealed",type:"string"}},required:["state","record"],type:"object"}]},WorkAttemptIdentityV1:b6,WorkAttemptListCoverageV1:b3,WorkAttemptListCursorV1:b9,WorkAttemptProviderOutcomeV1:b7,WorkAttemptStreamChannelV1:$r,WorkAttemptStreamSummaryV1:$i,WorkAttemptTopologyBindingV1:$o,WorkProviderAvailabilityV1:So,WorkProviderBackendV1:Sn,WorkProviderFallbackRecordV1:Sa,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One authority-scoped artifact hydration read. Absence of any Work in\nscope is a typed state, distinct from an authorized-but-empty page.",oneOf:[{additionalProperties:!1,description:"No Work exists in this authority scope, so there is no attempt set to\nhydrate. Concealed scopes never reach this state: they are refused as\nnot-found-or-not-authorized before any read.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"One page of attempt artifact sets under the verified topology\nsnapshot.",properties:{attempts:{items:{$ref:"#/$defs/WorkAttemptArtifactsV1"},type:"array"},coverage:{$ref:"#/$defs/WorkAttemptListCoverageV1"},state:{const:"hydrated",type:"string"},topology:{$ref:"#/$defs/WorkAttemptTopologyBindingV1"}},required:["state","topology","attempts","coverage"],type:"object"}],title:"WorkArtifactHydrationV1"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptListCoverageV1:b3,WorkAttemptListCursorV1:b9,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptTopologyBindingV1:$o,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkSandboxPolicy:Sw,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One authority-scoped attempt-list read. Absence of any Work in scope is a\ntyped state, distinct from an authorized-but-empty page.",oneOf:[{additionalProperties:!1,description:"No Work exists in this authority scope, so there is no attempt set to\npage. Concealed scopes never reach this state: they are refused as\nnot-found-or-not-authorized before any read.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"One page of durable attempts under the verified topology snapshot.",properties:{attempts:{items:{$ref:"#/$defs/WorkAttemptV1"},type:"array"},coverage:{$ref:"#/$defs/WorkAttemptListCoverageV1"},state:{const:"listed",type:"string"},topology:{$ref:"#/$defs/WorkAttemptTopologyBindingV1"}},required:["state","topology","attempts","coverage"],type:"object"}],title:"WorkAttemptListV1"},{$defs:{AcceptWorkTaskRequestV1:{additionalProperties:!1,properties:{evidence_by_criterion:{additionalProperties:{type:"string"},type:"object"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","evidence_by_criterion","mutation"],type:"object"},ActorId:fb,AddWorkTaskRequestV1:{additionalProperties:!1,properties:{item:{$ref:"#/$defs/WorkItemV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","item","mutation"],type:"object"},AdmitWorkExecutionRequestV1:{additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","based_on_version","mutation"],type:"object"},ApplyWorkRelationReplanRequestV1:{additionalProperties:!1,properties:{mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal_id:{$ref:"#/$defs/ProposalId"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal_id","mutation"],type:"object"},AttemptId:fW,CatalogGenerationId:hp,ConfigurationRevisionId:hM,CreateWorkProductRequestV1:{additionalProperties:!1,properties:{initial_graph:{$ref:"#/$defs/WorkProductGraphV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","initial_graph","mutation"],type:"object"},CreateWorkTaskRequestV1:{additionalProperties:!1,properties:{initiative:{$ref:"#/$defs/WorkInitiativeV1"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},plan:{$ref:"#/$defs/WorkPlanV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","initiative","plan","milestone","item","mutation"],type:"object"},DecideWorkProposalRequestV1:{additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal","disposition","mutation"],type:"object"},DecideWorkRelationReplanRequestV1:{additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal:{$ref:"#/$defs/WorkRelationReplanProposalV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal","disposition","mutation"],type:"object"},LinkAcceptedWorkAttemptRequestV1:{additionalProperties:!1,properties:{based_on_version:{format:"uint64",minimum:0,type:"integer"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["selection","task_id","based_on_version","identity","mutation"],type:"object"},ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RecordWorkHandoffRequestV1:{additionalProperties:!1,properties:{handoff:{$ref:"#/$defs/WorkHandoffV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","handoff","mutation"],type:"object"},RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,SourceStoreId:bS,TaskEvidenceLinkV1:bj,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductGraphV1:$4,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",description:"Closed public mutation surface for the Work-product graph authority.",oneOf:[{properties:{mutation:{const:"create",type:"string"},request:{$ref:"#/$defs/CreateWorkProductRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"add_task",type:"string"},request:{$ref:"#/$defs/AddWorkTaskRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"create_task",type:"string"},request:{$ref:"#/$defs/CreateWorkTaskRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"decide_proposal",type:"string"},request:{$ref:"#/$defs/DecideWorkProposalRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"decide_relation_replan",type:"string"},request:{$ref:"#/$defs/DecideWorkRelationReplanRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"apply_relation_replan",type:"string"},request:{$ref:"#/$defs/ApplyWorkRelationReplanRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"accept_task",type:"string"},request:{$ref:"#/$defs/AcceptWorkTaskRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"admit_execution",type:"string"},request:{$ref:"#/$defs/AdmitWorkExecutionRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"link_accepted_attempt",type:"string"},request:{$ref:"#/$defs/LinkAcceptedWorkAttemptRequestV1"}},required:["mutation","request"],type:"object"},{properties:{mutation:{const:"record_handoff",type:"string"},request:{$ref:"#/$defs/RecordWorkHandoffRequestV1"}},required:["mutation","request"],type:"object"}],title:"WorkProductMutationRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkRunControlReasonV1:S$},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_authority_version:{default:null,description:'The authority version the caller read. Absent means "no control row was\npublished yet"; a mismatch is a conflict, never an overwrite.',format:"uint64",minimum:0,type:["integer","null"]},occurred_at:{$ref:"#/$defs/UtcMicros"},reason:{$ref:"#/$defs/WorkRunControlReasonV1"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","reason","occurred_at"],title:"PauseWorkRunCommand",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkRunControlAuthorityV1:Sb,WorkRunControlReasonV1:S$,WorkRunControlStateV1:SS,WorkRunDeadlineCheckpointV1:Sk},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One run's durable control aggregate.",properties:{authority:{$ref:"#/$defs/WorkRunControlAuthorityV1"},deadline:{$ref:"#/$defs/WorkRunDeadlineCheckpointV1"},fenced_attempts:{description:'The exact attempts that were live when the current state published.\nEmpty means "none were live", never "we did not look".',items:{$ref:"#/$defs/AttemptId"},type:"array"},reason:{anyOf:[{$ref:"#/$defs/WorkRunControlReasonV1"},{type:"null"}]},run_id:{$ref:"#/$defs/RunId"},state:{$ref:"#/$defs/WorkRunControlStateV1"},task_id:{$ref:"#/$defs/TaskId"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["task_id","run_id","state","authority","deadline","transitioned_at","fenced_attempts"],title:"WorkRunControlV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementKindV1:$B,WorkPlacementTargetV1:$J},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{occurred_at:{$ref:"#/$defs/UtcMicros"},run_id:{$ref:"#/$defs/RunId"},target:{$ref:"#/$defs/WorkPlacementTargetV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","target","occurred_at"],title:"WorkPlacementPreflightRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementObservationV1:{additionalProperties:!1,description:'What was actually observed at the target, in counts rather than prose.\n\nCounts are measurements: a zero is "we looked and found none", and\n`readable: false` is the separate state for "we could not look". Collapsing\nthem would let an unreadable target read as a clean one.',properties:{active_holder:{description:"Whether another admitted placement already holds this target.",type:"boolean"},dirty_tracked_paths:{description:"Tracked paths that differ from the index or HEAD.",format:"uint32",minimum:0,type:"integer"},network_required:{description:"Whether the declared network-free placement would require network.",type:"boolean"},observed_at:{$ref:"#/$defs/UtcMicros"},readable:{description:"Whether the target could be read at all.",type:"boolean"},unique_commits:{description:'Commits in the target reachable from nowhere else.\n\n`None` means reachability was not measured, and it blocks removal\nexactly as a positive count does: an unmeasured target is "unknown"\nand is retained rather than assumed worthless. Only removal consults\nthis; admission does not.',format:"uint32",minimum:0,type:["integer","null"]},untracked_paths:{description:"Untracked paths present in the target.",format:"uint32",minimum:0,type:"integer"}},required:["dirty_tracked_paths","untracked_paths","readable","active_holder","network_required","observed_at"],title:"WorkPlacementObservationV1",type:"object"},WorkPlacementTargetV1:$J},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One placement preflight reading: what was asked for, what was seen, and\nexactly what blocks it.",properties:{blockers:{items:{$ref:"#/$defs/WorkPlacementBlockerV1"},type:"array",uniqueItems:!0},identity:{$ref:"#/$defs/WorkPlacementIdentityV1"},observation:{$ref:"#/$defs/WorkPlacementObservationV1"},target:{$ref:"#/$defs/WorkPlacementTargetV1"}},required:["identity","target","observation","blockers"],title:"WorkPlacementPreflightV1",type:"object"},{$defs:{RunId:vF,TaskId:bT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id"],title:"WorkPlacementStatusRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementStateV1:$K,WorkPlacementTargetV1:$J,WorkPlacementV1:$Z},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One placement reading. Absence is a state, not an empty placement.",oneOf:[{additionalProperties:!1,description:"No placement was ever admitted for this run.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The durable placement relation.",properties:{placement:{$ref:"#/$defs/WorkPlacementV1"},state:{const:"placed",type:"string"}},required:["state","placement"],type:"object"}],title:"WorkPlacementReadingV1"},{$defs:{AttemptId:fW,CoverageStateV1:yf,DuplicateEffectOutcomeV1:yP,DuplicateEffortKindV1:yV,QuantityEvidenceClassV1:vs,RunId:vF,TaskId:bT,WorkAttemptIdentityV1:b6,WorkDuplicateAdjudicationQuantitiesV1:$f},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Operator judgment before the owning Work authority binds exact current\ngenerations, relation revision, command identity, and observation time.",properties:{first_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},quantities:{$ref:"#/$defs/WorkDuplicateAdjudicationQuantitiesV1"},reason:{type:"string"},second_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},verdict:{$ref:"#/$defs/DuplicateEffortKindV1"}},required:["first_attempt","second_attempt","verdict","quantities","reason"],title:"PrepareWorkDuplicateAdjudicationRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductChangeDraftV1:{description:"Operator-selected graph change before the owning Work authority binds the\ncurrent verified head and revision authorities.",oneOf:[{properties:{change:{const:"add_task",type:"string"},item:{$ref:"#/$defs/WorkItemV1"}},required:["change","item"],type:"object"},{properties:{change:{const:"create_task",type:"string"},initiative:{$ref:"#/$defs/WorkInitiativeV1"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},plan:{$ref:"#/$defs/WorkPlanV1"}},required:["change","initiative","plan","milestone","item"],type:"object"},{properties:{change:{const:"decide_proposal",type:"string"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["change","proposal","disposition"],type:"object"},{properties:{change:{const:"decide_relation_replan",type:"string"},disposition:{$ref:"#/$defs/WorkProposalDispositionV1"},proposal:{$ref:"#/$defs/WorkRelationReplanProposalV1"}},required:["change","proposal","disposition"],type:"object"},{properties:{change:{const:"apply_relation_replan",type:"string"},proposal_id:{$ref:"#/$defs/ProposalId"}},required:["change","proposal_id"],type:"object"},{properties:{change:{const:"accept_task",type:"string"},evidence_by_criterion:{additionalProperties:{type:"string"},type:"object"},task_id:{$ref:"#/$defs/TaskId"}},required:["change","task_id","evidence_by_criterion"],type:"object"},{properties:{change:{const:"admit_execution",type:"string"},task_id:{$ref:"#/$defs/TaskId"}},required:["change","task_id"],type:"object"},{properties:{change:{const:"link_accepted_attempt",type:"string"},identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},task_id:{$ref:"#/$defs/TaskId"}},required:["change","task_id","identity"],type:"object"},{properties:{change:{const:"record_handoff",type:"string"},handoff:{$ref:"#/$defs/WorkHandoffV1"}},required:["change","handoff"],type:"object"}]},WorkProductEventEvidenceV1:$Y,WorkProductSelectionScopeV1:$7,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Read-only preparation input. Authority identities, clocks, and revision\npins are deliberately absent because the backend owns them.",properties:{causation_event_id:{type:["string","null"]},change:{$ref:"#/$defs/WorkProductChangeDraftV1"},evidence:{items:{$ref:"#/$defs/WorkProductEventEvidenceV1"},type:"array"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","change","evidence"],title:"PrepareWorkProductMutationRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_authority_version:{format:"uint64",minimum:0,type:"integer"},occurred_at:{$ref:"#/$defs/UtcMicros"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","expected_authority_version","occurred_at"],title:"ReleaseWorkPlacementCommand",type:"object"},{$defs:{UtcMicros:bZ},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{occurred_at:{$ref:"#/$defs/UtcMicros"}},required:["occurred_at"],title:"ResumeWorkAttemptsCommand",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkSandboxPolicy:Sw,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"What restart recovery did to each open attempt.\n\nThis report never claims that a provider resumed. An attempt in\n`recovery_required` remains fenced under its original identity. This report\ndoes not authorize another launch; an explicit `retry_attempt` must verify\nthe exact recovery fence and effect safety before it can atomically admit a\nnew identity.",properties:{cancelled:{description:"Attempts whose in-flight cancellation was completed during recovery.",items:{$ref:"#/$defs/WorkAttemptV1"},type:"array"},recovery_required:{description:"Attempts fenced onto a new epoch and awaiting an explicit recovery\ndecision.",items:{$ref:"#/$defs/WorkAttemptV1"},type:"array"}},required:["recovery_required","cancelled"],title:"WorkAttemptRecoveryReportV1",type:"object"},{$defs:{RunId:vF,TaskId:bT,UtcMicros:bZ,WorkRunControlReasonV1:S$},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expected_authority_version:{format:"uint64",minimum:0,type:"integer"},occurred_at:{$ref:"#/$defs/UtcMicros"},reason:{$ref:"#/$defs/WorkRunControlReasonV1"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","reason","expected_authority_version","occurred_at"],title:"ResumeWorkRunCommand",type:"object"},{$defs:{AttemptId:fW,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProjectId:_4,ProviderId:vo,RepositoryId:vb,RunId:vF,SessionId:v8,TaskId:bT,TemporalModeV1:bW,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAttemptIdentityV1:b6,WorkEvidenceContinuationV1:$_,WorkEvidenceExpansionSelectorV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"anchor",type:"string"},link_id:{type:"string"}},required:["kind","link_id"],type:"object"},{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},kind:{const:"task_session",type:"string"}},required:["kind","attempt"],type:"object"}]},WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7,WorkTaskSessionContinuationV1:ST},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One TaskId-rooted read. The exact Work graph identity remains mandatory on\ncontinuation and expansion requests, so neither an anchor nor a cursor is\nauthority by possession.",properties:{continuation:{anyOf:[{$ref:"#/$defs/WorkEvidenceContinuationV1"},{type:"null"}],default:null},expansion:{anyOf:[{$ref:"#/$defs/WorkEvidenceExpansionSelectorV1"},{type:"null"}],default:null},observed_at:{$ref:"#/$defs/UtcMicros"},page_size:{format:"uint32",minimum:0,type:"integer"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"},task_id:{$ref:"#/$defs/TaskId"},temporal:{$ref:"#/$defs/TemporalModeV1"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["selection","task_id","verified_version","temporal","page_size","observed_at"],title:"WorkEvidenceRetrieveRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ObservationSourceIdentityV1:_M,ProposalId:_8,ProviderId:vo,RetrievalAnchorId:vI,RunId:vF,SessionId:v8,SessionRetrievalBudgetAccountingV1:{additionalProperties:!1,description:"The ceiling and count behind a budget refusal.\n\n`stage` names which budget refused; this is what tells an oversized request\napart from a read whose cost was mis-sized for it. The ceiling value also\ndistinguishes the resources inside one stage: a record read that stopped at\n1024 hit the item count, one that stopped at 16 MiB hit the byte total, so\nthe kernel's resource spelling stays in the kernel instead of becoming a\nsecond wire vocabulary to keep in step.",properties:{limit:{format:"uint64",minimum:0,type:"integer"},observed:{$ref:"#/$defs/SessionRetrievalBudgetObservationV1"}},required:["limit","observed"],type:"object"},SessionRetrievalBudgetObservationV1:{description:"What a refusing budget boundary had counted.\n\nBoth variants are exact. A bounded read never counts the rows it declined to\nread, so an exhausted read reports what it consumed and that storage held\nmore, never a total it would have to run the refused scan to learn.",oneOf:[{additionalProperties:!1,description:"The request asked for more units than the admitted maximum.",properties:{observation:{const:"requested",type:"string"},units:{format:"uint64",minimum:0,type:"integer"}},required:["observation","units"],type:"object"},{additionalProperties:!1,description:"The read consumed its whole budget and storage still held more.",properties:{observation:{const:"consumed_with_more_available",type:"string"},units:{format:"uint64",minimum:0,type:"integer"}},required:["observation","units"],type:"object"}]},SessionRetrievalBudgetStageV1:bo,SessionRetrievalStructuralRefusalV1:{oneOf:[{additionalProperties:!1,properties:{kind:{type:"string"},maximum:{format:"uint",minimum:0,type:"integer"},observed:{format:"uint",minimum:0,type:"integer"},refusal:{const:"cursor_manifest_limit_exceeded",type:"string"}},required:["refusal","kind","observed","maximum"],type:"object"},{additionalProperties:!1,properties:{accounting:{anyOf:[{$ref:"#/$defs/SessionRetrievalBudgetAccountingV1"},{type:"null"}],description:"Present when the refusing boundary keeps a counter. A request-shape\ncheck has none and reports `None` rather than inventing numbers."},refusal:{const:"budget_exhausted",type:"string"},stage:{$ref:"#/$defs/SessionRetrievalBudgetStageV1"}},required:["refusal","stage"],type:"object"}]},TaskEvidenceLinkV1:bj,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAnchorHydrationV1:{additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},content:{items:{type:"string"},type:"array"},continuation:{type:["string","null"]},coverage:{$ref:"#/$defs/WorkEvidenceCoverageStateV1"},exact_anchors:{items:{$ref:"#/$defs/RetrievalAnchorId"},type:"array"},freshness:{$ref:"#/$defs/WorkEvidenceFreshnessV1"},redacted:{type:"boolean"}},required:["anchor_id","exact_anchors","content","coverage","freshness","redacted"],type:"object"},WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptEvidenceRecordV1:b4,WorkAttemptIdentityV1:b6,WorkAttemptProviderOutcomeV1:b7,WorkAttemptReceiptV1:$e,WorkAttemptStreamChannelV1:$r,WorkAttemptStreamSummaryV1:$i,WorkEvidenceContinuationV1:$_,WorkEvidenceCoverageStateV1:{enum:["complete","partial","unknown"],type:"string"},WorkEvidenceCoverageV1:{additionalProperties:!1,properties:{hydrated:{format:"uint32",minimum:0,type:"integer"},omitted:{format:"uint32",minimum:0,type:"integer"},selected:{format:"uint32",minimum:0,type:"integer"},state:{$ref:"#/$defs/WorkEvidenceCoverageStateV1"}},required:["state","selected","hydrated","omitted"],type:"object"},WorkEvidenceFreshnessV1:{enum:["current","stale","unknown"],type:"string"},WorkEvidenceOmissionReasonV1:{oneOf:[{enum:["limit_reached","pending","not_found_or_not_authorized","unavailable","reset_required","stale","cancelled","timed_out","redacted"],type:"string"},{additionalProperties:!1,properties:{structural_refusal:{$ref:"#/$defs/SessionRetrievalStructuralRefusalV1"}},required:["structural_refusal"],type:"object"}]},WorkEvidenceOmissionV1:{additionalProperties:!1,properties:{reason:{$ref:"#/$defs/WorkEvidenceOmissionReasonV1"},relation:{type:"string"}},required:["relation","reason"],type:"object"},WorkEvidenceSourceV1:{oneOf:[{additionalProperties:!1,properties:{kind:{const:"attempt_receipt",type:"string"},receipt:{$ref:"#/$defs/WorkAttemptReceiptV1"}},required:["kind","receipt"],type:"object"},{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},evidence:{$ref:"#/$defs/WorkTaskSessionEvidenceV1"},kind:{const:"task_session",type:"string"}},required:["kind","attempt","evidence"],type:"object"},{additionalProperties:!1,properties:{hydration:{$ref:"#/$defs/WorkAnchorHydrationV1"},kind:{const:"anchor",type:"string"},link:{$ref:"#/$defs/TaskEvidenceLinkV1"}},required:["kind","link","hydration"],type:"object"}]},WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkItemInputV1:$M,WorkItemV1:$N,WorkProductRelationV1:$5,WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderAvailabilityV1:So,WorkProviderBackendV1:Sn,WorkProviderFallbackRecordV1:Sa,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTaskSessionContinuationV1:ST,WorkTaskSessionCoverageV1:{additionalProperties:!1,properties:{hidden:{format:"uint64",minimum:0,type:"integer"},redacted:{format:"uint64",minimum:0,type:"integer"},unknown:{format:"uint64",minimum:0,type:"integer"},visible:{format:"uint64",minimum:0,type:"integer"}},required:["visible","hidden","unknown","redacted"],type:"object"},WorkTaskSessionEvidenceV1:{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},continuation:{anyOf:[{$ref:"#/$defs/WorkTaskSessionContinuationV1"},{type:"null"}]},coverage:{$ref:"#/$defs/WorkEvidenceCoverageStateV1"},coverage_counts:{$ref:"#/$defs/WorkTaskSessionCoverageV1"},freshness:{$ref:"#/$defs/WorkEvidenceFreshnessV1"},hydrated:{items:{$ref:"#/$defs/WorkTaskSessionHydrationV1"},type:"array"},participant_epoch:{$ref:"#/$defs/ManifestDigest"},ranked_anchors:{items:{$ref:"#/$defs/WorkTaskSessionRankedAnchorV1"},type:"array"},redacted:{type:"boolean"},source:{$ref:"#/$defs/ObservationSourceIdentityV1"},task_id:{$ref:"#/$defs/TaskId"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["task_id","verified_version","attempt","source","participant_epoch","ranked_anchors","hydrated","coverage","coverage_counts","freshness","redacted"],type:"object"},WorkTaskSessionHydrationStateV1:{enum:["available","retained_but_unavailable","redacted","deleted","retention_expired","unauthorized","locked","unverifiable"],type:"string"},WorkTaskSessionHydrationV1:{additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},content:{items:{format:"uint8",maximum:255,minimum:0,type:"integer"},type:["array","null"]},rank:{format:"uint32",minimum:0,type:"integer"},state:{$ref:"#/$defs/WorkTaskSessionHydrationStateV1"}},required:["rank","anchor_id","state"],type:"object"},WorkTaskSessionRankContributionV1:{additionalProperties:!1,properties:{calibrated_feature_micros:{format:"uint32",minimum:0,type:"integer"},calibration_profile:{type:"string"},ordinal_rank:{format:"uint32",minimum:0,type:"integer"},raw_score_micros:{format:"int64",type:"integer"},retriever:{type:"string"},retriever_revision:{type:"string"},score_domain:{type:"string"},source_occurrence:{type:"string"},weight_micros:{format:"uint32",minimum:0,type:"integer"},weighted_contribution_micros:{format:"uint64",minimum:0,type:"integer"}},required:["retriever","retriever_revision","source_occurrence","ordinal_rank","raw_score_micros","score_domain","calibration_profile","calibrated_feature_micros","weight_micros","weighted_contribution_micros"],type:"object"},WorkTaskSessionRankedAnchorV1:{additionalProperties:!1,properties:{anchor_id:{$ref:"#/$defs/RetrievalAnchorId"},contributions:{items:{$ref:"#/$defs/WorkTaskSessionRankContributionV1"},type:"array"},final_ordinal:{format:"uint32",minimum:0,type:"integer"},utility_micros:{format:"uint64",minimum:0,type:"integer"}},required:["anchor_id","final_ordinal","utility_micros","contributions"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{continuations:{items:{$ref:"#/$defs/WorkEvidenceContinuationV1"},type:"array"},coverage:{$ref:"#/$defs/WorkEvidenceCoverageV1"},freshness:{$ref:"#/$defs/WorkEvidenceFreshnessV1"},item:{$ref:"#/$defs/WorkItemV1"},omissions:{items:{$ref:"#/$defs/WorkEvidenceOmissionV1"},type:"array"},proposal_decisions:{items:{$ref:"#/$defs/WorkProposalDecisionV1"},type:"array"},redacted:{type:"boolean"},relation_replan_decisions:{items:{$ref:"#/$defs/WorkRelationReplanDecisionV1"},type:"array"},relations:{items:{$ref:"#/$defs/WorkProductRelationV1"},type:"array"},sources:{items:{$ref:"#/$defs/WorkEvidenceSourceV1"},type:"array"},task_id:{$ref:"#/$defs/TaskId"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["task_id","verified_version","item","relations","proposal_decisions","relation_replan_decisions","sources","coverage","omissions","freshness","redacted","continuations"],title:"WorkEvidenceRetrievalV1",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkRetryCauseV1:Sf,WorkRetryFailureSelectorV1:Sh,WorkRetrySourceV1:Sy},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},failure:{$ref:"#/$defs/WorkRetryFailureSelectorV1"},new_attempt_id:{$ref:"#/$defs/AttemptId"},original_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["original_attempt","new_attempt_id","failure","command_id"],title:"RetryWorkAttemptCommandV1",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,RetryWorkAttemptCommandV1:{additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},failure:{$ref:"#/$defs/WorkRetryFailureSelectorV1"},new_attempt_id:{$ref:"#/$defs/AttemptId"},original_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["original_attempt","new_attempt_id","failure","command_id"],title:"RetryWorkAttemptCommandV1",type:"object"},ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,VerifiedWorkRetryFailureV1:{additionalProperties:!1,description:"Failure fact returned by a canonical evidence authority.",properties:{evidence_digest:{$ref:"#/$defs/ManifestDigest"},observed_at:{$ref:"#/$defs/UtcMicros"},selector:{$ref:"#/$defs/WorkRetryFailureSelectorV1"}},required:["selector","evidence_digest","observed_at"],type:"object"},WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkCommandId:$p,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkRetryCauseV1:Sf,WorkRetryFailureSelectorV1:Sh,WorkRetryReceiptV1:{additionalProperties:!1,properties:{canonical_input_digest:{$ref:"#/$defs/ManifestDigest"},command:{$ref:"#/$defs/RetryWorkAttemptCommandV1"},failure:{$ref:"#/$defs/VerifiedWorkRetryFailureV1"},new_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},owner_receipt_digest:{$ref:"#/$defs/ManifestDigest"},restarted_at:{$ref:"#/$defs/UtcMicros",description:"Daemon-owned admission time at which the new attempt was created."},retry_required_at:{$ref:"#/$defs/UtcMicros",description:"Exact source-owned time at which the failure made a retry necessary."}},required:["command","failure","new_attempt","retry_required_at","restarted_at","canonical_input_digest","owner_receipt_digest"],type:"object"},WorkRetrySourceV1:Sy,WorkSandboxPolicy:Sw,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptV1"},outcome:{const:"created",type:"string"},receipt:{$ref:"#/$defs/WorkRetryReceiptV1"}},required:["outcome","receipt","attempt"],type:"object"},{additionalProperties:!1,properties:{attempt:{$ref:"#/$defs/WorkAttemptV1"},outcome:{const:"replayed",type:"string"},receipt:{$ref:"#/$defs/WorkRetryReceiptV1"}},required:["outcome","receipt","attempt"],type:"object"}],title:"WorkRetryAttemptOutcomeV1"},{$defs:{CatalogGenerationId:hp,ConfigurationRevisionId:hM,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,ReviewWorkProposalDispositionV1:{description:"The only non-accepting dispositions the proposal-review operation can\ncommit. The broader decision request remains available to the graph\nmutation operation, which owns all decision forms.",enum:["rejected","superseded"],type:"string"},SourceStoreId:bS,TaskId:bT,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkCommandId:$p,WorkProductAuthorizedRelationScopeV1:$X,WorkProductEventEvidenceV1:$Y,WorkProductExpectedAuthorityV1:$2,WorkProductMutationIdentityV1:$6,WorkProductRevisionPinsV1:$8,WorkProductSelectionScopeV1:$7,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{disposition:{$ref:"#/$defs/ReviewWorkProposalDispositionV1"},mutation:{$ref:"#/$defs/WorkProductMutationIdentityV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","proposal","disposition","mutation"],title:"ReviewWorkProposalRequestV1",type:"object"},{$defs:{RunId:vF,TaskId:bT},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id"],title:"WorkRunControlRequestV1",type:"object"},{$defs:{AttemptId:fW,RunId:vF,TaskId:bT,UtcMicros:bZ,WorkRunControlAuthorityV1:Sb,WorkRunControlReasonV1:S$,WorkRunControlStateV1:SS,WorkRunControlV1:{additionalProperties:!1,description:"One run's durable control aggregate.",properties:{authority:{$ref:"#/$defs/WorkRunControlAuthorityV1"},deadline:{$ref:"#/$defs/WorkRunDeadlineCheckpointV1"},fenced_attempts:{description:'The exact attempts that were live when the current state published.\nEmpty means "none were live", never "we did not look".',items:{$ref:"#/$defs/AttemptId"},type:"array"},reason:{anyOf:[{$ref:"#/$defs/WorkRunControlReasonV1"},{type:"null"}]},run_id:{$ref:"#/$defs/RunId"},state:{$ref:"#/$defs/WorkRunControlStateV1"},task_id:{$ref:"#/$defs/TaskId"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["task_id","run_id","state","authority","deadline","transitioned_at","fenced_attempts"],title:"WorkRunControlV1",type:"object"},WorkRunDeadlineCheckpointV1:Sk},$schema:"https://json-schema.org/draft/2020-12/schema",description:"One run's control reading.\n\n`Uncontrolled` is a distinct answer from `Controlled`: it says the run is\nadmitted and running under its admitted deadline with no control transition\never published, which is not the same as a control row that happens to say\n`Running`.",oneOf:[{additionalProperties:!1,description:"The run holds durable attempts but no control transition has ever been\npublished for it.",properties:{deadline:{$ref:"#/$defs/UtcMicros",description:"The admitted deadline the run is running against."},live_attempts:{description:"Attempts that have not reached a terminal state.",items:{$ref:"#/$defs/AttemptId"},type:"array"},state:{const:"uncontrolled",type:"string"},total_attempts:{format:"uint32",minimum:0,type:"integer"}},required:["state","deadline","live_attempts","total_attempts"],type:"object"},{additionalProperties:!1,description:"The published control aggregate, plus the live frontier as of this\nread (which may differ from the frontier the transition fenced).",properties:{control:{$ref:"#/$defs/WorkRunControlV1"},live_attempts:{items:{$ref:"#/$defs/AttemptId"},type:"array"},state:{const:"controlled",type:"string"},total_attempts:{format:"uint32",minimum:0,type:"integer"}},required:["state","control","live_attempts","total_attempts"],type:"object"}],title:"WorkRunControlReadingV1"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Starts one admitted provider attempt. Every field is a typed fact; there\nis no argv, environment entry, executable path, or shell string here. The\nprojection binding and admission facts are re-read from the canonical Work\nauthority, never trusted from the caller.",properties:{attempt_id:{$ref:"#/$defs/AttemptId"},commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},instructions:{type:"string"},occurred_at:{$ref:"#/$defs/UtcMicros"},operation:{$ref:"#/$defs/WorkflowOperationRef"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"},worktree_root:{type:"string"}},required:["task_id","run_id","attempt_id","operation","execution_snapshot","worktree_root","commit","instructions","effect_state","occurred_at"],title:"StartWorkAttemptCommand",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,StartWorkAttemptCommand:{additionalProperties:!1,description:"Starts one admitted provider attempt. Every field is a typed fact; there\nis no argv, environment entry, executable path, or shell string here. The\nprojection binding and admission facts are re-read from the canonical Work\nauthority, never trusted from the caller.",properties:{attempt_id:{$ref:"#/$defs/AttemptId"},commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},instructions:{type:"string"},occurred_at:{$ref:"#/$defs/UtcMicros"},operation:{$ref:"#/$defs/WorkflowOperationRef"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"},worktree_root:{type:"string"}},required:["task_id","run_id","attempt_id","operation","execution_snapshot","worktree_root","commit","instructions","effect_state","occurred_at"],type:"object"},TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkAttemptIdentityV1:b6,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkSandboxPolicy:Sw,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Admits one synthesis attempt over an ordered set of sibling sources.",properties:{output_name:{$ref:"#/$defs/WorkflowOutputName",description:"The fan-out output the synthesis belongs to, carried into the draft\nthe workflow completion path verifies."},sources:{description:"The ordered sibling sources the synthesis consumes.",items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},start:{$ref:"#/$defs/StartWorkAttemptCommand",description:"The synthesis attempt's own admission facts; it is started through\nthe same admission machinery as any other attempt."}},required:["start","output_name","sources"],title:"AdmitWorkSynthesisCommand",type:"object"},{$defs:{AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAttemptProgressV1:b5,WorkAttemptProjectionBindingV1:b8,WorkAttemptStateV1:$t,WorkAttemptV1:$n,WorkCancellationAcknowledgementV1:$a,WorkCancellationEscalationV1:$s,WorkCancellationRequestId:$d,WorkCancellationRequestV1:$c,WorkCancellationStateV1:$l,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionEnvelopeV1:$k,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRecoveryStateV1:Sl,WorkRestartReasonV1:Sm,WorkSandboxPolicy:Sw,WorkSynthesisEvidenceGroupV1:Sq,WorkSynthesisRefusalV1:SI,WorkSynthesisSourceEnvelopeV1:Sx,WorkSynthesisSourceOutcomeV1:Sj,WorkSynthesisSourceSetV1:SC,WorkTerminalEvidenceV1:SO,WorkTopologyPolicyV1:SA,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowSynthesisDraft:SH,WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",description:"The typed outcome of a synthesis request: an admitted attempt, or the\nsealed unsynthesized set when synthesis could not truthfully begin.",oneOf:[{additionalProperties:!1,description:"The admitted synthesis attempt and everything it is accountable to.",properties:{attempt:{$ref:"#/$defs/WorkAttemptV1",description:"The leased (or idempotently replayed) synthesis attempt."},draft:{$ref:"#/$defs/WorkflowSynthesisDraft",description:"The citation obligation, complete by construction: the draft cites\nevery citable source digest and is verified downstream by\n[`crate::workflow_synthesis::verify_workflow_synthesis_draft`]."},groups:{description:"Disagreement structure over the succeeded sources.",items:{$ref:"#/$defs/WorkSynthesisEvidenceGroupV1"},type:"array"},source_set:{$ref:"#/$defs/WorkSynthesisSourceSetV1",description:"The sealed source envelopes the attempt was admitted against."},synthesis:{const:"admitted",type:"string"},uncited:{description:"Sources preserved without citations: failures, unknowns, and\nartifact-less successes, in the caller's requested order.",items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"}},required:["synthesis","attempt","source_set","groups","draft","uncited"],type:"object"},{properties:{refusal:{$ref:"#/$defs/WorkSynthesisRefusalV1"},sources:{$ref:"#/$defs/WorkSynthesisSourceSetV1"},synthesis:{const:"unsynthesized",type:"string"}},required:["synthesis","sources","refusal"],type:"object"}],title:"WorkSynthesisAttemptV1"},{$defs:{WorkAttemptListCursorV1:b9},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One page-bounded topology view read. The cursor vocabulary is the attempt\nlist's: a cursor minted under a superseded topology generation is a typed\nstaleness refusal, never a silently different page.",properties:{cursor:{anyOf:[{$ref:"#/$defs/WorkAttemptListCursorV1"},{type:"null"}],default:null},page_size:{format:"uint32",minimum:0,type:"integer"}},required:["page_size"],title:"WorkTopologyViewRequestV1",type:"object"},{$defs:{BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,TaskId:bT,TopologyGatePolicyV1:bH,UtcMicros:bZ,WorkAttemptListCoverageV1:b3,WorkAttemptListCursorV1:b9,WorkAttemptTopologyBindingV1:$o,WorkPlacementBlockerV1:$H,WorkPlacementIdentityV1:$G,WorkPlacementKindV1:$B,WorkPlacementReadingV1:{description:"One placement reading. Absence is a state, not an empty placement.",oneOf:[{additionalProperties:!1,description:"No placement was ever admitted for this run.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The durable placement relation.",properties:{placement:{$ref:"#/$defs/WorkPlacementV1"},state:{const:"placed",type:"string"}},required:["state","placement"],type:"object"}],title:"WorkPlacementReadingV1"},WorkPlacementStateV1:$K,WorkPlacementTargetV1:$J,WorkPlacementV1:$Z,WorkTopologyExecutionPlacementV1:{additionalProperties:!1,description:"The execution-placement dimension: the policy's placement mode plus one\nlane per distinct `(task, run)` pair in page order.",properties:{lanes:{items:{$ref:"#/$defs/WorkTopologyPlacementLaneV1"},type:"array"},mode:{$ref:"#/$defs/WorktreePlacementModeV1"}},required:["mode","lanes"],title:"WorkTopologyExecutionPlacementV1",type:"object"},WorkTopologyIntegrationStrategyV1:{additionalProperties:!1,description:"The integration-strategy dimension, read verbatim from the resolved work\ntopology policy the runs in scope are admitted against.",properties:{cross_merge:{$ref:"#/$defs/CrossMergePolicyV1"},gates:{$ref:"#/$defs/TopologyGatePolicyV1"},protected_refs:{items:{$ref:"#/$defs/ProtectedRefRuleV1"},type:"array"}},required:["cross_merge","gates","protected_refs"],title:"WorkTopologyIntegrationStrategyV1",type:"object"},WorkTopologyPlacementLaneV1:{additionalProperties:!1,description:"One execution-placement lane: a distinct `(task, run)` pair from the\nattempt page joined to its durable placement reading. Placement absence is\na state on the lane, not a dropped lane.",properties:{attempt_count:{description:"Attempts this lane carried within the requested page.",format:"uint32",minimum:0,type:"integer"},placement:{$ref:"#/$defs/WorkPlacementReadingV1"},run_id:{$ref:"#/$defs/RunId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","run_id","attempt_count","placement"],title:"WorkTopologyPlacementLaneV1",type:"object"},WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ},$schema:"https://json-schema.org/draft/2020-12/schema",description:"The application-owned execution-topology view. Absence of any Work in\nscope is a typed state, distinct from an authorized-but-empty page.",oneOf:[{additionalProperties:!1,description:"No Work exists in this authority scope, so there is no topology to\ndraw. Concealed scopes are refused before any read.",properties:{state:{const:"absent",type:"string"}},required:["state"],type:"object"},{additionalProperties:!1,description:"The four dimensions, pinned to one verified topology generation.",properties:{branch_topology:{$ref:"#/$defs/BranchTopologyPolicyV1"},coverage:{$ref:"#/$defs/WorkAttemptListCoverageV1"},execution_placement:{$ref:"#/$defs/WorkTopologyExecutionPlacementV1"},integration_strategy:{$ref:"#/$defs/WorkTopologyIntegrationStrategyV1"},review_topology:{$ref:"#/$defs/ReviewTopologyPolicyV1"},state:{const:"view",type:"string"},topology:{$ref:"#/$defs/WorkAttemptTopologyBindingV1"}},required:["state","topology","coverage","execution_placement","branch_topology","review_topology","integration_strategy"],type:"object"}],title:"ExecutionTopologyViewV1"},{$defs:{ObservabilityHorizonV1:_W},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"One horizon-bounded execution-topology metrics read. The authorized scope\nis taken from the request context, not from the request, so a caller can\nnever widen the population it reads.",properties:{horizon:{$ref:"#/$defs/ObservabilityHorizonV1"},max_events:{description:"Event budget for this read, at most\n[`MAX_EXECUTION_TOPOLOGY_EVENTS_V1`].",format:"uint32",minimum:0,type:"integer"}},required:["horizon","max_events"],title:"ExecutionTopologyMetricsRequestV1",type:"object"},{$defs:{CoverageStateV1:yf,ExecutionBlockedCauseV1:{description:"Cause a work item was blocked for.",enum:["dependency","needs_input","capability","policy","scope","conflict","lease","backpressure","test","ci","review","effect_unknown","other","unknown"],type:"string"},ExecutionConcurrencyPhaseV1:{description:"Concurrency-width phase. `Useful` counts only distinct admitted\nattempts that advanced a committed progress frontier; heartbeats,\nqueued work, child processes, and transport fanout never reach it.",enum:["requested","accepted","admitted","active","useful"],type:"string"},ExecutionConflictKindV1:{description:"Conflict prediction kind. Mechanical and semantic keep separate\ndenominators because their adjudicators are not interchangeable.",enum:["mechanical","semantic","combined"],type:"string"},ExecutionConflictOutcomeV1:{description:"Independently observed conflict outcome. `Censored` and `Unknown`\nnever enter a confusion-matrix denominator.",enum:["conflict","no_conflict","censored","unknown"],type:"string"},ExecutionDeliveryOutcomeV1:{description:"Per-surface delivery outcome. A multi-surface delivery is never a\nduplicate of product work; only `Deduplicated` is.",enum:["delivered","deduplicated","dropped","unknown"],type:"string"},ExecutionDuplicateKindV1:{description:"Adjudicated duplicate-work relation. Similarity, proximity, shared\npaths, and concurrency never produce one of these.",enum:["exact_duplicate","superseded_overlap","repeated_investigation","duplicate_effect","not_duplicate","censored","unknown"],type:"string"},ExecutionDuplicateOutcomeV1:{description:"Whether a duplicate effect was prevented or actually committed. The\ntwo never collapse into one count.",enum:["prevented","committed","unknown","not_applicable"],type:"string"},ExecutionDurationBucketV1:{description:"Fixed duration buckets shared by stale stack age, blocked time, and\nrerun latency. Raw timestamps and exact durations stay authorized\nlocal detail.",enum:["under1m","from1m_to5m","from5m_to15m","from15m_to1h","from1h_to4h","from4h_to24h","from1d_to7d","over7d"],type:"string"},ExecutionFanoutPhaseV1:{description:"Fan-out width phase. `PeakActive` is the sampled active width; the\nfan-out distribution is unweighted so serialized and blocked samples,\nwhich carry no interval, are preserved rather than dropped.",enum:["requested","accepted","admitted","peak_active","useful"],type:"string"},ExecutionGitHubStackCapabilityReadingV1:{additionalProperties:!1,description:"Latest trustworthy GitHub stacked-PR capability observation in the\nhorizon. It is a typed operational state, not a metric or success claim.",properties:{capability:{anyOf:[{$ref:"#/$defs/ExecutionGitHubStackCapabilityV1"},{type:"null"}]},coverage:{$ref:"#/$defs/MetricCoverageV1"},other_forge_fallback_available:{type:["boolean","null"]},standard_git_fallback_available:{type:["boolean","null"]},unavailable:{anyOf:[{$ref:"#/$defs/ExecutionMetricUnavailableV1"},{type:"null"}]}},required:["coverage"],title:"ExecutionGitHubStackCapabilityReadingV1",type:"object"},ExecutionGitHubStackCapabilityV1:{description:"Last bounded GitHub stacked-PR capability state observed in the\nhorizon. This remains orthogonal to GitHub ingress and item lifecycle.",enum:["unavailable","private_preview_disabled","enabled","degraded"],type:"string"},ExecutionIntegrationKindV1:{description:"Integration operation kind. Rebase remains external observation only.",enum:["fast_forward","merge_commit","rebase","cherry_pick","stack_retarget","graph_only","external_observed","unknown"],type:"string"},ExecutionIntegrationOutcomeV1:{description:"Terminal result of an observed native integration.",enum:["succeeded","conflicted","rejected","denied","stale","locked","cancelled","timed_out","failed","partial","effect_unknown","unsupported","unknown"],type:"string"},ExecutionIntervalStateV1:{description:"Whether the owning drift interval is still open or exactly closed.",enum:["open","closed"],type:"string"},ExecutionLeakKindV1:{description:"Independently proved execution-leak class.",enum:["lease_after_terminal","attempt_without_live_owner","effect_unknown_past_deadline","missing_worktree_binding","unbounded_delivery","none","unknown"],type:"string"},ExecutionLeakOutcomeV1:{description:"Recovery state a proved leak reached.",enum:["not_required","pending","recovered","failed","unknown"],type:"string"},ExecutionMetricUnavailableV1:{description:"Why a measurement carries no value. Absence is always one of these typed\nreasons; it is never an empty string, a zero, or a silently dropped row.",oneOf:[{const:"store_unavailable",description:"The observation store could not be read at all for this horizon.",type:"string"},{const:"event_budget_exceeded",description:"The horizon holds more events than one read may draw, so every\ndenominator here would be a partial count presented as a total.",type:"string"},{const:"cell_budget_exceeded",description:"The bounded projection would exceed the Plan 26 result-cell ceiling.\nThe whole read refuses rather than returning a misleading subset.",type:"string"},{const:"no_eligible_evidence",description:"No recorded event in the family supplies this metric's numerator or\ndenominator.",type:"string"},{const:"support_floor_unmet",description:"Eligible cases exist but fall below the metric's support floor.",type:"string"},{const:"coverage_floor_unmet",description:"Observed cases cover less of the eligible population than the metric's\ncoverage floor allows.",type:"string"},{const:"censoring_ceiling_exceeded",description:"More of the eligible population is censored than the metric admits.",type:"string"},{const:"unbounded_interval",description:"The interval this metric integrates over has no proved upper bound, so\nits duration cannot be measured without inventing a terminal.",type:"string"}]},ExecutionQuantityUnitV1:{description:"Quantity unit for duplicate-effort accounting. Each unit is reported\nseparately: wall time, tokens, cost, tests, and effects are never\nsummed into one number.",enum:["wall_micros","tokens","cost_micros","tests","effects"],type:"string"},ExecutionRerunCauseV1:{description:"Typed rerun cause. Repeated logs and transport redelivery are not\nreruns and never carry one of these.",enum:["runtime_retry","runtime_fallback","test_rerun","ci_rerun","recovery","human_requested","unknown"],type:"string"},ExecutionRerunSourceV1:{description:"Which independent system observed the rerun.",enum:["runtime","test","ci"],type:"string"},ExecutionStackDriftKindV1:{description:"Exact reason a stack became stale. The enum is bounded and never\ncarries a branch, ref, worktree, repository, or provider identity.",enum:["head_advanced","base_advanced","merge_base_changed","retargeted","superseded"],type:"string"},ExecutionSurfaceFamilyV1:{description:"Delivery surface family. Addresses, payloads, principals, and\nrecipients are never observed, so the family is the whole label.",enum:["hook","mcp","lsp","dashboard","cli","other"],type:"string"},ExecutionTopologyDimensionV1:{description:"One allowed local grouping dimension. The set is closed by construction:\nevery value is produced by an exhaustive match over a bounded domain class,\nso no person, agent, task, project, repository, worktree, branch, ref,\ncommit, model version, or route can ever appear as a label.",oneOf:[{properties:{dimension:{const:"concurrency_phase",type:"string"},value:{$ref:"#/$defs/ExecutionConcurrencyPhaseV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"fanout_phase",type:"string"},value:{$ref:"#/$defs/ExecutionFanoutPhaseV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"width_bucket",type:"string"},value:{$ref:"#/$defs/ExecutionWidthBucketV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"duration_bucket",type:"string"},value:{$ref:"#/$defs/ExecutionDurationBucketV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"duplicate_kind",type:"string"},value:{$ref:"#/$defs/ExecutionDuplicateKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"unit",type:"string"},value:{$ref:"#/$defs/ExecutionQuantityUnitV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"duplicate_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionDuplicateOutcomeV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"conflict_kind",type:"string"},value:{$ref:"#/$defs/ExecutionConflictKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"conflict_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionConflictOutcomeV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"integration_kind",type:"string"},value:{$ref:"#/$defs/ExecutionIntegrationKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"integration_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionIntegrationOutcomeV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"stack_drift_kind",type:"string"},value:{$ref:"#/$defs/ExecutionStackDriftKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"interval_state",type:"string"},value:{$ref:"#/$defs/ExecutionIntervalStateV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"blocked_cause",type:"string"},value:{$ref:"#/$defs/ExecutionBlockedCauseV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"rerun_source",type:"string"},value:{$ref:"#/$defs/ExecutionRerunSourceV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"rerun_cause",type:"string"},value:{$ref:"#/$defs/ExecutionRerunCauseV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"leak_kind",type:"string"},value:{$ref:"#/$defs/ExecutionLeakKindV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"leak_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionLeakOutcomeV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"surface",type:"string"},value:{$ref:"#/$defs/ExecutionSurfaceFamilyV1"}},required:["dimension","value"],type:"object"},{properties:{dimension:{const:"delivery_outcome",type:"string"},value:{$ref:"#/$defs/ExecutionDeliveryOutcomeV1"}},required:["dimension","value"],type:"object"}]},ExecutionTopologyDrillAnchorV1:{additionalProperties:!1,description:"An opaque cursor minted by the registered observation authority. It can be\nresolved only through that same authorized local query boundary and is not\na metric dimension or exportable identity.",properties:{cursor:{type:"string"}},required:["cursor"],title:"ExecutionTopologyDrillAnchorV1",type:"object"},ExecutionTopologyEmissionCoverageV1:{additionalProperties:!1,description:"Envelope-level delivery evidence for this read. `None` means the store did\nnot answer, so no zero may be inferred. `dropped` is the proved lower bound\nfrom the bound producer scope, deduplicated across explicit loss receipts\nand their next-envelope carriers; it is not attributed to a topology\nfamily. Sampling stays a count of sampled topology envelopes and is never\nexpanded into a fabricated population estimate.",properties:{delayed:{format:"uint64",minimum:0,type:["integer","null"]},dropped:{format:"uint64",minimum:0,type:["integer","null"]},emitted:{format:"uint64",minimum:0,type:["integer","null"]},sampled_events:{format:"uint64",minimum:0,type:["integer","null"]}},title:"ExecutionTopologyEmissionCoverageV1",type:"object"},ExecutionTopologyMeasurementV1:{additionalProperties:!1,description:"One descriptor cell: the Plan 26 descriptor name, its grouping dimensions,\nand the landed metric envelope carrying value, denominator, coverage, and\nprovenance.",properties:{dimensions:{description:"Allowed local grouping dimensions, at most\n[`MAX_METRIC_DIMENSIONS_V1`], in a fixed order per descriptor.",items:{$ref:"#/$defs/ExecutionTopologyDimensionV1"},type:"array"},unavailable:{anyOf:[{$ref:"#/$defs/ExecutionMetricUnavailableV1"},{type:"null"}],description:"Typed absence reason. It is `Some` exactly when `value.value` is\n`None`, so a reader can never mistake a refused metric for a zero."},value:{$ref:"#/$defs/MetricValueV1"}},required:["dimensions","value"],title:"ExecutionTopologyMeasurementV1",type:"object"},ExecutionWidthBucketV1:{description:"Fixed width buckets. Raw widths stay authorized local detail; only\nbucket counts leave the projection.",enum:["zero","one","two","from3_to4","from5_to8","from9_to16","from17_to32","from33_to64","over64"],type:"string"},MetricCalibrationV1:_h,MetricCohortV1:_y,MetricCoverageV1:_g,MetricEvidenceClassV1:__,MetricProvenanceV1:_v,MetricSourceV1:_b,MetricTemporalV1:_$,MetricUncertaintyV1:_S,MetricValueV1:_k,ObservabilityHorizonV1:_W},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"The canonical execution-topology read model. Observatory and Costs render\nthis without local formulas; CLI, MCP, and HTTP return the same bytes.",properties:{authorized_scope_ref:{description:"Local authorization anchor the read was admitted under. It is derived\nfrom the resolved scope, never from a caller-supplied string.",type:"string"},coverage:{$ref:"#/$defs/MetricCoverageV1",description:"Family-level coverage over the event population, independent of any\nsingle descriptor's denominator."},current:{description:"True only when the whole family was read with `Known` coverage. A\nfalse value means at least one descriptor below is a typed absence.",type:"boolean"},drill_anchors:{description:"Bounded registered source cursors for authorized local drill-down.\nPayload anchors, traces, and scope identifiers never enter this list.",items:{$ref:"#/$defs/ExecutionTopologyDrillAnchorV1"},type:"array"},emission_coverage:{$ref:"#/$defs/ExecutionTopologyEmissionCoverageV1"},github_stack_capability:{$ref:"#/$defs/ExecutionGitHubStackCapabilityReadingV1"},horizon:{$ref:"#/$defs/ObservabilityHorizonV1"},measurements:{items:{$ref:"#/$defs/ExecutionTopologyMeasurementV1"},type:"array"},observed_at_micros:{format:"int64",type:"integer"},watermark:{description:"Watermark of the last event this projection consumed. A rebuild at the\nsame watermark yields the same values.",type:"string"}},required:["authorized_scope_ref","horizon","watermark","observed_at_micros","current","coverage","emission_coverage","github_stack_capability","drill_anchors","measurements"],title:"ExecutionTopologyMetricsV1",type:"object"},{$defs:{ProjectId:_4,RepositoryId:vb,UtcMicros:bZ,WorkGraphReadModeV1:{oneOf:[{properties:{mode:{const:"current",type:"string"}},required:["mode"],type:"object"},{properties:{mode:{const:"as_of",type:"string"},valid_at:{$ref:"#/$defs/UtcMicros"}},required:["mode","valid_at"],type:"object"},{properties:{from_valid_at:{$ref:"#/$defs/UtcMicros"},mode:{const:"evolution",type:"string"},through_valid_at:{$ref:"#/$defs/UtcMicros"}},required:["mode","from_valid_at","through_valid_at"],type:"object"},{properties:{from_observed_at:{$ref:"#/$defs/UtcMicros"},mode:{const:"forensic",type:"string"},through_observed_at:{$ref:"#/$defs/UtcMicros"}},required:["mode","from_observed_at","through_observed_at"],type:"object"}]},WorkProductAuthorizedRelationScopeV1:$X,WorkProductSelectionScopeV1:$7},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{continuation:{type:["string","null"]},mode:{$ref:"#/$defs/WorkGraphReadModeV1"},observed_at:{$ref:"#/$defs/UtcMicros"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["selection","mode","observed_at"],title:"WorkGraphReadRequestV1",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,AuthorizedWorkProductScopeV1:{additionalProperties:!1,description:"Owner identity resolved by the registered profile authority. It is never\naccepted from a Work request.",properties:{owner_brain_id:{$ref:"#/$defs/BrainId"},owner_profile_id:{$ref:"#/$defs/UserProfileId"},selection:{$ref:"#/$defs/WorkProductSelectionScopeV1"}},required:["owner_brain_id","owner_profile_id","selection"],type:"object"},BrainId:f1,ManifestDigest:_l,ProjectId:_4,ProjectionGenerationId:_5,ProposalId:_8,ProviderId:vo,RepositoryId:vb,RetrievalAnchorId:vI,RunId:vF,TaskEvidenceLinkV1:bj,TaskId:bT,UserProfileId:bJ,UtcMicros:bZ,VerifiedWorkGraphVersionV1:bX,WorkAcceptanceCriterionV1:bY,WorkAttemptIdentityV1:b6,WorkAttemptStateV1:$t,WorkCausalProjectionV1:{additionalProperties:!1,properties:{candidate_edges:{items:{$ref:"#/$defs/WorkDagEdgeV1"},type:"array"},graph_version:{format:"uint64",minimum:0,type:"integer"}},required:["graph_version","candidate_edges"],type:"object"},WorkCriticalPathProjectionV1:{additionalProperties:!1,properties:{graph_version:{format:"uint64",minimum:0,type:"integer"},task_ids:{items:{$ref:"#/$defs/TaskId"},type:"array"},total_effort:{format:"uint32",minimum:0,type:"integer"}},required:["graph_version","task_ids","total_effort"],type:"object"},WorkDagEdgeV1:{additionalProperties:!1,properties:{dependency:{$ref:"#/$defs/TaskId"},dependent:{$ref:"#/$defs/TaskId"}},required:["dependency","dependent"],type:"object"},WorkDagProjectionV1:{additionalProperties:!1,properties:{gating_edges:{items:{$ref:"#/$defs/WorkDagEdgeV1"},type:"array"},graph_version:{format:"uint64",minimum:0,type:"integer"},task_ids:{items:{$ref:"#/$defs/TaskId"},type:"array"}},required:["graph_version","task_ids","gating_edges"],type:"object"},WorkGraphSelectionCoverageV1:{description:"How much of the owner's journal the read's selection actually covers.\n\nA selection names a slice of the owner's work, not the whole journal: an\nevent records the relation scopes it was admitted under, and a selection\nthat does not name them puts that event *outside* the slice. The events\noutside a selection do not poison the ones inside it, but they must never be\nconcealed either, a caller who is shown the covered slice with no way to\nlearn that more exists is reading a silently incomplete graph.\n\nSo the read answers over the covered slice and says so, in the same\n`Complete`/`Partial` vocabulary [`WorkGraphTimelineCoverageV1`] and\n[`WorkHistoryCoverageV1`](crate::WorkHistoryCoverageV1) already use.\n\nThe covered slice is always a *prefix* of the journal, and that is a\nproperty of folding rather than a simplification. A graph version is folded\nfrom every event up to its own sequence, so the first event a selection does\nnot cover ends the readable slice: every later version, whatever scopes its\nown event named, would have to be folded across that event to exist at all.\n`excluded_events` therefore counts every event from the first uncovered one\nonward.",oneOf:[{description:"The selection covers the owner's whole journal. Nothing was withheld.",properties:{coverage:{const:"complete",type:"string"},covered_events:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","covered_events"],type:"object"},{description:"The selection covers `covered_events` events and `excluded_events`\nevents lie outside it, starting at `first_excluded_sequence`. Every\nentry this read returned was folded from covered events alone.",properties:{coverage:{const:"partial",type:"string"},covered_events:{format:"uint32",minimum:0,type:"integer"},excluded_events:{format:"uint32",minimum:0,type:"integer"},first_excluded_sequence:{format:"uint64",minimum:0,type:"integer"}},required:["coverage","covered_events","excluded_events","first_excluded_sequence"],type:"object"}]},WorkGraphTimelineCoverageV1:{oneOf:[{properties:{coverage:{const:"complete",type:"string"},returned:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned"],type:"object"},{properties:{continuation:{type:"string"},coverage:{const:"partial",type:"string"},returned:{format:"uint32",minimum:0,type:"integer"}},required:["coverage","returned","continuation"],type:"object"}]},WorkGraphTimelineV1:{additionalProperties:!1,properties:{coverage:{$ref:"#/$defs/WorkGraphTimelineCoverageV1"},entries:{items:{$ref:"#/$defs/WorkGraphVersionEntryV1"},type:"array"}},required:["entries","coverage"],type:"object"},WorkGraphVersionEntryV1:{additionalProperties:!1,description:"One immutable graph version and every Work projection derived from that\nsame version at the caller's explicit observation time.",properties:{graph:{$ref:"#/$defs/WorkProductGraphV1"},observed_at:{$ref:"#/$defs/UtcMicros"},projected_at:{$ref:"#/$defs/UtcMicros"},projections:{$ref:"#/$defs/WorkProductProjectionBundleV1"},runtime:{$ref:"#/$defs/WorkRuntimeProjectionV1"},valid_at:{$ref:"#/$defs/UtcMicros"},verified_version:{$ref:"#/$defs/VerifiedWorkGraphVersionV1"}},required:["valid_at","observed_at","projected_at","verified_version","graph","runtime","projections"],type:"object"},WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkKanbanCardV1:{additionalProperties:!1,properties:{effort:{format:"uint32",minimum:0,type:"integer"},lane:{$ref:"#/$defs/WorkTimelineLaneV1"},legal_actions:{items:{$ref:"#/$defs/WorkLegalActionV1"},type:"array",uniqueItems:!0},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","lane","effort","legal_actions"],type:"object"},WorkKanbanProjectionV1:{additionalProperties:!1,properties:{cards:{items:{$ref:"#/$defs/WorkKanbanCardV1"},type:"array"},graph_version:{format:"uint64",minimum:0,type:"integer"}},required:["graph_version","cards"],type:"object"},WorkLegalActionV1:{enum:["view_evidence","generate_proposal","accept_proposal","link_accepted_attempt","accept_task","handoff","archive"],type:"string"},WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProductAuthorizedRelationScopeV1:$X,WorkProductGraphV1:$4,WorkProductProjectionBundleV1:{additionalProperties:!1,properties:{causal:{$ref:"#/$defs/WorkCausalProjectionV1"},critical_path:{$ref:"#/$defs/WorkCriticalPathProjectionV1"},dag:{$ref:"#/$defs/WorkDagProjectionV1"},graph_version:{format:"uint64",minimum:0,type:"integer"},kanban:{$ref:"#/$defs/WorkKanbanProjectionV1"},runtime:{$ref:"#/$defs/WorkRuntimeProjectionV1"},timeline:{$ref:"#/$defs/WorkTimelineProjectionV1"},workload:{$ref:"#/$defs/WorkWorkloadProjectionV1"}},required:["graph_version","runtime","kanban","dag","timeline","causal","critical_path","workload"],type:"object"},WorkProductSelectionScopeV1:$7,WorkProjectionSequenceV1:{format:"uint64",minimum:0,title:"WorkProjectionSequenceV1",type:"integer"},WorkProposalDecisionV1:Se,WorkProposalDispositionV1:St,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRelationReplanDecisionV1:Sp,WorkRelationReplanProposalV1:Su,WorkRouteDecisionV1:S_,WorkRuntimeAttemptProjectionV1:{additionalProperties:!1,properties:{identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},state:{$ref:"#/$defs/WorkAttemptStateV1"}},required:["identity","state"],type:"object"},WorkRuntimeProjectionCoverageV1:{oneOf:[{additionalProperties:!1,properties:{coverage:{const:"complete",type:"string"}},required:["coverage"],type:"object"},{additionalProperties:!1,properties:{coverage:{const:"partial",type:"string"},unavailable_attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array",uniqueItems:!0}},required:["coverage","unavailable_attempts"],type:"object"},{additionalProperties:!1,properties:{coverage:{const:"unavailable",type:"string"}},required:["coverage"],type:"object"}]},WorkRuntimeProjectionV1:{additionalProperties:!1,properties:{attempts:{items:{$ref:"#/$defs/WorkRuntimeAttemptProjectionV1"},type:"array"},coverage:{$ref:"#/$defs/WorkRuntimeProjectionCoverageV1"},generation_id:{$ref:"#/$defs/ProjectionGenerationId"},graph_version:{format:"uint64",minimum:0,type:"integer"},observed_at:{$ref:"#/$defs/UtcMicros"},sequence:{$ref:"#/$defs/WorkProjectionSequenceV1"}},required:["graph_version","generation_id","sequence","observed_at","attempts","coverage"],type:"object"},WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTimelineEntryV1:{additionalProperties:!1,properties:{created_at:{$ref:"#/$defs/UtcMicros"},deadline:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},scheduled_at:{anyOf:[{$ref:"#/$defs/UtcMicros"},{type:"null"}]},task_id:{$ref:"#/$defs/TaskId"},updated_at:{$ref:"#/$defs/UtcMicros"}},required:["task_id","created_at","updated_at"],type:"object"},WorkTimelineLaneV1:{enum:["triage","todo","scheduled","ready","running","blocked","review","done","archived","cancelled","unavailable"],type:"string"},WorkTimelineProjectionV1:{additionalProperties:!1,properties:{entries:{items:{$ref:"#/$defs/WorkTimelineEntryV1"},type:"array"},graph_version:{format:"uint64",minimum:0,type:"integer"}},required:["graph_version","entries"],type:"object"},WorkWorkloadProjectionV1:{additionalProperties:!1,properties:{actual_concurrency:{format:"uint32",minimum:0,type:["integer","null"]},blocked_effort:{format:"uint32",minimum:0,type:["integer","null"]},graph_version:{format:"uint64",minimum:0,type:"integer"},ready_effort:{format:"uint32",minimum:0,type:["integer","null"]},requested_concurrency:{format:"uint32",minimum:0,type:["integer","null"]},running_effort:{format:"uint32",minimum:0,type:["integer","null"]},total_effort:{format:"uint32",minimum:0,type:"integer"}},required:["graph_version","total_effort"],type:"object"}},$schema:"https://json-schema.org/draft/2020-12/schema",oneOf:[{properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"current",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"},snapshot:{$ref:"#/$defs/WorkGraphVersionEntryV1"}},required:["mode","authorized_scope","selection_coverage","snapshot"],type:"object"},{properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"as_of",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"},snapshot:{$ref:"#/$defs/WorkGraphVersionEntryV1"}},required:["mode","authorized_scope","selection_coverage","snapshot"],type:"object"},{properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"evolution",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"},timeline:{$ref:"#/$defs/WorkGraphTimelineV1"}},required:["mode","authorized_scope","selection_coverage","timeline"],type:"object"},{properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"forensic",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"},timeline:{$ref:"#/$defs/WorkGraphTimelineV1"}},required:["mode","authorized_scope","selection_coverage","timeline"],type:"object"},{description:"A `Current` or `AsOf` point read under an authorized selection that has\nno published graph version at that point: no task has been created yet.\nThe caller was authorized; the legal next action is creating a task.",properties:{authorized_scope:{$ref:"#/$defs/AuthorizedWorkProductScopeV1"},mode:{const:"absent",type:"string"},selection_coverage:{$ref:"#/$defs/WorkGraphSelectionCoverageV1"}},required:["mode","authorized_scope","selection_coverage"],type:"object"}],title:"WorkGraphReadV1"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::activate`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},expected_revision:{description:"Current candidate disposition revision. A newly registered candidate\nstarts at revision 1; activation reports expected and observed values\nwhen this compare-and-swap precondition is stale.",format:"uint64",minimum:1,type:"integer"}},required:["definition_id","definition_version","expected_revision"],title:"WorkflowDefinitionActivateRequest",type:"object"},{$defs:{UtcMicros:bZ,WorkflowDefinitionId:SM,WorkflowDefinitionLifecycleState:{description:'Durable lifecycle disposition of one immutable workflow definition version.\n\nPlan 32 ("Typed workflow definitions"): "Lifecycle retains candidate,\nvalidate, activate, retire, reject, list, get, diff, and history operations\nthrough the same application surfaces." The definition payload itself stays\nimmutable, "Editing creates a new version; admitted runs remain pinned",\nso the disposition is a separate revisioned aggregate keyed by the same\ndefinition identity.',enum:["candidate","validated","active","retired","rejected"],type:"string"}},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Revisioned lifecycle disposition of one definition version.",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},revision:{format:"uint64",minimum:1,type:"integer"},state:{$ref:"#/$defs/WorkflowDefinitionLifecycleState"},transitioned_at:{$ref:"#/$defs/UtcMicros"}},required:["definition_id","definition_version","state","revision","transitioned_at"],title:"WorkflowDefinitionDisposition",type:"object"},{$defs:{RunId:vF,WorkCommandId:$p},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Requests cooperative cancellation as a durable typed transition; the run\nsettles to `Cancelled` when the runtime reconciles in-flight steps.",properties:{command_id:{$ref:"#/$defs/WorkCommandId"},expected_sequence:{format:"uint64",minimum:0,type:"integer"},run_id:{$ref:"#/$defs/RunId"}},required:["run_id","expected_sequence","command_id"],title:"WorkflowRunCancelRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProjectId:_4,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkAcceptanceCriterionV1:bY,WorkApprovalPolicy:b1,WorkArtifactId:b0,WorkArtifactRefV1:b2,WorkAttemptIdentityV1:b6,WorkAuthority:{additionalProperties:!1,properties:{actor_id:{$ref:"#/$defs/ActorId"},policy_digest:{$ref:"#/$defs/ManifestDigest"},project_id:{$ref:"#/$defs/ProjectId"},repository_id:{$ref:"#/$defs/RepositoryId"},worktree_id:{$ref:"#/$defs/WorktreeId"}},required:["project_id","repository_id","worktree_id","actor_id","policy_digest"],type:"object"},WorkCommandId:$p,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFilesystemPolicy:$x,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_,WorkSandboxPolicy:Sw,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTopologyPolicyV1:SA,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowFanOutChildPlanV1:{additionalProperties:!1,properties:{admit_command_id:{$ref:"#/$defs/WorkCommandId"},attempt_identity:{$ref:"#/$defs/WorkAttemptIdentityV1"},create_command_id:{$ref:"#/$defs/WorkCommandId"},initiative:{$ref:"#/$defs/WorkInitiativeV1"},instructions:{type:"string"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},plan:{$ref:"#/$defs/WorkPlanV1"},proposal:{$ref:"#/$defs/WorkProposalV1"},proposal_command_id:{$ref:"#/$defs/WorkCommandId"},task_id:{$ref:"#/$defs/TaskId"}},required:["task_id","attempt_identity","create_command_id","proposal_command_id","admit_command_id","initiative","plan","milestone","item","proposal","instructions"],type:"object"},WorkflowFanOutFailurePolicyV1:{oneOf:[{properties:{policy:{const:"fail_fast",type:"string"}},required:["policy"],type:"object"},{properties:{policy:{const:"collect",type:"string"}},required:["policy"],type:"object"},{properties:{policy:{const:"require_at_least",type:"string"},successes:{format:"uint16",maximum:65535,minimum:1,type:"integer"}},required:["policy","successes"],type:"object"}]},WorkflowFanOutPlanV1:{additionalProperties:!1,properties:{admitted_at:{$ref:"#/$defs/UtcMicros"},authority:{$ref:"#/$defs/WorkAuthority",description:"Exact Work authority that admitted this plan. Recovery may execute the\nplan only from a runtime with this byte-identical authority."},children:{items:{$ref:"#/$defs/WorkflowFanOutChildPlanV1"},type:"array"},commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},failure_policy:{$ref:"#/$defs/WorkflowFanOutFailurePolicyV1"},maximum_parallel:{format:"uint16",maximum:65535,minimum:1,type:"integer"},operation:{$ref:"#/$defs/WorkflowOperationRef"},plan_digest:{$ref:"#/$defs/ManifestDigest"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]},step_id:{$ref:"#/$defs/WorkflowStepId"}},required:["authority","step_id","operation","plan_digest","admitted_at","maximum_parallel","failure_policy","execution_snapshot","commit","effect_state","children"],type:"object"},WorkflowOperationRef:Sz,WorkflowOutputArtifact:{additionalProperties:!1,properties:{artifact:{$ref:"#/$defs/WorkArtifactRefV1"},attempt_identity:{$ref:"#/$defs/WorkAttemptIdentityV1"}},required:["attempt_identity","artifact"],type:"object"},WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowPlacementReceipt:{additionalProperties:!1,properties:{backend:{$ref:"#/$defs/WorkProviderBackendV1"},configuration_digest:{$ref:"#/$defs/ManifestDigest"},model:{type:"string"},placement_digest:{$ref:"#/$defs/ManifestDigest"},provider_registry_digest:{$ref:"#/$defs/ManifestDigest"},route:{$ref:"#/$defs/WorkProviderRouteV1"},run_id:{$ref:"#/$defs/RunId"},step_id:{$ref:"#/$defs/WorkflowStepId"},topology_digest:{$ref:"#/$defs/ManifestDigest"},worktree_placement:{$ref:"#/$defs/WorktreePlacementModeV1"}},required:["run_id","step_id","route","backend","model","configuration_digest","topology_digest","provider_registry_digest","worktree_placement","placement_digest"],type:"object"},WorkflowRunEvent:{additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},event:{$ref:"#/$defs/WorkflowRunEventKind"},input_digest:{$ref:"#/$defs/ManifestDigest"},occurred_at:{$ref:"#/$defs/UtcMicros"},run_id:{$ref:"#/$defs/RunId"},sequence:{format:"uint64",minimum:0,type:"integer"}},required:["run_id","sequence","command_id","input_digest","occurred_at","event"],type:"object"},WorkflowRunEventKind:{oneOf:[{properties:{definition:{$ref:"#/$defs/WorkflowDefinition"},fan_out_plans:{default:[],items:{$ref:"#/$defs/WorkflowFanOutPlanV1"},type:"array"},pinned_provider_registry_digest:{$ref:"#/$defs/ManifestDigest"},pinned_topology_digest:{$ref:"#/$defs/ManifestDigest"},type:{const:"admitted",type:"string"}},required:["type","definition","pinned_topology_digest","pinned_provider_registry_digest"],type:"object"},{properties:{attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"fan_out_children_released",type:"string"}},required:["type","step_id","attempts"],type:"object"},{properties:{attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"fan_out_children_settled",type:"string"}},required:["type","step_id","attempts"],type:"object"},{properties:{planned_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},prior_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},replacement_attempt:{$ref:"#/$defs/WorkAttemptIdentityV1"},retry_receipt_digest:{$ref:"#/$defs/ManifestDigest"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"fan_out_child_retry_rebound",type:"string"}},required:["type","step_id","planned_attempt","prior_attempt","replacement_attempt","retry_receipt_digest"],type:"object"},{properties:{placement:{$ref:"#/$defs/WorkflowPlacementReceipt"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"step_started",type:"string"}},required:["type","step_id","placement"],type:"object"},{properties:{effect_receipt:{$ref:"#/$defs/WorkflowStepEffectReceipt"},outputs:{items:{$ref:"#/$defs/WorkflowStepOutput"},type:"array"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"step_completed",type:"string"}},required:["type","step_id","outputs","effect_receipt"],type:"object"},{properties:{effect_receipt:{$ref:"#/$defs/WorkflowStepEffectReceipt"},outputs:{items:{$ref:"#/$defs/WorkflowStepOutput"},type:"array"},step_id:{$ref:"#/$defs/WorkflowStepId"},type:{const:"step_failed",type:"string"}},required:["type","step_id","outputs","effect_receipt"],type:"object"},{properties:{type:{const:"paused",type:"string"}},required:["type"],type:"object"},{properties:{type:{const:"resumed",type:"string"}},required:["type"],type:"object"},{properties:{type:{const:"cancellation_requested",type:"string"}},required:["type"],type:"object"},{properties:{type:{const:"cancelled",type:"string"}},required:["type"],type:"object"}]},WorkflowRunStatus:{enum:["running","paused","cancelling","completed","failed","cancelled"],type:"string"},WorkflowStep:SL,WorkflowStepEffectOutcome:{enum:["completed","failed","cancelled","timed_out","unknown"],type:"string"},WorkflowStepEffectReceipt:{additionalProperties:!1,properties:{effect_digest:{$ref:"#/$defs/ManifestDigest"},outcome:{$ref:"#/$defs/WorkflowStepEffectOutcome"},output_set_digest:{$ref:"#/$defs/ManifestDigest"},placement_digest:{$ref:"#/$defs/ManifestDigest"},receipt_digest:{$ref:"#/$defs/ManifestDigest"},run_id:{$ref:"#/$defs/RunId"},step_id:{$ref:"#/$defs/WorkflowStepId"}},required:["run_id","step_id","placement_digest","outcome","effect_digest","output_set_digest","receipt_digest"],type:"object"},WorkflowStepId:SU,WorkflowStepOutput:{additionalProperties:!1,properties:{artifacts:{items:{$ref:"#/$defs/WorkflowOutputArtifact"},type:"array"},output_name:{$ref:"#/$defs/WorkflowOutputName"}},required:["output_name","artifacts"],type:"object"},WorkflowStepRunProjection:{additionalProperties:!1,properties:{effect_receipt:{anyOf:[{$ref:"#/$defs/WorkflowStepEffectReceipt"},{type:"null"}]},outputs:{additionalProperties:{$ref:"#/$defs/WorkflowStepOutput"},type:"object"},placement_receipt:{anyOf:[{$ref:"#/$defs/WorkflowPlacementReceipt"},{type:"null"}]},status:{$ref:"#/$defs/WorkflowStepStatus"}},required:["status","outputs"],type:"object"},WorkflowStepStatus:{enum:["blocked","ready","running","succeeded","failed","cancelled"],type:"string"},WorktreeCleanlinessRequirementV1:SG,WorktreeId:SB,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{definition:{$ref:"#/$defs/WorkflowDefinition"},fan_out_plans:{additionalProperties:{$ref:"#/$defs/WorkflowFanOutPlanV1"},type:"object"},history:{items:{$ref:"#/$defs/WorkflowRunEvent"},type:"array"},pinned_provider_registry_digest:{$ref:"#/$defs/ManifestDigest"},pinned_topology_digest:{$ref:"#/$defs/ManifestDigest"},released_fan_out_attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array",uniqueItems:!0},run_id:{$ref:"#/$defs/RunId"},sequence:{format:"uint64",minimum:0,type:"integer"},settled_fan_out_attempts:{items:{$ref:"#/$defs/WorkAttemptIdentityV1"},type:"array",uniqueItems:!0},status:{$ref:"#/$defs/WorkflowRunStatus"},steps:{additionalProperties:{$ref:"#/$defs/WorkflowStepRunProjection"},type:"object"}},required:["run_id","definition","pinned_topology_digest","pinned_provider_registry_digest","status","sequence","steps","fan_out_plans","released_fan_out_attempts","settled_fan_out_attempts","history"],title:"WorkflowRunProjection",type:"object"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::history`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"}},required:["definition_id"],title:"WorkflowDefinitionHistoryRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",items:{$ref:"#/$defs/WorkflowDefinition"},title:"Array_of_WorkflowDefinition",type:"array"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::diff`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},from_version:{format:"uint64",minimum:1,type:"integer"},to_version:{format:"uint64",minimum:1,type:"integer"}},required:["definition_id","from_version","to_version"],title:"WorkflowDefinitionDiffRequest",type:"object"},{$defs:{WorkflowDefinitionId:SM,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{catalog_changed:{type:"boolean"},changed_steps:{items:{$ref:"#/$defs/WorkflowStepId"},type:"array",uniqueItems:!0},configuration_changed:{type:"boolean"},definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},from_version:{format:"uint64",minimum:0,type:"integer"},policy_changed:{type:"boolean"},to_version:{format:"uint64",minimum:0,type:"integer"}},required:["definition_id","from_version","to_version","changed_steps","policy_changed","configuration_changed","catalog_changed"],title:"WorkflowDefinitionDiff",type:"object"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::get`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"}},required:["definition_id","definition_version"],title:"WorkflowDefinitionGetRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:0,type:"integer"},pinned_catalog_digest:{$ref:"#/$defs/ManifestDigest",description:"Must equal the live Work executable catalog digest. Validation and\nactivation report the current digest when this pin is stale."},pinned_configuration_digest:{$ref:"#/$defs/ManifestDigest"},pinned_policy_digest:{$ref:"#/$defs/ManifestDigest"},project_id:{$ref:"#/$defs/ProjectId"},steps:{items:{$ref:"#/$defs/WorkflowStep"},type:"array"}},required:["definition_id","definition_version","project_id","steps","pinned_policy_digest","pinned_configuration_digest","pinned_catalog_digest"],title:"WorkflowDefinition",type:"object"},{$defs:{RunId:vF},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{run_id:{$ref:"#/$defs/RunId"}},required:["run_id"],title:"WorkflowRunGetRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RunId:vF,TaskHandoffScope:bC,TaskId:bT,ThreadId:bz,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkAttemptStateV1:$t,WorkHandoffAttemptFrontierV1:$C,WorkHandoffFrontierV1:$T,WorkHandoffLineageV1:$O,WorkflowDefinitionId:SM,WorkflowStepId:SU,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`TaskHandoffService::issue`].\n\n`secret` is the caller-supplied bearer token; the authority persists only\nits digest, never the secret itself. The scope must name a step the\nActive definition version declares and a run admitted from that version;\nany other scope is refused as not found and journals no grant.",properties:{frontier:{$ref:"#/$defs/WorkHandoffFrontierV1",description:"The exact work/evidence frontier this handoff records (Plan 24)."},scope:{$ref:"#/$defs/TaskHandoffScope"},secret:{type:"string"}},required:["scope","secret","frontier"],title:"TaskHandoffIssueRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RunId:vF,TaskHandoffScope:bC,TaskId:bT,ThreadId:bz,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkAttemptStateV1:$t,WorkHandoffAttemptFrontierV1:$C,WorkHandoffFrontierV1:$T,WorkHandoffLineageV1:$O,WorkflowDefinitionId:SM,WorkflowStepId:SU,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{expires_at:{$ref:"#/$defs/UtcMicros"},frontier:{$ref:"#/$defs/WorkHandoffFrontierV1",description:"The exact work/evidence frontier this handoff records (Plan 24)."},frontier_digest:{$ref:"#/$defs/ManifestDigest",description:"The canonical digest of `frontier`; lineage chains hold this value."},issued_at:{$ref:"#/$defs/UtcMicros"},scope:{$ref:"#/$defs/TaskHandoffScope"},token_digest:{$ref:"#/$defs/ManifestDigest"}},required:["scope","token_digest","issued_at","expires_at","frontier","frontier_digest"],title:"TaskHandoffGrant",type:"object"},{$defs:{ActorId:fb,ProjectId:_4,RepositoryId:vb,RunId:vF,TaskHandoffScope:bC,TaskId:bT,ThreadId:bz,WorkflowDefinitionId:SM,WorkflowStepId:SU,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`TaskHandoffService::redeem`].",properties:{expected_scope:{$ref:"#/$defs/TaskHandoffScope"},secret:{type:"string"}},required:["secret","expected_scope"],title:"TaskHandoffRedeemRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,ManifestDigest:_l,ProjectId:_4,RepositoryId:vb,RunId:vF,TaskHandoffScope:bC,TaskId:bT,ThreadId:bz,UtcMicros:bZ,WorkAttemptIdentityV1:b6,WorkAttemptStateV1:$t,WorkHandoffAttemptFrontierV1:$C,WorkHandoffFrontierV1:$T,WorkHandoffLineageV1:$O,WorkflowDefinitionId:SM,WorkflowStepId:SU,WorktreeId:SB},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire response for [`TaskHandoffService::redeem`]: the redemption receipt,\nonce and only once, for the caller that actually consumed the grant.\n\nThe receipt is checkpoint evidence only. It deliberately carries no\nlease, fence, or acceptance authority: redeeming a handoff cannot renew\na lease, establish task acceptance, or mutate graph or runtime state\n(Plan 24). The redeemer must earn runtime authority through the normal\nadmission and lease paths.",properties:{frontier:{$ref:"#/$defs/WorkHandoffFrontierV1",description:"The frontier exactly as the issuer recorded it."},frontier_digest:{$ref:"#/$defs/ManifestDigest",description:"The canonical digest of `frontier`, for lineage chaining."},redeemed_at:{$ref:"#/$defs/UtcMicros"},scope:{$ref:"#/$defs/TaskHandoffScope"}},required:["scope","frontier","frontier_digest","redeemed_at"],title:"TaskHandoffRedeemed",type:"object"},{$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::list`].",title:"WorkflowDefinitionListRequest",type:"object"},{$defs:{RunId:vF,WorkCommandId:$p},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},expected_sequence:{format:"uint64",minimum:0,type:"integer"},run_id:{$ref:"#/$defs/RunId"}},required:["run_id","expected_sequence","command_id"],title:"WorkflowRunPauseRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::register`].",properties:{definition:{$ref:"#/$defs/WorkflowDefinition"}},required:["definition"],title:"WorkflowDefinitionRegisterRequest",type:"object"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::reject`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},expected_revision:{format:"uint64",minimum:1,type:"integer"}},required:["definition_id","definition_version","expected_revision"],title:"WorkflowDefinitionRejectRequest",type:"object"},{$defs:{RunId:vF,WorkCommandId:$p},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{command_id:{$ref:"#/$defs/WorkCommandId"},expected_sequence:{format:"uint64",minimum:0,type:"integer"},run_id:{$ref:"#/$defs/RunId"}},required:["run_id","expected_sequence","command_id"],title:"WorkflowRunResumeRequest",type:"object"},{$defs:{WorkflowDefinitionId:SM},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::retire`].",properties:{definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},expected_revision:{format:"uint64",minimum:1,type:"integer"}},required:["definition_id","definition_version","expected_revision"],title:"WorkflowDefinitionRetireRequest",type:"object"},{$defs:{ActorId:fb,AttemptId:fW,AutomaticWorktreeGcV1:fF,BranchCollisionPolicyV1:f0,BranchNameComponentV1:f2,BranchNameSeparatorV1:f4,BranchNamingPolicyV1:f6,BranchTopologyKindV1:ht,BranchTopologyPolicyV1:hr,CanonicalGitRefNameV1:hd,CanonicalGitRefPrefix:hc,CapabilityId:hl,CommitId:hq,ConfigurationRevisionId:hM,ConfigurationSnapshotId:hN,CredentialReferenceId:yh,CrossMergeModeV1:yy,CrossMergePolicyV1:yg,GitHubStackedPullRequestPolicyV1:gw,HistoryRewritePolicyV1:gF,LocatorDigest:_r,ManifestDigest:_l,ProposalId:_8,ProtectedRefDispositionV1:_7,ProtectedRefRuleV1:ve,ProtectedRefSelectorV1:vt,ProviderId:vo,RefId:vm,RepositoryId:vb,RepositoryPlacementScopeV1:v$,RequiredCheckExpectationV1:vS,RequiredCheckV1:vk,ReviewRequirementV1:vE,ReviewTopologyKindV1:vA,ReviewTopologyPolicyV1:vW,RunId:vF,SensitiveFilesystemLocatorV1:v4,TaskId:bT,TopologyConcurrencyPolicyV1:bL,TopologyEscalationPolicyV1:bU,TopologyGatePolicyV1:bH,TopologyNotificationLevelV1:bG,UtcMicros:bZ,WorkAcceptanceCriterionV1:bY,WorkApprovalPolicy:b1,WorkAttemptIdentityV1:b6,WorkCommandId:$p,WorkEffectStateV1:$h,WorkEgressPolicy:$g,WorkExecutableReference:$S,WorkExecutionLimits:$w,WorkExecutionSnapshot:$P,WorkFallbackTopology:$q,WorkFenceEpochV1:$I,WorkFilesystemPolicy:$x,WorkHandoffV1:$E,WorkHierarchyV1:$A,WorkInitiativeV1:$W,WorkItemInputV1:$M,WorkItemV1:$N,WorkLeaseFenceV1:$D,WorkLeaseId:$F,WorkMilestoneV1:$L,WorkPlanV1:$Q,WorkProposalV1:Sr,WorkProposedChildV1:Si,WorkProviderBackendV1:Sn,WorkProviderProtocol:Ss,WorkProviderRouteId:Sd,WorkProviderRouteV1:Sc,WorkRouteDecisionV1:S_,WorkSandboxPolicy:Sw,WorkScoreKindV1:SP,WorkShapeAssessmentV1:SV,WorkSizingV1:SR,WorkTopologyPolicyV1:SA,WorkflowDefinitionId:SM,WorkflowExecutionFence:{additionalProperties:!1,properties:{attempt_id:{$ref:"#/$defs/AttemptId"},lease:{$ref:"#/$defs/WorkLeaseFenceV1"}},required:["attempt_id","lease"],type:"object"},WorkflowFailurePolicy:{oneOf:[{properties:{policy:{const:"fail_fast",type:"string"}},required:["policy"],type:"object"},{properties:{policy:{const:"collect",type:"string"}},required:["policy"],type:"object"},{properties:{policy:{const:"require_at_least",type:"string"},successes:{format:"uint32",minimum:1,type:"integer"}},required:["policy","successes"],type:"object"}]},WorkflowFanOutInput:{additionalProperties:!1,properties:{initiative:{$ref:"#/$defs/WorkInitiativeV1"},input_digest:{$ref:"#/$defs/ManifestDigest"},instructions:{type:"string"},item:{$ref:"#/$defs/WorkItemV1"},milestone:{$ref:"#/$defs/WorkMilestoneV1"},plan:{$ref:"#/$defs/WorkPlanV1"},proposal:{$ref:"#/$defs/WorkProposalV1"}},required:["instructions","input_digest","initiative","plan","milestone","item","proposal"],type:"object"},WorkflowFanOutStartV1:{additionalProperties:!1,description:"Caller input required to durably plan the entry fan-out of a workflow run.\nDaemon-owned registration and topology digests are resolved at admission.",properties:{commit:{$ref:"#/$defs/CommitId"},effect_state:{$ref:"#/$defs/WorkEffectStateV1"},execution_snapshot:{$ref:"#/$defs/WorkExecutionSnapshot"},failure_policy:{$ref:"#/$defs/WorkflowFailurePolicy"},fence:{$ref:"#/$defs/WorkflowExecutionFence"},inputs:{items:{$ref:"#/$defs/WorkflowFanOutInput"},type:"array"},max_parallel:{format:"uint32",minimum:1,type:"integer"},reference:{anyOf:[{$ref:"#/$defs/RefId"},{type:"null"}]}},required:["fence","max_parallel","failure_policy","execution_snapshot","commit","effect_state","inputs"],type:"object"},WorkflowProviderRegistration:{additionalProperties:!1,properties:{backend:{$ref:"#/$defs/WorkProviderBackendV1"},model:{type:"string"},priority:{format:"uint32",minimum:0,type:"integer"},route:{$ref:"#/$defs/WorkProviderRouteV1"}},required:["route","backend","model","priority"],type:"object"},WorktreeCleanlinessRequirementV1:SG,WorktreePlacementModeV1:SZ,WorktreeRetentionPolicyV1:SQ,WorktreeRootPolicyV1:SX},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Starts (admits) a journaled workflow run from an active definition.\n\nThe daemon derives every admission digest itself: the definition's own\npinned policy/configuration/catalog digests are checked against the live\nenvironment, the topology digest comes from the evaluated topology policy,\nand the provider registry digest is computed from this registration. The\ncaller never supplies a digest the runtime must trust.",properties:{command_id:{$ref:"#/$defs/WorkCommandId"},definition_id:{$ref:"#/$defs/WorkflowDefinitionId"},definition_version:{format:"uint64",minimum:1,type:"integer"},fan_out:{anyOf:[{$ref:"#/$defs/WorkflowFanOutStartV1"},{type:"null"}]},provider:{$ref:"#/$defs/WorkflowProviderRegistration"},run_id:{$ref:"#/$defs/RunId"}},required:["run_id","definition_id","definition_version","provider","command_id"],title:"WorkflowRunStartRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,description:"Wire request for [`WorkflowDefinitionService::validate`].",properties:{definition:{$ref:"#/$defs/WorkflowDefinition"}},required:["definition"],title:"WorkflowDefinitionValidateRequest",type:"object"},{$defs:{ManifestDigest:_l,ProjectId:_4,WorkflowDefinition:SW,WorkflowDefinitionId:SM,WorkflowFanOut:SN,WorkflowOperationRef:Sz,WorkflowOutputName:SD,WorkflowOutputReference:SF,WorkflowStep:SL,WorkflowStepId:SU},$schema:"https://json-schema.org/draft/2020-12/schema",additionalProperties:!1,properties:{definition:{$ref:"#/$defs/WorkflowDefinition"}},required:["definition"],title:"WorkflowDefinitionValidation",type:"object"}].map(e=>t=>(!function e(t,r,i,o,n){var a;if("boolean"==typeof r){if(!r)throw TypeError(`${o} is rejected by the canonical schema`);return}let s=ft(r,o);if("string"==typeof s.$ref){if(n.has(s.$ref))throw TypeError(`cyclic canonical schema reference: ${s.$ref}`);n.add(s.$ref),e(t,function(e,t){if(!t.startsWith("#/"))throw TypeError(`unsupported canonical schema reference: ${t}`);let r=e;for(let e of t.slice(2).split("/")){let i=e.replaceAll("~1","/").replaceAll("~0","~");r=ft(r,t)[i]}return ft(r,t)}(i,s.$ref),i,o,n),n.delete(s.$ref);return}if("const"in s&&(a=s.const,fe(t)!==fe(a)))throw TypeError(`${o} does not match the canonical constant`);if(Array.isArray(s.enum)&&!s.enum.some(e=>fe(t)===fe(e)))throw TypeError(`${o} is not a canonical enum value`);if(Array.isArray(s.allOf))for(let r of s.allOf)e(t,r,i,o,new Set(n));if(Array.isArray(s.anyOf)&&!s.anyOf.some(r=>{try{return e(t,r,i,o,new Set(n)),!0}catch{return!1}}))throw TypeError(`${o} does not match any canonical variant`);if(Array.isArray(s.oneOf)&&1!==s.oneOf.filter(r=>{try{return e(t,r,i,o,new Set(n)),!0}catch{return!1}}).length)throw TypeError(`${o} must match exactly one canonical variant`);let d=s.type;if("string"==typeof d&&!fr(t,d))throw TypeError(`${o} must be ${d}`);if(Array.isArray(d)&&!d.some(e=>"string"==typeof e&&fr(t,e)))throw TypeError(`${o} has no canonical type`);if("string"==typeof t){if("number"==typeof s.minLength&&t.length<s.minLength)throw TypeError(`${o} is shorter than minLength`);if("number"==typeof s.maxLength&&t.length>s.maxLength)throw TypeError(`${o} exceeds maxLength`);if("string"==typeof s.pattern&&!RegExp(s.pattern,"u").test(t))throw TypeError(`${o} does not match the canonical pattern`)}if("number"==typeof t){if("integer"===s.type){if("uint32"===s.format&&(t<0||t>0xffffffff))throw TypeError(`${o} is outside uint32`);if("uint64"===s.format&&(t<0||t>Number.MAX_SAFE_INTEGER))throw TypeError(`${o} is outside safely representable uint64`);if("int64"===s.format&&(t<Number.MIN_SAFE_INTEGER||t>Number.MAX_SAFE_INTEGER))throw TypeError(`${o} is outside safely representable int64`)}if("number"==typeof s.minimum&&t<s.minimum)throw TypeError(`${o} is below minimum`);if("number"==typeof s.maximum&&t>s.maximum)throw TypeError(`${o} exceeds maximum`)}if(Array.isArray(t)){if("number"==typeof s.minItems&&t.length<s.minItems)throw TypeError(`${o} has too few items`);if("number"==typeof s.maxItems&&t.length>s.maxItems)throw TypeError(`${o} has too many items`);if(!0===s.uniqueItems){let e=new Set;for(let r of t){let t=fe(r);if(e.has(t))throw TypeError(`${o} contains duplicate items`);e.add(t)}}Array.isArray(s.prefixItems)&&s.prefixItems.forEach((r,n)=>{n<t.length&&e(t[n],r,i,`${o}[${n}]`,new Set)}),void 0===s.items||Array.isArray(s.prefixItems)||t.forEach((t,r)=>e(t,s.items,i,`${o}[${r}]`,new Set))}if("object"==typeof t&&null!==t&&!Array.isArray(t)){let r=void 0===s.properties?{}:ft(s.properties,`${o}.properties`);if(Array.isArray(s.required)){for(let e of s.required)if("string"==typeof e&&!(e in t))throw TypeError(`${o}.${e} is required`)}for(let[n,a]of Object.entries(t))if(n in r)e(a,r[n],i,`${o}.${n}`,new Set);else if(!1===s.additionalProperties)throw TypeError(`${o}.${n} is not allowed`);else"object"==typeof s.additionalProperties&&e(a,s.additionalProperties,i,`${o}.${n}`,new Set)}}(t,e,e,"value",new Set),t));function S1(e){let t=SY[e];if(void 0===t)throw TypeError(`generated canonical schema ${e} is missing`);return t}let S0=[{operation:"active_project",operationId:"operation.application.active_project",transport:{kind:"mcp_tool",toolName:"tracedecay_active_project"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.active_project.v1",requestSchema:{schemaId:"schema.application.primitive.active-project.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.active-project.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(0),decodeResult:S1(1)},{operation:"admin_cli",operationId:"operation.application.admin_cli",transport:{kind:"mcp_tool",toolName:"tracedecay_admin_cli"},effect:"maintains_profile_state",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.admin_cli.v1",requestSchema:{schemaId:"schema.application.primitive.admin-cli.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.admin-cli.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","effect_in_flight"]},deadline:{behavior:"return_operation_receipt",maximum_millis:6e5},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(2),decodeResult:S1(3)},{operation:"admin_project",operationId:"operation.application.admin_project",transport:{kind:"mcp_tool",toolName:"tracedecay_admin_project"},effect:"maintains_owner_state",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.admin_project.v1",requestSchema:{schemaId:"schema.application.primitive.admin-project.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.admin-project.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:6e5},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","unavailable","partial"],decodeRequest:S1(4),decodeResult:S1(5)},{operation:"admin_sync",operationId:"operation.application.admin_sync",transport:{kind:"mcp_tool",toolName:"tracedecay_admin_sync"},effect:"schedules_work",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.admin_sync.v1",requestSchema:{schemaId:"schema.application.primitive.admin-sync.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.admin-sync.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:6e5},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","unavailable","partial"],decodeRequest:S1(6),decodeResult:S1(7)},{operation:"affected",operationId:"operation.application.affected",transport:{kind:"mcp_tool",toolName:"tracedecay_affected"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.affected.v1",requestSchema:{schemaId:"schema.application.primitive.affected.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.affected.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(8),decodeResult:S1(9)},{operation:"application_affected_tests",operationId:"operation.application.affected_tests",transport:{kind:"http",route:"/application/tests/affected",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.affected_tests.v1",requestSchema:{schemaId:"schema.application.feedback.affected-tests.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.affected-tests.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(11),decodeSuccess:e=>fp(e,"binding.http.affected_tests.v1","schema.application.feedback.affected-tests.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(11))},{operation:"analytics",operationId:"operation.application.analytics",transport:{kind:"mcp_tool",toolName:"tracedecay_analytics"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.analytics.v1",requestSchema:{schemaId:"schema.application.primitive.analytics.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.analytics.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(12),decodeResult:S1(13)},{operation:"apply_native_integration",operationId:"operation.application.apply_native_integration",transport:{kind:"mcp_tool",toolName:"tracedecay_apply_native_integration"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.apply_native_integration.v1",requestSchema:{schemaId:"schema.application.native-integration.apply.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.apply.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(14),decodeResult:S1(15)},{operation:"approve_native_integration",operationId:"operation.application.approve_native_integration",transport:{kind:"mcp_tool",toolName:"tracedecay_approve_native_integration"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.approve_native_integration.v1",requestSchema:{schemaId:"schema.application.native-integration.approve.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.approve.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(16),decodeResult:S1(15)},{operation:"ast_grep_rewrite",operationId:"operation.application.ast_grep_rewrite",transport:{kind:"mcp_tool",toolName:"tracedecay_ast_grep_rewrite"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.ast_grep_rewrite.v1",requestSchema:{schemaId:"schema.application.source-edit.ast-grep-rewrite.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.ast-grep-rewrite.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(17),decodeResult:S1(18)},{operation:"ast_grep_search",operationId:"operation.application.ast_grep_search",transport:{kind:"mcp_tool",toolName:"tracedecay_ast_grep_search"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.ast_grep_search.v1",requestSchema:{schemaId:"schema.application.primitive.ast-grep-search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.ast-grep-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(19),decodeResult:S1(20)},{operation:"automation_run_artifact_view",operationId:"operation.application.automation_run_artifact_view",transport:{kind:"mcp_tool",toolName:"tracedecay_automation_run_artifact_view"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.automation_run_artifact_view.v1",requestSchema:{schemaId:"schema.application.primitive.automation-run-artifact-view.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.automation-run-artifact-view.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(21),decodeResult:S1(22)},{operation:"automation_run_list",operationId:"operation.application.automation_run_list",transport:{kind:"mcp_tool",toolName:"tracedecay_automation_run_list"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.automation_run_list.v1",requestSchema:{schemaId:"schema.application.primitive.automation-run-list.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.automation-run-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(23),decodeResult:S1(24)},{operation:"automation_run_view",operationId:"operation.application.automation_run_view",transport:{kind:"mcp_tool",toolName:"tracedecay_automation_run_view"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.automation_run_view.v1",requestSchema:{schemaId:"schema.application.primitive.automation-run-view.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.automation-run-view.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(25),decodeResult:S1(26)},{operation:"branch_diff",operationId:"operation.application.branch_diff",transport:{kind:"mcp_tool",toolName:"tracedecay_branch_diff"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.branch_diff.v1",requestSchema:{schemaId:"schema.application.primitive.branch-diff.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.branch-diff.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(27),decodeResult:S1(28)},{operation:"branch_list",operationId:"operation.application.branch_list",transport:{kind:"mcp_tool",toolName:"tracedecay_branch_list"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.branch_list.v1",requestSchema:{schemaId:"schema.application.primitive.branch-list.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.branch-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(29),decodeResult:S1(30)},{operation:"branch_search",operationId:"operation.application.branch_search",transport:{kind:"mcp_tool",toolName:"tracedecay_branch_search"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.branch_search.v1",requestSchema:{schemaId:"schema.application.primitive.branch-search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.branch-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(31),decodeResult:S1(32)},{operation:"by_qualified_name",operationId:"operation.application.by_qualified_name",transport:{kind:"mcp_tool",toolName:"tracedecay_by_qualified_name"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.by_qualified_name.v1",requestSchema:{schemaId:"schema.application.primitive.by-qualified-name.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.by-qualified-name.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(33),decodeResult:S1(34)},{operation:"application_call_chain",operationId:"operation.application.call_chain",transport:{kind:"http",route:"/application/primitives/call_chain",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.call_chain.v1",requestSchema:{schemaId:"schema.application.primitive.call-chain.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.call-chain.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(35),decodeResult:S1(36),decodeSuccess:e=>fp(e,"binding.http.call_chain.v1","schema.application.primitive.call-chain.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(36))},{operation:"cancel_native_integration",operationId:"operation.application.cancel_native_integration",transport:{kind:"mcp_tool",toolName:"tracedecay_cancel_native_integration"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.cancel_native_integration.v1",requestSchema:{schemaId:"schema.application.native-integration.cancel.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.cancel.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(37),decodeResult:S1(15)},{operation:"changelog",operationId:"operation.application.changelog",transport:{kind:"mcp_tool",toolName:"tracedecay_changelog"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.changelog.v1",requestSchema:{schemaId:"schema.application.primitive.changelog.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.changelog.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(38),decodeResult:S1(39)},{operation:"circular",operationId:"operation.application.circular",transport:{kind:"mcp_tool",toolName:"tracedecay_circular"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.circular.v1",requestSchema:{schemaId:"schema.application.primitive.circular.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.circular.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(40),decodeResult:S1(41)},{operation:"code_callees",operationId:"operation.application.code_callees",transport:{kind:"http",route:"/application/code/code_callees",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_callees.v1",requestSchema:{schemaId:"schema.application.code-query.callees.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.callees.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(42),decodeResult:S1(43),decodeSuccess:e=>fp(e,"binding.http.code_callees.v1","schema.application.code-query.callees.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(43))},{operation:"code_callers",operationId:"operation.application.code_callers",transport:{kind:"http",route:"/application/code/code_callers",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_callers.v1",requestSchema:{schemaId:"schema.application.primitive.code-callers.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.code-callers.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(44),decodeResult:S1(45),decodeSuccess:e=>fp(e,"binding.http.code_callers.v1","schema.application.primitive.code-callers.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(45))},{operation:"code_declaration",operationId:"operation.application.code_declaration",transport:{kind:"http",route:"/application/code/code_declaration",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_declaration.v1",requestSchema:{schemaId:"schema.application.code-query.declaration.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.declaration.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(46),decodeResult:S1(47),decodeSuccess:e=>fp(e,"binding.http.code_declaration.v1","schema.application.code-query.declaration.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(47))},{operation:"code_exact_occurrence",operationId:"operation.application.code_exact_occurrence",transport:{kind:"http",route:"/application/code/code_exact_occurrence",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_exact_occurrence.v1",requestSchema:{schemaId:"schema.application.code-query.exact-occurrence.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.exact-occurrence.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(48),decodeResult:S1(49),decodeSuccess:e=>fp(e,"binding.http.code_exact_occurrence.v1","schema.application.code-query.exact-occurrence.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(49))},{operation:"code_facets",operationId:"operation.application.code_facets",transport:{kind:"http",route:"/application/code/code_facets",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_facets.v1",requestSchema:{schemaId:"schema.application.code-query.facets.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.facets.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(50),decodeResult:S1(51),decodeSuccess:e=>fp(e,"binding.http.code_facets.v1","schema.application.code-query.facets.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(51))},{operation:"code_implementations",operationId:"operation.application.code_implementations",transport:{kind:"http",route:"/application/code/code_implementations",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_implementations.v1",requestSchema:{schemaId:"schema.application.primitive.code-implementations.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.code-implementations.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(52),decodeResult:S1(53),decodeSuccess:e=>fp(e,"binding.http.code_implementations.v1","schema.application.primitive.code-implementations.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(53))},{operation:"code_phrase_search",operationId:"operation.application.code_phrase_search",transport:{kind:"http",route:"/application/code/code_phrase_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_phrase_search.v1",requestSchema:{schemaId:"schema.application.code-query.phrase-search.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.phrase-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(54),decodeResult:S1(55),decodeSuccess:e=>fp(e,"binding.http.code_phrase_search.v1","schema.application.code-query.phrase-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(55))},{operation:"code_references",operationId:"operation.application.code_references",transport:{kind:"http",route:"/application/code/code_references",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_references.v1",requestSchema:{schemaId:"schema.application.code-query.references.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.references.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(46),decodeResult:S1(43),decodeSuccess:e=>fp(e,"binding.http.code_references.v1","schema.application.code-query.references.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(43))},{operation:"code_signature_search",operationId:"operation.application.code_signature_search",transport:{kind:"http",route:"/application/code/code_signature_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_signature_search.v1",requestSchema:{schemaId:"schema.application.primitive.code-signature-search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.code-signature-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(56),decodeResult:S1(57),decodeSuccess:e=>fp(e,"binding.http.code_signature_search.v1","schema.application.primitive.code-signature-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(57))},{operation:"code_symbol_search",operationId:"operation.application.code_symbol_search",transport:{kind:"http",route:"/application/code/code_symbol_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_symbol_search.v1",requestSchema:{schemaId:"schema.application.symbol-search.request",revision:1},resultSchema:{schemaId:"schema.application.symbol-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(58),decodeResult:S1(57),decodeSuccess:e=>fp(e,"binding.http.code_symbol_search.v1","schema.application.symbol-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(57))},{operation:"code_timeline",operationId:"operation.application.code_timeline",transport:{kind:"http",route:"/application/code/code_timeline",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_timeline.v1",requestSchema:{schemaId:"schema.application.code-query.timeline.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.timeline.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(59),decodeResult:S1(60),decodeSuccess:e=>fp(e,"binding.http.code_timeline.v1","schema.application.code-query.timeline.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(60))},{operation:"code_type_definition",operationId:"operation.application.code_type_definition",transport:{kind:"http",route:"/application/code/code_type_definition",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_type_definition.v1",requestSchema:{schemaId:"schema.application.code-query.type-definition.request",revision:1},resultSchema:{schemaId:"schema.application.code-query.type-definition.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(46),decodeResult:S1(47),decodeSuccess:e=>fp(e,"binding.http.code_type_definition.v1","schema.application.code-query.type-definition.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(47))},{operation:"code_type_hierarchy",operationId:"operation.application.code_type_hierarchy",transport:{kind:"http",route:"/application/code/code_type_hierarchy",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.code_type_hierarchy.v1",requestSchema:{schemaId:"schema.application.primitive.code-type-hierarchy.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.code-type-hierarchy.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(61),decodeResult:S1(62),decodeSuccess:e=>fp(e,"binding.http.code_type_hierarchy.v1","schema.application.primitive.code-type-hierarchy.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(62))},{operation:"commit_context",operationId:"operation.application.commit_context",transport:{kind:"mcp_tool",toolName:"tracedecay_commit_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.commit_context.v1",requestSchema:{schemaId:"schema.application.primitive.commit-context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.commit-context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(63),decodeResult:S1(64)},{operation:"complexity",operationId:"operation.application.complexity",transport:{kind:"mcp_tool",toolName:"tracedecay_complexity"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.complexity.v1",requestSchema:{schemaId:"schema.application.primitive.complexity.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.complexity.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(65),decodeResult:S1(66)},{operation:"config",operationId:"operation.application.config",transport:{kind:"mcp_tool",toolName:"tracedecay_config"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.config.v1",requestSchema:{schemaId:"schema.application.primitive.config.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.config.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(67),decodeResult:S1(68)},{operation:"application_configuration_audit",operationId:"operation.application.configuration_audit",transport:{kind:"http",route:"/application/configuration/configuration_audit",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_audit.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_audit.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_audit.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(69),decodeResult:S1(70),decodeSuccess:e=>fp(e,"binding.http.configuration_audit.v1","schema.application.configuration.configuration_audit.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(70))},{operation:"application_configuration_batch",operationId:"operation.application.configuration_batch",transport:{kind:"http",route:"/application/configuration/configuration_batch",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_batch.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_batch.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_batch.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(71),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_batch.v1","schema.application.configuration.configuration_batch.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_configuration_get",operationId:"operation.application.configuration_get",transport:{kind:"http",route:"/application/configuration/configuration_get",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_get.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_get.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_get.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(73),decodeResult:S1(74),decodeSuccess:e=>fp(e,"binding.http.configuration_get.v1","schema.application.configuration.configuration_get.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(74))},{operation:"application_configuration_list",operationId:"operation.application.configuration_list",transport:{kind:"http",route:"/application/configuration/configuration_list",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_list.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_list.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(75),decodeResult:S1(76),decodeSuccess:e=>fp(e,"binding.http.configuration_list.v1","schema.application.configuration.configuration_list.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(76))},{operation:"application_configuration_observed_state",operationId:"operation.application.configuration_observed_state",transport:{kind:"http",route:"/application/configuration/configuration_observed_state",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_observed_state.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_observed_state.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_observed_state.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(77),decodeResult:S1(78),decodeSuccess:e=>fp(e,"binding.http.configuration_observed_state.v1","schema.application.configuration.configuration_observed_state.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(78))},{operation:"application_configuration_protected_apply",operationId:"operation.application.configuration_protected_apply",transport:{kind:"http",route:"/application/configuration/configuration_protected_apply",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_protected_apply.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_protected_apply.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_protected_apply.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(79),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_protected_apply.v1","schema.application.configuration.configuration_protected_apply.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_configuration_protected_preview",operationId:"operation.application.configuration_protected_preview",transport:{kind:"http",route:"/application/configuration/configuration_protected_preview",method:"POST"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_protected_preview.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_protected_preview.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_protected_preview.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(80),decodeResult:S1(81),decodeSuccess:e=>fp(e,"binding.http.configuration_protected_preview.v1","schema.application.configuration.configuration_protected_preview.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(81))},{operation:"application_configuration_rollback_apply",operationId:"operation.application.configuration_rollback_apply",transport:{kind:"http",route:"/application/configuration/configuration_rollback_apply",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_rollback_apply.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_rollback_apply.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_rollback_apply.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(79),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_rollback_apply.v1","schema.application.configuration.configuration_rollback_apply.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_configuration_rollback_preview",operationId:"operation.application.configuration_rollback_preview",transport:{kind:"http",route:"/application/configuration/configuration_rollback_preview",method:"POST"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_rollback_preview.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_rollback_preview.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_rollback_preview.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(82),decodeResult:S1(81),decodeSuccess:e=>fp(e,"binding.http.configuration_rollback_preview.v1","schema.application.configuration.configuration_rollback_preview.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(81))},{operation:"application_configuration_set",operationId:"operation.application.configuration_set",transport:{kind:"http",route:"/application/configuration/configuration_set",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_set.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_set.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_set.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(83),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_set.v1","schema.application.configuration.configuration_set.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_configuration_unset",operationId:"operation.application.configuration_unset",transport:{kind:"http",route:"/application/configuration/configuration_unset",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.configuration_unset.v1",requestSchema:{schemaId:"schema.application.configuration.configuration_unset.request",revision:1},resultSchema:{schemaId:"schema.application.configuration.configuration_unset.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(84),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.configuration_unset.v1","schema.application.configuration.configuration_unset.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"constructors",operationId:"operation.application.constructors",transport:{kind:"mcp_tool",toolName:"tracedecay_constructors"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.constructors.v1",requestSchema:{schemaId:"schema.application.primitive.constructors.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.constructors.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(85),decodeResult:S1(86)},{operation:"context",operationId:"operation.application.context",transport:{kind:"mcp_tool",toolName:"tracedecay_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.context.v1",requestSchema:{schemaId:"schema.application.primitive.context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(87),decodeResult:S1(88)},{operation:"application_context_scout_budget",operationId:"operation.application.context_scout_budget",transport:{kind:"http",route:"/application/context-scout/context_scout_budget",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_budget.v1",requestSchema:{schemaId:"schema.application.context-scout-budget.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-budget.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(89),decodeResult:S1(90),decodeSuccess:e=>fp(e,"binding.http.context_scout_budget.v1","schema.application.context-scout-budget.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(90))},{operation:"application_context_scout_cancel",operationId:"operation.application.context_scout_cancel",transport:{kind:"http",route:"/application/context-scout/context_scout_cancel",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_cancel.v1",requestSchema:{schemaId:"schema.application.context-scout-cancel.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-cancel.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(91),decodeResult:S1(92),decodeSuccess:e=>fp(e,"binding.http.context_scout_cancel.v1","schema.application.context-scout-cancel.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(92))},{operation:"application_context_scout_capability",operationId:"operation.application.context_scout_capability",transport:{kind:"http",route:"/application/context-scout/context_scout_capability",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_capability.v1",requestSchema:{schemaId:"schema.application.context-scout-capability.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-capability.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(89),decodeResult:S1(93),decodeSuccess:e=>fp(e,"binding.http.context_scout_capability.v1","schema.application.context-scout-capability.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(93))},{operation:"application_context_scout_claim",operationId:"operation.application.context_scout_claim",transport:{kind:"http",route:"/application/context-scout/context_scout_claim",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_claim.v1",requestSchema:{schemaId:"schema.application.context-scout-claim.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-claim.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(94),decodeResult:S1(95),decodeSuccess:e=>fp(e,"binding.http.context_scout_claim.v1","schema.application.context-scout-claim.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(95))},{operation:"application_context_scout_delivery",operationId:"operation.application.context_scout_delivery",transport:{kind:"http",route:"/application/context-scout/context_scout_delivery",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_delivery.v1",requestSchema:{schemaId:"schema.application.context-scout-delivery.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-delivery.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(96),decodeResult:S1(97),decodeSuccess:e=>fp(e,"binding.http.context_scout_delivery.v1","schema.application.context-scout-delivery.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(97))},{operation:"application_context_scout_explain",operationId:"operation.application.context_scout_explain",transport:{kind:"http",route:"/application/context-scout/context_scout_explain",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_explain.v1",requestSchema:{schemaId:"schema.application.context-scout-explain.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-explain.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(98),decodeResult:S1(99),decodeSuccess:e=>fp(e,"binding.http.context_scout_explain.v1","schema.application.context-scout-explain.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(99))},{operation:"application_context_scout_feedback",operationId:"operation.application.context_scout_feedback",transport:{kind:"http",route:"/application/context-scout/context_scout_feedback",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_feedback.v1",requestSchema:{schemaId:"schema.application.context-scout-feedback.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-feedback.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(100),decodeResult:S1(92),decodeSuccess:e=>fp(e,"binding.http.context_scout_feedback.v1","schema.application.context-scout-feedback.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(92))},{operation:"application_context_scout_pause",operationId:"operation.application.context_scout_pause",transport:{kind:"http",route:"/application/context-scout/context_scout_pause",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_pause.v1",requestSchema:{schemaId:"schema.application.context-scout-pause.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-pause.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(101),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.context_scout_pause.v1","schema.application.context-scout-pause.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_context_scout_recent",operationId:"operation.application.context_scout_recent",transport:{kind:"http",route:"/application/context-scout/context_scout_recent",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_recent.v1",requestSchema:{schemaId:"schema.application.context-scout-recent.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-recent.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(98),decodeResult:S1(102),decodeSuccess:e=>fp(e,"binding.http.context_scout_recent.v1","schema.application.context-scout-recent.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(102))},{operation:"application_context_scout_resume",operationId:"operation.application.context_scout_resume",transport:{kind:"http",route:"/application/context-scout/context_scout_resume",method:"POST"},effect:"configuration_write",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_resume.v1",requestSchema:{schemaId:"schema.application.context-scout-resume.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-resume.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:15e3},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(101),decodeResult:S1(72),decodeSuccess:e=>fp(e,"binding.http.context_scout_resume.v1","schema.application.context-scout-resume.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(72))},{operation:"application_context_scout_status",operationId:"operation.application.context_scout_status",transport:{kind:"http",route:"/application/context-scout/context_scout_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.context_scout_status.v1",requestSchema:{schemaId:"schema.application.context-scout-status.request",revision:1},resultSchema:{schemaId:"schema.application.context-scout-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(89),decodeResult:S1(103),decodeSuccess:e=>fp(e,"binding.http.context_scout_status.v1","schema.application.context-scout-status.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(103))},{operation:"coupling",operationId:"operation.application.coupling",transport:{kind:"mcp_tool",toolName:"tracedecay_coupling"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.coupling.v1",requestSchema:{schemaId:"schema.application.primitive.coupling.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.coupling.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(104),decodeResult:S1(105)},{operation:"dashboard",operationId:"operation.application.dashboard",transport:{kind:"mcp_tool",toolName:"tracedecay_dashboard"},effect:"binds_server",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.dashboard.v1",requestSchema:{schemaId:"schema.application.primitive.dashboard.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.dashboard.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","unavailable","partial"],decodeRequest:S1(106),decodeResult:S1(107)},{operation:"dead_code",operationId:"operation.application.dead_code",transport:{kind:"mcp_tool",toolName:"tracedecay_dead_code"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.dead_code.v1",requestSchema:{schemaId:"schema.application.primitive.dead-code.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.dead-code.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(108),decodeResult:S1(109)},{operation:"dependency_depth",operationId:"operation.application.dependency_depth",transport:{kind:"mcp_tool",toolName:"tracedecay_dependency_depth"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.dependency_depth.v1",requestSchema:{schemaId:"schema.application.primitive.dependency-depth.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.dependency-depth.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(110),decodeResult:S1(111)},{operation:"derives",operationId:"operation.application.derives",transport:{kind:"mcp_tool",toolName:"tracedecay_derives"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.derives.v1",requestSchema:{schemaId:"schema.application.primitive.derives.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.derives.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(112),decodeResult:S1(113)},{operation:"diagnose",operationId:"operation.application.diagnose",transport:{kind:"mcp_tool",toolName:"tracedecay_diagnose"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.diagnose.v1",requestSchema:{schemaId:"schema.application.primitive.diagnose.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.diagnose.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(114),decodeResult:S1(115)},{operation:"application_diagnostics_read",operationId:"operation.application.diagnostics_read",transport:{kind:"http",route:"/application/primitives/diagnostics_read",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.diagnostics_read.v1",requestSchema:{schemaId:"schema.application.primitive.diagnostics-read.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.diagnostics-read.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(116),decodeResult:S1(117),decodeSuccess:e=>fp(e,"binding.http.diagnostics_read.v1","schema.application.primitive.diagnostics-read.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(117))},{operation:"diff_context",operationId:"operation.application.diff_context",transport:{kind:"mcp_tool",toolName:"tracedecay_diff_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.diff_context.v1",requestSchema:{schemaId:"schema.application.primitive.diff-context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.diff-context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(118),decodeResult:S1(119)},{operation:"distribution",operationId:"operation.application.distribution",transport:{kind:"mcp_tool",toolName:"tracedecay_distribution"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.distribution.v1",requestSchema:{schemaId:"schema.application.primitive.distribution.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.distribution.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(120),decodeResult:S1(121)},{operation:"doc_coverage",operationId:"operation.application.doc_coverage",transport:{kind:"mcp_tool",toolName:"tracedecay_doc_coverage"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.doc_coverage.v1",requestSchema:{schemaId:"schema.application.primitive.doc-coverage.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.doc-coverage.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(122),decodeResult:S1(123)},{operation:"dsm",operationId:"operation.application.dsm",transport:{kind:"mcp_tool",toolName:"tracedecay_dsm"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.dsm.v1",requestSchema:{schemaId:"schema.application.primitive.dsm.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.dsm.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(124),decodeResult:S1(125)},{operation:"application_fact_feedback",operationId:"operation.application.fact_feedback",transport:{kind:"http",route:"/application/retained/fact_feedback",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_feedback.v1",requestSchema:{schemaId:"schema.application.retained.fact-feedback.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-feedback.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(126),decodeResult:S1(127),decodeSuccess:e=>fp(e,"binding.http.fact_feedback.v1","schema.application.retained.fact-feedback.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(127))},{operation:"application_fact_store_add",operationId:"operation.application.fact_store_add",transport:{kind:"http",route:"/application/retained/fact_store_add",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_add.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-add.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-add.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(128),decodeResult:S1(129),decodeSuccess:e=>fp(e,"binding.http.fact_store_add.v1","schema.application.retained.fact-store-add.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(129))},{operation:"application_fact_store_contradict",operationId:"operation.application.fact_store_contradict",transport:{kind:"http",route:"/application/retained/fact_store_contradict",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_contradict.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-contradict.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-contradict.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(130),decodeResult:S1(131),decodeSuccess:e=>fp(e,"binding.http.fact_store_contradict.v1","schema.application.retained.fact-store-contradict.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(131))},{operation:"application_fact_store_curate",operationId:"operation.application.fact_store_curate",transport:{kind:"http",route:"/application/retained/fact_store_curate",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"required",resultSemantics:"fact_store_curate_receipt",bindingId:"binding.http.fact_store_curate.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-curate.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-curate.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:9e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(132),decodeResult:S1(133),decodeSuccess:e=>fp(e,"binding.http.fact_store_curate.v1","schema.application.retained.fact-store-curate.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(133))},{operation:"application_fact_store_get",operationId:"operation.application.fact_store_get",transport:{kind:"http",route:"/application/retained/fact_store_get",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_get.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-get.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-get.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(134),decodeResult:S1(135),decodeSuccess:e=>fp(e,"binding.http.fact_store_get.v1","schema.application.retained.fact-store-get.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(135))},{operation:"application_fact_store_list",operationId:"operation.application.fact_store_list",transport:{kind:"http",route:"/application/retained/fact_store_list",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_list.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-list.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(136),decodeResult:S1(137),decodeSuccess:e=>fp(e,"binding.http.fact_store_list.v1","schema.application.retained.fact-store-list.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(137))},{operation:"application_fact_store_probe",operationId:"operation.application.fact_store_probe",transport:{kind:"http",route:"/application/retained/fact_store_probe",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_probe.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-probe.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-probe.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(138),decodeResult:S1(139),decodeSuccess:e=>fp(e,"binding.http.fact_store_probe.v1","schema.application.retained.fact-store-probe.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(139))},{operation:"application_fact_store_reason",operationId:"operation.application.fact_store_reason",transport:{kind:"http",route:"/application/retained/fact_store_reason",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_reason.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-reason.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-reason.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(140),decodeResult:S1(141),decodeSuccess:e=>fp(e,"binding.http.fact_store_reason.v1","schema.application.retained.fact-store-reason.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(141))},{operation:"application_fact_store_related",operationId:"operation.application.fact_store_related",transport:{kind:"http",route:"/application/retained/fact_store_related",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_related.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-related.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-related.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(142),decodeResult:S1(143),decodeSuccess:e=>fp(e,"binding.http.fact_store_related.v1","schema.application.retained.fact-store-related.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(143))},{operation:"application_fact_store_remove",operationId:"operation.application.fact_store_remove",transport:{kind:"http",route:"/application/retained/fact_store_remove",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_remove.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-remove.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-remove.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(144),decodeResult:S1(145),decodeSuccess:e=>fp(e,"binding.http.fact_store_remove.v1","schema.application.retained.fact-store-remove.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(145))},{operation:"application_fact_store_search",operationId:"operation.application.fact_store_search",transport:{kind:"http",route:"/application/retained/fact_store_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_search.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-search.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(146),decodeResult:S1(147),decodeSuccess:e=>fp(e,"binding.http.fact_store_search.v1","schema.application.retained.fact-store-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(147))},{operation:"application_fact_store_supersede",operationId:"operation.application.fact_store_supersede",transport:{kind:"http",route:"/application/retained/fact_store_supersede",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_supersede.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-supersede.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-supersede.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(148),decodeResult:S1(149),decodeSuccess:e=>fp(e,"binding.http.fact_store_supersede.v1","schema.application.retained.fact-store-supersede.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(149))},{operation:"application_fact_store_update",operationId:"operation.application.fact_store_update",transport:{kind:"http",route:"/application/retained/fact_store_update",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.fact_store_update.v1",requestSchema:{schemaId:"schema.application.retained.fact-store-update.request",revision:1},resultSchema:{schemaId:"schema.application.retained.fact-store-update.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(150),decodeResult:S1(151),decodeSuccess:e=>fp(e,"binding.http.fact_store_update.v1","schema.application.retained.fact-store-update.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(151))},{operation:"application_feedback_advisory_cycle",operationId:"operation.application.feedback_advisory_cycle",transport:{kind:"http",route:"/application/feedback/advisory_cycle",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_advisory_cycle.v1",requestSchema:{schemaId:"schema.application.feedback.advisory-cycle.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.advisory-cycle.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(152),decodeResult:S1(153),decodeSuccess:e=>fp(e,"binding.http.feedback_advisory_cycle.v1","schema.application.feedback.advisory-cycle.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(153))},{operation:"application_feedback_diagnostics",operationId:"operation.application.feedback_diagnostics",transport:{kind:"http",route:"/application/feedback/diagnostics",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_diagnostics.v1",requestSchema:{schemaId:"schema.application.feedback.diagnostics.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.diagnostics.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(154),decodeSuccess:e=>fp(e,"binding.http.feedback_diagnostics.v1","schema.application.feedback.diagnostics.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(154))},{operation:"application_feedback_expand",operationId:"operation.application.feedback_expand",transport:{kind:"http",route:"/application/feedback/expand",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_expand.v1",requestSchema:{schemaId:"schema.application.feedback.expand.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.expand.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(155),decodeSuccess:e=>fp(e,"binding.http.feedback_expand.v1","schema.application.feedback.expand.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(155))},{operation:"application_feedback_get",operationId:"operation.application.feedback_get",transport:{kind:"http",route:"/application/feedback/get",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_get.v1",requestSchema:{schemaId:"schema.application.feedback.get.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.get.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(156),decodeSuccess:e=>fp(e,"binding.http.feedback_get.v1","schema.application.feedback.get.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(156))},{operation:"application_feedback_impact",operationId:"operation.application.feedback_impact",transport:{kind:"http",route:"/application/feedback/impact",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_impact.v1",requestSchema:{schemaId:"schema.application.feedback.impact.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.impact.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(157),decodeSuccess:e=>fp(e,"binding.http.feedback_impact.v1","schema.application.feedback.impact.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(157))},{operation:"application_feedback_list",operationId:"operation.application.feedback_list",transport:{kind:"http",route:"/application/feedback/list",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_list.v1",requestSchema:{schemaId:"schema.application.feedback.list.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(10),decodeResult:S1(158),decodeSuccess:e=>fp(e,"binding.http.feedback_list.v1","schema.application.feedback.list.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(158))},{operation:"application_feedback_proximity",operationId:"operation.application.feedback_proximity",transport:{kind:"http",route:"/application/feedback/proximity",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.feedback_proximity.v1",requestSchema:{schemaId:"schema.application.feedback.proximity.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.proximity.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(159),decodeResult:S1(160),decodeSuccess:e=>fp(e,"binding.http.feedback_proximity.v1","schema.application.feedback.proximity.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(160))},{operation:"field_sites",operationId:"operation.application.field_sites",transport:{kind:"mcp_tool",toolName:"tracedecay_field_sites"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.field_sites.v1",requestSchema:{schemaId:"schema.application.primitive.field-sites.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.field-sites.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(161),decodeResult:S1(162)},{operation:"application_file_dependents",operationId:"operation.application.file_dependents",transport:{kind:"http",route:"/application/primitives/file_dependents",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.file_dependents.v1",requestSchema:{schemaId:"schema.application.primitive.file-dependents.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.file-dependents.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(163),decodeResult:S1(164),decodeSuccess:e=>fp(e,"binding.http.file_dependents.v1","schema.application.primitive.file-dependents.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(164))},{operation:"files",operationId:"operation.application.files",transport:{kind:"mcp_tool",toolName:"tracedecay_files"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.files.v1",requestSchema:{schemaId:"schema.application.primitive.files.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.files.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(165),decodeResult:S1(166)},{operation:"find_exact_symbol",operationId:"operation.application.find_exact_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_find_exact_symbol"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.find_exact_symbol.v1",requestSchema:{schemaId:"schema.application.primitive.find-exact-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.find-exact-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(167),decodeResult:S1(168)},{operation:"gini",operationId:"operation.application.gini",transport:{kind:"mcp_tool",toolName:"tracedecay_gini"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.gini.v1",requestSchema:{schemaId:"schema.application.primitive.gini.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.gini.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(169),decodeResult:S1(170)},{operation:"git_apply",operationId:"operation.application.git_apply",transport:{kind:"mcp_tool",toolName:"tracedecay_git_apply"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.git_apply.v1",requestSchema:{schemaId:"schema.application.git.apply.request",revision:1},resultSchema:{schemaId:"schema.application.git.apply.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(171),decodeResult:S1(172)},{operation:"application_git_blame",operationId:"operation.application.git_blame",transport:{kind:"http",route:"/application/git/blame",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_blame.v1",requestSchema:{schemaId:"schema.application.git.blame.request",revision:1},resultSchema:{schemaId:"schema.application.git.blame.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(173),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_blame.v1","schema.application.git.blame.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"application_git_diff",operationId:"operation.application.git_diff",transport:{kind:"http",route:"/application/git/diff",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_diff.v1",requestSchema:{schemaId:"schema.application.git.diff.request",revision:1},resultSchema:{schemaId:"schema.application.git.diff.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(175),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_diff.v1","schema.application.git.diff.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"application_git_history",operationId:"operation.application.git_history",transport:{kind:"http",route:"/application/git/history",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_history.v1",requestSchema:{schemaId:"schema.application.git.history.request",revision:1},resultSchema:{schemaId:"schema.application.git.history.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(176),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_history.v1","schema.application.git.history.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"application_git_hunks",operationId:"operation.application.git_hunks",transport:{kind:"http",route:"/application/git/hunks",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_hunks.v1",requestSchema:{schemaId:"schema.application.git.hunks.request",revision:1},resultSchema:{schemaId:"schema.application.git.hunks.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(177),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_hunks.v1","schema.application.git.hunks.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"git_preview",operationId:"operation.application.git_preview",transport:{kind:"mcp_tool",toolName:"tracedecay_git_preview"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.git_preview.v1",requestSchema:{schemaId:"schema.application.git.preview.request",revision:1},resultSchema:{schemaId:"schema.application.git.preview.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(178),decodeResult:S1(179)},{operation:"application_git_status",operationId:"operation.application.git_status",transport:{kind:"http",route:"/application/git/status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.git_status.v1",requestSchema:{schemaId:"schema.application.git.status.request",revision:1},resultSchema:{schemaId:"schema.application.git.status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(180),decodeResult:S1(174),decodeSuccess:e=>fp(e,"binding.http.git_status.v1","schema.application.git.status.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(174))},{operation:"application_github_stack_signal_expand",operationId:"operation.application.github_stack_signal_expand",transport:{kind:"http",route:"/application/github-stack/signal-expand",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.github_stack_signal_expand.v1",requestSchema:{schemaId:"schema.application.github-stack.signal-expand.request",revision:1},resultSchema:{schemaId:"schema.application.github-stack.signal-expand.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(181),decodeResult:S1(182),decodeSuccess:e=>fp(e,"binding.http.github_stack_signal_expand.v1","schema.application.github-stack.signal-expand.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(182))},{operation:"god_class",operationId:"operation.application.god_class",transport:{kind:"mcp_tool",toolName:"tracedecay_god_class"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.god_class.v1",requestSchema:{schemaId:"schema.application.primitive.god-class.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.god-class.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(183),decodeResult:S1(184)},{operation:"grep",operationId:"operation.application.grep",transport:{kind:"mcp_tool",toolName:"tracedecay_grep"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.grep.v1",requestSchema:{schemaId:"schema.application.primitive.grep.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.grep.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(185),decodeResult:S1(186)},{operation:"health",operationId:"operation.application.health",transport:{kind:"mcp_tool",toolName:"tracedecay_health"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.health.v1",requestSchema:{schemaId:"schema.application.primitive.health.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.health.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(187),decodeResult:S1(188)},{operation:"application_health_delta",operationId:"operation.application.health_delta",transport:{kind:"http",route:"/application/primitives/health_delta",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.health_delta.v1",requestSchema:{schemaId:"schema.application.primitive.health-delta.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.health-delta.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(189),decodeResult:S1(190),decodeSuccess:e=>fp(e,"binding.http.health_delta.v1","schema.application.primitive.health-delta.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(190))},{operation:"application_health_read",operationId:"operation.application.health_read",transport:{kind:"http",route:"/application/primitives/health_read",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.health_read.v1",requestSchema:{schemaId:"schema.application.primitive.health-read.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.health-read.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(191),decodeResult:S1(192),decodeSuccess:e=>fp(e,"binding.http.health_read.v1","schema.application.primitive.health-read.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(192))},{operation:"hermes_skill_bridge",operationId:"operation.application.hermes_skill_bridge",transport:{kind:"mcp_tool",toolName:"tracedecay_hermes_skill_bridge"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.hermes_skill_bridge.v1",requestSchema:{schemaId:"schema.application.primitive.hermes-skill-bridge.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.hermes-skill-bridge.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(193),decodeResult:S1(194)},{operation:"hook_runtime",operationId:"operation.application.hook_runtime",transport:{kind:"mcp_tool",toolName:"tracedecay_hook_runtime"},effect:"records_host_evidence",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.hook_runtime.v1",requestSchema:{schemaId:"schema.application.primitive.hook-runtime.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.hook-runtime.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","unavailable","partial"],decodeRequest:S1(195),decodeResult:S1(196)},{operation:"hotspots",operationId:"operation.application.hotspots",transport:{kind:"mcp_tool",toolName:"tracedecay_hotspots"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.hotspots.v1",requestSchema:{schemaId:"schema.application.primitive.hotspots.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.hotspots.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(197),decodeResult:S1(198)},{operation:"impact",operationId:"operation.application.impact",transport:{kind:"mcp_tool",toolName:"tracedecay_impact"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.impact.v1",requestSchema:{schemaId:"schema.application.primitive.impact.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.impact.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(199),decodeResult:S1(200)},{operation:"inheritance_depth",operationId:"operation.application.inheritance_depth",transport:{kind:"mcp_tool",toolName:"tracedecay_inheritance_depth"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.inheritance_depth.v1",requestSchema:{schemaId:"schema.application.primitive.inheritance-depth.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.inheritance-depth.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(201),decodeResult:S1(202)},{operation:"insert_at",operationId:"operation.application.insert_at",transport:{kind:"mcp_tool",toolName:"tracedecay_insert_at"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.insert_at.v1",requestSchema:{schemaId:"schema.application.source-edit.insert-at.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.insert-at.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(203),decodeResult:S1(18)},{operation:"insert_at_symbol",operationId:"operation.application.insert_at_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_insert_at_symbol"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.insert_at_symbol.v1",requestSchema:{schemaId:"schema.application.source-edit.insert-at-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.insert-at-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(204),decodeResult:S1(18)},{operation:"largest",operationId:"operation.application.largest",transport:{kind:"mcp_tool",toolName:"tracedecay_largest"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.largest.v1",requestSchema:{schemaId:"schema.application.primitive.largest.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.largest.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(205),decodeResult:S1(206)},{operation:"application_lcm_describe",operationId:"operation.application.lcm_describe",transport:{kind:"http",route:"/application/retained/lcm_describe",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_describe.v1",requestSchema:{schemaId:"schema.application.retained.lcm-describe.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-describe.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(207),decodeResult:S1(208),decodeSuccess:e=>fp(e,"binding.http.lcm_describe.v1","schema.application.retained.lcm-describe.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(208))},{operation:"application_lcm_doctor",operationId:"operation.application.lcm_doctor",transport:{kind:"http",route:"/application/retained/lcm_doctor",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_doctor.v1",requestSchema:{schemaId:"schema.application.retained.lcm-doctor.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-doctor.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(209),decodeResult:S1(210),decodeSuccess:e=>fp(e,"binding.http.lcm_doctor.v1","schema.application.retained.lcm-doctor.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(210))},{operation:"application_lcm_expand",operationId:"operation.application.lcm_expand",transport:{kind:"http",route:"/application/retained/lcm_expand",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_expand.v1",requestSchema:{schemaId:"schema.application.retained.lcm-expand.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-expand.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(211),decodeResult:S1(212),decodeSuccess:e=>fp(e,"binding.http.lcm_expand.v1","schema.application.retained.lcm-expand.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(212))},{operation:"application_lcm_expand_query",operationId:"operation.application.lcm_expand_query",transport:{kind:"http",route:"/application/retained/lcm_expand_query",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_expand_query.v1",requestSchema:{schemaId:"schema.application.retained.lcm-expand-query.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-expand-query.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(213),decodeResult:S1(214),decodeSuccess:e=>fp(e,"binding.http.lcm_expand_query.v1","schema.application.retained.lcm-expand-query.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(214))},{operation:"application_lcm_grep",operationId:"operation.application.lcm_grep",transport:{kind:"http",route:"/application/retained/lcm_grep",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_grep.v1",requestSchema:{schemaId:"schema.application.retained.lcm-grep.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-grep.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(215),decodeResult:S1(216),decodeSuccess:e=>fp(e,"binding.http.lcm_grep.v1","schema.application.retained.lcm-grep.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(216))},{operation:"application_lcm_load_session",operationId:"operation.application.lcm_load_session",transport:{kind:"http",route:"/application/retained/lcm_load_session",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_load_session.v1",requestSchema:{schemaId:"schema.application.retained.lcm-load-session.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-load-session.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(217),decodeResult:S1(218),decodeSuccess:e=>fp(e,"binding.http.lcm_load_session.v1","schema.application.retained.lcm-load-session.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(218))},{operation:"application_lcm_status",operationId:"operation.application.lcm_status",transport:{kind:"http",route:"/application/retained/lcm_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.lcm_status.v1",requestSchema:{schemaId:"schema.application.retained.lcm-status.request",revision:1},resultSchema:{schemaId:"schema.application.retained.lcm-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(219),decodeResult:S1(220),decodeSuccess:e=>fp(e,"binding.http.lcm_status.v1","schema.application.retained.lcm-status.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(220))},{operation:"application_memory_status",operationId:"operation.application.memory_status",transport:{kind:"http",route:"/application/retained/memory_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.memory_status.v1",requestSchema:{schemaId:"schema.application.retained.memory-status.request",revision:1},resultSchema:{schemaId:"schema.application.retained.memory-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(221),decodeResult:S1(222),decodeSuccess:e=>fp(e,"binding.http.memory_status.v1","schema.application.retained.memory-status.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(222))},{operation:"application_message_search",operationId:"operation.application.message_search",transport:{kind:"http",route:"/application/retained/message_search",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.message_search.v1",requestSchema:{schemaId:"schema.application.retained.message-search.request",revision:1},resultSchema:{schemaId:"schema.application.retained.message-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(223),decodeResult:S1(224),decodeSuccess:e=>fp(e,"binding.http.message_search.v1","schema.application.retained.message-search.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(224))},{operation:"application_module_api",operationId:"operation.application.module_api",transport:{kind:"http",route:"/application/primitives/module_api",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.module_api.v1",requestSchema:{schemaId:"schema.application.primitive.module-api.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.module-api.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(225),decodeResult:S1(226),decodeSuccess:e=>fp(e,"binding.http.module_api.v1","schema.application.primitive.module-api.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(226))},{operation:"move_symbol",operationId:"operation.application.move_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_move_symbol"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.move_symbol.v1",requestSchema:{schemaId:"schema.application.source-edit.move-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.move-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(227),decodeResult:S1(18)},{operation:"multi_str_replace",operationId:"operation.application.multi_str_replace",transport:{kind:"mcp_tool",toolName:"tracedecay_multi_str_replace"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.multi_str_replace.v1",requestSchema:{schemaId:"schema.application.source-edit.multi-str-replace.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.multi-str-replace.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(228),decodeResult:S1(18)},{operation:"native_integration_status",operationId:"operation.application.native_integration_status",transport:{kind:"mcp_tool",toolName:"tracedecay_native_integration_status"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.native_integration_status.v1",requestSchema:{schemaId:"schema.application.native-integration.status.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(229),decodeResult:S1(15)},{operation:"node",operationId:"operation.application.node",transport:{kind:"mcp_tool",toolName:"tracedecay_node"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.node.v1",requestSchema:{schemaId:"schema.application.primitive.node.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.node.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(230),decodeResult:S1(231)},{operation:"observatory_read",operationId:"operation.application.observatory_read",transport:{kind:"mcp_tool",toolName:"tracedecay_observatory_read"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.observatory_read.v1",requestSchema:{schemaId:"schema.application.observatory-read.request",revision:1},resultSchema:{schemaId:"schema.application.observatory-read.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(232),decodeResult:S1(233)},{operation:"port_order",operationId:"operation.application.port_order",transport:{kind:"mcp_tool",toolName:"tracedecay_port_order"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.port_order.v1",requestSchema:{schemaId:"schema.application.primitive.port-order.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.port-order.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(234),decodeResult:S1(235)},{operation:"port_status",operationId:"operation.application.port_status",transport:{kind:"mcp_tool",toolName:"tracedecay_port_status"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.port_status.v1",requestSchema:{schemaId:"schema.application.primitive.port-status.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.port-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(236),decodeResult:S1(237)},{operation:"pr_context",operationId:"operation.application.pr_context",transport:{kind:"mcp_tool",toolName:"tracedecay_pr_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.pr_context.v1",requestSchema:{schemaId:"schema.application.primitive.pr-context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.pr-context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(238),decodeResult:S1(239)},{operation:"preflight_native_integration",operationId:"operation.application.preflight_native_integration",transport:{kind:"mcp_tool",toolName:"tracedecay_preflight_native_integration"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.preflight_native_integration.v1",requestSchema:{schemaId:"schema.application.native-integration.preflight.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.preflight.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(240),decodeResult:S1(15)},{operation:"project_context",operationId:"operation.application.project_context",transport:{kind:"mcp_tool",toolName:"tracedecay_project_context"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.project_context.v1",requestSchema:{schemaId:"schema.application.primitive.project-context.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.project-context.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(241),decodeResult:S1(242)},{operation:"project_list",operationId:"operation.application.project_list",transport:{kind:"mcp_tool",toolName:"tracedecay_project_list"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.project_list.v1",requestSchema:{schemaId:"schema.application.primitive.project-list.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.project-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(243),decodeResult:S1(244)},{operation:"project_search",operationId:"operation.application.project_search",transport:{kind:"mcp_tool",toolName:"tracedecay_project_search"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.project_search.v1",requestSchema:{schemaId:"schema.application.primitive.project-search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.project-search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(245),decodeResult:S1(244)},{operation:"application_qualified_name",operationId:"operation.application.qualified_name",transport:{kind:"http",route:"/application/primitives/qualified_name",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.qualified_name.v1",requestSchema:{schemaId:"schema.application.primitive.qualified-name.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.qualified-name.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(246),decodeResult:S1(247),decodeSuccess:e=>fp(e,"binding.http.qualified_name.v1","schema.application.primitive.qualified-name.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(247))},{operation:"rank",operationId:"operation.application.rank",transport:{kind:"mcp_tool",toolName:"tracedecay_rank"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.rank.v1",requestSchema:{schemaId:"schema.application.primitive.rank.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.rank.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(248),decodeResult:S1(249)},{operation:"recursion",operationId:"operation.application.recursion",transport:{kind:"mcp_tool",toolName:"tracedecay_recursion"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.recursion.v1",requestSchema:{schemaId:"schema.application.primitive.recursion.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.recursion.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(250),decodeResult:S1(251)},{operation:"redundancy",operationId:"operation.application.redundancy",transport:{kind:"mcp_tool",toolName:"tracedecay_redundancy"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.redundancy.v1",requestSchema:{schemaId:"schema.application.primitive.redundancy.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.redundancy.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(252),decodeResult:S1(253)},{operation:"remote_status",operationId:"operation.application.remote_status",transport:{kind:"mcp_tool",toolName:"tracedecay_remote_status"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.remote_status.v1",requestSchema:{schemaId:"schema.application.primitive.remote-status.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.remote-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(254),decodeResult:S1(255)},{operation:"rename_preview",operationId:"operation.application.rename_preview",transport:{kind:"mcp_tool",toolName:"tracedecay_rename_preview"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.rename_preview.v1",requestSchema:{schemaId:"schema.application.primitive.rename-preview.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.rename-preview.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(256),decodeResult:S1(257)},{operation:"rename_symbol",operationId:"operation.application.rename_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_rename_symbol"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.rename_symbol.v1",requestSchema:{schemaId:"schema.application.source-edit.rename-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.rename-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(258),decodeResult:S1(18)},{operation:"replace_symbol",operationId:"operation.application.replace_symbol",transport:{kind:"mcp_tool",toolName:"tracedecay_replace_symbol"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.replace_symbol.v1",requestSchema:{schemaId:"schema.application.source-edit.replace-symbol.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.replace-symbol.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(259),decodeResult:S1(18)},{operation:"retrieve",operationId:"operation.application.retrieve",transport:{kind:"mcp_tool",toolName:"tracedecay_retrieve"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.retrieve.v1",requestSchema:{schemaId:"schema.application.primitive.retrieve.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.retrieve.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(260),decodeResult:S1(261)},{operation:"run_affected_tests",operationId:"operation.application.run_affected_tests",transport:{kind:"mcp_tool",toolName:"tracedecay_run_affected_tests"},effect:"spawns_process",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.run_affected_tests.v1",requestSchema:{schemaId:"schema.application.primitive.run-affected-tests.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.run-affected-tests.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","effect_in_flight"]},deadline:{behavior:"return_operation_receipt",maximum_millis:6e5},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(262),decodeResult:S1(263)},{operation:"runtime",operationId:"operation.application.runtime",transport:{kind:"mcp_tool",toolName:"tracedecay_runtime"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.runtime.v1",requestSchema:{schemaId:"schema.application.primitive.runtime.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.runtime.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(264),decodeResult:S1(265)},{operation:"search",operationId:"operation.application.search",transport:{kind:"mcp_tool",toolName:"tracedecay_search"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.search.v1",requestSchema:{schemaId:"schema.application.primitive.search.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.search.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(266),decodeResult:S1(267)},{operation:"session_lookup",operationId:"operation.application.session_lookup",transport:{kind:"mcp_tool",toolName:"tracedecay_session_lookup"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.session_lookup.v1",requestSchema:{schemaId:"schema.application.primitive.session-lookup.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.session-lookup.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(268),decodeResult:S1(269)},{operation:"application_session_refresh_begin",operationId:"operation.application.session_refresh_begin",transport:{kind:"http",route:"/application/retained/session_refresh_begin",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.session_refresh_begin.v1",requestSchema:{schemaId:"schema.application.retained.session-refresh-begin.request",revision:1},resultSchema:{schemaId:"schema.application.retained.session-refresh-begin.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(270),decodeResult:S1(271),decodeSuccess:e=>fp(e,"binding.http.session_refresh_begin.v1","schema.application.retained.session-refresh-begin.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(271))},{operation:"application_session_refresh_cancel",operationId:"operation.application.session_refresh_cancel",transport:{kind:"http",route:"/application/retained/session_refresh_cancel",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.session_refresh_cancel.v1",requestSchema:{schemaId:"schema.application.retained.session-refresh-cancel.request",revision:1},resultSchema:{schemaId:"schema.application.retained.session-refresh-cancel.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],decodeRequest:S1(270),decodeResult:S1(272),decodeSuccess:e=>fp(e,"binding.http.session_refresh_cancel.v1","schema.application.retained.session-refresh-cancel.result",1,["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","reconciling","after_commit"]},"durable_effect","required",S1(272))},{operation:"application_session_refresh_status",operationId:"operation.application.session_refresh_status",transport:{kind:"http",route:"/application/retained/session_refresh_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.session_refresh_status.v1",requestSchema:{schemaId:"schema.application.retained.session-refresh-status.request",revision:1},resultSchema:{schemaId:"schema.application.retained.session-refresh-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(270),decodeResult:S1(273),decodeSuccess:e=>fp(e,"binding.http.session_refresh_status.v1","schema.application.retained.session-refresh-status.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(273))},{operation:"application_sessions_for",operationId:"operation.application.sessions_for",transport:{kind:"http",route:"/application/retained/sessions_for",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.sessions_for.v1",requestSchema:{schemaId:"schema.application.retained.sessions-for.request",revision:1},resultSchema:{schemaId:"schema.application.retained.sessions-for.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(274),decodeResult:S1(275),decodeSuccess:e=>fp(e,"binding.http.sessions_for.v1","schema.application.retained.sessions-for.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(275))},{operation:"signature",operationId:"operation.application.signature",transport:{kind:"mcp_tool",toolName:"tracedecay_signature"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.signature.v1",requestSchema:{schemaId:"schema.application.primitive.signature.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.signature.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(112),decodeResult:S1(276)},{operation:"similar",operationId:"operation.application.similar",transport:{kind:"mcp_tool",toolName:"tracedecay_similar"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.similar.v1",requestSchema:{schemaId:"schema.application.primitive.similar.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.similar.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(277),decodeResult:S1(278)},{operation:"skill_list",operationId:"operation.application.skill_list",transport:{kind:"mcp_tool",toolName:"tracedecay_skill_list"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.skill_list.v1",requestSchema:{schemaId:"schema.application.primitive.skill-list.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.skill-list.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(279),decodeResult:S1(280)},{operation:"skill_view",operationId:"operation.application.skill_view",transport:{kind:"mcp_tool",toolName:"tracedecay_skill_view"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.skill_view.v1",requestSchema:{schemaId:"schema.application.primitive.skill-view.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.skill-view.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(281),decodeResult:S1(282)},{operation:"application_source_body",operationId:"operation.application.source_body",transport:{kind:"http",route:"/application/primitives/source_body",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.source_body.v1",requestSchema:{schemaId:"schema.application.primitive.source-body.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.source-body.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(283),decodeResult:S1(284),decodeSuccess:e=>fp(e,"binding.http.source_body.v1","schema.application.primitive.source-body.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(284))},{operation:"source_edit_reconcile",operationId:"operation.application.source_edit_reconcile",transport:{kind:"mcp_tool",toolName:"tracedecay_source_edit_reconcile"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.source_edit_reconcile.v1",requestSchema:{schemaId:"schema.application.source-edit.reconcile.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.reconcile.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(285),decodeResult:S1(18)},{operation:"application_source_lines",operationId:"operation.application.source_lines",transport:{kind:"http",route:"/application/primitives/source_lines",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.source_lines.v1",requestSchema:{schemaId:"schema.application.primitive.source-lines.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.source-lines.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(286),decodeResult:S1(287),decodeSuccess:e=>fp(e,"binding.http.source_lines.v1","schema.application.primitive.source-lines.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(287))},{operation:"application_source_outline",operationId:"operation.application.source_outline",transport:{kind:"http",route:"/application/primitives/source_outline",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.source_outline.v1",requestSchema:{schemaId:"schema.application.primitive.source-outline.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.source-outline.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(288),decodeResult:S1(289),decodeSuccess:e=>fp(e,"binding.http.source_outline.v1","schema.application.primitive.source-outline.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(289))},{operation:"stack_snapshot",operationId:"operation.application.stack_snapshot",transport:{kind:"mcp_tool",toolName:"tracedecay_stack_snapshot"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.stack_snapshot.v1",requestSchema:{schemaId:"schema.application.native-integration.stack-snapshot.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.stack-snapshot.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(290),decodeResult:S1(15)},{operation:"status",operationId:"operation.application.status",transport:{kind:"mcp_tool",toolName:"tracedecay_status"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.status.v1",requestSchema:{schemaId:"schema.application.primitive.status.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(291),decodeResult:S1(292)},{operation:"application_storage_status",operationId:"operation.application.storage_status",transport:{kind:"http",route:"/application/primitives/storage_status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.storage_status.v1",requestSchema:{schemaId:"schema.application.primitive.storage-status.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.storage-status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(293),decodeResult:S1(294),decodeSuccess:e=>fp(e,"binding.http.storage_status.v1","schema.application.primitive.storage-status.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(294))},{operation:"str_replace",operationId:"operation.application.str_replace",transport:{kind:"mcp_tool",toolName:"tracedecay_str_replace"},effect:"source_edit",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.str_replace.v1",requestSchema:{schemaId:"schema.application.source-edit.str-replace.request",revision:1},resultSchema:{schemaId:"schema.application.source-edit.str-replace.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(295),decodeResult:S1(18)},{operation:"test_map",operationId:"operation.application.test_map",transport:{kind:"mcp_tool",toolName:"tracedecay_test_map"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.test_map.v1",requestSchema:{schemaId:"schema.application.primitive.test-map.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.test-map.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(296),decodeResult:S1(297)},{operation:"application_test_results",operationId:"operation.application.test_results",transport:{kind:"http",route:"/application/tests/results",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.test_results.v1",requestSchema:{schemaId:"schema.application.feedback.test-results.request",revision:1},resultSchema:{schemaId:"schema.application.feedback.test-results.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:15e3},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(298),decodeResult:S1(299),decodeSuccess:e=>fp(e,"binding.http.test_results.v1","schema.application.feedback.test-results.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(299))},{operation:"test_risk",operationId:"operation.application.test_risk",transport:{kind:"mcp_tool",toolName:"tracedecay_test_risk"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.test_risk.v1",requestSchema:{schemaId:"schema.application.primitive.test-risk.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.test-risk.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(300),decodeResult:S1(301)},{operation:"todos",operationId:"operation.application.todos",transport:{kind:"mcp_tool",toolName:"tracedecay_todos"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.todos.v1",requestSchema:{schemaId:"schema.application.primitive.todos.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.todos.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:1e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(302),decodeResult:S1(303)},{operation:"unmounted_files",operationId:"operation.application.unmounted_files",transport:{kind:"mcp_tool",toolName:"tracedecay_unmounted_files"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.unmounted_files.v1",requestSchema:{schemaId:"schema.application.primitive.unmounted-files.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.unmounted-files.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(304),decodeResult:S1(305)},{operation:"unsafe_patterns",operationId:"operation.application.unsafe_patterns",transport:{kind:"mcp_tool",toolName:"tracedecay_unsafe_patterns"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.mcp.unsafe_patterns.v1",requestSchema:{schemaId:"schema.application.primitive.unsafe-patterns.request",revision:1},resultSchema:{schemaId:"schema.application.primitive.unsafe-patterns.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:12e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(306),decodeResult:S1(307)},{operation:"application_workflows",operationId:"operation.application.workflows",transport:{kind:"http",route:"/application/retained/workflows",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflows.v1",requestSchema:{schemaId:"schema.application.retained.workflows.request",revision:1},resultSchema:{schemaId:"schema.application.retained.workflows.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","unavailable","partial"],decodeRequest:S1(308),decodeResult:S1(309),decodeSuccess:e=>fp(e,"binding.http.workflows.v1","schema.application.retained.workflows.result",1,["completed","cancelled","timed_out","failed","unavailable","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(309))},{operation:"application_worktree_cleanup_confirm",operationId:"operation.application.worktree_cleanup_confirm",transport:{kind:"http",route:"/application/native-integration/worktree_cleanup_confirm",method:"POST"},effect:"preview",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_cleanup_confirm.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-confirm.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-confirm.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(310),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_cleanup_confirm.v1","schema.application.native-integration.worktree-cleanup-confirm.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(15))},{operation:"application_worktree_cleanup_inspect",operationId:"operation.application.worktree_cleanup_inspect",transport:{kind:"http",route:"/application/native-integration/worktree_cleanup_inspect",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_cleanup_inspect.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-inspect.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-inspect.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(311),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_cleanup_inspect.v1","schema.application.native-integration.worktree-cleanup-inspect.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(15))},{operation:"application_worktree_cleanup_reconcile",operationId:"operation.application.worktree_cleanup_reconcile",transport:{kind:"http",route:"/application/native-integration/worktree_cleanup_reconcile",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_cleanup_reconcile.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-reconcile.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-reconcile.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(312),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_cleanup_reconcile.v1","schema.application.native-integration.worktree-cleanup-reconcile.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(15))},{operation:"application_worktree_cleanup_remove",operationId:"operation.application.worktree_cleanup_remove",transport:{kind:"http",route:"/application/native-integration/worktree_cleanup_remove",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_cleanup_remove.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-remove.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-cleanup-remove.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(313),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_cleanup_remove.v1","schema.application.native-integration.worktree-cleanup-remove.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(15))},{operation:"application_worktree_inventory",operationId:"operation.application.worktree_inventory",transport:{kind:"http",route:"/application/native-integration/worktree_inventory",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.worktree_inventory.v1",requestSchema:{schemaId:"schema.application.native-integration.worktree-inventory.request",revision:1},resultSchema:{schemaId:"schema.application.native-integration.worktree-inventory.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(314),decodeResult:S1(15),decodeSuccess:e=>fp(e,"binding.http.worktree_inventory.v1","schema.application.native-integration.worktree-inventory.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(15))},{operation:"handoff_issue_task_handoff",operationId:"operation.handoff.issue_task_handoff",transport:{kind:"http",route:"/application/handoff/issue-task",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.handoff.issue_task_handoff",requestSchema:{schemaId:"schema.handoff.issue_task_handoff.request",revision:1},resultSchema:{schemaId:"schema.handoff.issue_task_handoff.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(315),decodeResult:S1(316),decodeSuccess:e=>fp(e,"binding.http.handoff.issue_task_handoff","schema.handoff.issue_task_handoff.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(316))},{operation:"handoff_list_task_handoffs",operationId:"operation.handoff.list_task_handoffs",transport:{kind:"http",route:"/application/handoff/list-task",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.handoff.list_task_handoffs",requestSchema:{schemaId:"schema.handoff.list_task_handoffs.request",revision:1},resultSchema:{schemaId:"schema.handoff.list_task_handoffs.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","timed_out","failed","partial"],decodeRequest:S1(317),decodeResult:S1(318),decodeSuccess:e=>fp(e,"binding.http.handoff.list_task_handoffs","schema.handoff.list_task_handoffs.result",1,["completed","timed_out","failed","partial"],{mode:"not_cancellable"},"operation","not_required",S1(318))},{operation:"handoff_open_investigation_handoff",operationId:"operation.handoff.open_investigation_handoff",transport:{kind:"http",route:"/application/handoff/open-investigation",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.handoff.open_investigation_handoff",requestSchema:{schemaId:"schema.handoff.open_investigation_handoff.request",revision:1},resultSchema:{schemaId:"schema.handoff.open_investigation_handoff.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(319),decodeResult:S1(320),decodeSuccess:e=>fp(e,"binding.http.handoff.open_investigation_handoff","schema.handoff.open_investigation_handoff.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(320))},{operation:"handoff_open_task_handoff",operationId:"operation.handoff.open_task_handoff",transport:{kind:"http",route:"/application/handoff/open-task",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.handoff.open_task_handoff",requestSchema:{schemaId:"schema.handoff.open_task_handoff.request",revision:1},resultSchema:{schemaId:"schema.handoff.open_task_handoff.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(321),decodeResult:S1(322),decodeSuccess:e=>fp(e,"binding.http.handoff.open_task_handoff","schema.handoff.open_task_handoff.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(322))},{operation:"multi_root_execute",operationId:"operation.multi_root.execute",transport:{kind:"http",route:"/application/multi-root/execute",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.multi_root.execute.v1",requestSchema:{schemaId:"schema.tracedecay.multi-root.execute-request.v1",revision:1},resultSchema:{schemaId:"schema.tracedecay.multi-root.execute-result.v1",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(323),decodeResult:S1(324),decodeSuccess:e=>fp(e,"binding.http.multi_root.execute.v1","schema.tracedecay.multi-root.execute-result.v1",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(324))},{operation:"multi_root_scope_set_compare_and_swap",operationId:"operation.multi_root.scope_set_compare_and_swap",transport:{kind:"http",route:"/application/multi-root/scope-set/compare-and-swap",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.multi_root.scope_set_compare_and_swap.v1",requestSchema:{schemaId:"schema.tracedecay.multi-root.scope-set-compare-and-swap-request.v1",revision:1},resultSchema:{schemaId:"schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(325),decodeResult:S1(326),decodeSuccess:e=>fp(e,"binding.http.multi_root.scope_set_compare_and_swap.v1","schema.tracedecay.multi-root.scope-set-compare-and-swap-result.v1",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(326))},{operation:"multi_root_scope_set_read",operationId:"operation.multi_root.scope_set_read",transport:{kind:"http",route:"/application/multi-root/scope-set/read",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.multi_root.scope_set_read.v1",requestSchema:{schemaId:"schema.tracedecay.multi-root.scope-set-read-request.v1",revision:1},resultSchema:{schemaId:"schema.tracedecay.multi-root.scope-set-read-result.v1",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(327),decodeResult:S1(328),decodeSuccess:e=>fp(e,"binding.http.multi_root.scope_set_read.v1","schema.tracedecay.multi-root.scope-set-read-result.v1",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(328))},{operation:"work_accept_proposal",operationId:"operation.work.accept_proposal",transport:{kind:"http",route:"/application/work/accept-proposal",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.accept_proposal",requestSchema:{schemaId:"schema.work.accept_proposal.request",revision:1},resultSchema:{schemaId:"schema.work.accept_proposal.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(329),decodeResult:S1(330),decodeSuccess:e=>fp(e,"binding.http.work.accept_proposal","schema.work.accept_proposal.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(330))},{operation:"work_adjudicate_duplicate",operationId:"operation.work.adjudicate_duplicate",transport:{kind:"http",route:"/application/work/adjudicate-duplicate",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.adjudicate_duplicate",requestSchema:{schemaId:"schema.work.adjudicate_duplicate.request",revision:1},resultSchema:{schemaId:"schema.work.adjudicate_duplicate.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(331),decodeResult:S1(332),decodeSuccess:e=>fp(e,"binding.http.work.adjudicate_duplicate","schema.work.adjudicate_duplicate.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(332))},{operation:"work_adjudicate_leak",operationId:"operation.work.adjudicate_leak",transport:{kind:"http",route:"/application/work/adjudicate-leak",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.adjudicate_leak",requestSchema:{schemaId:"schema.work.adjudicate_leak.request",revision:1},resultSchema:{schemaId:"schema.work.adjudicate_leak.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(333),decodeResult:S1(334),decodeSuccess:e=>fp(e,"binding.http.work.adjudicate_leak","schema.work.adjudicate_leak.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(334))},{operation:"work_admit_execution",operationId:"operation.work.admit_execution",transport:{kind:"http",route:"/application/work/admit-execution",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.admit_execution",requestSchema:{schemaId:"schema.work.admit_execution.request",revision:1},resultSchema:{schemaId:"schema.work.admit_execution.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(335),decodeResult:S1(336),decodeSuccess:e=>fp(e,"binding.http.work.admit_execution","schema.work.admit_execution.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(336))},{operation:"work_admit_placement",operationId:"operation.work.admit_placement",transport:{kind:"http",route:"/application/work/admit-placement",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.admit_placement",requestSchema:{schemaId:"schema.work.admit_placement.request",revision:1},resultSchema:{schemaId:"schema.work.admit_placement.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(337),decodeResult:S1(338),decodeSuccess:e=>fp(e,"binding.http.work.admit_placement","schema.work.admit_placement.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(338))},{operation:"work_advance_job",operationId:"operation.work.advance_job",transport:{kind:"http",route:"/application/work/advance-job",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.advance_job",requestSchema:{schemaId:"schema.work.advance_job.request",revision:1},resultSchema:{schemaId:"schema.work.advance_job.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(339),decodeResult:S1(340),decodeSuccess:e=>fp(e,"binding.http.work.advance_job","schema.work.advance_job.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(340))},{operation:"work_attempt_status",operationId:"operation.work.attempt_status",transport:{kind:"http",route:"/application/work/attempt-status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.attempt_status",requestSchema:{schemaId:"schema.work.attempt_status.request",revision:1},resultSchema:{schemaId:"schema.work.attempt_status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(341),decodeResult:S1(342),decodeSuccess:e=>fp(e,"binding.http.work.attempt_status","schema.work.attempt_status.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(342))},{operation:"work_cancel_attempt",operationId:"operation.work.cancel_attempt",transport:{kind:"http",route:"/application/work/cancel-attempt",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.cancel_attempt",requestSchema:{schemaId:"schema.work.cancel_attempt.request",revision:1},resultSchema:{schemaId:"schema.work.cancel_attempt.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(343),decodeResult:S1(342),decodeSuccess:e=>fp(e,"binding.http.work.cancel_attempt","schema.work.cancel_attempt.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(342))},{operation:"work_compare_proposal",operationId:"operation.work.compare_proposal",transport:{kind:"http",route:"/application/work/compare-proposal",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.compare_proposal",requestSchema:{schemaId:"schema.work.compare_proposal.request",revision:1},resultSchema:{schemaId:"schema.work.compare_proposal.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(344),decodeResult:S1(345),decodeSuccess:e=>fp(e,"binding.http.work.compare_proposal","schema.work.compare_proposal.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(345))},{operation:"work_create",operationId:"operation.work.create",transport:{kind:"http",route:"/application/work/create",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.create",requestSchema:{schemaId:"schema.work.create.request",revision:1},resultSchema:{schemaId:"schema.work.create.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(346),decodeResult:S1(330),decodeSuccess:e=>fp(e,"binding.http.work.create","schema.work.create.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(330))},{operation:"work_execution_history",operationId:"operation.work.execution_history",transport:{kind:"http",route:"/application/work/execution-history",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.execution_history",requestSchema:{schemaId:"schema.work.execution_history.request",revision:1},resultSchema:{schemaId:"schema.work.execution_history.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(347),decodeResult:S1(348),decodeSuccess:e=>fp(e,"binding.http.work.execution_history","schema.work.execution_history.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(348))},{operation:"work_experience",operationId:"operation.work.experience",transport:{kind:"http",route:"/application/work/experience",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.experience",requestSchema:{schemaId:"schema.work.experience.request",revision:1},resultSchema:{schemaId:"schema.work.experience.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(349),decodeResult:S1(350),decodeSuccess:e=>fp(e,"binding.http.work.experience","schema.work.experience.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(350))},{operation:"work_generate_proposal",operationId:"operation.work.generate_proposal",transport:{kind:"http",route:"/application/work/generate-proposal",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.generate_proposal",requestSchema:{schemaId:"schema.work.generate_proposal.request",revision:1},resultSchema:{schemaId:"schema.work.generate_proposal.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(351),decodeResult:S1(352),decodeSuccess:e=>fp(e,"binding.http.work.generate_proposal","schema.work.generate_proposal.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(352))},{operation:"work_hydrate_artifacts",operationId:"operation.work.hydrate_artifacts",transport:{kind:"http",route:"/application/work/hydrate-artifacts",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.hydrate_artifacts",requestSchema:{schemaId:"schema.work.hydrate_artifacts.request",revision:1},resultSchema:{schemaId:"schema.work.hydrate_artifacts.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(353),decodeResult:S1(354),decodeSuccess:e=>fp(e,"binding.http.work.hydrate_artifacts","schema.work.hydrate_artifacts.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(354))},{operation:"work_list_attempts",operationId:"operation.work.list_attempts",transport:{kind:"http",route:"/application/work/list-attempts",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.list_attempts",requestSchema:{schemaId:"schema.work.list_attempts.request",revision:1},resultSchema:{schemaId:"schema.work.list_attempts.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(347),decodeResult:S1(355),decodeSuccess:e=>fp(e,"binding.http.work.list_attempts","schema.work.list_attempts.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(355))},{operation:"work_mutate_graph",operationId:"operation.work.mutate_graph",transport:{kind:"http",route:"/application/work/mutate-graph",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.mutate_graph",requestSchema:{schemaId:"schema.work.mutate_graph.request",revision:1},resultSchema:{schemaId:"schema.work.mutate_graph.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(356),decodeResult:S1(330),decodeSuccess:e=>fp(e,"binding.http.work.mutate_graph","schema.work.mutate_graph.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(330))},{operation:"work_pause_run",operationId:"operation.work.pause_run",transport:{kind:"http",route:"/application/work/pause-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.pause_run",requestSchema:{schemaId:"schema.work.pause_run.request",revision:1},resultSchema:{schemaId:"schema.work.pause_run.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(357),decodeResult:S1(358),decodeSuccess:e=>fp(e,"binding.http.work.pause_run","schema.work.pause_run.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(358))},{operation:"work_placement_preflight",operationId:"operation.work.placement_preflight",transport:{kind:"http",route:"/application/work/placement-preflight",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.placement_preflight",requestSchema:{schemaId:"schema.work.placement_preflight.request",revision:1},resultSchema:{schemaId:"schema.work.placement_preflight.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(359),decodeResult:S1(360),decodeSuccess:e=>fp(e,"binding.http.work.placement_preflight","schema.work.placement_preflight.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(360))},{operation:"work_placement_status",operationId:"operation.work.placement_status",transport:{kind:"http",route:"/application/work/placement-status",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.placement_status",requestSchema:{schemaId:"schema.work.placement_status.request",revision:1},resultSchema:{schemaId:"schema.work.placement_status.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(361),decodeResult:S1(362),decodeSuccess:e=>fp(e,"binding.http.work.placement_status","schema.work.placement_status.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(362))},{operation:"work_prepare_duplicate_adjudication",operationId:"operation.work.prepare_duplicate_adjudication",transport:{kind:"http",route:"/application/work/prepare-duplicate-adjudication",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.prepare_duplicate_adjudication",requestSchema:{schemaId:"schema.work.prepare_duplicate_adjudication.request",revision:1},resultSchema:{schemaId:"schema.work.prepare_duplicate_adjudication.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(363),decodeResult:S1(331),decodeSuccess:e=>fp(e,"binding.http.work.prepare_duplicate_adjudication","schema.work.prepare_duplicate_adjudication.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(331))},{operation:"work_prepare_graph_mutation",operationId:"operation.work.prepare_graph_mutation",transport:{kind:"http",route:"/application/work/prepare-graph-mutation",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.prepare_graph_mutation",requestSchema:{schemaId:"schema.work.prepare_graph_mutation.request",revision:1},resultSchema:{schemaId:"schema.work.prepare_graph_mutation.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(364),decodeResult:S1(356),decodeSuccess:e=>fp(e,"binding.http.work.prepare_graph_mutation","schema.work.prepare_graph_mutation.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(356))},{operation:"work_release_placement",operationId:"operation.work.release_placement",transport:{kind:"http",route:"/application/work/release-placement",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.release_placement",requestSchema:{schemaId:"schema.work.release_placement.request",revision:1},resultSchema:{schemaId:"schema.work.release_placement.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(365),decodeResult:S1(338),decodeSuccess:e=>fp(e,"binding.http.work.release_placement","schema.work.release_placement.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(338))},{operation:"work_resume_attempts",operationId:"operation.work.resume_attempts",transport:{kind:"http",route:"/application/work/resume-attempts",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.resume_attempts",requestSchema:{schemaId:"schema.work.resume_attempts.request",revision:1},resultSchema:{schemaId:"schema.work.resume_attempts.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(366),decodeResult:S1(367),decodeSuccess:e=>fp(e,"binding.http.work.resume_attempts","schema.work.resume_attempts.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(367))},{operation:"work_resume_run",operationId:"operation.work.resume_run",transport:{kind:"http",route:"/application/work/resume-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.resume_run",requestSchema:{schemaId:"schema.work.resume_run.request",revision:1},resultSchema:{schemaId:"schema.work.resume_run.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(368),decodeResult:S1(358),decodeSuccess:e=>fp(e,"binding.http.work.resume_run","schema.work.resume_run.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(358))},{operation:"work_retrieve_evidence",operationId:"operation.work.retrieve_evidence",transport:{kind:"http",route:"/application/work/retrieve-evidence",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.retrieve_evidence",requestSchema:{schemaId:"schema.work.retrieve_evidence.request",revision:1},resultSchema:{schemaId:"schema.work.retrieve_evidence.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(369),decodeResult:S1(370),decodeSuccess:e=>fp(e,"binding.http.work.retrieve_evidence","schema.work.retrieve_evidence.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(370))},{operation:"work_retry_attempt",operationId:"operation.work.retry_attempt",transport:{kind:"http",route:"/application/work/retry-attempt",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.retry_attempt",requestSchema:{schemaId:"schema.work.retry_attempt.request",revision:1},resultSchema:{schemaId:"schema.work.retry_attempt.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(371),decodeResult:S1(372),decodeSuccess:e=>fp(e,"binding.http.work.retry_attempt","schema.work.retry_attempt.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(372))},{operation:"work_review_proposal",operationId:"operation.work.review_proposal",transport:{kind:"http",route:"/application/work/review-proposal",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.review_proposal",requestSchema:{schemaId:"schema.work.review_proposal.request",revision:1},resultSchema:{schemaId:"schema.work.review_proposal.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(373),decodeResult:S1(330),decodeSuccess:e=>fp(e,"binding.http.work.review_proposal","schema.work.review_proposal.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(330))},{operation:"work_run_control",operationId:"operation.work.run_control",transport:{kind:"http",route:"/application/work/run-control",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.run_control",requestSchema:{schemaId:"schema.work.run_control.request",revision:1},resultSchema:{schemaId:"schema.work.run_control.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(374),decodeResult:S1(375),decodeSuccess:e=>fp(e,"binding.http.work.run_control","schema.work.run_control.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(375))},{operation:"work_start_attempt",operationId:"operation.work.start_attempt",transport:{kind:"http",route:"/application/work/start-attempt",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.start_attempt",requestSchema:{schemaId:"schema.work.start_attempt.request",revision:1},resultSchema:{schemaId:"schema.work.start_attempt.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(376),decodeResult:S1(342),decodeSuccess:e=>fp(e,"binding.http.work.start_attempt","schema.work.start_attempt.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(342))},{operation:"work_synthesize",operationId:"operation.work.synthesize",transport:{kind:"http",route:"/application/work/synthesize",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.synthesize",requestSchema:{schemaId:"schema.work.synthesize.request",revision:1},resultSchema:{schemaId:"schema.work.synthesize.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","cancelled","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(377),decodeResult:S1(378),decodeSuccess:e=>fp(e,"binding.http.work.synthesize","schema.work.synthesize.result",1,["completed","cancelled","timed_out","failed","effect_unknown","partial"],{mode:"cooperative",points:["before_admission","before_effect","effect_in_flight","after_commit"]},"durable_effect","required",S1(378))},{operation:"work_topology",operationId:"operation.work.topology",transport:{kind:"http",route:"/application/work/topology",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.topology",requestSchema:{schemaId:"schema.work.topology.request",revision:1},resultSchema:{schemaId:"schema.work.topology.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(379),decodeResult:S1(380),decodeSuccess:e=>fp(e,"binding.http.work.topology","schema.work.topology.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(380))},{operation:"work_topology_metrics",operationId:"operation.work.topology_metrics",transport:{kind:"http",route:"/application/work/topology-metrics",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.topology_metrics",requestSchema:{schemaId:"schema.work.topology_metrics.request",revision:1},resultSchema:{schemaId:"schema.work.topology_metrics.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(381),decodeResult:S1(382),decodeSuccess:e=>fp(e,"binding.http.work.topology_metrics","schema.work.topology_metrics.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(382))},{operation:"work_views",operationId:"operation.work.views",transport:{kind:"http",route:"/application/work/views",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.work.views",requestSchema:{schemaId:"schema.work.views.request",revision:1},resultSchema:{schemaId:"schema.work.views.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(383),decodeResult:S1(384),decodeSuccess:e=>fp(e,"binding.http.work.views","schema.work.views.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(384))},{operation:"workflow_activate_definition",operationId:"operation.workflow.activate_definition",transport:{kind:"http",route:"/application/workflow/activate-definition",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.activate_definition",requestSchema:{schemaId:"schema.workflow.activate_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.activate_definition.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(385),decodeResult:S1(386),decodeSuccess:e=>fp(e,"binding.http.workflow.activate_definition","schema.workflow.activate_definition.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(386))},{operation:"workflow_cancel_run",operationId:"operation.workflow.cancel_run",transport:{kind:"http",route:"/application/workflow/cancel-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.cancel_run",requestSchema:{schemaId:"schema.workflow.cancel_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.cancel_run.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(387),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.cancel_run","schema.workflow.cancel_run.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(388))},{operation:"workflow_definition_history",operationId:"operation.workflow.definition_history",transport:{kind:"http",route:"/application/workflow/definition-history",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.definition_history",requestSchema:{schemaId:"schema.workflow.definition_history.request",revision:1},resultSchema:{schemaId:"schema.workflow.definition_history.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(389),decodeResult:S1(390),decodeSuccess:e=>fp(e,"binding.http.workflow.definition_history","schema.workflow.definition_history.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(390))},{operation:"workflow_diff_definition",operationId:"operation.workflow.diff_definition",transport:{kind:"http",route:"/application/workflow/diff-definition",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.diff_definition",requestSchema:{schemaId:"schema.workflow.diff_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.diff_definition.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(391),decodeResult:S1(392),decodeSuccess:e=>fp(e,"binding.http.workflow.diff_definition","schema.workflow.diff_definition.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(392))},{operation:"workflow_get_definition",operationId:"operation.workflow.get_definition",transport:{kind:"http",route:"/application/workflow/get-definition",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.get_definition",requestSchema:{schemaId:"schema.workflow.get_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.get_definition.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(393),decodeResult:S1(394),decodeSuccess:e=>fp(e,"binding.http.workflow.get_definition","schema.workflow.get_definition.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(394))},{operation:"workflow_get_run",operationId:"operation.workflow.get_run",transport:{kind:"http",route:"/application/workflow/get-run",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.get_run",requestSchema:{schemaId:"schema.workflow.get_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.get_run.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(395),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.get_run","schema.workflow.get_run.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(388))},{operation:"workflow_handoff_issue",operationId:"operation.workflow.handoff_issue",transport:{kind:"http",route:"/application/workflow/handoff-issue",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.handoff_issue",requestSchema:{schemaId:"schema.workflow.handoff_issue.request",revision:1},resultSchema:{schemaId:"schema.workflow.handoff_issue.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(396),decodeResult:S1(397),decodeSuccess:e=>fp(e,"binding.http.workflow.handoff_issue","schema.workflow.handoff_issue.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(397))},{operation:"workflow_handoff_redeem",operationId:"operation.workflow.handoff_redeem",transport:{kind:"http",route:"/application/workflow/handoff-redeem",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.handoff_redeem",requestSchema:{schemaId:"schema.workflow.handoff_redeem.request",revision:1},resultSchema:{schemaId:"schema.workflow.handoff_redeem.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(398),decodeResult:S1(399),decodeSuccess:e=>fp(e,"binding.http.workflow.handoff_redeem","schema.workflow.handoff_redeem.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(399))},{operation:"workflow_list_definitions",operationId:"operation.workflow.list_definitions",transport:{kind:"http",route:"/application/workflow/list-definitions",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.list_definitions",requestSchema:{schemaId:"schema.workflow.list_definitions.request",revision:1},resultSchema:{schemaId:"schema.workflow.list_definitions.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(400),decodeResult:S1(390),decodeSuccess:e=>fp(e,"binding.http.workflow.list_definitions","schema.workflow.list_definitions.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(390))},{operation:"workflow_pause_run",operationId:"operation.workflow.pause_run",transport:{kind:"http",route:"/application/workflow/pause-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.pause_run",requestSchema:{schemaId:"schema.workflow.pause_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.pause_run.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(401),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.pause_run","schema.workflow.pause_run.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(388))},{operation:"workflow_register_definition",operationId:"operation.workflow.register_definition",transport:{kind:"http",route:"/application/workflow/register-definition",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.register_definition",requestSchema:{schemaId:"schema.workflow.register_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.register_definition.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(402),decodeResult:S1(394),decodeSuccess:e=>fp(e,"binding.http.workflow.register_definition","schema.workflow.register_definition.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(394))},{operation:"workflow_reject_definition",operationId:"operation.workflow.reject_definition",transport:{kind:"http",route:"/application/workflow/reject-definition",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.reject_definition",requestSchema:{schemaId:"schema.workflow.reject_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.reject_definition.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(403),decodeResult:S1(386),decodeSuccess:e=>fp(e,"binding.http.workflow.reject_definition","schema.workflow.reject_definition.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(386))},{operation:"workflow_resume_run",operationId:"operation.workflow.resume_run",transport:{kind:"http",route:"/application/workflow/resume-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.resume_run",requestSchema:{schemaId:"schema.workflow.resume_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.resume_run.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(404),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.resume_run","schema.workflow.resume_run.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(388))},{operation:"workflow_retire_definition",operationId:"operation.workflow.retire_definition",transport:{kind:"http",route:"/application/workflow/retire-definition",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.retire_definition",requestSchema:{schemaId:"schema.workflow.retire_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.retire_definition.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(405),decodeResult:S1(386),decodeSuccess:e=>fp(e,"binding.http.workflow.retire_definition","schema.workflow.retire_definition.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(386))},{operation:"workflow_start_run",operationId:"operation.workflow.start_run",transport:{kind:"http",route:"/application/workflow/start-run",method:"POST"},effect:"administrative",idempotency:"required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.start_run",requestSchema:{schemaId:"schema.workflow.start_run.request",revision:1},resultSchema:{schemaId:"schema.workflow.start_run.result",revision:1},cancellation:{mode:"not_cancellable"},deadline:{behavior:"return_effect_receipt",maximum_millis:3e4},reconciliation:"required",receipt:"durable_effect",terminalStates:["completed","timed_out","failed","effect_unknown","partial"],decodeRequest:S1(406),decodeResult:S1(388),decodeSuccess:e=>fp(e,"binding.http.workflow.start_run","schema.workflow.start_run.result",1,["completed","timed_out","failed","effect_unknown","partial"],{mode:"not_cancellable"},"durable_effect","required",S1(388))},{operation:"workflow_validate_definition",operationId:"operation.workflow.validate_definition",transport:{kind:"http",route:"/application/workflow/validate-definition",method:"POST"},effect:"read",idempotency:"not_required",requestIdControl:"server_minted",resultSemantics:"schema_only",bindingId:"binding.http.workflow.validate_definition",requestSchema:{schemaId:"schema.workflow.validate_definition.request",revision:1},resultSchema:{schemaId:"schema.workflow.validate_definition.result",revision:1},cancellation:{mode:"cooperative",points:["before_admission","before_read","during_read"]},deadline:{behavior:"return_operation_receipt",maximum_millis:3e4},reconciliation:"not_required",receipt:"operation",terminalStates:["completed","cancelled","timed_out","failed","partial"],decodeRequest:S1(407),decodeResult:S1(408),decodeSuccess:e=>fp(e,"binding.http.workflow.validate_definition","schema.workflow.validate_definition.result",1,["completed","cancelled","timed_out","failed","partial"],{mode:"cooperative",points:["before_admission","before_read","during_read"]},"operation","not_required",S1(408))}],S2=new TextEncoder;class S4 extends Error{cause;constructor(e,t){super(e),this.name=new.target.name,this.cause=t}}class S6 extends S4{constructor(e){super("the caller aborted the request",e)}}class S3 extends S4{}class S9 extends S4{status;constructor(e){super(401===e?"the daemon rejected HTTP authentication":"the daemon rejected the HTTP origin"),this.status=e}}class S5 extends Error{status;payload;constructor(e,t={}){super(e),this.name=new.target.name,this.status=t.status,this.payload=t.payload}}class S8 extends S5{}class S7 extends Error{status;envelope;problem;constructor(e,t){super(`${t.problem.kind}/${t.problem.code}: ${t.problem.message}`),this.name=new.target.name,this.status=e,this.envelope=t,this.problem=t.problem}}class ke extends S7{}class kt extends S7{}class kr extends S7{}class ki extends S7{}class ko extends S7{}class kn extends S7{}class ka extends S7{}class ks extends S7{}class kd extends S7{}class kc extends S7{}class kl extends S7{}let kp=new Set(["completed","cancelled","timed_out","failed","unavailable","effect_unknown","partial"]),ku=new TextEncoder;function km(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function kf(e){return"number"==typeof e&&Number.isSafeInteger(e)&&e>=0}function kh(e){return"number"==typeof e&&Number.isSafeInteger(e)}function ky(e,t){return"string"==typeof e&&e.length>0&&e.trim()===e&&ku.encode(e).byteLength<=t&&!/\p{Cc}/u.test(e)}function kg(e,t){let r=e.headers.get("content-type");return null!==r&&r.split(";",1)[0]?.trim().toLowerCase()===t}function k_(e){return!!km(e)&&!!kh(e.started_at)&&!!kh(e.ended_at)&&!(e.ended_at<e.started_at)&&"effective_deadline"in e&&(null===e.cancellation||!!km(e.cancellation))&&!!km(e.budget)&&!!kf(e.budget.units_consumed)&&!!kf(e.budget.bytes_consumed)&&!!kf(e.budget.elapsed_micros)&&"string"==typeof e.termination&&("cancelled"!==e.termination&&"timed_out"!==e.termination||km(e.cancellation))}function kv(e,t){try{return JSON.parse(e)}catch(r){throw new S8("the daemon returned non-JSON data",{status:t,payload:{text:e,cause:r}})}}async function kb(e,t){if(t?.aborted)throw new S6(t.reason);await new Promise((r,i)=>{let o=setTimeout(()=>{t?.removeEventListener("abort",n),r()},e),n=()=>{clearTimeout(o),i(new S6(t?.reason))};t?.addEventListener("abort",n,{once:!0})})}async function*k$(e,t){let r,i=e.getReader(),o=new TextDecoder("utf-8",{fatal:!0}),n=new Uint8Array(65536),a=0,s=0,d=!1,c="",l=0,p=t??"",u=ku.encode(p).byteLength,m=[],f=0,h=!1,y=()=>new S8("the daemon returned an SSE line or frame exceeding 65536 bytes",{payload:{limitBytes:65536}}),g=(e,t)=>{try{return o.decode(e,{stream:t})}catch(e){throw new S8("the daemon returned malformed UTF-8 event-stream data",{payload:e})}},_=e=>{if(""===e){if(h=!1,l=0,0===m.length)return c="",null;let e={event:""===c?"message":c,id:""===p?null:p,data:m.join("\n"),...void 0===r?{}:{retryDelayMs:r}};return c="",m=[],f=0,e}if(e.startsWith(":"))return null;h=!0;let t=e.indexOf(":"),i=t<0?e:e.slice(0,t),o=t<0?"":e.slice(t+1);o.startsWith(" ")&&(o=o.slice(1));let n=ku.encode(o).byteLength;if(("event"===i||"id"===i||"data"===i)&&l+u+f+n+1>65536)throw y();switch(i){case"event":c=o,l=n;break;case"id":o.includes("\0")||(p=o,u=n);break;case"data":f+=n+ +(0!==m.length),m.push(o);break;case"retry":if(/^[0-9]+$/.test(o)){let e=BigInt(o);r=e>2147483647n?0x7fffffff:Number(e)}}return null};try{for(;;){let e=await i.read();if(e.done){g(n.subarray(0,a),!1);break}for(let t=0;t<e.value.length;t+=1){let r=e.value[t];if(d&&(d=!1,10===r)){if(65536===s)throw y();continue}if(65536===a)throw y();if(n[a++]=r,10!==r&&13!==r)continue;let i=g(n.subarray(0,a),!0).slice(0,-1);s=a,a=0,d=13===r;let o=_(i);null!==o&&(yield o)}}if(a>0||h||m.length>0)throw new S3("operation stream ended with an incomplete SSE event")}catch(e){if(e instanceof S5||e instanceof S4)throw e;throw new S3("operation stream transport was interrupted",e)}finally{i.releaseLock()}}class kS{operations;projectRoot;applicationRoot;token;origin;doFetch;mcp;constructor(e){let t=new URL(e.baseUrl);if("http:"!==t.protocol&&"https:"!==t.protocol||""!==t.username||""!==t.password||""!==t.search||""!==t.hash)throw new S5("baseUrl must be an absolute HTTP URL without credentials, query, or fragment");let r=t.toString().replace(/\/+$/u,"");this.projectRoot=`${r}/projects/${encodeURIComponent(e.projectId)}`,this.applicationRoot=`${this.projectRoot}/application`,this.token=e.token,this.origin=e.origin??t.origin,this.doFetch=e.fetch??globalThis.fetch.bind(globalThis),this.mcp=e.mcp;let i={};for(let e of S0)i[e.operation]=(t,r)=>this.#p(e,t,r);this.operations=Object.freeze(i)}headers(e){return new Headers({accept:e,authorization:`Bearer ${this.token}`,origin:this.origin})}operationUrl(e,t){if(t?.size!==void 0&&(!Number.isSafeInteger(t.size)||t.size<1||t.size>1e3))throw new S5("page size must be an integer between 1 and 1000");if(t?.cursor!==void 0&&!ky(t.cursor,4096))throw new S5("page cursor is not a canonical opaque cursor");let r=new URL(`${this.projectRoot}${e}`);return t?.size!==void 0&&r.searchParams.set("page_size",String(t.size)),t?.cursor!==void 0&&r.searchParams.set("cursor",t.cursor),r}lifecycleUrl(e,t){if(!ky(e,512))throw new S5("operationId is not a canonical request handle");return new URL(`${this.applicationRoot}/operations/${encodeURIComponent(e)}/${t}`)}async fetchResponse(e,t,r){try{return await this.doFetch(e,t)}catch(t){if(r?.aborted)throw new S6(r.reason);throw new S3(`transport failure requesting ${e.pathname}`,t)}}async readJson(e,t,r,i){let o,n,a=!1,s=()=>n??=o?.cancel(i?.reason)??e.body?.cancel(i?.reason)??Promise.resolve(),d=()=>{s().catch(()=>void 0)};try{if(i?.aborted)throw new S6(i.reason);if(401===e.status||403===e.status)throw new S9(e.status);if(!kg(e,"application/json"))throw new S8("the daemon returned JSON with an invalid media type",{status:e.status});let n="";try{if(o=e.body?.getReader(),i?.addEventListener("abort",d,{once:!0}),i?.aborted)throw new S6(i.reason);if(void 0!==o){let e=new TextDecoder;for(;;){let{done:t,value:r}=await o.read();if(i?.aborted)throw new S6(i.reason);if(t)break;n+=e.decode(r,{stream:!0})}n+=e.decode()}a=!0}catch(e){if(i?.aborted)throw new S6(i.reason);throw new S3("transport failure reading the daemon response body",e)}let s=kv(n,e.status);if(km(s)&&"problem"===s.kind){var c;let i=s.value;if(!function(e){var t,r,i;if(!fu(e)||void 0!==e.binding_id&&"string"!=typeof e.binding_id||!(fu(t=e.contract)&&fh(t.schema_id,512)&&fm(t.schema_revision)&&t.schema_revision>0)||!fh(e.request_id,512)||!fu(e.problem))return!1;let o=e.problem,n=Array.isArray(o.legal_actions)?o.legal_actions:null,a="never"===o.retry?null:"same_request"===o.retry||"after_delay"===o.retry?"same_request":"after_revalidate"===o.retry?"fresh_request":"after_reconcile"===o.retry?"same_operation":void 0;if(!(1===o.revision&&"string"==typeof o.kind&&["invalid_request","not_found_or_not_authorized","conflict","partial_effect","stale","unsupported","unavailable","execution_failed","reset_required","saturated","cancelled","timed_out"].includes(o.kind)&&"string"==typeof o.code&&"string"==typeof o.message&&(null===o.diagnostic||fg(o.diagnostic))&&"detail"in o&&(null===o.detail||function(e){if(!fu(e))return!1;switch(e.kind){case"parked":return"string"==typeof e.cause&&"string"==typeof e.remedy&&"boolean"==typeof e.retries_on_wake;case"stale_refresh_frontier":return fm(e.requested)&&fm(e.committed)&&fm(e.active);case"stale_precondition":return"string"==typeof e.field&&fm(e.requested)&&fm(e.current);case"lock_deadline":return"string"==typeof e.resource&&fm(e.deadline_ms);case"diagnostics_unsupported":return(null===e.file||"string"==typeof e.file)&&Array.isArray(e.searched)&&e.searched.every(e=>fu(e)&&"string"==typeof e.path&&"boolean"==typeof e.present);case"diagnostics_pending":return"string"==typeof e.producer&&(null===e.generation||"string"==typeof e.generation);case"code_graph_rewarming":return fm(e.retry_after_millis);case"reset_required":return"string"==typeof e.authority&&(null===e.found_version||ff(e.found_version))&&(null===e.required_version||ff(e.required_version))&&"string"==typeof e.reason&&"string"==typeof e.remedy;default:return!1}}(o.detail))&&"committed_receipt"in o&&"string"==typeof o.owning_layer&&"string"==typeof o.terminality&&"boolean"==typeof o.retryable&&"string"==typeof o.retry&&(null===o.retry_scope||"string"==typeof o.retry_scope)&&(null===o.retry_after_millis||fm(o.retry_after_millis))&&"cancellation_stage"in o&&(null===o.cancellation_stage||"string"==typeof o.cancellation_stage&&["before_admission","before_read","during_read","before_effect","effect_in_flight"].includes(o.cancellation_stage))&&"unavailable_classification"in o&&(null===o.unavailable_classification||"string"==typeof o.unavailable_classification&&["authority","backend_unavailable","backend_disconnected","backend_retryable"].includes(o.unavailable_classification))&&"execution_failure_classification"in o&&(null===o.execution_failure_classification||"string"==typeof o.execution_failure_classification&&["denied","malformed_output","permanent"].includes(o.execution_failure_classification))&&o.request_id===e.request_id&&fh(o.trace_id,512)&&Array.isArray(o.details)&&o.details.every(fg)&&null!==n&&n.every(e=>"string"==typeof e)&&"coverage"in o)||null===n)return!1;let s=null!==o.cancellation_stage&&"before_admission"!==o.cancellation_stage,d=null!==o.unavailable_classification&&"authority"!==o.unavailable_classification,c="partial_effect"===o.kind||"reset_required"===o.kind||"execution_failed"===o.kind||s||d;return o.terminality===(c?"admitted_terminal":"pre_admission")&&"unavailable"===o.kind==(null!==o.unavailable_classification)&&"execution_failed"===o.kind==(null!==o.execution_failure_classification)&&("cancelled"===o.kind||"timed_out"===o.kind)==(null!==o.cancellation_stage)&&null!==o.diagnostic===("string"==typeof o.kind&&["invalid_request","conflict","partial_effect","stale","unsupported","unavailable","execution_failed","reset_required","saturated"].includes(o.kind))&&(null===o.detail||!!("string"==typeof o.kind&&["stale","unsupported","unavailable","reset_required","saturated"].includes(o.kind)))&&o.retryable===("never"!==o.retry)&&void 0!==a&&o.retry_scope===a&&"after_delay"===o.retry==(null!==o.retry_after_millis)&&("partial_effect"===o.kind?"admitted_terminal"===o.terminality&&!1===o.retryable&&"never"===o.retry&&(r=o.committed_receipt,i=e.request_id,fu(r)&&r.request_id===i&&"partial"===r.outcome&&"string"==typeof r.operation&&"string"==typeof r.effect_class&&"string"==typeof r.idempotency_key&&"string"==typeof r.input_digest&&("string"==typeof r.committed_state||"string"==typeof r.external_proof))&&1===n.length&&"reconcile"===n[0]:"reset_required"===o.kind?"admitted_terminal"===o.terminality&&!1===o.retryable&&"never"===o.retry&&null===o.committed_receipt&&1===n.length&&"reset"===n[0]:"unavailable"===o.kind&&"authority"!==o.unavailable_classification?"admitted_terminal"===o.terminality&&!0===o.retryable&&"after_revalidate"===o.retry&&null===o.committed_receipt&&1===n.length&&"retry"===n[0]:"execution_failed"===o.kind?"admitted_terminal"===o.terminality&&!1===o.retryable&&"never"===o.retry&&null===o.committed_receipt&&1===n.length&&"contact_administrator"===n[0]:null===o.committed_receipt)}(i))throw new S8("the daemon returned a malformed problem envelope",{status:e.status,payload:i});let o=void 0===t||(c=[t],"not_found_or_not_authorized"===i.problem.kind?void 0===i.binding_id:c.some(e=>e===i.binding_id));if(e.ok||!o||void 0!==r&&i.request_id!==r||!function(e,t){switch(t){case"invalid_request":return 400===e;case"not_found_or_not_authorized":return 404===e;case"conflict":case"partial_effect":case"stale":return 409===e;case"unsupported":return 422===e;case"unavailable":case"reset_required":return 503===e;case"execution_failed":return 500===e;case"saturated":return 429===e;case"cancelled":return 408===e;case"timed_out":return 504===e;default:return!1}}(e.status,i.problem.kind))throw new S8("the daemon returned a malformed problem envelope",{status:e.status,payload:i});throw function(e,t){switch(t.problem.kind){case"not_found_or_not_authorized":return new ke(e,t);case"unavailable":return new kt(e,t);case"unsupported":return new kr(e,t);case"stale":return new ki(e,t);case"conflict":return new ko(e,t);case"partial_effect":return new kn(e,t);case"reset_required":return new ka(e,t);case"saturated":return new ks(e,t);case"cancelled":return new kd(e,t);case"timed_out":return new kc(e,t);case"invalid_request":return new kl(e,t);default:return new S7(e,t)}}(e.status,i)}return s}finally{i?.removeEventListener("abort",d);try{a||await s()}catch{}finally{o?.releaseLock()}}}async #p(e,t,r={}){var i,o,n,a;let s=e.decodeRequest(t);if("http"!==e.transport.kind){let t;if(void 0!==r.page||void 0!==r.deadlineMicros||void 0!==r.requestId)throw new S5(`${e.operation} does not accept HTTP transport options`);if(void 0===this.mcp)throw new S4(`${e.operation} requires an MCP tool adapter`);try{t=await this.mcp.callTool(e.transport.toolName,s,{signal:r.signal})}catch(t){if(r.signal?.aborted)throw new S6(r.signal.reason??t);throw new S4(`MCP tool ${e.transport.toolName} failed`,t)}try{return e.decodeResult(t)}catch(r){throw new S8(`MCP tool ${e.transport.toolName} returned an invalid ${e.operation} result`,{payload:{response:t,cause:r}})}}let d=this.operationUrl(e.transport.route,r.page),c=JSON.stringify(s);if(void 0===c)throw new S5(`${e.operation} request decoder returned a non-JSON value`);let l=this.headers("application/json");l.set("content-type","application/json");let p=(i=l,o=e,void 0!==(n=r).deadlineMicros&&(!Number.isSafeInteger(n.deadlineMicros)||n.deadlineMicros<=0)?"deadlineMicros must be a positive safe integer":"required"===o.requestIdControl&&void 0===n.requestId?`${o.operation} requires a stable requestId replay handle`:"server_minted"===o.requestIdControl&&void 0!==n.requestId?`${o.operation} uses a server-minted request ID`:void 0===n.requestId||(a=n.requestId).length>0&&a.trim()===a&&S2.encode(a).byteLength<=512&&!/\p{Cc}/u.test(a)?void(void 0!==n.deadlineMicros&&i.set("x-tracedecay-deadline-micros",String(n.deadlineMicros)),void 0!==n.requestId&&i.set("x-tracedecay-request-id",n.requestId)):"requestId is not a canonical request identity");if(void 0!==p)throw new S5(p);let u=await this.fetchResponse(d,{method:e.transport.method,headers:l,body:c,signal:r.signal},r.signal),m=await this.readJson(u,e.bindingId,r.requestId,r.signal);if(!km(m)||"success"!==m.kind)throw new S8("the daemon returned an unknown HTTP envelope",{status:u.status,payload:m});if(!u.ok)throw new S8("the daemon returned success with a failing HTTP status",{status:u.status,payload:m});try{let t=e.decodeSuccess(m.value);if(!(km(t)&&km(t.outcome)&&km(t.outcome.value)&&"payload"in t.outcome.value&&k_(t.outcome.value.execution))||("evidence"===t.outcome.outcome?"completed"===t.outcome.value.execution.termination&&null===t.outcome.value.payload:"preview"!==t.outcome.outcome&&"effect"!==t.outcome.outcome))throw TypeError("decoded application success invariants are invalid");if(void 0!==r.requestId&&t.request_id!==r.requestId)throw TypeError("daemon returned a different application request ID");if("fact_store_curate_receipt"===e.resultSemantics&&!await async function(e,t){if(!fu(e)||!fu(t)||!fu(t.outcome))return!1;let r=t.outcome,i=fu(r.value)?r.value.payload:void 0;if("effect"!==r.outcome||!fu(i)||!fh(t.request_id,512)||"request_digest,run_id,state,task"!==Object.keys(i).sort().join(",")||i.run_id!==t.request_id||"memory_curator"!==i.task||"started"!==i.state)return!1;let o=e.fact_review_limit??24,n=e.min_confidence_millionths??72e4;return!!fm(o)&&!(o<1)&&!(o>1e3)&&!!fm(n)&&!(n>1e6)&&!!await async function(e){return!!fu(e)&&"project_id,reference,repository_id,scope_digest,worktree_id"===Object.keys(e).sort().join(",")&&!!fh(e.project_id,512)&&!!fh(e.repository_id,512)&&!!fh(e.worktree_id,512)&&(null===e.reference||!!fh(e.reference,512))&&e.scope_digest===await fy(["tracedecay.application.scope.v1",e.project_id,e.repository_id,e.worktree_id,e.reference])}(t.scope)&&i.request_digest===await fy(["tracedecay.automation-run.request-identity.v1",{kind:"memory_curator",options:{fact_review_limit:o,min_confidence_millionths:n}}])}(s,t))throw TypeError("automatic curation receipt invariants are invalid");return t}catch(t){throw new S8(`the daemon returned an invalid ${e.operation} success envelope`,{status:u.status,payload:{envelope:m.value,cause:t}})}}async *streamOperation(e,t={}){let r=t.resume?.resumeToken,i=t.resume?.nextSequence===void 0?void 0:function(e,t){let r;if("number"==typeof e){if(!kf(e))throw new S5(`${t} must be an unsigned safe integer`);r=BigInt(e)}else if("bigint"==typeof e)r=e;else if(/^[0-9]+$/.test(e))r=BigInt(e);else throw new S5(`${t} must be unsigned decimal`);if(r<0n||r>0xffffffffffffffffn)throw new S5(`${t} exceeds the canonical u64 range`);return r.toString()}(t.resume.nextSequence,"resume nextSequence");if(void 0!==r&&!ky(r,4096))throw new S5("resumeToken is not a canonical stream resume token");let o=t.maxReconnects??0;if(!Number.isSafeInteger(o)||o<0)throw new S5("maxReconnects must be a non-negative integer");let n=0,a=0;for(;;){let d;if(t.signal?.aborted)throw new S6(t.signal.reason);let c=this.lifecycleUrl(e,"events");void 0!==i&&c.searchParams.set("next_sequence",i),void 0!==r&&c.searchParams.set("resume_token",r);try{d=await this.fetchResponse(c,{method:"GET",headers:this.headers("text/event-stream"),signal:t.signal},t.signal)}catch(e){if(0===n||n>=o||!(e instanceof S3))throw e;n+=1,await kb(a,t.signal);continue}let l=!1;try{if(!d.ok||null===d.body)throw await this.readJson(d,void 0,void 0,t.signal),new S8("the daemon did not open an SSE stream",{status:d.status});if(!kg(d,"text/event-stream"))throw new S8("the daemon opened an operation stream with an invalid media type",{status:d.status});try{for await(let t of k$(d.body)){void 0!==t.retryDelayMs&&(a=t.retryDelayMs);let o=function(e,t,r){let i=kv(e.data,t);if(!km(i)||"string"!=typeof i.event||i.event!==e.event||!km(i.data))throw new S8("the daemon returned a malformed SSE event",{status:t,payload:i});let o=i.event,n=i.data;if("open"===o){let e=n.frontier;if(n.correlation_id!==r||!km(e)||!kf(e.next_sequence)||!kf(e.retained_from_sequence)||e.retained_from_sequence>e.next_sequence||null!==e.resume_token&&"string"!=typeof e.resume_token)throw new S8("the daemon returned a malformed SSE open frontier",{status:t,payload:i});return{event:{...i,event:o,data:n},frontier:{..."string"==typeof e.resume_token?{resumeToken:e.resume_token}:{}}}}if(!kf(n.sequence)||null===e.id)throw new S8("the daemon returned an SSE event without a valid sequence",{status:t,payload:i});let a=String(n.sequence);if(e.id!==a)throw new S8("the SSE event ID does not match its canonical sequence",{status:t,payload:i});if("item"===o&&!("item"in n))throw new S8("the SSE item payload is missing",{status:t,payload:i});if("progress"===o&&(!kf(n.completed)||null!==n.total&&!kf(n.total)))throw new S8("the SSE progress payload is malformed",{status:t,payload:i});if("resume_gap"===o){let e=n.gap;if(!km(e)||!kf(e.first_missing_sequence)||!kf(e.last_missing_sequence)||e.first_missing_sequence!==n.sequence||e.first_missing_sequence>e.last_missing_sequence||!km(e.frontier)||!kf(e.frontier.next_sequence)||!kf(e.frontier.retained_from_sequence)||e.frontier.retained_from_sequence>e.frontier.next_sequence||e.last_missing_sequence>=e.frontier.next_sequence||null!==e.frontier.resume_token&&"string"!=typeof e.frontier.resume_token)throw new S8("the SSE resume gap is malformed",{status:t,payload:i})}if(kp.has(o)){let e=n.terminal;if(!km(e)||!k_(e.receipt))throw new S8("the SSE terminal event is malformed",{status:t,payload:i});if(e.termination!==o||e.receipt.termination!==o)throw new S8("the SSE terminal event is inconsistent",{status:t,payload:i})}let s={...i,event:o,data:n};if("resume_gap"===o){let e=n.gap,t=e.frontier;return{event:s,sequence:a,lastSequence:String(e.last_missing_sequence),frontier:{..."string"==typeof t.resume_token?{resumeToken:t.resume_token}:{}}}}return{event:s,sequence:a}}(t,d.status,e);if(void 0!==o.sequence){var s;let e=i??"0",r=(s=o.lastSequence??o.sequence,(BigInt(s)+1n).toString()),n=kp.has(t.event);if(!n&&BigInt(o.sequence)<BigInt(e))continue;if(o.sequence!==e&&!(n&&r===e))throw new S8("the daemon returned a non-contiguous SSE sequence",{status:d.status,payload:o.event});i=r}else i??="0";if(void 0!==o.frontier&&(r=o.frontier.resumeToken),yield{event:t.event,id:o.sequence??null,data:o.event},kp.has(t.event))return}}catch(e){if(l=!0,e instanceof S5)throw e;if(t.signal?.aborted)throw new S6(t.signal.reason??e);if(n>=o){if(e instanceof S3)throw e;throw new S3(`operation stream disconnected after ${n} reconnects`,e)}}}catch(e){throw l=!0,e}finally{try{await d.body?.cancel()}catch(e){if(!l)throw new S3("failed to close operation stream transport",e)}}if(n>=o)throw new S3(`operation stream ended before a terminal event after ${n} reconnects`);if(void 0===i||void 0===r)throw new S3("operation stream ended before exposing a resumable frontier");n+=1,await kb(a,t.signal)}}async cancelOperation(e,t={}){let r=await this.fetchResponse(this.lifecycleUrl(e,"cancel"),{method:"POST",headers:this.headers("application/json"),signal:t.signal},t.signal),i=await this.readJson(r,void 0,void 0,t.signal);if(!km(i))throw new S8("the daemon returned a malformed cancellation response",{status:r.status,payload:i});let o=i.status,n="requested"===o&&202===r.status||("already_requested"===o||"already_terminal"===o)&&200===r.status;if(!r.ok||"requested"!==o&&"already_requested"!==o&&"already_terminal"!==o||!n)throw new S8("the daemon returned a malformed cancellation response",{status:r.status,payload:i});return{...i,status:o}}}function kk(e){let t=S0.find(t=>t.operation===e);if(void 0===t||"mcp_tool"!==t.transport.kind)throw TypeError(`${e} is not an MCP-backed operation in the canonical catalog`);return t}let kw=kk("project_list"),kP=kk("project_search"),kV=kk("project_context");class kR{#u;constructor(e){this.#u=e}projectList(e,t){return this.#m(kw,e,t)}projectContext(e,t){return this.#m(kV,e,t)}projectSearch(e,t){return this.#m(kP,e,t)}async #m(e,t,r){let i,o=e.transport.toolName,n=e.decodeRequest(t);try{if(r?.aborted||(i=await this.#u(o,n,r),r?.aborted))throw new S6(r.reason)}catch(e){if(r?.aborted)throw new S6(r.reason);throw new S4(`MCP tool ${o} failed`,e)}try{return e.decodeResult(i)}catch(t){throw new S8(`MCP tool ${o} returned an invalid ${e.operation} result`,{payload:{response:i,cause:t}})}}}var kq=Object.create,kI=Object.defineProperty,kx=Object.getOwnPropertyDescriptor,kj=Object.getOwnPropertyNames,kC=Object.getPrototypeOf,kT=Object.prototype.hasOwnProperty,kO=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);let kE=new Set(["https://json-schema.org/draft/2020-12/schema","http://json-schema.org/draft/2020-12/schema"]),kA=new Set(["https://json-schema.org/draft/2019-09/schema","http://json-schema.org/draft/2019-09/schema"]),kW=new Set(["https://json-schema.org/draft-07/schema","http://json-schema.org/draft-07/schema"]),kM=new Set(["https://json-schema.org/draft-06/schema","http://json-schema.org/draft-06/schema"]),kN=Symbol.for("mcp.sdk.errorBrands");function kz(e,t){let r=new Set,i=t;for(;"function"==typeof i;){let e=i.mcpBrand;Object.prototype.hasOwnProperty.call(i,"mcpBrand")&&"string"==typeof e&&r.add(e),i=Object.getPrototypeOf(i)}0!==r.size&&Object.defineProperty(e,kN,{value:r,enumerable:!1,configurable:!0})}function kD(e,t){try{if("object"==typeof t&&null!==t&&Object.prototype.hasOwnProperty.call(e,"mcpBrand")&&"string"==typeof e.mcpBrand&&Object.prototype.hasOwnProperty.call(t,kN)){let r=t[kN];if(r&&"function"==typeof r.has&&r.has(e.mcpBrand))return!0}}catch{}return Function.prototype[Symbol.hasInstance].call(e,t)}(class e extends Error{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.OAuthError"})}static[Symbol.hasInstance](e){return kD(this,e)}static isInstance(e){if("function"!=typeof this)throw TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");return kD(this,e)}constructor(e,t,r){super(t),this.code=e,this.errorUri=r,this.name="OAuthError",kz(this,new.target)}toResponseObject(){let e={error:this.code,error_description:this.message};return this.errorUri&&(e.error_uri=this.errorUri),e}static fromResponse(t){return new e(t.error,t.error_description??t.error,t.error_uri)}});let kF=((X={}).NotConnected="NOT_CONNECTED",X.AlreadyConnected="ALREADY_CONNECTED",X.NotInitialized="NOT_INITIALIZED",X.CapabilityNotSupported="CAPABILITY_NOT_SUPPORTED",X.RequestTimeout="REQUEST_TIMEOUT",X.ConnectionClosed="CONNECTION_CLOSED",X.SendFailed="SEND_FAILED",X.InvalidResult="INVALID_RESULT",X.UnsupportedResultType="UNSUPPORTED_RESULT_TYPE",X.InputRequiredRoundsExceeded="INPUT_REQUIRED_ROUNDS_EXCEEDED",X.ListPaginationExceeded="LIST_PAGINATION_EXCEEDED",X.MethodNotSupportedByProtocolVersion="METHOD_NOT_SUPPORTED_BY_PROTOCOL_VERSION",X.EraNegotiationFailed="ERA_NEGOTIATION_FAILED",X.ClientHttpNotImplemented="CLIENT_HTTP_NOT_IMPLEMENTED",X.ClientHttpAuthentication="CLIENT_HTTP_AUTHENTICATION",X.ClientHttpForbidden="CLIENT_HTTP_FORBIDDEN",X.ClientHttpUnexpectedContent="CLIENT_HTTP_UNEXPECTED_CONTENT",X.ClientHttpFailedToOpenStream="CLIENT_HTTP_FAILED_TO_OPEN_STREAM",X.ClientHttpFailedToTerminateSession="CLIENT_HTTP_FAILED_TO_TERMINATE_SESSION",X);var kL=class extends Error{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.SdkError"})}static[Symbol.hasInstance](e){return kD(this,e)}static isInstance(e){if("function"!=typeof this)throw TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");return kD(this,e)}constructor(e,t,r,i){super(t,i),this.code=e,this.data=r,this.name="SdkError",kz(this,new.target)}},kU=class extends kL{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.SdkHttpError"})}constructor(e,t,r,i){super(e,t,r,i),this.name="SdkHttpError"}get status(){return this.data.status}get statusText(){return this.data.statusText}};let kH="2026-07-28",kG=[kH];function kB(e){return e.filter(e=>!(e>=kH))}function kK(e){return e.filter(e=>e>=kH)}function kJ(e){let t=e.structuredContent;return void 0===t||!("object"!=typeof t||null===t||Array.isArray(t))||e.content?.some(e=>"text"===e.type)?e:{...e,content:[...e.content??[],{type:"text",text:JSON.stringify(t)}]}}let kZ=["task","inputRequests","requestState"];function kQ(e){return null===e||"object"!=typeof e||Array.isArray(e)||void 0!==e.content||kZ.some(t=>t in e)?e:{...e,content:[]}}function kX(){let e,t,r,i,o,n,a,s,c,l,p,u,m,f,h,y,g,_,v,b,$,S,k,w,P,V,R,q,I,x,j,C,T,O,E,A,W,M,N,z,D,F,L,U,H,G,B,K,J,Z,Q,X,Y,ee,et,er,ei,eo,en,ea,es,ed,ec,el,ep,eu,em,ef,eh,ey,eg,e_,ev,eb,e$,eS,ek,ew,eP,eV,eR,eq,eI,ex,ej,eC,eT,eO,eE,eA,eW,eM,eN,ez,eD,eF,eL,eU,eH,eG,eB,eK,eJ,eZ,eQ,eX,eY,e1,e0,e2,e4,e6,e3,e9,e5,e8,e7,te,tt,tr,ti,to,tn,ta,ts,td,tc,tl,tp,tu,tm,tf,th,ty,tg,t_,tv,tb,t$,tS;return d??=(e=ao(()=>nD([o5(),nk(),nR(),nI(),nB(o5(),e),nA(e)])),t=nB(o5(),e),r=nD([o5(),nk().int()]),i=o5(),o=nM({ttl:nk().optional()}),n=nM({taskId:o5()}),c=(s=nM({_meta:(a=nN({progressToken:r.optional(),"io.modelcontextprotocol/related-task":n.optional()})).optional()})).extend({task:o.optional()}),l=nM({method:o5(),params:s.loose().optional()}),p=nM({_meta:a.optional()}),u=nM({method:o5(),params:p.loose().optional()}),m=nN({_meta:a.optional()}),f=nD([o5(),nk().int()]),h=m.strict(),y=p.extend({requestId:f.optional(),reason:o5().optional()}),g=u.extend({method:nQ("notifications/cancelled"),params:y}),_=nM({src:o5(),mimeType:o5().optional(),sizes:nA(o5()).optional(),theme:nJ(["light","dark"]).optional()}),v=nM({icons:nA(_).optional()}),$=(b=nM({name:o5(),title:o5().optional()})).extend({...b.shape,...v.shape,version:o5(),websiteUrl:o5().optional(),description:o5().optional()}),S=nH(nM({applyDefaults:nR().optional()}),t),k=aa(e=>e&&"object"==typeof e&&!Array.isArray(e)&&0===Object.keys(e).length?{form:{}}:e,nH(nM({form:S.optional(),url:t.optional()}),t.optional())),w=nN({list:t.optional(),cancel:t.optional(),requests:nN({sampling:nN({createMessage:t.optional()}).optional(),elicitation:nN({create:t.optional()}).optional()}).optional()}),P=nN({list:t.optional(),cancel:t.optional(),requests:nN({tools:nN({call:t.optional()}).optional()}).optional()}),V=nM({experimental:nB(o5(),t).optional(),sampling:nM({context:t.optional(),tools:t.optional()}).optional(),elicitation:k.optional(),roots:nM({listChanged:nR().optional()}).optional(),tasks:w.optional(),extensions:nB(o5(),t).optional()}),R=s.extend({protocolVersion:o5(),capabilities:V,clientInfo:$}),q=l.extend({method:nQ("initialize"),params:R}),I=nM({experimental:nB(o5(),t).optional(),logging:t.optional(),completions:t.optional(),prompts:nM({listChanged:nR().optional()}).optional(),resources:nM({subscribe:nR().optional(),listChanged:nR().optional()}).optional(),tools:nM({listChanged:nR().optional()}).optional(),tasks:P.optional(),extensions:nB(o5(),t).optional()}),x=m.extend({protocolVersion:o5(),capabilities:I,serverInfo:$,instructions:o5().optional()}),j=u.extend({method:nQ("notifications/initialized"),params:p.optional()}),C=l.extend({method:nQ("ping"),params:s.optional()}),T=nM({progress:nk(),total:n0(nk()),message:n0(o5())}),O=nM({...p.shape,...T.shape,progressToken:r}),E=u.extend({method:nQ("notifications/progress"),params:O}),A=s.extend({cursor:i.optional()}),W=l.extend({params:A.optional()}),M=m.extend({nextCursor:i.optional()}),z=(N=nM({uri:o5(),mimeType:n0(o5()),_meta:nB(o5(),nT()).optional()})).extend({text:o5()}),D=o5().refine(e=>{try{return atob(e),!0}catch{return!1}},{message:"Invalid Base64 string"}),F=N.extend({blob:D}),U=nM({audience:nA(L=nJ(["user","assistant"])).optional(),priority:nk().min(0).max(1).optional(),lastModified:as({offset:!0}).optional()}),H=nM({...b.shape,...v.shape,uri:o5(),description:n0(o5()),mimeType:n0(o5()),size:n0(nk()),annotations:U.optional(),_meta:n0(nN({}))}),G=nM({...b.shape,...v.shape,uriTemplate:o5(),description:n0(o5()),mimeType:n0(o5()),annotations:U.optional(),_meta:n0(nN({}))}),B=W.extend({method:nQ("resources/list")}),K=M.extend({resources:nA(H)}),J=W.extend({method:nQ("resources/templates/list")}),Z=M.extend({resourceTemplates:nA(G)}),Q=s.extend({uri:o5()}),X=l.extend({method:nQ("resources/read"),params:Q}),Y=m.extend({contents:nA(nD([z,F]))}),ee=u.extend({method:nQ("notifications/resources/list_changed"),params:p.optional()}),et=l.extend({method:nQ("resources/subscribe"),params:Q}),er=l.extend({method:nQ("resources/unsubscribe"),params:Q}),ei=p.extend({uri:o5()}),eo=u.extend({method:nQ("notifications/resources/updated"),params:ei}),en=nM({name:o5(),description:n0(o5()),required:n0(nR())}),ea=nM({...b.shape,...v.shape,description:n0(o5()),arguments:n0(nA(en)),_meta:n0(nN({}))}),es=W.extend({method:nQ("prompts/list")}),ed=M.extend({prompts:nA(ea)}),ec=s.extend({name:o5(),arguments:nB(o5(),o5()).optional()}),el=l.extend({method:nQ("prompts/get"),params:ec}),ep=nM({type:nQ("text"),text:o5(),annotations:U.optional(),_meta:nB(o5(),nT()).optional()}),eu=nM({type:nQ("image"),data:D,mimeType:o5(),annotations:U.optional(),_meta:nB(o5(),nT()).optional()}),em=nM({type:nQ("audio"),data:D,mimeType:o5(),annotations:U.optional(),_meta:nB(o5(),nT()).optional()}),ef=nM({type:nQ("tool_use"),name:o5(),id:o5(),input:nB(o5(),nT()),_meta:nB(o5(),nT()).optional()}),eh=nM({type:nQ("resource"),resource:nD([z,F]),annotations:U.optional(),_meta:nB(o5(),nT()).optional()}),e_=nM({role:L,content:eg=nD([ep,eu,em,ey=H.extend({type:nQ("resource_link")}),eh])}),ev=m.extend({description:o5().optional(),messages:nA(e_)}),eb=u.extend({method:nQ("notifications/prompts/list_changed"),params:p.optional()}),e$=nM({title:o5().optional(),readOnlyHint:nR().optional(),destructiveHint:nR().optional(),idempotentHint:nR().optional(),openWorldHint:nR().optional()}),eS=nM({taskSupport:nJ(["required","optional","forbidden"]).optional()}),ek=nM({...b.shape,...v.shape,description:o5().optional(),inputSchema:nM({type:nQ("object"),properties:nB(o5(),e).optional(),required:nA(o5()).optional()}).catchall(nT()),outputSchema:nM({type:nQ("object"),properties:nB(o5(),e).optional(),required:nA(o5()).optional()}).catchall(nT()).optional(),annotations:e$.optional(),execution:eS.optional(),_meta:nB(o5(),nT()).optional()}),ew=W.extend({method:nQ("tools/list")}),eP=M.extend({tools:nA(ek)}),eV=m.extend({content:nA(eg),structuredContent:nB(o5(),nT()).optional(),isError:nR().optional()}),eR=c.extend({name:o5(),arguments:nB(o5(),nT()).optional()}),eq=l.extend({method:nQ("tools/call"),params:eR}),eI=u.extend({method:nQ("notifications/tools/list_changed"),params:p.optional()}),ex=nJ(["debug","info","notice","warning","error","critical","alert","emergency"]),ej=s.extend({level:ex}),eC=l.extend({method:nQ("logging/setLevel"),params:ej}),eT=p.extend({level:ex,logger:o5().optional(),data:nT()}),eO=u.extend({method:nQ("notifications/message"),params:eT}),eE=nM({name:o5().optional()}),eA=nM({hints:nA(eE).optional(),costPriority:nk().min(0).max(1).optional(),speedPriority:nk().min(0).max(1).optional(),intelligencePriority:nk().min(0).max(1).optional()}),eW=nM({mode:nJ(["auto","required","none"]).optional()}),eM=nM({type:nQ("tool_result"),toolUseId:o5().describe("The unique identifier for the corresponding tool call."),content:nA(eg),structuredContent:nM({}).loose().optional(),isError:nR().optional(),_meta:nB(o5(),nT()).optional()}),eN=nL("type",[ep,eu,em]),eD=nM({role:L,content:nD([ez=nL("type",[ep,eu,em,ef,eM]),nA(ez)]),_meta:nB(o5(),nT()).optional()}),eF=c.extend({messages:nA(eD),modelPreferences:eA.optional(),systemPrompt:o5().optional(),includeContext:nJ(["none","thisServer","allServers"]).optional(),temperature:nk().optional(),maxTokens:nk().int(),stopSequences:nA(o5()).optional(),metadata:t.optional(),tools:nA(ek).optional(),toolChoice:eW.optional()}),eL=l.extend({method:nQ("sampling/createMessage"),params:eF}),eU=m.extend({model:o5(),stopReason:n0(nJ(["endTurn","stopSequence","maxTokens"]).or(o5())),role:L,content:eN}),eH=m.extend({model:o5(),stopReason:n0(nJ(["endTurn","stopSequence","maxTokens","toolUse"]).or(o5())),role:L,content:nD([ez,nA(ez)])}),eG=nM({type:nQ("boolean"),title:o5().optional(),description:o5().optional(),default:nR().optional()}),eB=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),minLength:nk().optional(),maxLength:nk().optional(),format:nJ(["email","uri","date","date-time"]).optional(),default:o5().optional()}),eK=nM({type:nJ(["number","integer"]),title:o5().optional(),description:o5().optional(),minimum:nk().optional(),maximum:nk().optional(),default:nk().optional()}),eJ=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),enum:nA(o5()),default:o5().optional()}),eZ=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),oneOf:nA(nM({const:o5(),title:o5()})),default:o5().optional()}),eQ=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),enum:nA(o5()),enumNames:nA(o5()).optional(),default:o5().optional()}),eX=nD([eJ,eZ]),eY=nM({type:nQ("array"),title:o5().optional(),description:o5().optional(),minItems:nk().optional(),maxItems:nk().optional(),items:nM({type:nQ("string"),enum:nA(o5())}),default:nA(o5()).optional()}),e0=nD([eY,e1=nM({type:nQ("array"),title:o5().optional(),description:o5().optional(),minItems:nk().optional(),maxItems:nk().optional(),items:nM({anyOf:nA(nM({const:o5(),title:o5()}))}),default:nA(o5()).optional()})]),e2=nD([eQ,eX,e0]),e4=nD([e2,eG,eB,eK]),e6=c.extend({mode:nQ("form").optional(),message:o5(),requestedSchema:nM({type:nQ("object"),properties:nB(o5(),e4),required:nA(o5()).optional()}).catchall(nT())}),e9=nD([e6,e3=c.extend({mode:nQ("url"),message:o5(),elicitationId:o5(),url:o5().url()})]),e5=l.extend({method:nQ("elicitation/create"),params:e9}),e8=p.extend({elicitationId:o5()}),e7=u.extend({method:nQ("notifications/elicitation/complete"),params:e8}),te=m.extend({action:nJ(["accept","decline","cancel"]),content:aa(e=>null===e?void 0:e,nB(o5(),nD([o5(),nk(),nR(),nA(o5())])).optional())}),tt=nM({type:nQ("ref/resource"),uri:o5()}),tr=nM({type:nQ("ref/prompt"),name:o5()}),ti=s.extend({ref:nD([tr,tt]),argument:nM({name:o5(),value:o5()}),context:nM({arguments:nB(o5(),o5()).optional()}).optional()}),to=l.extend({method:nQ("completion/complete"),params:ti}),tn=m.extend({completion:nN({values:nA(o5()).max(100),total:n0(nk().int()),hasMore:n0(nR())})}),ta=nM({uri:o5().startsWith("file://"),name:o5().optional(),_meta:nB(o5(),nT()).optional()}),ts=l.extend({method:nQ("roots/list"),params:s.optional()}),td=m.extend({roots:nA(ta)}),tc=u.extend({method:nQ("notifications/roots/list_changed"),params:p.optional()}),tl=nN({ttl:nk().optional(),pollInterval:nk().optional()}),tp=nJ(["working","input_required","completed","failed","cancelled"]),tu=nM({taskId:o5(),status:tp,ttl:nD([nk(),nI()]),createdAt:o5(),lastUpdatedAt:o5(),pollInterval:n0(nk()),statusMessage:n0(o5())}),tm=m.extend({task:tu}),tf=p.merge(tu),th=u.extend({method:nQ("notifications/tasks/status"),params:tf}),ty=l.extend({method:nQ("tasks/get"),params:s.extend({taskId:o5()})}),tg=m.merge(tu),t_=l.extend({method:nQ("tasks/result"),params:s.extend({taskId:o5()})}),tv=m.loose(),tb=W.extend({method:nQ("tasks/list")}),t$=M.extend({tasks:nA(tu)}),tS=l.extend({method:nQ("tasks/cancel"),params:s.extend({taskId:o5()})}),{JSONValueSchema:e,JSONObjectSchema:t,ProgressTokenSchema:r,CursorSchema:i,TaskMetadataSchema:o,RelatedTaskMetadataSchema:n,RequestMetaSchema:a,BaseRequestParamsSchema:s,TaskAugmentedRequestParamsSchema:c,RequestSchema:l,NotificationsParamsSchema:p,NotificationSchema:u,ResultSchema:m,RequestIdSchema:f,EmptyResultSchema:h,CancelledNotificationParamsSchema:y,CancelledNotificationSchema:g,IconSchema:_,IconsSchema:v,BaseMetadataSchema:b,ImplementationSchema:$,ClientTasksCapabilitySchema:w,ServerTasksCapabilitySchema:P,ClientCapabilitiesSchema:V,InitializeRequestParamsSchema:R,InitializeRequestSchema:q,ServerCapabilitiesSchema:I,InitializeResultSchema:x,InitializedNotificationSchema:j,PingRequestSchema:C,ProgressSchema:T,ProgressNotificationParamsSchema:O,ProgressNotificationSchema:E,PaginatedRequestParamsSchema:A,PaginatedRequestSchema:W,PaginatedResultSchema:M,ResourceContentsSchema:N,TextResourceContentsSchema:z,BlobResourceContentsSchema:F,RoleSchema:L,AnnotationsSchema:U,ResourceSchema:H,ResourceTemplateSchema:G,ListResourcesRequestSchema:B,ListResourcesResultSchema:K,ListResourceTemplatesRequestSchema:J,ListResourceTemplatesResultSchema:Z,ResourceRequestParamsSchema:Q,ReadResourceRequestParamsSchema:Q,ReadResourceRequestSchema:X,ReadResourceResultSchema:Y,ResourceListChangedNotificationSchema:ee,SubscribeRequestParamsSchema:Q,SubscribeRequestSchema:et,UnsubscribeRequestParamsSchema:Q,UnsubscribeRequestSchema:er,ResourceUpdatedNotificationParamsSchema:ei,ResourceUpdatedNotificationSchema:eo,PromptArgumentSchema:en,PromptSchema:ea,ListPromptsRequestSchema:es,ListPromptsResultSchema:ed,GetPromptRequestParamsSchema:ec,GetPromptRequestSchema:el,TextContentSchema:ep,ImageContentSchema:eu,AudioContentSchema:em,ToolUseContentSchema:ef,EmbeddedResourceSchema:eh,ResourceLinkSchema:ey,ContentBlockSchema:eg,PromptMessageSchema:e_,GetPromptResultSchema:ev,PromptListChangedNotificationSchema:eb,ToolAnnotationsSchema:e$,ToolExecutionSchema:eS,ToolSchema:ek,ListToolsRequestSchema:ew,ListToolsResultSchema:eP,CallToolResultSchema:eV,CallToolRequestParamsSchema:eR,CallToolRequestSchema:eq,ToolListChangedNotificationSchema:eI,LoggingLevelSchema:ex,SetLevelRequestParamsSchema:ej,SetLevelRequestSchema:eC,LoggingMessageNotificationParamsSchema:eT,LoggingMessageNotificationSchema:eO,ModelHintSchema:eE,ModelPreferencesSchema:eA,ToolChoiceSchema:eW,ToolResultContentSchema:eM,SamplingContentSchema:eN,SamplingMessageContentBlockSchema:ez,SamplingMessageSchema:eD,CreateMessageRequestParamsSchema:eF,CreateMessageRequestSchema:eL,CreateMessageResultSchema:eU,CreateMessageResultWithToolsSchema:eH,BooleanSchemaSchema:eG,StringSchemaSchema:eB,NumberSchemaSchema:eK,UntitledSingleSelectEnumSchemaSchema:eJ,TitledSingleSelectEnumSchemaSchema:eZ,LegacyTitledEnumSchemaSchema:eQ,SingleSelectEnumSchemaSchema:eX,UntitledMultiSelectEnumSchemaSchema:eY,TitledMultiSelectEnumSchemaSchema:e1,MultiSelectEnumSchemaSchema:e0,EnumSchemaSchema:e2,PrimitiveSchemaDefinitionSchema:e4,ElicitRequestFormParamsSchema:e6,ElicitRequestURLParamsSchema:e3,ElicitRequestParamsSchema:e9,ElicitRequestSchema:e5,ElicitationCompleteNotificationParamsSchema:e8,ElicitationCompleteNotificationSchema:e7,ElicitResultSchema:te,ResourceTemplateReferenceSchema:tt,PromptReferenceSchema:tr,CompleteRequestParamsSchema:ti,CompleteRequestSchema:to,CompleteResultSchema:tn,RootSchema:ta,ListRootsRequestSchema:ts,ListRootsResultSchema:td,RootsListChangedNotificationSchema:tc,TaskCreationParamsSchema:tl,TaskStatusSchema:tp,TaskSchema:tu,CreateTaskResultSchema:tm,TaskStatusNotificationParamsSchema:tf,TaskStatusNotificationSchema:th,GetTaskRequestSchema:ty,GetTaskResultSchema:tg,GetTaskPayloadRequestSchema:t_,GetTaskPayloadResultSchema:tv,ListTasksRequestSchema:tb,ListTasksResultSchema:t$,CancelTaskRequestSchema:tS,CancelTaskResultSchema:m.merge(tu),ClientRequestSchema:nD([C,q,to,eC,el,es,B,J,X,et,er,eq,ew,ty,t_,tb,tS]),ClientNotificationSchema:nD([g,E,j,tc,th]),ClientResultSchema:nD([h,eU,eH,te,td,tg,t$,tm]),ServerRequestSchema:nD([C,eL,e5,ts,ty,t_,tb,tS]),ServerNotificationSchema:nD([g,E,eO,eo,ee,eI,eb,th,e7]),ServerResultSchema:nD([h,x,tn,ev,ed,K,Z,Y,eV,eP,tg,t$,tm]),CallToolResultWireSchema:nT().superRefine((e,t)=>{if(!("object"!=typeof e||null===e||Array.isArray(e))&&void 0===e.content){for(let r of kZ)if(r in e)return void t.addIssue({code:"custom",message:`content is required when the body carries '${r}' — another result family cannot default into an empty tools/call success`})}}).transform(kQ).pipe(eV)})}function kY(e){return"object"!==e.type}let k1=new Set(["const","enum","default","examples"]),k0=new Set(["properties","patternProperties","$defs","definitions","dependentSchemas","dependencies"]);function k2(e){return void 0!==e&&!("string"==typeof e&&e.startsWith("#"))}let k4={ping:null,initialize:null,"completion/complete":null,"logging/setLevel":null,"prompts/get":null,"prompts/list":null,"resources/list":null,"resources/templates/list":null,"resources/read":null,"resources/subscribe":null,"resources/unsubscribe":null,"tools/call":null,"tools/list":null,"tasks/get":null,"tasks/result":null,"tasks/list":null,"tasks/cancel":null,"sampling/createMessage":null,"elicitation/create":null,"roots/list":null},k6={"notifications/cancelled":null,"notifications/progress":null,"notifications/initialized":null,"notifications/roots/list_changed":null,"notifications/tasks/status":null,"notifications/message":null,"notifications/resources/updated":null,"notifications/resources/list_changed":null,"notifications/tools/list_changed":null,"notifications/prompts/list_changed":null,"notifications/elicitation/complete":null},k3={ping:null,initialize:null,"completion/complete":null,"logging/setLevel":null,"prompts/get":null,"prompts/list":null,"resources/list":null,"resources/templates/list":null,"resources/read":null,"resources/subscribe":null,"resources/unsubscribe":null,"tools/call":null,"tools/list":null,"sampling/createMessage":null,"elicitation/create":null,"roots/list":null};function k9(){if(c)return c;let e=kX();return c={requestSchemas:{ping:e.PingRequestSchema,initialize:e.InitializeRequestSchema,"completion/complete":e.CompleteRequestSchema,"logging/setLevel":e.SetLevelRequestSchema,"prompts/get":e.GetPromptRequestSchema,"prompts/list":e.ListPromptsRequestSchema,"resources/list":e.ListResourcesRequestSchema,"resources/templates/list":e.ListResourceTemplatesRequestSchema,"resources/read":e.ReadResourceRequestSchema,"resources/subscribe":e.SubscribeRequestSchema,"resources/unsubscribe":e.UnsubscribeRequestSchema,"tools/call":e.CallToolRequestSchema,"tools/list":e.ListToolsRequestSchema,"tasks/get":e.GetTaskRequestSchema,"tasks/result":e.GetTaskPayloadRequestSchema,"tasks/list":e.ListTasksRequestSchema,"tasks/cancel":e.CancelTaskRequestSchema,"sampling/createMessage":e.CreateMessageRequestSchema,"elicitation/create":e.ElicitRequestSchema,"roots/list":e.ListRootsRequestSchema},notificationSchemas:{"notifications/cancelled":e.CancelledNotificationSchema,"notifications/progress":e.ProgressNotificationSchema,"notifications/initialized":e.InitializedNotificationSchema,"notifications/roots/list_changed":e.RootsListChangedNotificationSchema,"notifications/tasks/status":e.TaskStatusNotificationSchema,"notifications/message":e.LoggingMessageNotificationSchema,"notifications/resources/updated":e.ResourceUpdatedNotificationSchema,"notifications/resources/list_changed":e.ResourceListChangedNotificationSchema,"notifications/tools/list_changed":e.ToolListChangedNotificationSchema,"notifications/prompts/list_changed":e.PromptListChangedNotificationSchema,"notifications/elicitation/complete":e.ElicitationCompleteNotificationSchema},resultSchemas:{ping:e.EmptyResultSchema,initialize:e.InitializeResultSchema,"completion/complete":e.CompleteResultSchema,"logging/setLevel":e.EmptyResultSchema,"prompts/get":e.GetPromptResultSchema,"prompts/list":e.ListPromptsResultSchema,"resources/list":e.ListResourcesResultSchema,"resources/templates/list":e.ListResourceTemplatesResultSchema,"resources/read":e.ReadResourceResultSchema,"resources/subscribe":e.EmptyResultSchema,"resources/unsubscribe":e.EmptyResultSchema,"tools/call":e.CallToolResultWireSchema,"tools/list":e.ListToolsResultSchema,"sampling/createMessage":e.CreateMessageResultWithToolsSchema,"elicitation/create":e.ElicitResultSchema,"roots/list":e.ListRootsResultSchema}}}function k5(e){return Object.prototype.hasOwnProperty.call(k4,e)}function k8(e){return Object.prototype.hasOwnProperty.call(k6,e)}function k7(e){return null!==e&&"object"==typeof e&&!Array.isArray(e)}function we(e,t){if(void 0===e)return{ok:!1,reason:"not-in-era"};let r=e.safeParse(t);return r.success?{ok:!0,value:r.data}:{ok:!1,reason:"invalid",message:String(r.error)}}Object.keys(k4),Object.keys(k6);let wt={ok:!1,reason:"not-in-era"};function wr(e){return k7(e)&&k7(e.outputSchema)&&kY(e.outputSchema)}let wi={era:"2025-11-25",hasRequestMethod:k5,hasNotificationMethod:k8,validateRequest:(e,t)=>we(k5(e)?k9().requestSchemas[e]:void 0,t),validateResult:(e,t)=>we(Object.prototype.hasOwnProperty.call(k3,e)?k9().resultSchemas[e]:void 0,t),validateNotification:(e,t)=>we(k8(e)?k9().notificationSchemas[e]:void 0,t),hasInputRequestMethod:()=>!1,validateInputRequest:()=>wt,validateInputResponse:()=>wt,samplingResultVariant:(e,t)=>{let r=kX();return we(e?r.CreateMessageResultWithToolsSchema:r.CreateMessageResultSchema,t)},outboundEnvelope:e=>void 0,validateEnvelopeMeta:e=>[],projectCallToolResult(e,t){let r=kJ(e),i=r.structuredContent;if(void 0===i)return r;let o="object"!=typeof i||null===i||Array.isArray(i),n=void 0!==t&&kY(t);return o||n?{...r,structuredContent:{result:i}}:r},decodeResult(e,t){if(k7(t)&&"resultType"in t){let e={...t};return delete e.resultType,{kind:"complete",result:e}}return{kind:"complete",result:t}},encodeResult(e,t){if("tools/list"!==e)return t;let r=t.tools;return Array.isArray(r)&&r.some(e=>wr(e))?{...t,tools:r.map(e=>wr(e)?{...e,outputSchema:function(e){var t;let r="string"==typeof e.$schema?e.$schema:void 0;if(k2(e.$id))return{...void 0!==r&&{$schema:r},type:"object",properties:{result:e},required:["result"]};let i="string"==typeof(t=e.$schema)&&kA.has(t.replace(/#$/,""))&&!0!==e.$recursiveAnchor,o=(e,t)=>{if(Array.isArray(e))return e.map(e=>o(e,!1));if(null===e||"object"!=typeof e||!t&&k2(e.$id))return e;let r={},n=!1;for(let[a,s]of Object.entries(e))t?r[a]=o(s,!1):("$ref"===a||"$dynamicRef"===a)&&"string"==typeof s?r[a]="#"===s?"#/properties/result":s.startsWith("#/")?`#/properties/result${s.slice(1)}`:s:"$recursiveRef"===a&&"#"===s&&i?n=!0:k1.has(a)?r[a]=s:k0.has(a)?r[a]=o(s,!0):r[a]=o(s,!1);return n&&("$ref"in r?r.allOf=[...Array.isArray(r.allOf)?r.allOf:[],{$ref:"#/properties/result"}]:r.$ref="#/properties/result"),r};return{...void 0!==r&&{$schema:r},type:"object",properties:{result:o(e,!1)},required:["result"]}}(e.outputSchema)}:e)}:t},encodeErrorCode:e=>-32002===e?-32602:e,checkInboundEnvelope:e=>void 0};function wo(){return l??=function(){let e=ao(()=>nD([o5(),nk(),nR(),nI(),nB(o5(),e),nA(e)])),t=nB(o5(),e),r=nD([o5(),nk().int()]),i=o5(),o=nD([o5(),nk().int()]),n=nJ(["user","assistant"]),a=nJ(["debug","info","notice","warning","error","critical","alert","emergency"]),s=o5().refine(e=>{try{return atob(e),!0}catch{return!1}},{message:"Invalid Base64 string"}),d=nM({ttl:nk().optional()}),c=nM({taskId:o5()}),l=nN({progressToken:r.optional(),"io.modelcontextprotocol/related-task":c.optional()}),p=nM({_meta:l.optional()}),u=p.extend({task:d.optional()}),m=nM({_meta:l.optional()}),f=nM({method:o5(),params:m.loose().optional()}),h=nM({src:o5(),mimeType:o5().optional(),sizes:nA(o5()).optional(),theme:nJ(["light","dark"]).optional()}),y=nM({icons:nA(h).optional()}),g=nM({name:o5(),title:o5().optional()}),_=g.extend({...g.shape,...y.shape,version:o5(),websiteUrl:o5().optional(),description:o5().optional()}),v=nH(nM({applyDefaults:nR().optional()}),t),b=aa(e=>e&&"object"==typeof e&&!Array.isArray(e)&&0===Object.keys(e).length?{form:{}}:e,nH(nM({form:v.optional(),url:t.optional()}),t.optional())),$=nN({list:t.optional(),cancel:t.optional(),requests:nN({sampling:nN({createMessage:t.optional()}).optional(),elicitation:nN({create:t.optional()}).optional()}).optional()}),S=nN({list:t.optional(),cancel:t.optional(),requests:nN({tools:nN({call:t.optional()}).optional()}).optional()}),k=nM({experimental:nB(o5(),t).optional(),sampling:nM({context:t.optional(),tools:t.optional()}).optional(),elicitation:b.optional(),roots:nM({listChanged:nR().optional()}).optional(),tasks:$.optional(),extensions:nB(o5(),t).optional()}),w=nM({experimental:nB(o5(),t).optional(),logging:t.optional(),completions:t.optional(),prompts:nM({listChanged:nR().optional()}).optional(),resources:nM({subscribe:nR().optional(),listChanged:nR().optional()}).optional(),tools:nM({listChanged:nR().optional()}).optional(),tasks:S.optional(),extensions:nB(o5(),t).optional()}),P=nM({progress:nk(),total:n0(nk()),message:n0(o5())}),V=nM({...m.shape,...P.shape,progressToken:r}),R=f.extend({method:nQ("notifications/progress"),params:V}),q=m.extend({level:a,logger:o5().optional(),data:nT()}),I=f.extend({method:nQ("notifications/message"),params:q}),x=nM({uri:o5(),mimeType:n0(o5()),_meta:nB(o5(),nT()).optional()}),j=x.extend({text:o5()}),C=x.extend({blob:s}),T=nM({audience:nA(n).optional(),priority:nk().min(0).max(1).optional(),lastModified:as({offset:!0}).optional()}),O=nM({...g.shape,...y.shape,uri:o5(),description:n0(o5()),mimeType:n0(o5()),size:n0(nk()),annotations:T.optional(),_meta:n0(nN({}))}),E=nM({...g.shape,...y.shape,uriTemplate:o5(),description:n0(o5()),mimeType:n0(o5()),annotations:T.optional(),_meta:n0(nN({}))}),A=f.extend({method:nQ("notifications/resources/list_changed"),params:m.optional()}),W=m.extend({uri:o5()}),M=f.extend({method:nQ("notifications/resources/updated"),params:W}),N=nM({name:o5(),description:n0(o5()),required:n0(nR())}),z=nM({...g.shape,...y.shape,description:n0(o5()),arguments:n0(nA(N)),_meta:n0(nN({}))}),D=f.extend({method:nQ("notifications/prompts/list_changed"),params:m.optional()}),F=nM({type:nQ("text"),text:o5(),annotations:T.optional(),_meta:nB(o5(),nT()).optional()}),L=nM({type:nQ("image"),data:s,mimeType:o5(),annotations:T.optional(),_meta:nB(o5(),nT()).optional()}),U=nM({type:nQ("audio"),data:s,mimeType:o5(),annotations:T.optional(),_meta:nB(o5(),nT()).optional()}),H=nM({type:nQ("tool_use"),name:o5(),id:o5(),input:nB(o5(),nT()),_meta:nB(o5(),nT()).optional()}),G=nM({type:nQ("resource"),resource:nD([j,C]),annotations:T.optional(),_meta:nB(o5(),nT()).optional()}),B=O.extend({type:nQ("resource_link")}),K=nD([F,L,U,B,G]),J=nM({role:n,content:K}),Z=nM({title:o5().optional(),readOnlyHint:nR().optional(),destructiveHint:nR().optional(),idempotentHint:nR().optional(),openWorldHint:nR().optional()}),Q=f.extend({method:nQ("notifications/tools/list_changed"),params:m.optional()}),X=nM({name:o5().optional()}),Y=nM({hints:nA(X).optional(),costPriority:nk().min(0).max(1).optional(),speedPriority:nk().min(0).max(1).optional(),intelligencePriority:nk().min(0).max(1).optional()}),ee=nM({mode:nJ(["auto","required","none"]).optional()}),et=nM({type:nQ("boolean"),title:o5().optional(),description:o5().optional(),default:nR().optional()}),er=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),minLength:nk().optional(),maxLength:nk().optional(),format:nJ(["email","uri","date","date-time"]).optional(),default:o5().optional()}),ei=nM({type:nJ(["number","integer"]),title:o5().optional(),description:o5().optional(),minimum:nk().optional(),maximum:nk().optional(),default:nk().optional()}),eo=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),enum:nA(o5()),default:o5().optional()}),en=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),oneOf:nA(nM({const:o5(),title:o5()})),default:o5().optional()}),ea=nM({type:nQ("string"),title:o5().optional(),description:o5().optional(),enum:nA(o5()),enumNames:nA(o5()).optional(),default:o5().optional()}),es=nD([eo,en]),ed=nM({type:nQ("array"),title:o5().optional(),description:o5().optional(),minItems:nk().optional(),maxItems:nk().optional(),items:nM({type:nQ("string"),enum:nA(o5())}),default:nA(o5()).optional()}),ec=nM({type:nQ("array"),title:o5().optional(),description:o5().optional(),minItems:nk().optional(),maxItems:nk().optional(),items:nM({anyOf:nA(nM({const:o5(),title:o5()}))}),default:nA(o5()).optional()}),el=nD([ed,ec]),ep=nD([ea,es,el]),eu=nD([ep,et,er,ei]),em=u.extend({mode:nQ("form").optional(),message:o5(),requestedSchema:nM({type:nQ("object"),properties:nB(o5(),eu),required:nA(o5()).optional()}).catchall(nT())}),ef=nM({type:nQ("ref/resource"),uri:o5()}),eh=nM({type:nQ("ref/prompt"),name:o5()}),ey=nM({uri:o5().startsWith("file://"),name:o5().optional(),_meta:nB(o5(),nT()).optional()}),eg=k.shape,e_=nM({experimental:eg.experimental,sampling:eg.sampling,elicitation:eg.elicitation,roots:eg.roots,extensions:eg.extensions}),ev=w.shape,eb=nM({experimental:ev.experimental,logging:ev.logging,completions:ev.completions,prompts:ev.prompts,resources:ev.resources,tools:ev.tools,extensions:ev.extensions}),e$=nN({progressToken:r.optional(),[al]:o5(),[ap]:_.optional(),[am]:e_,[ah]:a.optional()}),eS=nM({...g.shape,...y.shape,description:o5().optional(),inputSchema:nN({$schema:o5().optional(),type:nQ("object")}),outputSchema:nN({$schema:o5().optional()}).optional(),annotations:Z.optional(),_meta:nB(o5(),nT()).optional()}),ek=nM({type:nQ("tool_result"),toolUseId:o5(),content:nA(K),structuredContent:nT().optional(),isError:nR().optional(),_meta:nB(o5(),nT()).optional()}),ew=nD([F,L,U,H,ek]),eP=nM({role:n,content:nD([ew,nA(ew)]),_meta:nB(o5(),nT()).optional()}),eV=o5(),eR=nN({[au]:_.optional().catch(void 0)}),eq=eR.optional();function eI(e){return nN({_meta:eq,resultType:eV.default("complete"),...e})}let ex=eI({}),ej=eI({nextCursor:i.optional()}),eC=eI({content:nA(K),structuredContent:nT().optional(),isError:nR().optional()}),eT=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),tools:nA(eS),nextCursor:i.optional()}),eO=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),prompts:nA(z),nextCursor:i.optional()}),eE=eI({description:o5().optional(),messages:nA(J)}),eA=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),resources:nA(O),nextCursor:i.optional()}),eW=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),resourceTemplates:nA(E),nextCursor:i.optional()}),eM=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),contents:nA(nD([j,C]))}),eN=eI({completion:nM({values:nA(o5()).max(100),total:nk().int().optional(),hasMore:nR().optional()}).loose()}),ez=eI({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"])}),eD=eI({ttlMs:nk().int().min(0).catch(0),cacheScope:nJ(["public","private"]).catch("private"),supportedVersions:nA(o5()),capabilities:eb,instructions:o5().optional()}),eF=nM({messages:nA(eP),modelPreferences:Y.optional(),systemPrompt:o5().optional(),includeContext:nJ(["none","thisServer","allServers"]).optional(),temperature:nk().optional(),maxTokens:nk().int(),stopSequences:nA(o5()).optional(),metadata:t.optional(),tools:nA(eS).optional(),toolChoice:ee.optional()}),eL=nM({method:nQ("sampling/createMessage"),params:eF}),eU=nM({method:nQ("roots/list"),params:nM({_meta:nB(o5(),nT()).optional()}).optional()}),eH=nM({...eP.shape,model:o5(),stopReason:o5().optional()}),eG=nM({roots:nA(ey)}),eB=nM({action:nJ(["accept","decline","cancel"]),content:nB(o5(),nD([o5(),nk(),nR(),nA(o5())])).optional()}),eK=nM({mode:nQ("url"),message:o5(),url:o5().url()}),eJ=nD([em,eK]),eZ=nM({method:nQ("elicitation/create"),params:eJ}),eQ=nD([eL,eU,eZ]),eX=nD([eH,eG,eB]),eY=nB(o5(),eQ),e1=nB(o5(),eX),e0=eI({inputRequests:eY.optional(),requestState:o5().optional()}),e2={inputResponses:e1.optional(),requestState:o5().optional()},e4=nM({_meta:e$,...e2}),e6=nN({progressToken:r.optional()});function e3(e,t){return nM({method:nQ(e),params:nM({_meta:e$,...t})})}function e9(e,t){return nM({method:nQ(e),params:nM({_meta:e6.optional(),...t}).optional()})}let e5={name:o5(),arguments:nB(o5(),nT()).optional(),...e2},e8={cursor:i.optional()},e7=e3("tools/call",e5),te=e3("tools/list",e8),tt=e3("prompts/list",e8),tr=e3("prompts/get",{name:o5(),arguments:nB(o5(),o5()).optional(),...e2}),ti=e3("resources/list",e8),to=e3("resources/templates/list",e8),tn=e3("resources/read",{uri:o5(),...e2}),ta={ref:nD([eh,ef]),argument:nM({name:o5(),value:o5()}),context:nM({arguments:nB(o5(),o5()).optional()}).optional()},ts=e3("completion/complete",ta),td=e3("server/discover",{}),tc=nM({toolsListChanged:nR().optional(),promptsListChanged:nR().optional(),resourcesListChanged:nR().optional(),resourceSubscriptions:nA(o5()).optional()}),tl={notifications:tc},tp=e3("subscriptions/listen",tl),tu=eR.extend({"io.modelcontextprotocol/subscriptionId":o}),tm=nN({_meta:tu,resultType:eV.default("complete")}),tf={"tools/call":e9("tools/call",e5),"tools/list":e9("tools/list",e8),"prompts/get":e9("prompts/get",{name:o5(),arguments:nB(o5(),o5()).optional()}),"prompts/list":e9("prompts/list",e8),"resources/list":e9("resources/list",e8),"resources/templates/list":e9("resources/templates/list",e8),"resources/read":e9("resources/read",{uri:o5()}),"completion/complete":e9("completion/complete",ta),"server/discover":e9("server/discover",{}),"subscriptions/listen":e9("subscriptions/listen",tl)};function th(e){return nN({_meta:eq,...e})}let ty={"tools/call":th({content:nA(K),structuredContent:nT().optional(),isError:nR().optional()}),"tools/list":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),tools:nA(eS),nextCursor:i.optional()}),"prompts/get":th({description:o5().optional(),messages:nA(J)}),"prompts/list":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),prompts:nA(z),nextCursor:i.optional()}),"resources/list":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),resources:nA(O),nextCursor:i.optional()}),"resources/templates/list":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),resourceTemplates:nA(E),nextCursor:i.optional()}),"resources/read":th({ttlMs:nk().int().min(0),cacheScope:nJ(["public","private"]),contents:nA(nD([j,C]))}),"completion/complete":th({completion:nM({values:nA(o5()).max(100),total:nk().int().optional(),hasMore:nR().optional()}).loose()}),"server/discover":th({ttlMs:nk().int().min(0).catch(0),cacheScope:nJ(["public","private"]).catch("private"),supportedVersions:nA(o5()),capabilities:eb,instructions:o5().optional()}),"subscriptions/listen":th({})},tg=nN({"io.modelcontextprotocol/subscriptionId":o.optional()}),t_=nM({method:nQ("notifications/subscriptions/acknowledged"),params:nM({_meta:tg.optional(),notifications:tc})}),tv=nM({_meta:tg.optional(),requestId:o,reason:o5().optional()}),tb=nM({method:nQ("notifications/cancelled"),params:tv}),t$=e=>nM({jsonrpc:nQ("2.0"),id:nD([o5(),nk().int()]),result:e}).strict();return{JSONValueSchema:e,JSONObjectSchema:t,ProgressTokenSchema:r,CursorSchema:i,RequestIdSchema:o,RoleSchema:n,LoggingLevelSchema:a,TaskMetadataSchema:d,RelatedTaskMetadataSchema:c,RequestMetaSchema:l,BaseRequestParamsSchema:p,TaskAugmentedRequestParamsSchema:u,NotificationsParamsSchema:m,NotificationSchema:f,IconSchema:h,IconsSchema:y,BaseMetadataSchema:g,ImplementationSchema:_,ClientTasksCapabilitySchema:$,ServerTasksCapabilitySchema:S,ClientCapabilitiesSchema:k,ServerCapabilitiesSchema:w,ProgressSchema:P,ProgressNotificationParamsSchema:V,ProgressNotificationSchema:R,LoggingMessageNotificationParamsSchema:q,LoggingMessageNotificationSchema:I,ResourceContentsSchema:x,TextResourceContentsSchema:j,BlobResourceContentsSchema:C,AnnotationsSchema:T,ResourceSchema:O,ResourceTemplateSchema:E,ResourceListChangedNotificationSchema:A,ResourceUpdatedNotificationParamsSchema:W,ResourceUpdatedNotificationSchema:M,PromptArgumentSchema:N,PromptSchema:z,PromptListChangedNotificationSchema:D,TextContentSchema:F,ImageContentSchema:L,AudioContentSchema:U,ToolUseContentSchema:H,EmbeddedResourceSchema:G,ResourceLinkSchema:B,ContentBlockSchema:K,PromptMessageSchema:J,ToolAnnotationsSchema:Z,ToolListChangedNotificationSchema:Q,ModelHintSchema:X,ModelPreferencesSchema:Y,ToolChoiceSchema:ee,BooleanSchemaSchema:et,StringSchemaSchema:er,NumberSchemaSchema:ei,UntitledSingleSelectEnumSchemaSchema:eo,TitledSingleSelectEnumSchemaSchema:en,LegacyTitledEnumSchemaSchema:ea,SingleSelectEnumSchemaSchema:es,UntitledMultiSelectEnumSchemaSchema:ed,TitledMultiSelectEnumSchemaSchema:ec,MultiSelectEnumSchemaSchema:el,EnumSchemaSchema:ep,PrimitiveSchemaDefinitionSchema:eu,ElicitRequestFormParamsSchema:em,ResourceTemplateReferenceSchema:ef,PromptReferenceSchema:eh,RootSchema:ey,ClientCapabilities2026Schema:e_,ServerCapabilities2026Schema:eb,RequestMetaEnvelopeSchema:e$,ToolSchema:eS,ToolResultContentSchema:ek,SamplingMessageContentBlockSchema:ew,SamplingMessageSchema:eP,ResultTypeSchema:eV,ResultMetaSchema:eR,ResultSchema:ex,PaginatedResultSchema:ej,CallToolResultSchema:eC,ListToolsResultSchema:eT,ListPromptsResultSchema:eO,GetPromptResultSchema:eE,ListResourcesResultSchema:eA,ListResourceTemplatesResultSchema:eW,ReadResourceResultSchema:eM,CompleteResultSchema:eN,CacheableResultSchema:ez,DiscoverResultSchema:eD,CreateMessageRequestParamsSchema:eF,CreateMessageRequestSchema:eL,ListRootsRequestSchema:eU,CreateMessageResultSchema:eH,ListRootsResultSchema:eG,ElicitResultSchema:eB,ElicitRequestURLParamsSchema:eK,ElicitRequestParamsSchema:eJ,ElicitRequestSchema:eZ,InputRequestSchema:eQ,InputResponseSchema:eX,InputRequestsSchema:eY,InputResponsesSchema:e1,InputRequiredResultSchema:e0,InputResponseRequestParamsSchema:e4,CallToolRequestSchema:e7,ListToolsRequestSchema:te,ListPromptsRequestSchema:tt,GetPromptRequestSchema:tr,ListResourcesRequestSchema:ti,ListResourceTemplatesRequestSchema:to,ReadResourceRequestSchema:tn,CompleteRequestSchema:ts,DiscoverRequestSchema:td,SubscriptionFilterSchema:tc,SubscriptionsListenRequestSchema:tp,SubscriptionsListenResultMetaSchema:tu,SubscriptionsListenResultSchema:tm,dispatchRequestSchemas:tf,dispatchResultSchemas:ty,NotificationMetaSchema:tg,SubscriptionsAcknowledgedNotificationSchema:t_,CancelledNotificationParamsSchema:tv,CancelledNotificationSchema:tb,notificationSchemas2026:{"notifications/cancelled":tb,"notifications/progress":R,"notifications/message":I,"notifications/resources/updated":M,"notifications/resources/list_changed":A,"notifications/tools/list_changed":Q,"notifications/prompts/list_changed":D,"notifications/subscriptions/acknowledged":t_},JSONRPCResultResponseSchema:t$(ex),CallToolResultResponseSchema:t$(nD([eC,e0])),ListToolsResultResponseSchema:t$(eT),ListPromptsResultResponseSchema:t$(eO),GetPromptResultResponseSchema:t$(nD([eE,e0])),ListResourcesResultResponseSchema:t$(eA),ListResourceTemplatesResultResponseSchema:t$(eW),ReadResourceResultResponseSchema:t$(nD([eM,e0])),CompleteResultResponseSchema:t$(eN),DiscoverResultResponseSchema:t$(eD),SubscriptionsListenResultResponseSchema:t$(tm)}}()}let wn=["tools/list","prompts/list","resources/list","resources/templates/list","resources/read","server/discover"],wa=Symbol("modelcontextprotocol.resultCacheHintFallback");function ws(e){return"number"==typeof e&&Number.isSafeInteger(e)&&e>=0}function wd(e){return"public"===e||"private"===e}let wc=((Y={})[Y.ParseError=-32700]="ParseError",Y[Y.InvalidRequest=-32600]="InvalidRequest",Y[Y.MethodNotFound=-32601]="MethodNotFound",Y[Y.InvalidParams=-32602]="InvalidParams",Y[Y.InternalError=-32603]="InternalError",Y[Y.ResourceNotFound=-32002]="ResourceNotFound",Y[Y.MissingRequiredClientCapability=-32021]="MissingRequiredClientCapability",Y[Y.UnsupportedProtocolVersion=-32022]="UnsupportedProtocolVersion",Y[Y.UrlElicitationRequired=-32042]="UrlElicitationRequired",Y);var wl=class e extends Error{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.ProtocolError"})}static[Symbol.hasInstance](e){return kD(this,e)}static isInstance(e){if("function"!=typeof this)throw TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");return kD(this,e)}constructor(e,t,r){super(t),this.code=e,this.data=r,this.name="ProtocolError",kz(this,new.target)}static fromError(t,r,i){return t===wc.UrlElicitationRequired&&i&&i.elicitations?new wu(i.elicitations,r):t===wc.UnsupportedProtocolVersion&&i&&Array.isArray(i.supported)&&"string"==typeof i.requested?new wm({supported:i.supported,requested:i.requested},r):(t===wc.InvalidParams||t===wc.ResourceNotFound)&&"string"==typeof i?.uri&&(t===wc.ResourceNotFound||1===Object.keys(i).length)?new wp(i.uri,r):t===wc.MissingRequiredClientCapability&&i&&null!==i.requiredCapabilities&&"object"==typeof i.requiredCapabilities&&!Array.isArray(i.requiredCapabilities)?new wf({requiredCapabilities:i.requiredCapabilities},r):new e(t,r,i)}},wp=class extends wl{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.ResourceNotFoundError"})}constructor(e,t=`Resource not found: ${e}`){super(wc.InvalidParams,t,{uri:e})}get uri(){return this.data.uri}},wu=class extends wl{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.UrlElicitationRequiredError"})}constructor(e,t=`URL elicitation${e.length>1?"s":""} required`){super(wc.UrlElicitationRequired,t,{elicitations:e})}get elicitations(){return this.data?.elicitations??[]}},wm=class extends wl{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.UnsupportedProtocolVersionError"})}constructor(e,t=`Unsupported protocol version: ${e.requested}`){super(wc.UnsupportedProtocolVersion,t,e)}get supported(){return this.data.supported}get requested(){return this.data.requested}},wf=class extends wl{static{Object.defineProperty(this,"mcpBrand",{value:"mcp.MissingRequiredClientCapabilityError"})}constructor(e,t=`Missing required client capabilities: ${Object.keys(e.requiredCapabilities).join(", ")}`){super(wc.MissingRequiredClientCapability,t,e)}get requiredCapabilities(){return this.data.requiredCapabilities}};let wh=["tools/call","prompts/get","resources/read"],wy=["elicitation/create","sampling/createMessage","roots/list"];function wg(){if(p)return p;let e=wo();return p={request:{"elicitation/create":nM({method:nQ("elicitation/create"),params:e.ElicitRequestParamsSchema}),"sampling/createMessage":nM({method:nQ("sampling/createMessage"),params:e.CreateMessageRequestParamsSchema}),"roots/list":nM({method:nQ("roots/list"),params:nN({}).optional()})},response:{"elicitation/create":e.ElicitResultSchema,"sampling/createMessage":e.CreateMessageResultSchema,"roots/list":e.ListRootsResultSchema}}}function w_(e){return wy.includes(e)}function wv(e){return w_(e)?wg().request[e]:void 0}let wb={"tools/call":null,"tools/list":null,"prompts/get":null,"prompts/list":null,"resources/list":null,"resources/templates/list":null,"resources/read":null,"completion/complete":null,"server/discover":null,"subscriptions/listen":null},w$={"notifications/cancelled":null,"notifications/progress":null,"notifications/message":null,"notifications/resources/updated":null,"notifications/resources/list_changed":null,"notifications/tools/list_changed":null,"notifications/prompts/list_changed":null,"notifications/subscriptions/acknowledged":null};function wS(e){return Object.prototype.hasOwnProperty.call(wb,e)}function wk(e){return Object.prototype.hasOwnProperty.call(w$,e)}function ww(e){return null!==e&&"object"==typeof e&&!Array.isArray(e)}function wP(e,t){if(void 0===e)return{ok:!1,reason:"not-in-era"};let r=e.safeParse(t);return r.success?{ok:!0,value:r.data}:{ok:!1,reason:"invalid",message:String(r.error)}}Object.keys(wb),Object.keys(w$);let wV={ok:!1,reason:"not-in-era"},wR=[al,am],wq={era:"2026-07-28",hasRequestMethod:wS,hasNotificationMethod:wk,hasInputRequestMethod:e=>void 0!==wv(e),validateRequest:(e,t)=>wP(wS(e)?wo().dispatchRequestSchemas[e]:void 0,t),validateResult:(e,t)=>wP(Object.prototype.hasOwnProperty.call(wb,e)?wo().dispatchResultSchemas[e]:void 0,t),validateNotification:(e,t)=>wP(wk(e)?wo().notificationSchemas2026[e]:void 0,t),validateInputRequest:(e,t)=>wP(wv(e),t),validateInputResponse:(e,t)=>wP(w_(e)?wg().response[e]:void 0,t),samplingResultVariant:()=>wV,outboundEnvelope:e=>({[al]:e.protocolVersion,[ap]:e.clientInfo,[am]:e.clientCapabilities,...void 0!==e.logLevel&&{[ah]:e.logLevel}}),validateEnvelopeMeta(e){let t=[];for(let r of wR)r in e||t.push({key:r,problem:"missing"});let r=wo().RequestMetaEnvelopeSchema.safeParse(e);if(!r.success)for(let e of r.error.issues){let r=e.path.map(String),i=r.length>0?r.join("."):"_meta";1===r.length&&t.some(e=>e.key===i&&"missing"===e.problem)||t.push({key:i,problem:e.message})}return t},projectCallToolResult:e=>kJ(e),inputRequestSchema:wv,decodeResult(e,t){if(!ww(t))return{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: not an object`,{method:e})};let r=t.resultType;if(void 0===r)return{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: missing required resultType — servers implementing protocol revision 2026-07-28 MUST include it (the absent-means-complete bridge applies only to earlier-revision servers)`,{method:e,violation:"missing-resultType"})};if("string"!=typeof r)return{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: non-string resultType`,{method:e,resultType:r})};if("input_required"===r){let r=t.inputRequests,i=ww(r)?r:{},o=t.requestState,n=void 0===t._meta?void 0:wo().ResultMetaSchema.safeParse(t._meta),a=n?.success?n.data:void 0;return 0===Object.keys(i).length&&"string"!=typeof o?{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: input_required carries neither inputRequests nor requestState (every input_required result must include at least one of the two)`,{method:e,violation:"input-required-missing-both"})}:{kind:"input_required",inputRequests:i,..."string"==typeof o&&{requestState:o},...void 0!==a&&{_meta:a}}}if("complete"!==r)return{kind:"invalid",error:new kL(kF.UnsupportedResultType,`Unsupported result type '${r}' for ${e}`,{resultType:r,method:e})};let i=function(){if(u)return u;let e=wo();return u={"tools/call":e.CallToolResultSchema,"tools/list":e.ListToolsResultSchema,"prompts/get":e.GetPromptResultSchema,"prompts/list":e.ListPromptsResultSchema,"resources/list":e.ListResourcesResultSchema,"resources/templates/list":e.ListResourceTemplatesResultSchema,"resources/read":e.ReadResourceResultSchema,"completion/complete":e.CompleteResultSchema,"server/discover":e.DiscoverResultSchema}}(),o=Object.hasOwn(i,e)?i[e]:void 0;if(void 0!==o){let r=o.safeParse(t);if(!r.success)return{kind:"invalid",error:new kL(kF.InvalidResult,`Invalid result for ${e}: ${r.error}`,{method:e})}}let n={...t};return delete n.resultType,{kind:"complete",result:n}},encodeResult:(e,t,r)=>(function(e,t){if(void 0===t)return e;let r=e._meta;return void 0===r?{...e,_meta:{[au]:t}}:null===r||"object"!=typeof r||Array.isArray(r)||void 0!==r[au]?e:{...e,_meta:{...r,[au]:t}}})(function(e,t){var r,i;let o=t[wa];if("complete"!==t.resultType||!wn.includes(e)){let e;return void 0===o?t:(e={...t},delete e[wa],e)}let n=ws(t.ttlMs)?t.ttlMs:void 0!==(r=o)&&ws(r.ttlMs)?r.ttlMs:0,a=wd(t.cacheScope)?t.cacheScope:void 0!==(i=o)&&wd(i.cacheScope)?i.cacheScope:"private",s={...t,ttlMs:n,cacheScope:a};return delete s[wa],s}(e,function(e,t){let r=t.resultType;if(void 0===r)return{...t,resultType:"complete"};if("complete"===r||wh.includes(e))return t;throw new wl(wc.InternalError,`Handler for ${e} returned resultType '${String(r)}', but results of ${e} only support 'complete' on protocol revision 2026-07-28`)}(e,function(e,t){let r=t,i=!1,o=()=>(i||(r={...r},i=!0),r),n=t.tools;"tools/list"===e&&Array.isArray(n)&&n.some(e=>ww(e)&&"execution"in e)&&(o().tools=n.map(e=>{if(!ww(e)||!("execution"in e))return e;let t={...e};return delete t.execution,t}));let a=t.capabilities;if(ww(a)&&"tasks"in a){let e={...a};delete e.tasks,o().capabilities=e}return r}(e,t))),r),encodeErrorCode:e=>-32002===e?-32602:e,checkInboundEnvelope(e){if(void 0===e.envelope)return"Request is missing the required _meta envelope for protocol revision 2026-07-28 (io.modelcontextprotocol/protocolVersion, io.modelcontextprotocol/clientCapabilities)";let t=wo().RequestMetaEnvelopeSchema.safeParse(e.envelope);if(!t.success)return`Invalid _meta envelope for protocol revision 2026-07-28: ${t.error.issues.map(e=>e.message).join("; ")}`}},wI="2026-07-28";function wx(e){return void 0!==e&&e>=kH?wq:wi}function wj(e){return void 0!==e.revision?wx(e.revision).era:"modern"===e.era?wq.era:wi.era}function wC(e){return wE.some(t=>t.hasRequestMethod(e))}function wT(e){return wE.some(t=>t.hasNotificationMethod(e))}function wO(e){return"tasks/get"===e||"tasks/cancel"===e}let wE=[wi,wq];var wA=(e=>{let t={};for(var r in e)kI(t,r,{get:e[r],enumerable:!0});return t})({AnnotationsSchema:()=>sn,AudioContentSchema:()=>sE,BaseMetadataSchema:()=>aL,BaseRequestParamsSchema:()=>aw,BlobResourceContentsSchema:()=>si,BooleanSchemaSchema:()=>ds,CallToolRequestParamsSchema:()=>sZ,CallToolRequestSchema:()=>sQ,CallToolResultSchema:()=>sK,CancelTaskRequestSchema:()=>dB,CancelTaskResultSchema:()=>dK,CancelledNotificationParamsSchema:()=>aN,CancelledNotificationSchema:()=>az,ClientCapabilitiesSchema:()=>aJ,ClientNotificationSchema:()=>dZ,ClientRequestSchema:()=>dJ,ClientResultSchema:()=>dQ,ClientTasksCapabilitySchema:()=>aB,CompatibilityCallToolResultSchema:()=>sJ,CompleteRequestParamsSchema:()=>dq,CompleteRequestSchema:()=>dI,CompleteResultSchema:()=>dx,ContentBlockSchema:()=>sN,CreateMessageRequestParamsSchema:()=>dr,CreateMessageRequestSchema:()=>di,CreateMessageResultSchema:()=>dn,CreateMessageResultWithToolsSchema:()=>da,CreateTaskResultSchema:()=>dM,CursorSchema:()=>ab,DiscoverRequestSchema:()=>a0,DiscoverResultSchema:()=>a2,ElicitRequestFormParamsSchema:()=>dv,ElicitRequestParamsSchema:()=>d$,ElicitRequestSchema:()=>dS,ElicitRequestURLParamsSchema:()=>db,ElicitResultSchema:()=>dP,ElicitationCompleteNotificationParamsSchema:()=>dk,ElicitationCompleteNotificationSchema:()=>dw,EmbeddedResourceSchema:()=>sW,EmptyResultSchema:()=>aM,EnumSchemaSchema:()=>dg,GetPromptRequestParamsSchema:()=>sj,GetPromptRequestSchema:()=>sC,GetPromptResultSchema:()=>sD,GetTaskPayloadRequestSchema:()=>dL,GetTaskPayloadResultSchema:()=>dU,GetTaskRequestSchema:()=>dD,GetTaskResultSchema:()=>dF,IconSchema:()=>aD,IconsSchema:()=>aF,ImageContentSchema:()=>sO,ImplementationSchema:()=>aU,InitializeRequestParamsSchema:()=>aZ,InitializeRequestSchema:()=>aQ,InitializeResultSchema:()=>aY,InitializedNotificationSchema:()=>a1,JSONArraySchema:()=>a_,JSONObjectSchema:()=>ag,JSONRPCErrorResponseSchema:()=>aE,JSONRPCMessageSchema:()=>aA,JSONRPCNotificationSchema:()=>aT,JSONRPCRequestSchema:()=>aC,JSONRPCResponseSchema:()=>aW,JSONRPCResultResponseSchema:()=>aO,JSONValueSchema:()=>ay,LegacyTitledEnumSchemaSchema:()=>du,ListChangedOptionsBaseSchema:()=>sY,ListPromptsRequestSchema:()=>sI,ListPromptsResultSchema:()=>sx,ListResourceTemplatesRequestSchema:()=>sl,ListResourceTemplatesResultSchema:()=>sp,ListResourcesRequestSchema:()=>sd,ListResourcesResultSchema:()=>sc,ListRootsRequestSchema:()=>dC,ListRootsResultSchema:()=>dT,ListTasksRequestSchema:()=>dH,ListTasksResultSchema:()=>dG,ListToolsRequestSchema:()=>sG,ListToolsResultSchema:()=>sB,LoggingLevelSchema:()=>s1,LoggingMessageNotificationParamsSchema:()=>s4,LoggingMessageNotificationSchema:()=>s6,ModelHintSchema:()=>s3,ModelPreferencesSchema:()=>s9,MultiSelectEnumSchemaSchema:()=>dy,NotificationSchema:()=>aq,NotificationsParamsSchema:()=>aR,NumberSchemaSchema:()=>dc,PaginatedRequestParamsSchema:()=>a5,PaginatedRequestSchema:()=>a8,PaginatedResultSchema:()=>a7,PingRequestSchema:()=>a4,PrimitiveSchemaDefinitionSchema:()=>d_,ProgressNotificationParamsSchema:()=>a3,ProgressNotificationSchema:()=>a9,ProgressSchema:()=>a6,ProgressTokenSchema:()=>av,PromptArgumentSchema:()=>sR,PromptListChangedNotificationSchema:()=>sF,PromptMessageSchema:()=>sz,PromptReferenceSchema:()=>dR,PromptSchema:()=>sq,ReadResourceRequestParamsSchema:()=>su,ReadResourceRequestSchema:()=>sm,ReadResourceResultSchema:()=>sf,RelatedTaskMetadataSchema:()=>aS,RequestIdSchema:()=>aj,RequestMetaSchema:()=>ak,RequestSchema:()=>aV,ResourceContentsSchema:()=>se,ResourceLinkSchema:()=>sM,ResourceListChangedNotificationSchema:()=>sh,ResourceRequestParamsSchema:()=>su,ResourceSchema:()=>sa,ResourceTemplateReferenceSchema:()=>dV,ResourceTemplateSchema:()=>ss,ResourceUpdatedNotificationParamsSchema:()=>sP,ResourceUpdatedNotificationSchema:()=>sV,ResultMetaObjectSchema:()=>aI,ResultSchema:()=>ax,RoleSchema:()=>so,RootSchema:()=>dj,RootsListChangedNotificationSchema:()=>dO,SamplingContentSchema:()=>s7,SamplingMessageContentBlockSchema:()=>de,SamplingMessageSchema:()=>dt,ServerCapabilitiesSchema:()=>aX,ServerNotificationSchema:()=>dY,ServerRequestSchema:()=>dX,ServerResultSchema:()=>d1,ServerTasksCapabilitySchema:()=>aK,SetLevelRequestParamsSchema:()=>s0,SetLevelRequestSchema:()=>s2,SingleSelectEnumSchemaSchema:()=>dm,StringSchemaSchema:()=>dd,SubscribeRequestParamsSchema:()=>su,SubscribeRequestSchema:()=>sy,SubscriptionFilterSchema:()=>s_,SubscriptionsAcknowledgedNotificationParamsSchema:()=>s$,SubscriptionsAcknowledgedNotificationSchema:()=>sS,SubscriptionsListenRequestParamsSchema:()=>sv,SubscriptionsListenRequestSchema:()=>sb,SubscriptionsListenResultMetaSchema:()=>sk,SubscriptionsListenResultSchema:()=>sw,TaskAugmentedRequestParamsSchema:()=>aP,TaskCreationParamsSchema:()=>dE,TaskMetadataSchema:()=>a$,TaskSchema:()=>dW,TaskStatusNotificationParamsSchema:()=>dN,TaskStatusNotificationSchema:()=>dz,TaskStatusSchema:()=>dA,TextContentSchema:()=>sT,TextResourceContentsSchema:()=>st,TitledMultiSelectEnumSchemaSchema:()=>dh,TitledSingleSelectEnumSchemaSchema:()=>dp,ToolAnnotationsSchema:()=>sL,ToolChoiceSchema:()=>s5,ToolExecutionSchema:()=>sU,ToolListChangedNotificationSchema:()=>sX,ToolResultContentSchema:()=>s8,ToolSchema:()=>sH,ToolUseContentSchema:()=>sA,UnsubscribeRequestParamsSchema:()=>su,UnsubscribeRequestSchema:()=>sg,UntitledMultiSelectEnumSchemaSchema:()=>df,UntitledSingleSelectEnumSchemaSchema:()=>dl});let wW=e=>"object"==typeof e&&null!==e&&!Array.isArray(e)&&"input_required"===e.resultType,wM="x-mcp-header",wN=/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/,wz=new Set(["string","integer","boolean"]);function wD(e){let t,r=[],i=new Map,o=(e,n,a)=>{if(null===e||"object"!=typeof e)return;if(wM in e){if(!a||0===n.length)return`${wU(n)}: x-mcp-header is only permitted on properties statically reachable via a chain of 'properties' keys (not under items, additionalProperties, oneOf/anyOf/allOf/not, if/then/else, or $ref)`;let o=e[wM];if("string"!=typeof o||0===o.length)return`${wU(n)}: x-mcp-header MUST be a non-empty string`;if(!wN.test(o))return`${wU(n)}: x-mcp-header '${o}' is not a valid RFC 9110 token (no spaces, control characters or HTTP delimiters)`;let s="string"==typeof e.type?e.type:void 0;if(void 0===s||!wz.has(s)){let e=`${wU(n)}: x-mcp-header is only permitted on primitive-typed properties (string, integer, boolean); got ${s??"<none>"}`;if("number"!==s)return e;t??=e}let d=o.toLowerCase(),c=i.get(d);if(void 0!==c)return`x-mcp-header '${o}' is not case-insensitively unique (also declared as '${c}')`;i.set(d,o),r.push({path:n,headerName:o,type:s})}let s=e.properties;if(null!==s&&"object"==typeof s)for(let[e,t]of Object.entries(s)){let r=o(t,[...n,e],a);if(void 0!==r)return r}for(let t of wF){let r=e[t];if(void 0!==r)for(let e of Array.isArray(r)?r:null!==r&&"object"==typeof r&&wL.has(t)?Object.values(r):[r]){let r=o(e,[...n,`<${t}>`],!1);if(void 0!==r)return r}}},n=o(e,[],!0);return void 0!==n?{valid:!1,reason:t??n}:void 0===t?{valid:!0,declarations:r}:{valid:!1,reason:t,declarations:r}}let wF=["items","prefixItems","contains","additionalProperties","unevaluatedProperties","unevaluatedItems","propertyNames","patternProperties","dependentSchemas","oneOf","anyOf","allOf","not","if","then","else","$defs","definitions"],wL=new Set(["patternProperties","dependentSchemas","$defs","definitions"]);function wU(e){return 0===e.length?"<root>":e.join(".")}let wH="=?base64?";function wG(e){return new Set(e.flatMap(e=>Object.keys(e.shape)))}function wB(e){if(null==e)return!1;let t=typeof e;return("object"===t||"function"===t)&&"~standard"in e&&"function"==typeof e["~standard"]?.validate}wc.InvalidRequest,wc.UnsupportedProtocolVersion,wc.InvalidParams,wc.MethodNotFound,wc.InvalidParams,wc.MissingRequiredClientCapability,wc.ParseError,wc.InvalidRequest,wc.MethodNotFound,wc.UnsupportedProtocolVersion,wc.MissingRequiredClientCapability;let wK=!1,wJ="draft-2020-12",wZ=/^#\/(\$defs|definitions)\/([^/~%]+)$/;async function wQ(e,t){let r=await e["~standard"].validate(t);return r.issues&&r.issues.length>0?{success:!1,error:r.issues.map(e=>e.path?.length?`${e.path.map(e=>String("object"==typeof e?e.key:e)).join(".")}: ${e.message}`:e.message).join(", ")}:{success:!0,data:r.value}}let wX=/\\\.\\d\{(\d+)\}/;function wY(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}let w1=new Set(["$comment","deprecated","description","examples","readOnly","title","writeOnly"]);function w0(e){return w1.has(e)||e.startsWith("x-")}let w2=new Set(["$schema",...Object.keys(dv.shape.requestedSchema.shape)]),w4={string:wG([dd,dl,dp,du]),number:wG([dc]),integer:wG([dc]),boolean:wG([ds]),array:wG([df,dh])},w6=new Set(dd.shape.format.unwrap().options);Object.assign(function(e){let t=void 0!==e.inputRequests&&Object.keys(e.inputRequests).length>0,r="string"==typeof e.requestState;if(!t&&!r)throw TypeError("inputRequired() requires at least one of inputRequests (with at least one entry) or requestState (spec: every InputRequiredResult MUST include at least one of the two)");return{resultType:"input_required",...void 0!==e.inputRequests&&{inputRequests:e.inputRequests},...void 0!==e.requestState&&{requestState:e.requestState}}},{elicit(e){try{return{method:"elicitation/create",params:function(e){var t;if(!wB(e.requestedSchema))return{...e,mode:"form",requestedSchema:e.requestedSchema};let r=e.requestedSchema["~standard"].vendor,i=function(e,t){let r={},i=[];for(let[o,n]of Object.entries(e))"properties"===o&&wY(n)?r[o]=Object.fromEntries(Object.entries(n).map(([e,r])=>[e,function(e,t,r,i){if(!wY(e))return e;let o="string"==typeof e.type&&Object.hasOwn(w4,e.type)?w4[e.type]:void 0;if(void 0===o)return e;let n={};for(let[s,d]of Object.entries(e))if(o.has(s)||w0(s))n[s]=d;else if("pattern"===s&&"string"===e.type&&"string"==typeof e.format)if(w6.has(e.format)){var a;"string"==typeof d&&(a=e.format,"zod"!==r||(function(e,t){let r;switch(e){case"email":r=[iS(ni,void 0)];break;case"uri":r=[ik(na,void 0)];break;case"date":r=[iP(ne,void 0)];break;case"date-time":let i,o;i=wX.exec(t),o=[void 0,-1,0],i&&o.push(Number(i[1])),r=[!1,!0].flatMap(e=>[!1,!0].flatMap(t=>o.map(r=>as({local:e,offset:t,precision:r}))))}return new Set(r.map(e=>{let t;return t=oq(e,{target:wJ,io:"input"}),"string"==typeof t.pattern?t.pattern:void 0}).filter(e=>void 0!==e))})(a,d).has(d))||i.push(`${t}.${s}`)}else n[s]=d;else i.push(`${t}.${s}`);return n}(r,`properties.${e}`,t,i)])):w2.has(o)?r[o]=n:w0(o)||i.push(o);if(i.length>0)throw new wl(wc.InvalidParams,`Elicitation requestedSchema contains unsupported JSON Schema constraint(s) after Standard Schema conversion: ${i.join(", ")}`);return r}(function(e){try{return function(e,t="input"){let r,i=e["~standard"];if(i.jsonSchema)r=i.jsonSchema[t]({target:wJ});else if("zod"===i.vendor){if(!("_zod"in e))throw Error("Schema appears to be from zod 3, which the SDK cannot convert to JSON Schema. Upgrade to zod >=4.2.0, or wrap your JSON Schema with fromJsonSchema().");wK||(wK=!0,console.warn("[mcp-sdk] Your zod version does not implement `~standard.jsonSchema` (added in zod 4.2.0). Falling back to z.toJSONSchema(). Upgrade to zod >=4.2.0 to silence this warning.")),r=oq(e,{target:wJ,io:t})}else throw Error(`Schema library "${i.vendor}" does not implement StandardJSONSchemaV1 (\`~standard.jsonSchema\`). Upgrade to a version that does, or wrap your JSON Schema with fromJsonSchema().`);if("output"===t)return void 0!==r.type||!function e(t,r=t){if("properties"in t||"patternProperties"in t||"additionalProperties"in t||"required"in t)return!0;let i="string"==typeof t.$ref&&wZ.exec(t.$ref);if(i&&r[i[1]]?.[i[2]]?.type==="object")return!0;for(let i of["oneOf","anyOf","allOf"]){let o=t[i];if(Array.isArray(o)&&o.length>0)return o.every(t=>null!==t&&"object"==typeof t&&("object"===t.type||e(t,"$id"in t?{}:r)))}return!1}(r)?r:{type:"object",...r};if(void 0!==r.type&&"object"!==r.type)throw Error(`MCP tool and prompt schemas must describe objects (got type: ${JSON.stringify(r.type)}). Wrap your schema in z.object({...}) or equivalent.`);return{type:"object",...r}}(e,"input")}catch(t){let e=t instanceof Error?t.message:String(t);throw new wl(wc.InvalidParams,`Elicitation requestedSchema must describe an object with flat primitive properties: ${e}`)}}(e.requestedSchema),r),o=(t=dv.shape.requestedSchema,oB(t,i));if(!o.success)throw new wl(wc.InvalidParams,`Elicitation requestedSchema only supports flat primitive properties (string, number, integer, boolean, and string enums): ${function(e,t){if(!wY(e.properties))return t;let r=Object.entries(e.properties).filter(([,e])=>!oB(d_,e).success).map(([e])=>`properties.${e}`);return r.length>0?r.join(", "):t}(i,o.error.message)}`);let n=function e(t,r,i=""){return Array.isArray(t)&&Array.isArray(r)?t.flatMap((t,o)=>e(t,r[o],`${i}[${o}]`)):wY(t)&&wY(r)?Object.entries(t).flatMap(([t,o])=>{let n=i?`${i}.${t}`:t;return Object.prototype.hasOwnProperty.call(r,t)?e(o,r[t],n):w0(t)?[]:[n]}):[]}(i,o.data);if(n.length>0)throw new wl(wc.InvalidParams,`Elicitation requestedSchema contains unsupported JSON Schema constraint(s) after Standard Schema conversion: ${n.join(", ")}`);let a=(o.data.required??[]).filter(e=>!Object.prototype.hasOwnProperty.call(o.data.properties,e));if(a.length>0)throw new wl(wc.InvalidParams,`Elicitation requestedSchema lists required properties that are not defined in properties: ${a.join(", ")}`);return{...e,mode:"form",requestedSchema:o.data}}(e)}}catch(e){throw e instanceof wl?TypeError(e.message,{cause:e}):e}},elicitUrl:e=>({method:"elicitation/create",params:{...e,mode:"url"}}),createMessage:e=>({method:"sampling/createMessage",params:e}),listRoots:()=>({method:"roots/list"})});let w3={},w9={};function w5(e,t){let r=e.slice(0,-6);w3[r]=t,w9[r]=e=>t.safeParse(e).success}for(let e of["AnnotationsSchema","AudioContentSchema","BaseMetadataSchema","BlobResourceContentsSchema","BooleanSchemaSchema","CallToolRequestSchema","CallToolRequestParamsSchema","CallToolResultSchema","CancelledNotificationSchema","CancelledNotificationParamsSchema","CancelTaskRequestSchema","CancelTaskResultSchema","ClientCapabilitiesSchema","ClientNotificationSchema","ClientRequestSchema","ClientResultSchema","CompatibilityCallToolResultSchema","CompleteRequestSchema","CompleteRequestParamsSchema","CompleteResultSchema","ContentBlockSchema","CreateMessageRequestSchema","CreateMessageRequestParamsSchema","CreateMessageResultSchema","CreateMessageResultWithToolsSchema","CreateTaskResultSchema","CursorSchema","DiscoverRequestSchema","DiscoverResultSchema","ElicitationCompleteNotificationSchema","ElicitationCompleteNotificationParamsSchema","ElicitRequestSchema","ElicitRequestFormParamsSchema","ElicitRequestParamsSchema","ElicitRequestURLParamsSchema","ElicitResultSchema","EmbeddedResourceSchema","EmptyResultSchema","EnumSchemaSchema","GetPromptRequestSchema","GetPromptRequestParamsSchema","GetPromptResultSchema","GetTaskPayloadRequestSchema","GetTaskPayloadResultSchema","GetTaskRequestSchema","GetTaskResultSchema","IconSchema","IconsSchema","ImageContentSchema","ImplementationSchema","InitializedNotificationSchema","InitializeRequestSchema","InitializeRequestParamsSchema","InitializeResultSchema","JSONArraySchema","JSONObjectSchema","JSONRPCErrorResponseSchema","JSONRPCMessageSchema","JSONRPCNotificationSchema","JSONRPCRequestSchema","JSONRPCResponseSchema","JSONRPCResultResponseSchema","JSONValueSchema","LegacyTitledEnumSchemaSchema","ListPromptsRequestSchema","ListPromptsResultSchema","ListResourcesRequestSchema","ListResourcesResultSchema","ListResourceTemplatesRequestSchema","ListResourceTemplatesResultSchema","ListRootsRequestSchema","ListRootsResultSchema","ListTasksRequestSchema","ListTasksResultSchema","ListToolsRequestSchema","ListToolsResultSchema","LoggingLevelSchema","LoggingMessageNotificationSchema","LoggingMessageNotificationParamsSchema","ModelHintSchema","ModelPreferencesSchema","MultiSelectEnumSchemaSchema","NotificationSchema","NumberSchemaSchema","PaginatedRequestSchema","PaginatedRequestParamsSchema","PaginatedResultSchema","PingRequestSchema","PrimitiveSchemaDefinitionSchema","ProgressSchema","ProgressNotificationSchema","ProgressNotificationParamsSchema","ProgressTokenSchema","PromptSchema","PromptArgumentSchema","PromptListChangedNotificationSchema","PromptMessageSchema","PromptReferenceSchema","ReadResourceRequestSchema","ReadResourceRequestParamsSchema","ReadResourceResultSchema","RelatedTaskMetadataSchema","RequestSchema","RequestIdSchema","RequestMetaSchema","ResourceSchema","ResourceContentsSchema","ResourceLinkSchema","ResourceListChangedNotificationSchema","ResourceRequestParamsSchema","ResourceTemplateSchema","ResourceTemplateReferenceSchema","ResourceUpdatedNotificationSchema","ResourceUpdatedNotificationParamsSchema","ResultMetaObjectSchema","ResultSchema","RoleSchema","RootSchema","RootsListChangedNotificationSchema","SamplingContentSchema","SamplingMessageSchema","SamplingMessageContentBlockSchema","ServerCapabilitiesSchema","ServerNotificationSchema","ServerRequestSchema","ServerResultSchema","SetLevelRequestSchema","SetLevelRequestParamsSchema","SingleSelectEnumSchemaSchema","StringSchemaSchema","SubscribeRequestSchema","SubscribeRequestParamsSchema","SubscriptionFilterSchema","SubscriptionsAcknowledgedNotificationSchema","SubscriptionsAcknowledgedNotificationParamsSchema","SubscriptionsListenRequestSchema","SubscriptionsListenRequestParamsSchema","SubscriptionsListenResultSchema","SubscriptionsListenResultMetaSchema","TaskAugmentedRequestParamsSchema","TaskCreationParamsSchema","TaskMetadataSchema","TaskSchema","TaskStatusSchema","TaskStatusNotificationSchema","TaskStatusNotificationParamsSchema","TextContentSchema","TextResourceContentsSchema","TitledMultiSelectEnumSchemaSchema","TitledSingleSelectEnumSchemaSchema","ToolSchema","ToolAnnotationsSchema","ToolChoiceSchema","ToolExecutionSchema","ToolListChangedNotificationSchema","ToolResultContentSchema","ToolUseContentSchema","UnsubscribeRequestSchema","UnsubscribeRequestParamsSchema","UntitledMultiSelectEnumSchemaSchema","UntitledSingleSelectEnumSchemaSchema"])w5(e,wA[e]);for(let[e,t]of Object.entries({IdJagTokenExchangeResponseSchema:d7,OAuthClientInformationFullSchema:co,OAuthClientInformationSchema:ci,OAuthClientMetadataSchema:cr,OAuthClientRegistrationErrorSchema:cn,OAuthErrorResponseSchema:ce,OAuthMetadataSchema:d3,OAuthProtectedResourceMetadataSchema:d6,OAuthTokenRevocationRequestSchema:ca,OAuthTokensSchema:d8,OpenIdProviderDiscoveryMetadataSchema:d5,OpenIdProviderMetadataSchema:d9}))w5(e,t);Object.freeze(w3);let w8=Object.freeze(w9),w7=[al,ap,am,ah],Pe=["inputResponses","requestState"];function Pt(e,t){let r=e.params;if(!Pn(r))return{message:e,lifted:{}};let i=r._meta,o=Pn(i)?w7.filter(e=>e in i):[],n="request"===t?Pe.filter(e=>e in r):[];if(0===o.length&&0===n.length)return{message:e,lifted:{}};let a={},s={...r};if(o.length>0&&Pn(i)){let e={},t={...i};for(let r of o)e[r]=i[r],delete t[r];a.envelope=e,Object.keys(t).length>0?s._meta=t:delete s._meta}for(let e of n)"inputResponses"===e&&(a.inputResponses=s[e]),"requestState"===e&&(a.requestState=s[e]),delete s[e];return{message:{...e,params:s},lifted:a}}function Pr(e,t){let r=e.validateResult(t,void 0);if(r.ok||"not-in-era"!==r.reason)return{"~standard":{version:1,vendor:"mcp-wire-codec",validate(r){let i=e.validateResult(t,r);return i.ok?{value:i.value}:{issues:[{message:"invalid"===i.reason?i.message:`not-in-era: ${t}`}]}}}}}let Pi=(ee=void 0,()=>ee);var Po=class{_transport;_requestMessageId=0;_requestHandlers=new Map;_customSchemaRequestMethods=new Set;_requestHandlerAbortControllers=new Map;_notificationHandlers=new Map;_responseHandlers=new Map;_progressHandlers=new Map;_timeoutInfo=new Map;_pendingDebouncedNotifications=new Set;_negotiatedProtocolVersion;_supportedProtocolVersions;onclose;onerror;fallbackRequestHandler;fallbackNotificationHandler;constructor(e){this._options=e,this._supportedProtocolVersions=e?.supportedProtocolVersions??ac,this.setNotificationHandler("notifications/cancelled",e=>{this._oncancel(e)}),this.setNotificationHandler("notifications/progress",e=>{this._onprogress(e)}),this.setRequestHandler("ping",e=>({}))}_shouldDropInbound(e){}_outboundMetaEnvelope(){}_envelopeOutbound(e){let t=this._outboundMetaEnvelope();if(void 0===t)return e;let r=e.params??{};return{...e,params:{...r,_meta:{...t,...r._meta}}}}_resolveNonCompleteResult(e,t){return Promise.reject(new kL(kF.UnsupportedResultType,`Unsupported result type '${e.kind}' for ${t.request.method}`,{resultType:e.kind,method:t.request.method}))}_getRequestHandler(e){return this._requestHandlers.get(e)}async _oncancel(e){void 0!==e.params.requestId&&this._requestHandlerAbortControllers.get(e.params.requestId)?.abort(e.params.reason)}_setupTimeout(e,t,r,i,o=!1){this._timeoutInfo.set(e,{timeoutId:setTimeout(i,t),startTime:Date.now(),timeout:t,maxTotalTimeout:r,resetTimeoutOnProgress:o,onTimeout:i})}_resetTimeout(e){let t=this._timeoutInfo.get(e);if(!t)return!1;let r=Date.now()-t.startTime;if(t.maxTotalTimeout&&r>=t.maxTotalTimeout)throw this._timeoutInfo.delete(e),new kL(kF.RequestTimeout,"Maximum total timeout exceeded",{maxTotalTimeout:t.maxTotalTimeout,totalElapsed:r});return clearTimeout(t.timeoutId),t.timeoutId=setTimeout(t.onTimeout,t.timeout),!0}_cleanupTimeout(e){let t=this._timeoutInfo.get(e);t&&(clearTimeout(t.timeoutId),this._timeoutInfo.delete(e))}async connect(e){this._transport=e;let t=this.transport?.onclose;this._transport.onclose=()=>{try{t?.()}finally{this._onclose()}};let r=this.transport?.onerror;this._transport.onerror=e=>{r?.(e),this._onerror(e)};let i=this._transport?.onmessage;this._transport.onmessage=(e,t)=>{if(i?.(e,t),aO.safeParse(e).success||aE.safeParse(e).success)this._onresponse(e);else if(aC.safeParse(e).success)this._onrequest(e,t);else aT.safeParse(e).success?this._onnotification(e,t):this._onerror(Error(`Unknown message type: ${JSON.stringify(e)}`))},e.setSupportedProtocolVersions?.(this._supportedProtocolVersions),await this._transport.start()}_onclose(){let e=this._responseHandlers;for(let e of(this._responseHandlers=new Map,this._progressHandlers.clear(),this._pendingDebouncedNotifications.clear(),this._timeoutInfo.values()))clearTimeout(e.timeoutId);this._timeoutInfo.clear();let t=this._requestHandlerAbortControllers;this._requestHandlerAbortControllers=new Map;let r=new kL(kF.ConnectionClosed,"Connection closed");this._transport=void 0;try{this.onclose?.()}finally{for(let t of e.values())t(r);for(let e of t.values())e.abort(r)}}_onerror(e){this.onerror?.(e)}_onnotification(e,t){let{message:r}=Pt(e,"notification"),i=this._negotiatedWireCodec();if(t?.classification===void 0&&"drop"===this._shouldDropInbound(e))return;if(t?.classification!==void 0){let e=wj(t.classification);if(e!==i.era)return void this._onerror(Error(`Era mismatch on inbound notification '${r.method}': classified as ${e} but this instance serves ${i.era}`))}if(wT(r.method)&&!i.hasNotificationMethod(r.method))return;let o=this._notificationHandlers.get(r.method),n=this.fallbackNotificationHandler;(void 0!==o||void 0!==n)&&Promise.resolve().then(()=>void 0===o?n(r):o(r,i)).catch(e=>this._onerror(Error(`Uncaught error in notification handler: ${e}`)))}_onrequest(e,t){var r;let{message:i,lifted:o}=Pt(e,"request"),n=this._negotiatedWireCodec();if(t?.classification===void 0&&"drop"===this._shouldDropInbound(e))return void this._onerror(Error(`Dropped inbound request '${e.method}': not servable on this connection's protocol era`));let a=this._transport,s=(e,t,r)=>{let o={jsonrpc:"2.0",id:i.id,error:{code:e,message:t,...void 0!==r&&{data:r}}};a?.send(o).catch(e=>this._onerror(Error(`Failed to send an error response: ${e}`)))};if(t?.classification!==void 0){let e=wj(t.classification);if(e!==n.era){this._onerror(Error(`Era mismatch on inbound request '${i.method}': classified as ${e} but this instance serves ${n.era}`));let r=t.classification.revision??e;s(wc.UnsupportedProtocolVersion,`Unsupported protocol version: ${r}`,{supported:this._supportedProtocolVersions,requested:r});return}}if(wC(i.method)&&!n.hasRequestMethod(i.method)&&!(wO(i.method)&&this._customSchemaRequestMethods.has(i.method)))return void s(wc.MethodNotFound,"Method not found");let d=this._requestHandlers.get(i.method)??this.fallbackRequestHandler;if(void 0===d)return void s(wc.MethodNotFound,"Method not found");let c=n.checkInboundEnvelope(o);if(void 0!==c)return void s(wc.InvalidParams,c);let l=(e,t)=>this._notificationViaCodec(this._resolveOutboundCodec(e.method),e,{...t,relatedRequestId:i.id}),p=(e,t,r)=>this._requestWithSchemaViaCodec(this._resolveOutboundCodec(e.method),e,t,{...r,relatedRequestId:i.id}),u=new AbortController;this._requestHandlerAbortControllers.set(i.id,u);let m=void 0===o.inputResponses?void 0:function(e){let t={},r=[];if(!Pa(e))return{accepted:t,droppedKeys:r};for(let[i,o]of Object.entries(e)){if(!Pa(o)||"method"in o||"result"in o){r.push(i);continue}t[i]=o}return{accepted:t,droppedKeys:r}}(o.inputResponses),f={sessionId:a?.sessionId,mcpReq:{id:i.id,method:i.method,_meta:i.params?._meta,...void 0!==o.envelope&&{envelope:o.envelope},...void 0!==m&&{inputResponses:m.accepted},...void 0!==m&&m.droppedKeys.length>0&&{droppedInputResponseKeys:m.droppedKeys},requestState:void 0===o.requestState?Pi:(r=o.requestState,()=>r),signal:u.signal,send:(e,t,r)=>{let i=this._resolveOutboundCodec(e.method);if(this._assertOutboundRequestInEra(i,e.method),wB(t))return p(e,t,r);let o=Pr(i,e.method);if(void 0===o)throw TypeError(`'${e.method}' is not a spec method; pass a result schema as the second argument to ctx.mcpReq.send().`);return p(e,o,t)},notify:l},http:t?.authInfo?{authInfo:t.authInfo}:void 0},h=this.buildContext(f,t);Promise.resolve().then(()=>d(i,h)).then(async e=>{let t;if(u.signal.aborted)return;try{t=n.encodeResult(i.method,e,this._outboundServerInfo())}catch(e){this._onerror(Error(`Failed to encode result for ${i.method}: ${e}`)),s(wc.InternalError,"Internal error");return}let r={result:t,jsonrpc:"2.0",id:i.id};await a?.send(r)},async e=>{if(u.signal.aborted)return;let t=Number.isSafeInteger(e.code)?e.code:wc.InternalError,r={jsonrpc:"2.0",id:i.id,error:{code:n.encodeErrorCode(t),message:e.message??"Internal error",...void 0!==e.data&&{data:e.data}}};await a?.send(r)}).catch(e=>this._onerror(Error(`Failed to send response: ${e}`))).finally(()=>{this._requestHandlerAbortControllers.get(i.id)===u&&this._requestHandlerAbortControllers.delete(i.id)})}_onprogress(e){let{progressToken:t,...r}=e.params,i=Number(t),o=this._progressHandlers.get(i);if(!o)return void this._onerror(Error(`Received a progress notification for an unknown token: ${JSON.stringify(e)}`));let n=this._responseHandlers.get(i),a=this._timeoutInfo.get(i);if(a&&n&&a.resetTimeoutOnProgress)try{this._resetTimeout(i)}catch(e){this._responseHandlers.delete(i),this._progressHandlers.delete(i),this._cleanupTimeout(i),n(e);return}o(r)}_onresponse(e){let t=Number(e.id),r=this._responseHandlers.get(t);void 0===r?this._onerror(Error(`Received a response for an unknown message ID: ${JSON.stringify(e)}`)):(this._responseHandlers.delete(t),this._cleanupTimeout(t),this._progressHandlers.delete(t),r(aO.safeParse(e).success?e:wl.fromError(e.error.code,e.error.message,e.error.data)))}get transport(){return this._transport}async close(){await this._transport?.close()}request(e,t,r){let i=this._resolveOutboundCodec(e.method);if(wB(t))return wO(e.method)||this._assertOutboundRequestInEra(i,e.method),this._requestWithSchemaViaCodec(i,e,t,r);this._assertOutboundRequestInEra(i,e.method);let o=Pr(i,e.method);if(void 0===o)throw TypeError(`'${e.method}' is not a spec method; pass a result schema as the second argument to request().`);return this._requestWithSchemaViaCodec(i,e,o,t)}_negotiatedWireCodec(){return wx(this._negotiatedProtocolVersion)}_wireCodec(){return this._negotiatedWireCodec()}_resolveOutboundCodec(e){if(void 0===this._negotiatedProtocolVersion){let t=function(e){switch(e){case"initialize":case"notifications/initialized":return wx(void 0);case"server/discover":return wx(wI);default:return}}(e);if(t)return t}return this._negotiatedWireCodec()}_assertOutboundRequestInEra(e,t){if(wC(t)&&!e.hasRequestMethod(t))throw new kL(kF.MethodNotSupportedByProtocolVersion,`Method '${t}' is not supported by the negotiated protocol version (wire era ${e.era})`,{method:t,era:e.era})}_requestWithSchema(e,t,r){let i=this._resolveOutboundCodec(e.method);return this._assertOutboundRequestInEra(i,e.method),this._requestWithSchemaViaCodec(i,e,t,r)}_requestWithSchemaViaCodec(e,t,r,i){let o,n,{relatedRequestId:a,resumptionToken:s,onresumptiontoken:d,headers:c}=i??{},l=Date.now();return new Promise((p,u)=>{let m=e=>{u(e)};if(!this._transport)return void m(Error("Not connected"));if(this._options?.enforceStrictCapabilities===!0)try{this.assertCapabilityForMethod(t.method)}catch(e){m(e);return}if(i?.signal?.aborted){let e=i.signal.reason;throw e instanceof kL?e:new kL(kF.RequestTimeout,String(e))}let f=e.era===wI&&!0===this._transport.hasPerRequestStream?new AbortController:void 0,h=this._requestMessageId++;n=h;let y={...t,jsonrpc:"2.0",id:h};i?.onprogress&&(this._progressHandlers.set(h,i.onprogress),y.params={...t.params,_meta:{...t.params?._meta,progressToken:h}});let g=this._envelopeOutbound(y),_=!1,v=e=>{_||(this._progressHandlers.delete(h),void 0===f?"initialize"!==t.method&&this._transport?.send(this._envelopeOutbound({jsonrpc:"2.0",method:"notifications/cancelled",params:{requestId:h,reason:String(e)}}),{relatedRequestId:a,resumptionToken:s,onresumptiontoken:d}).catch(e=>this._onerror(Error(`Failed to send cancellation: ${e}`))):f.abort(),u(e instanceof kL?e:new kL(kF.RequestTimeout,String(e))))};this._responseHandlers.set(h,o=>{let n;if(!i?.signal?.aborted){if(_=!0,o instanceof Error)return u(o);try{n=e.decodeResult(t.method,o.result)}catch(e){return u(e instanceof Error?e:Error(String(e)))}if("invalid"===n.kind)return u(n.error);if("input_required"===n.kind){var a;return i?.allowInputRequired===!0?p({resultType:"input_required",inputRequests:(a=n).inputRequests,...void 0!==a.requestState&&{requestState:a.requestState},...void 0!==a._meta&&{_meta:a._meta}}):p(this._resolveNonCompleteResult(n,{codec:e,request:t,resultSchema:r,options:i,flowStartedAt:l,retry:(i,o)=>this._requestWithSchemaViaCodec(e,void 0===i?{method:t.method}:{method:t.method,params:i},r,o)}))}wQ(r,n.result).then(e=>{e.success?p(e.data):u(new kL(kF.InvalidResult,`Invalid result for ${t.method}: ${e.error}`))},u)}}),o=()=>v(i?.signal?.reason),i?.signal?.addEventListener("abort",o,{once:!0});let b=i?.timeout??6e4;this._setupTimeout(h,b,i?.maxTotalTimeout,()=>v(new kL(kF.RequestTimeout,"Request timed out",{timeout:b})),i?.resetTimeoutOnProgress??!1),this._transport.send(g,{relatedRequestId:a,resumptionToken:s,onresumptiontoken:d,headers:c,requestSignal:f?.signal}).catch(e=>{this._progressHandlers.delete(h),u(e)})}).finally(()=>{o&&i?.signal?.removeEventListener("abort",o),void 0!==n&&(this._responseHandlers.delete(n),this._cleanupTimeout(n))})}async notification(e,t){return await this._notificationViaCodec(this._resolveOutboundCodec(e.method),e,t)}async _notificationViaCodec(e,t,r){if(!this._transport)throw new kL(kF.NotConnected,"Not connected");if(wT(t.method)&&!e.hasNotificationMethod(t.method))throw new kL(kF.MethodNotSupportedByProtocolVersion,`Notification '${t.method}' is not supported by the negotiated protocol version (wire era ${e.era})`,{method:t.method,era:e.era});this.assertNotificationCapability(t.method);let i=this._envelopeOutbound({jsonrpc:"2.0",...t});if((this._options?.debouncedNotificationMethods??[]).includes(t.method)&&!t.params&&r?.relatedRequestId===void 0){if(this._pendingDebouncedNotifications.has(t.method))return;this._pendingDebouncedNotifications.add(t.method),Promise.resolve().then(()=>{this._pendingDebouncedNotifications.delete(t.method),this._transport&&this._transport?.send(i,r).catch(e=>this._onerror(e))});return}await this._transport.send(i,r)}setRequestHandler(e,t,r){let i;if(this.assertRequestHandlerCapability(e),"function"==typeof t){if(!wC(e))throw TypeError(`'${e}' is not a spec request method; pass schemas as the second argument to setRequestHandler().`);i=(r,i)=>{let o=this._negotiatedWireCodec(),n=o.validateRequest(e,r);if(n.ok||"not-in-era"!==n.reason||(n=o.validateInputRequest(e,r)),!n.ok){if("not-in-era"===n.reason)throw new wl(wc.InternalError,`No wire schema for ${e} in the resolved era`);throw Error(n.message)}return Promise.resolve(t(n.value,i))}}else if(r)i=async(i,o)=>{let n=await wQ(t.params,{...i.params});if(!n.success)throw new wl(wc.InvalidParams,`Invalid params for ${e}: ${n.error}`);return r(n.data,o)};else throw TypeError("setRequestHandler: handler is required");"function"==typeof t?this._customSchemaRequestMethods.delete(e):this._customSchemaRequestMethods.add(e),this._requestHandlers.set(e,this._wrapHandler(e,i))}_wrapHandler(e,t){return t}_outboundServerInfo(){}removeRequestHandler(e){this._requestHandlers.delete(e),this._customSchemaRequestMethods.delete(e)}assertCanSetRequestHandler(e){if(this._requestHandlers.has(e))throw Error(`A request handler for ${e} already exists, which would be overridden`)}setNotificationHandler(e,t,r){if("function"==typeof t){if(!wT(e))throw TypeError(`'${e}' is not a spec notification method; pass schemas as the second argument to setNotificationHandler().`);this._notificationHandlers.set(e,(r,i)=>{let o=i.validateNotification(e,r);if(!o.ok){if("not-in-era"===o.reason)throw new wl(wc.InternalError,`No wire schema for ${e} in the resolved era`);throw Error(o.message)}return Promise.resolve(t(o.value))});return}if(!r)throw TypeError("setNotificationHandler: handler is required");this._notificationHandlers.set(e,async i=>{let o=await wQ(t.params,{...i.params});if(!o.success)throw new wl(wc.InvalidParams,`Invalid params for notification ${e}: ${o.error}`);await r(o.data,i)})}removeNotificationHandler(e){this._notificationHandlers.delete(e)}};function Pn(e){return null!==e&&"object"==typeof e&&!Array.isArray(e)}function Pa(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function Ps(e){throw new kL(kF.SendFailed,`ctx.mcpReq.${e} is not available while fulfilling an embedded input request: the request is fulfilled locally and has no related peer request`)}(kO(e=>{var t=/; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g,r=/\\([\u000b\u0020-\u00ff])/g,i=/^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;function o(e){this.parameters=Object.create(null),this.type=e}e.parse=function(e){if(!e)throw TypeError("argument string is required");var n,a,s,d="object"==typeof e?function(e){var t;if("function"==typeof e.getHeader?t=e.getHeader("content-type"):"object"==typeof e.headers&&(t=e.headers&&e.headers["content-type"]),"string"!=typeof t)throw TypeError("content-type header is missing from object");return t}(e):e;if("string"!=typeof d)throw TypeError("argument string is required to be a string");var c=d.indexOf(";"),l=-1!==c?d.slice(0,c).trim():d.trim();if(!i.test(l))throw TypeError("invalid media type");var p=new o(l.toLowerCase());if(-1!==c){for(t.lastIndex=c;a=t.exec(d);){if(a.index!==c)throw TypeError("invalid parameter format");c+=a[0].length,n=a[1].toLowerCase(),34===(s=a[2]).charCodeAt(0)&&-1!==(s=s.slice(1,-1)).indexOf("\\")&&(s=s.replace(r,"$1")),p.parameters[n]=s}if(c!==d.length)throw TypeError("invalid parameter format")}return p}}))();var Pd=class{_buffer;_maxBufferSize;constructor(e){this._maxBufferSize=e?.maxBufferSize??0xa00000}append(e){if((this._buffer?.length??0)+e.length>this._maxBufferSize)throw this.clear(),Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);this._buffer=this._buffer?Buffer.concat([this._buffer,e]):e}readMessage(){for(;this._buffer;){let t=this._buffer.indexOf("\n");if(-1===t)break;let r=this._buffer.toString("utf8",0,t).replace(/\r$/,"");this._buffer=this._buffer.subarray(t+1);try{var e;return e=r,aA.parse(JSON.parse(e))}catch(e){if(e instanceof SyntaxError)continue;throw e}}return null}clear(){this._buffer=void 0}};let Pc=ed("../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"),Pl="win32"===N.platform?["APPDATA","COMSPEC","HOMEDRIVE","HOMEPATH","LOCALAPPDATA","PATH","PATHEXT","PROCESSOR_ARCHITECTURE","PROGRAMDATA","PROGRAMFILES","PROGRAMFILES(X86)","PROGRAMW6432","SYSTEMDRIVE","SYSTEMROOT","TEMP","USERNAME","USERPROFILE","WINDIR"]:["HOME","LOGNAME","PATH","SHELL","TERM","USER"];var Pp=class{_process;_readBuffer;_serverParams;_stderrStream=null;onclose;onerror;onmessage;constructor(e){this._serverParams=e,this._readBuffer=new Pd({maxBufferSize:e.maxBufferSize}),("pipe"===e.stderr||"overlapped"===e.stderr)&&(this._stderrStream=new F)}async start(){if(this._process)throw Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");return new Promise((e,t)=>{this._process=Pc(this._serverParams.command,this._serverParams.args??[],{env:{...function(){let e={};for(let t of Pl){let r=N.env[t];void 0!==r&&(r.startsWith("()")||(e[t]=r))}return e}(),...this._serverParams.env},stdio:["pipe","pipe",this._serverParams.stderr??"inherit"],shell:!1,windowsHide:"win32"===N.platform,cwd:this._serverParams.cwd}),this._process.on("error",e=>{t(e),this.onerror?.(e)}),this._process.on("spawn",()=>{e()}),this._process.on("close",e=>{this._process=void 0,this.onclose?.()}),this._process.stdin?.on("error",e=>{this.onerror?.(e)}),this._process.stdout?.on("data",e=>{try{this._readBuffer.append(e),this.processReadBuffer()}catch(e){this.onerror?.(e),this.close().catch(()=>{})}}),this._process.stdout?.on("error",e=>{this.onerror?.(e)}),this._stderrStream&&this._process.stderr&&this._process.stderr.pipe(this._stderrStream)})}get stderr(){return this._stderrStream?this._stderrStream:this._process?.stderr??null}get pid(){return this._process?.pid??null}processReadBuffer(){for(;;)try{let e=this._readBuffer.readMessage();if(null===e)break;this.onmessage?.(e)}catch(e){this.onerror?.(e)}}async _dispose(){let e=this._process;if(this._process=void 0,e&&null===e.exitCode&&null===e.signalCode){let t=new Promise(t=>e.once("exit",()=>t()));try{e.stdin?.end()}catch{}try{e.kill("SIGTERM")}catch{}if(await Promise.race([t,new Promise(e=>setTimeout(e,1e3).unref())]),null===e.exitCode&&null===e.signalCode)try{e.kill("SIGKILL")}catch{}await t}try{e?.stdout?.destroy()}catch{}try{e?.stdin?.destroy()}catch{}try{e?.stderr?.destroy()}catch{}this._readBuffer.clear()}async close(){if(this._process){let e=this._process;this._process=void 0;let t=new Promise(t=>{e.once("close",()=>{t()})});try{e.stdin?.end()}catch{}if(await Promise.race([t,new Promise(e=>setTimeout(e,2e3).unref())]),null===e.exitCode){try{e.kill("SIGTERM")}catch{}await Promise.race([t,new Promise(e=>setTimeout(e,2e3).unref())])}if(null===e.exitCode)try{e.kill("SIGKILL")}catch{}}this._readBuffer.clear()}send(e){return new Promise(t=>{if(!this._process?.stdin)throw new kL(kF.NotConnected,"Not connected");let r=JSON.stringify(e)+"\n";this._process.stdin.write(r)?t():this._process.stdin.once("drain",t)})}};let Pu=new TextEncoder,Pm=new TextDecoder,Pf=new TextDecoder("utf-8",{fatal:!0});function Ph(...e){let t=new Uint8Array(e.reduce((e,{length:t})=>e+t,0)),r=0;for(let i of e)t.set(i,r),r+=i.length;return t}function Py(e,t,r){if(t<0||t>=0x100000000)throw RangeError(`value must be >= 0 and <= 4294967295. Received ${t}`);e.set([t>>>24,t>>>16,t>>>8,255&t],r)}function Pg(e){let t=Math.floor(e/0x100000000),r=new Uint8Array(8);return Py(r,t,0),Py(r,e%0x100000000,4),r}function P_(e){let t=new Uint8Array(4);return Py(t,e),t}let Pv=/[^\x00-\x7f]/;function Pb(e){if("string"==typeof e&&e.length>=128){if(Pv.test(e))throw TypeError("non-ASCII string encountered in encode()");return Pu.encode(e)}let t=new Uint8Array(e.length);for(let r=0;r<e.length;r++){let i=e.charCodeAt(r);if(i>127)throw TypeError("non-ASCII string encountered in encode()");t[r]=i}return t}function P$(e,t=!1){if(Uint8Array.prototype.toBase64)return e.toBase64({alphabet:t?"base64url":"base64",omitPadding:t});let r=[];for(let t=0;t<e.length;t+=32768)r.push(String.fromCharCode.apply(null,e.subarray(t,t+32768)));let i=btoa(r.join(""));return t?i.replace(/=/g,"").replace(/\+/g,"-").replace(/\//g,"_"):i}function PS(e,t=!1){if(Uint8Array.fromBase64)return Uint8Array.fromBase64(e,{alphabet:t?"base64url":"base64"});if(t){if(e.includes("+")||e.includes("/"))throw TypeError("Invalid base64url");e=e.replace(/-/g,"+").replace(/_/g,"/")}let r=atob(e),i=new Uint8Array(r.length);for(let e=0;e<r.length;e++)i[e]=r.charCodeAt(e);return i}async function Pk(e,t){let r=`SHA-${e.slice(-3)}`;return new Uint8Array(await crypto.subtle.digest(r,t))}class Pw extends Error{static code="ERR_JOSE_GENERIC";code="ERR_JOSE_GENERIC";constructor(e,t){super(e,t),this.name=this.constructor.name,Error.captureStackTrace?.(this,this.constructor)}}class PP extends Pw{static code="ERR_JWT_CLAIM_VALIDATION_FAILED";code="ERR_JWT_CLAIM_VALIDATION_FAILED";claim;reason;payload;constructor(e,t,r="unspecified",i="unspecified"){super(e,{cause:{claim:r,reason:i,payload:t}}),this.claim=r,this.reason=i,this.payload=t}}class PV extends Pw{static code="ERR_JWT_EXPIRED";code="ERR_JWT_EXPIRED";claim;reason;payload;constructor(e,t,r="unspecified",i="unspecified"){super(e,{cause:{claim:r,reason:i,payload:t}}),this.claim=r,this.reason=i,this.payload=t}}class PR extends Pw{static code="ERR_JOSE_ALG_NOT_ALLOWED";code="ERR_JOSE_ALG_NOT_ALLOWED"}class Pq extends Pw{static code="ERR_JOSE_NOT_SUPPORTED";code="ERR_JOSE_NOT_SUPPORTED"}class PI extends Pw{static code="ERR_JWE_DECRYPTION_FAILED";code="ERR_JWE_DECRYPTION_FAILED";constructor(e="decryption operation failed",t){super(e,t)}}class Px extends Pw{static code="ERR_JWE_INVALID";code="ERR_JWE_INVALID"}class Pj extends Pw{static code="ERR_JWS_INVALID";code="ERR_JWS_INVALID"}class PC extends Pw{static code="ERR_JWT_INVALID";code="ERR_JWT_INVALID"}class PT extends Pw{static code="ERR_JWK_INVALID";code="ERR_JWK_INVALID"}class PO extends Pw{static code="ERR_JWKS_INVALID";code="ERR_JWKS_INVALID"}class PE extends Pw{static code="ERR_JWKS_NO_MATCHING_KEY";code="ERR_JWKS_NO_MATCHING_KEY";constructor(e="no applicable key found in the JSON Web Key Set",t){super(e,t)}}class PA extends Pw{[Symbol.asyncIterator]=async function*(){};static code="ERR_JWKS_MULTIPLE_MATCHING_KEYS";code="ERR_JWKS_MULTIPLE_MATCHING_KEYS";constructor(e="multiple matching keys found in the JSON Web Key Set",t){super(e,t)}}class PW extends Pw{static code="ERR_JWKS_TIMEOUT";code="ERR_JWKS_TIMEOUT";constructor(e="request timed out",t){super(e,t)}}class PM extends Pw{static code="ERR_JWS_SIGNATURE_VERIFICATION_FAILED";code="ERR_JWS_SIGNATURE_VERIFICATION_FAILED";constructor(e="signature verification failed",t){super(e,t)}}function PN(e){try{return PS("string"==typeof e?e:Pm.decode(e),!0)}catch(e){throw TypeError("The input to be decoded is not correctly encoded.",{cause:e})}}function Pz(e){return P$("string"==typeof e?Pu.encode(e):e,!0)}function PD(e,t){if(!(e instanceof Uint8Array))throw TypeError(`${t} must be an instance of Uint8Array`)}function PF(e){if("object"!=typeof e||null===e||"[object Object]"!==Object.prototype.toString.call(e))return!1;let t=Object.getPrototypeOf(e);return null===t||null===Object.getPrototypeOf(t)}function PL(e){return PF(e)&&Array.isArray(e.keys)&&Array.from(e.keys).every(PF)}function PU(...e){let t=new Set;for(let r of e)if(r)for(let e of Object.keys(r)){if(t.has(e))return!1;t.add(e)}return!0}function PH(e,t){if(void 0!==e)throw TypeError(`${t} can only be called once`)}function PG(e,t,r){try{return PN(e)}catch{throw new r(`Failed to base64url decode the ${t}`)}}function PB(e,t,r){try{return Pb(e)}catch{throw new r(`The ${t} is not a valid base64url string`)}}function PK(e,t,r){let i;try{i=JSON.parse(Pf.decode(PN(e)))}catch{throw new t(r)}if(!PF(i))throw new t(r);return i}let PJ={__proto__:null,b64:!0},PZ={__proto__:null};function PQ(e,t){if(void 0!==t&&(!Array.isArray(t)||t.some(e=>"string"!=typeof e)))throw TypeError(`"${e}" option must be an array of strings`);return void 0===t?void 0:new Set(t)}function PX(e,t){let{crit:r}=t??{};if(Array.isArray(r)&&new Set(r).size!==r.length)throw new e('"crit" (Critical) Header Parameter MUST NOT contain duplicate values')}function PY(e,t,r,i,o){if(void 0!==o.crit&&i?.crit===void 0)throw new e('"crit" (Critical) Header Parameter MUST be integrity protected');if(!i||void 0===i.crit)return[];if(!Array.isArray(i.crit)||0===i.crit.length||i.crit.some(e=>"string"!=typeof e||0===e.length))throw new e('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');let n=void 0===r?t:{__proto__:null,...r,...t};for(let t of i.crit){if(!(t in n))throw new Pq(`Extension Header Parameter "${t}" is not recognized`);if(!Object.hasOwn(o,t)||void 0===o[t])throw new e(`Extension Header Parameter "${t}" is missing`);if(n[t]&&(!Object.hasOwn(i,t)||void 0===i[t]))throw new e(`Extension Header Parameter "${t}" MUST be integrity protected`)}return i.crit}function P1(e,t){if(t.includes("b64")){let t=e.b64;if("boolean"!=typeof t)throw new Pj('The "b64" (base64url-encode payload) Header Parameter must be a boolean');return t}return!0}function P0(e,t){let r,i;try{r=JSON.stringify(t),i=JSON.parse(r)}catch(t){throw new e("JOSE Header is not valid JSON",{cause:t})}if(!PF(i))throw new e("JOSE Header is not a JSON object");return[i,r]}async function P2(e,t,r){let i,o,{alg:n,secret:a}=e,s="decrypt"===r||"sign"===r;if(a&&t instanceof Uint8Array)return t;if(PF(t)){if("string"!=typeof(i=Va(t)).kty)throw Ve(n,t,a);if(!(a?"oct"===i.kty&&"string"==typeof i.k:"oct"!==i.kty&&(s?"AKP"===i.kty&&"string"==typeof i.priv||"string"==typeof i.d:void 0===i.d&&void 0===i.priv)))throw TypeError(a?'JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present':`JSON Web Key for this operation must be a ${s?"private":"public"} JWK`);if(((e,t,r)=>{let{alg:i}=e;if(void 0!==t.use){let e="sign"===r||"verify"===r?"sig":"enc";if(t.use!==e)throw TypeError(`Invalid key for this operation, its "use" must be "${e}" when present`)}if(void 0!==t.alg&&t.alg!==i)throw TypeError(`Invalid key for this operation, its "alg" must be "${i}" when present`);if(Array.isArray(t.key_ops)){let i="encrypt"===r||"decrypt"===r?e.ops?.[+("encrypt"!==r)]:r;if(i&&!t.key_ops.includes(i))throw TypeError(`Invalid key for this operation, its "key_ops" must include "${i}" when present`)}})(e,i,r),"oct"===i.kty)return PN(i.k);if(!Object.isFrozen(t)){let{key_ops:e}=t;Array.isArray(e)&&Object.freeze(e),Object.freeze(t)}}else{if(!P5(t))throw Ve(n,t,a);let e=a?"secret":s?"private":"public";if(t.type!==e&&(a||["secret","public","private"].includes(t.type)))throw TypeError(`${t[Symbol.toStringTag]} instances must be of type "${e}" for the ${n} algorithm`);if(P3(t))return t;if("secret"===(o=t).type)return o.export()}let d=(m||=new WeakMap).get(t);if(d?.[n])return d[n];if(d||m.set(t,d={}),o&&"function"==typeof o.toCryptoKey){let t="public"===o.type,r=P4[o.asymmetricKeyDetails?.namedCurve],i=e.resolve?.({crv:r,asymmetricKeyType:o.asymmetricKeyType})??e.subtle;return d[n]=o.toCryptoKey(i,t,e.usages[+!t])}return(i??=o.export({format:"jwk"})).alg=n,d[n]=await Vd(e,i)}let P4={__proto__:null,prime256v1:"P-256",secp384r1:"P-384",secp521r1:"P-521"};function P6(e){if(!P3(e))throw Error("CryptoKey instance expected")}let P3=e=>{if(e?.[Symbol.toStringTag]==="CryptoKey")return!0;try{return e instanceof CryptoKey}catch{return!1}},P9=e=>e?.[Symbol.toStringTag]==="KeyObject",P5=e=>P3(e)||P9(e);function P8(e,t,...r){if(r.length>2){let t=r.pop();e+=`one of type ${r.join(", ")}, or ${t}.`}else 2===r.length?e+=`one of type ${r[0]} or ${r[1]}.`:e+=`of type ${r[0]}.`;return null==t?e+=` Received ${t}`:"function"==typeof t&&t.name?e+=` Received function ${t.name}`:"object"==typeof t&&null!=t&&t.constructor?.name&&(e+=` Received an instance of ${t.constructor.name}`),e}let P7=(e,...t)=>P8("Key must be ",e,...t);function Ve(e,t,r){let i=["CryptoKey","KeyObject","JSON Web Key"];return r&&i.push("Uint8Array"),TypeError(P8(`Key for the ${e} algorithm must be `,t,...i))}let Vt=(e,t="algorithm.name")=>TypeError(`CryptoKey does not support this operation, its ${t} must be ${e}`);function Vr(e,t){if(t&&!e.usages.includes(t))throw TypeError(`CryptoKey does not support this operation, its usages must include ${t}.`)}function Vi(e,t){let{modulusLength:r}=t.algorithm;if("number"!=typeof r||r<2048)throw TypeError(`${e} requires key modulusLength to be 2048 bits or larger`)}function Vo(e,t,r){let i=e.algorithm;if(i.name!==t.name)throw Vt(t.name);if(t.hash&&i.hash?.name!==t.hash)throw Vt(t.hash,"algorithm.hash");if(t.namedCurve&&i.namedCurve!==t.namedCurve)throw Vt(t.namedCurve,"algorithm.namedCurve");if(void 0!==t.length&&i.length!==t.length)throw Vt(t.length,"algorithm.length");Vr(e,r)}function Vn(e){return{__proto__:null,...e}}function Va(e){let t=Vn(e);if(void 0!==t.ext&&"boolean"!=typeof t.ext)throw TypeError('"ext" (Extractable) Parameter must be a boolean');if(void 0!==t.key_ops){let e=t.key_ops,r=Array.isArray(e)?[...e]:void 0;if(!r||r.some(e=>"string"!=typeof e)||new Set(r).size!==r.length)throw TypeError('"key_ops" (Key Operations) Parameter must be an array of unique strings');t.key_ops=r}return t}function Vs(e){if(void 0!==e&&"boolean"!=typeof e)throw TypeError('"extractable" option must be a boolean');return e}async function Vd(e,t,r){if(!e.kty.includes(t.kty))throw new Pq('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');let i=e.resolve?.({kty:t.kty,crv:t.crv})??e.subtle,o=!!(t.d||t.priv),n={...t,ext:r??t.ext};return"AKP"!==n.kty&&delete n.alg,delete n.use,crypto.subtle.importKey("jwk",n,i,n.ext??!o,t.key_ops??e.usages[+!!o])}async function Vc(e,t,r,i=!1){return e instanceof Uint8Array&&(e=await crypto.subtle.importKey("raw",e,t,i,[r])),Vo(e,t,r),e}let Vl=e=>crypto.getRandomValues(new Uint8Array(e.cekBits>>3));function Vp(e,t){let r=e.byteLength<<3;if(r!==t)throw new Px(`Invalid Content Encryption Key length. Expected ${t} bits, got ${r} bits`)}function Vu(e,t){if(t.length<<3!==e.ivBits)throw new Px("Invalid Initialization Vector length")}async function Vm(e,t,r){if(!(t instanceof Uint8Array))throw TypeError(P7(t,"Uint8Array"));let i=e.cekBits>>1;return[await crypto.subtle.importKey("raw",t.subarray(i>>3),"AES-CBC",!1,[r]),await crypto.subtle.importKey("raw",t.subarray(0,i>>3),{hash:`SHA-${i<<1}`,name:"HMAC"},!1,["sign"]),i]}async function Vf(e,t,r){return new Uint8Array((await crypto.subtle.sign("HMAC",e,t)).slice(0,r>>3))}async function Vh(e,t,r,i,o){if(!P3(r)&&!(r instanceof Uint8Array))throw TypeError(P7(r,"CryptoKey","KeyObject","Uint8Array","JSON Web Key"));if(i?Vu(e,i):i=crypto.getRandomValues(new Uint8Array(e.ivBits>>3)),r instanceof Uint8Array&&Vp(r,e.cekBits),e.cbc)return async function(e,t,r,i,o){let[n,a,s]=await Vm(e,r,"encrypt"),d=new Uint8Array(await crypto.subtle.encrypt({iv:i,name:"AES-CBC"},n,t)),c=Ph(o,i,d,Pg(8*o.length));return{ciphertext:d,tag:await Vf(a,c,s),iv:i}}(e,t,r,i,o);let n=await Vc(r,e.subtle,"encrypt"),a=new Uint8Array(await crypto.subtle.encrypt({additionalData:o,iv:i,name:"AES-GCM",tagLength:128},n,t));return{ciphertext:a.subarray(0,-16),tag:a.subarray(-16),iv:i}}async function Vy(e,t,r,i,o,n){if(!P3(t)&&!(t instanceof Uint8Array))throw TypeError(P7(t,"CryptoKey","KeyObject","Uint8Array","JSON Web Key"));if(!i)throw new Px("JWE Initialization Vector missing");if(!o)throw new Px("JWE Authentication Tag missing");if(!e.cbc&&16!==o.length)throw new Px("Invalid Authentication Tag length");if(Vu(e,i),t instanceof Uint8Array&&Vp(t,e.cekBits),e.cbc)return async function(e,t,r,i,o,n){let[a,s,d]=await Vm(e,t,"decrypt"),c=Ph(n,i,r,Pg(8*n.length)),l=await Vf(s,c,d);try{if(await async function(e,t){let r={name:"HMAC",hash:"SHA-256"},i=await crypto.subtle.generateKey(r,!1,["sign","verify"]),o=await crypto.subtle.sign(r,i,e);return crypto.subtle.verify(r,i,o,t)}(o,l))return new Uint8Array(await crypto.subtle.decrypt({iv:i,name:"AES-CBC"},a,r))}catch{}throw new PI}(e,t,r,i,o,n);let a=await Vc(t,e.subtle,"decrypt");try{return new Uint8Array(await crypto.subtle.decrypt({additionalData:n,iv:i,name:"AES-GCM",tagLength:128},a,Ph(r,o)))}catch{throw new PI}}function Vg(e){let t={__proto__:null};for(let r in e)t[r]={...e[r],alg:r};return t}let V_=[["encrypt","wrapKey"],["decrypt","unwrapKey"]],Vv=[[],["deriveBits"]],Vb=[[],[]];function V$(e){return{kty:["RSA"],mode:"key-encryption",subtle:{name:"RSA-OAEP",hash:`SHA-${e}`},usages:V_,ops:["wrapKey","unwrapKey"]}}function VS(e){return{kty:["EC","OKP"],mode:e,subtle:{name:"ECDH"},resolve:({kty:e,crv:t,asymmetricKeyType:r})=>{if("X25519"===t||"x25519"===r)return{name:"X25519"};if("OKP"===e)throw new Pq('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');return{name:"ECDH",namedCurve:t}},usages:Vv,ops:[void 0,"deriveBits"]}}function Vk(e,t=!1){return{kty:["oct"],mode:"key-wrapping",secret:!0,subtle:{name:t?"AES-GCM":"AES-KW",length:e},usages:Vb,ops:t?["encrypt","decrypt"]:["wrapKey","unwrapKey"]}}function Vw(){return{kty:["oct"],mode:"key-wrapping",secret:!0,subtle:{name:"PBKDF2"},usages:Vb,ops:["deriveBits","deriveBits"]}}let VP=Vg({dir:{kty:["oct"],mode:"direct-encryption",secret:!0,subtle:{name:"AES-GCM"},usages:Vb,ops:["encrypt","decrypt"]},"RSA-OAEP":V$(1),"RSA-OAEP-256":V$(256),"RSA-OAEP-384":V$(384),"RSA-OAEP-512":V$(512),"ECDH-ES":VS("direct-key-agreement"),"ECDH-ES+A128KW":VS("key-agreement-with-key-wrapping"),"ECDH-ES+A192KW":VS("key-agreement-with-key-wrapping"),"ECDH-ES+A256KW":VS("key-agreement-with-key-wrapping"),A128KW:Vk(128),A192KW:Vk(192),A256KW:Vk(256),A128GCMKW:Vk(128,!0),A192GCMKW:Vk(192,!0),A256GCMKW:Vk(256,!0),"PBES2-HS256+A128KW":Vw(),"PBES2-HS384+A192KW":Vw(),"PBES2-HS512+A256KW":Vw()}),VV=["encrypt","decrypt"];function VR(e,t=!1){return{kty:["oct"],secret:!0,subtle:{name:t?"AES-CBC":"AES-GCM",length:e},usages:Vb,ops:VV,cekBits:e,ivBits:t?128:96,cbc:t}}let Vq=Vg({A128GCM:VR(128),A192GCM:VR(192),A256GCM:VR(256),"A128CBC-HS256":VR(256,!0),"A192CBC-HS384":VR(384,!0),"A256CBC-HS512":VR(512,!0)});function VI(e,t){throw new Pq(`Invalid or unsupported "${e}" (JWE ${t}) header value`)}function Vx(e){return("string"==typeof e?VP[e]:void 0)??VI("alg","Algorithm")}function Vj(e){return"key-wrapping"===e.mode||"key-encryption"===e.mode||"key-agreement-with-key-wrapping"===e.mode}function VC(e){return("string"==typeof e?Vq[e]:void 0)??VI("enc","Encryption Algorithm")}function VT(e,t){if("ECDH"!==e.algorithm.name&&"X25519"!==e.algorithm.name)throw TypeError("CryptoKey does not support this operation, its algorithm.name must be ECDH or X25519");Vr(e,t)}function VO(e,t,r){Vo(t,Vx(e).subtle,r),Vi(e,t)}async function VE(e,t,r,i){if(!(e instanceof Uint8Array)||e.length<8)throw new Px("PBES2 Salt Input must be 8 or more octets");if(!Number.isSafeInteger(r)||1!==Math.sign(r))throw new Px("PBES2 Count Input must be a positive integer");let o=Ph(Pb(t),Uint8Array.of(0),e),n=parseInt(t.slice(13,16),10),a={hash:`SHA-${t.slice(8,11)}`,iterations:r,name:"PBKDF2",salt:o},s=await Vc(i,Vx(t).subtle,"deriveBits");return new Uint8Array(await crypto.subtle.deriveBits(a,s,n))}function VA(e){return Ph(P_(e.length),e)}async function VW(e,t,r,i,o=new Uint8Array,n=new Uint8Array){VT(e),VT(t,"deriveBits");let a=Ph(VA(Pb(r)),VA(o),VA(n),P_(i));return async function(e,t,r){let i=t>>3,o=Math.ceil(i/32),n=new Uint8Array(32*o);for(let t=1;t<=o;t++){let i=await Pk("sha256",Ph(P_(t),e,r));n.set(i,(t-1)*32)}return n.slice(0,i)}(new Uint8Array(await crypto.subtle.deriveBits({name:e.algorithm.name,public:e},t,"X25519"===e.algorithm.name?256:Math.ceil(parseInt(e.algorithm.namedCurve.slice(-3),10)/8)<<3)),i,a)}function VM(e){P6(e);let t=e.algorithm.namedCurve;if("P-256"!==t&&"P-384"!==t&&"P-521"!==t&&"X25519"!==e.algorithm.name)throw new Pq("ECDH with the provided key is not allowed or not supported by your javascript runtime")}function VN(e,t){let r=e[t];if(void 0!==r){if("string"!=typeof r)throw new Px(`JOSE Header "${t}" (Agreement Party${"apu"===t?"U":"V"}Info) invalid`);return PG(r,t,Px)}}function Vz(e,t){if(void 0!==e&&void 0!==t&&e.byteLength===t.byteLength){for(let r=0;r<e.byteLength;r++)if(e[r]!==t[r])return;throw new Px('JOSE Header "apu" and "apv" values must be distinct')}}function VD(e){if(void 0!==e)throw new Px("Encountered unexpected JWE Encrypted Key")}async function VF(e,t,r,i,o,n={}){let a,s,{alg:d,mode:c}=e,l=Vj(e);if(void 0!==o&&!l)throw TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${d}`);let p=await P2("direct-encryption"===c?t:e,r,"encrypt");if("direct-encryption"===c)return[p,void 0,void 0];let u=l?o??Vl(t):void 0;switch(u&&Vp(u,t.cekBits),e.subtle.name){case"ECDH":{let r;VM(p);let{apu:o,apv:a}=n;void 0!==o&&PD(o,'"apu"'),void 0!==a&&PD(a,'"apv"');let l=o??VN(i,"apu"),u=a??VN(i,"apv");Vz(l,u),r=void 0!==n.epk?await P2(e,n.epk,"decrypt"):(await crypto.subtle.generateKey(p.algorithm,!0,["deriveBits"])).privateKey;let m=crypto.subtle,f=r;if(!f.extractable){if("function"!=typeof m.getPublicKey)throw TypeError('CryptoKey for "epk" must be extractable');f=await m.getPublicKey(r,[])}let{x:h,y,crv:g,kty:_}=await m.exportKey("jwk",f),v="direct-key-agreement"===c,b=await VW(p,r,v?t.alg:d,v?t.cekBits:parseInt(d.slice(-5,-2),10),l,u),$={x:h,crv:g,kty:_};if("EC"===_&&($.y=y),s={epk:$},void 0!==o&&(s.apu=Pz(o)),void 0!==a&&(s.apv=Pz(a)),v)return[b,void 0,s];p=b;break}case"RSA-OAEP":P6(p),VO(d,p,"encrypt"),a=new Uint8Array(await crypto.subtle.encrypt("RSA-OAEP",p,u));break;case"PBKDF2":{let{p2c:e=2048,p2s:t=crypto.getRandomValues(new Uint8Array(16))}=n;p=await VE(t,d,e,p),s={p2c:e,p2s:Pz(t)};break}case"AES-GCM":{let e=void 0===n.iv?crypto.getRandomValues(new Uint8Array(12)):n.iv;if(!(e instanceof Uint8Array))throw TypeError('"iv" must be an instance of Uint8Array');let t=await Vh(VC(d.slice(0,-2)),u,p,e,new Uint8Array);a=t.ciphertext,s={iv:Pz(t.iv),tag:Pz(t.tag)}}}if(!((a??=await async function(e,t,r){let i=await Vc(t,Vx(e).subtle,"wrapKey",!0),o=await crypto.subtle.importKey("raw",r,{hash:"SHA-256",name:"HMAC"},!0,["sign"]);return new Uint8Array(await crypto.subtle.wrapKey("raw",o,i,"AES-KW"))}(d.slice(-6),p,u))instanceof Uint8Array)||!a.byteLength)throw TypeError("JWE key management algorithm did not produce an Encrypted Key");return[u,a,s]}function VL(e,t){if(void 0!==e.zip&&"DEF"!==e.zip)throw new Pq('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');if(void 0!==e.zip&&!t?.zip)throw new Px('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.')}function VU(e){if(typeof globalThis[e]>"u")throw new Pq(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${e} API.`)}async function VH(e,t,r=1/0){let i=e.writable.getWriter();i.write(t).catch(()=>{}),i.close().catch(()=>{});let o=[],n=0,a=e.readable.getReader();for(;;){let{value:e,done:t}=await a.read();if(t)break;if(o.push(e),n+=e.byteLength,1/0!==r&&n>r)throw new Px("Decompressed plaintext exceeded the configured limit")}return Ph(...o)}function VG(e){let{aad:t,ciphertext:r,iv:i,protected:o,tag:n,unprotected:a}=e;if(void 0!==i&&("string"!=typeof i||!i))throw new Px("JWE Initialization Vector incorrect type");if("string"!=typeof r)throw new Px("JWE Ciphertext missing or incorrect type");if(void 0!==n&&("string"!=typeof n||!n))throw new Px("JWE Authentication Tag incorrect type");if(void 0!==o&&"string"!=typeof o)throw new Px("JWE Protected Header incorrect type");if(void 0!==t&&("string"!=typeof t||!t))throw new Px("JWE AAD incorrect type");if(void 0!==a&&!PF(a))throw new Px("JWE Shared Unprotected Header incorrect type");return{aad:t,ciphertext:r,iv:i,protected:o,tag:n,unprotected:void 0===a?void 0:{...a}}}function VB(e){let t,r;try{let{header:i}=e;if(PF(i)){r=i.alg;let e=Object.keys(i);e.includes("alg")||(r=void 0),t=Object.fromEntries(e.map(e=>[e,"alg"===e?r:i[e]]))}else t=i;let{encrypted_key:o}=e;return[{encrypted_key:o,header:t},r]}catch(e){return[void 0,r,e]}}function VK(e){let{encrypted_key:t,header:r}=e;if(void 0!==t&&"string"!=typeof t)throw new Px("JWE Encrypted Key incorrect type");if(void 0!==r&&!PF(r))throw new Px("JWE Per-Recipient Unprotected Header incorrect type");if(void 0===e.protected&&void 0===r&&void 0===e.unprotected)throw new Px("JOSE Header missing")}function VJ(e){let t,{protected:r,ciphertext:i,iv:o,tag:n,aad:a}=e;return void 0!==r&&(t=PK(r,Px,"JWE Protected Header is invalid")),[t,PG(i,"ciphertext",Px),void 0!==o?PG(o,"iv",Px):void 0,void 0!==n?PG(n,"tag",Px):void 0,PB((r??"")+(void 0!==a?`.${a}`:""),"aad",Px)]}function VZ(e){return[e&&PQ("keyManagementAlgorithms",e.keyManagementAlgorithms),e&&PQ("contentEncryptionAlgorithms",e.contentEncryptionAlgorithms),e?.crit,e?.maxPBES2Count,e?.maxDecompressedLength]}async function VQ(e,t,r,i=VJ(e)){let o,n,a,s,[d,c,l,p,u]=i,{header:m,unprotected:f,aad:h}=e;if(void 0!==m||void 0!==f){if(!PU(d,m,f))throw new Px("JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint");o={...d,...m,...f}}else o=d??{};let[y,g,_,v,b]=t,{encrypted_key:$}=e;PY(Px,PZ,_,d,o),VL(o,d);let{alg:S,enc:k}=o;if("string"!=typeof S||!S)throw new Px("missing JWE Algorithm (alg) in JWE Header");let w=VP[S];if(""===$&&(!w||!Vj(w)))throw new Px("JWE Encrypted Key incorrect type");let P=w?.mode==="integrated-encryption";if(!P&&("string"!=typeof k||!k))throw new Px("missing JWE Encryption Algorithm (enc) in JWE Header");if(y&&!y.has(S)||!y&&S.startsWith("PBES2"))throw new PR('"alg" (Algorithm) Header Parameter value not allowed');if(P){if(void 0!==k)throw new Px('JWE "enc" (Encryption Algorithm) Header Parameter must not be present for integrated encryption');if(l?.byteLength)throw new Px("JWE Initialization Vector must be empty for integrated encryption");if(p?.byteLength)throw new Px("JWE Authentication Tag must be empty for integrated encryption")}else{if(g&&!g.has(k))throw new PR('"enc" (Encryption Algorithm) Header Parameter value not allowed');n=VC(k)}if(void 0!==$)try{a=PG($,"encrypted_key",Px)}catch(e){if(!w||!Vj(w))throw e;a=new Uint8Array}let V=!1;"function"==typeof r&&(r=await r(d,e),V=!0);let R=w??Vx(S);Vj(R)&&void 0===a&&(a=new Uint8Array);let q=await P2("direct-encryption"===R.mode?n:R,r,"decrypt");if("integrated-encryption"===R.mode)s=await R.decrypt(q,a,c,u,d,o);else{let e,t=n;try{e=await async function(e,t,r,i,o,n){let{alg:a}=e,s=e.mode;if("direct-encryption"===s)return VD(i),r;let d="direct-key-agreement"===s;switch(d?VD(i):function(e){if(void 0===e)throw new Px("JWE Encrypted Key missing")}(i),e.subtle.name){case"ECDH":{let{epk:i}=o;if(!PF(i)||["d","k","p","q","dp","dq","qi","oth","priv"].some(e=>Object.hasOwn(i,e)))throw new Px('JOSE Header "epk" (Ephemeral Public Key) missing or invalid');VM(r);let n=await Vd(e,i),s=VN(o,"apu"),c=VN(o,"apv");Vz(s,c);let l=await VW(n,r,d?t.alg:a,d?t.cekBits:parseInt(a.slice(-5,-2),10),s,c);if(d)return l;r=l;break}case"RSA-OAEP":return P6(r),VO(a,r,"decrypt"),new Uint8Array(await crypto.subtle.decrypt("RSA-OAEP",r,i));case"PBKDF2":{if("number"!=typeof o.p2c)throw new Px('JOSE Header "p2c" (PBES2 Count) missing or invalid');if(void 0!==n&&1/0!==n&&(!Number.isSafeInteger(n)||n<1))throw TypeError("maxPBES2Count must be a positive safe integer or Infinity");if(o.p2c>(n??1e4))throw new Px('JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds');if("string"!=typeof o.p2s)throw new Px('JOSE Header "p2s" (PBES2 Salt) missing or invalid');let e=PG(o.p2s,"p2s",Px);r=await VE(e,a,o.p2c,r);break}case"AES-GCM":{if("string"!=typeof o.iv)throw new Px('JOSE Header "iv" (Initialization Vector) missing or invalid');if("string"!=typeof o.tag)throw new Px('JOSE Header "tag" (Authentication Tag) missing or invalid');let e=PG(o.iv,"iv",Px),t=PG(o.tag,"tag",Px);if(12!==e.byteLength)throw new Px("Invalid Initialization Vector length");if(16!==t.byteLength)throw new Px("Invalid Authentication Tag length");return Vy(VC(a.slice(0,-2)),r,i,e,t,new Uint8Array)}}return async function(e,t,r){let i=await Vc(t,Vx(e).subtle,"unwrapKey",!0),o=await crypto.subtle.unwrapKey("raw",r,i,"AES-KW",{hash:"SHA-256",name:"HMAC"},!0,["sign"]);return new Uint8Array(await crypto.subtle.exportKey("raw",o))}(a.slice(-6),r,i)}(R,t,q,a,o,v),Vj(R)&&e instanceof Uint8Array&&e.byteLength<<3!==t.cekBits&&(e=Vl(t))}catch(r){if(r instanceof TypeError||r instanceof Px||r instanceof Pq)throw r;e=Vl(t)}s=await Vy(t,e,c,l,p,u)}if("DEF"===o.zip){let e=b??25e4;if(0===e)throw new Pq('JWE "zip" (Compression Algorithm) Header Parameter is not supported.');if(1/0!==e&&(!Number.isSafeInteger(e)||e<1))throw TypeError("maxDecompressedLength must be 0, a positive safe integer, or Infinity");s=await (async function(e,t){return VU("DecompressionStream"),VH(new DecompressionStream("deflate-raw"),e,t)})(s,e).catch(e=>{throw e instanceof Px?e:new Px("Failed to decompress plaintext",{cause:e})})}return{plaintext:s,...d&&{protectedHeader:d},...void 0!==h&&{additionalAuthenticatedData:PG(h,"aad",Px)},...f&&{sharedUnprotectedHeader:f},...m&&{unprotectedHeader:m},...V&&{key:q}}}async function VX(e,t,r){if(e instanceof Uint8Array&&(e=Pm.decode(e)),"string"!=typeof e)throw new Px("Compact JWE must be a string or Uint8Array");let{0:i,1:o,2:n,3:a,4:s,length:d}=e.split(".");if(5!==d)throw new Px("Invalid Compact JWE");return VQ({ciphertext:a,iv:n||void 0,protected:i,tag:s||void 0,encrypted_key:o||void 0},t,r)}async function VY(e,t,r){return VX(e,VZ(r),t)}async function V1(e,t,r){if(!PF(e))throw new Px("Flattened JWE must be an object");let i=VG(e),[o,,n]=VB(e);if(!o)throw n;let a={...i,...o};return VK(a),VQ(a,VZ(r),t)}async function V0(e,t,r){let i,o,n;if(!PF(e))throw new Px("General JWE must be an object");let a=e.recipients;if(!Array.isArray(a))throw new Px("JWE Recipients missing or incorrect type");let s=Array.from(a);if(!s.every(PF))throw new Px("JWE Recipients missing or incorrect type");if(!s.length)throw new Px("JWE Recipients has no members");try{i=VZ(r),o=VG(e),n=VJ(o)}catch{throw new PI}let d=s.map(e=>VB(e));if(s.length>1)for(let[,e]of d){let t=n[0]?.alg??e??o.unprotected?.alg,r="string"==typeof t?VP[t]:void 0;if(r&&!Vj(r))throw new Px(`"${t}" alg may only have a single recipient`)}for(let[e]of d)if(e)try{let r={...o,...e};return VK(r),await VQ(r,i,t,n)}catch{}throw new PI}function V2(e,t,r){if(!PU(e,t,r))throw new Px("JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint")}function V4(e,t,r=!1){if(!e[1]&&!e[2]&&!e[3])throw new Px("either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()");void 0!==t&&(e[8]=t?.crit);let[,i,o,n,a,s,d,c,l]=e;if(void 0!==a&&PD(a,"JWE Additional Authenticated Data"),void 0!==s&&PD(s,"JWE Content Encryption Key"),void 0!==d&&PD(d,"JWE Initialization Vector"),r||void 0===i||(i=P0(Px,i)[0],e[1]=i),void 0!==o&&(o=P0(Px,o)[0],e[2]=o),r||void 0===n||(n=P0(Px,n)[0],e[3]=n),void 0!==c&&!PF(c))throw TypeError("JWE Key Management Parameters must be an object");V2(i,o,n);let p={...i,...o,...n};PX(Px,i),PY(Px,PZ,l,i,p),VL(p,i);let{alg:u,enc:m}=p;if("string"!=typeof u||!u)throw new Px('JWE "alg" (Algorithm) Header Parameter missing or invalid');let f=VP[u];if(f?.mode==="integrated-encryption"){if(void 0!==m)throw new Px('JWE "enc" (Encryption Algorithm) Header Parameter must not be present for integrated encryption');if(void 0!==s)throw TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${u}`);if(void 0!==d)throw TypeError(`setInitializationVector cannot be called with JWE "alg" (Algorithm) Header ${u}`);return[p,void 0,f]}if("string"!=typeof m||!m)throw new Px('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');return[p,VC(m),f]}async function V6(e,t,r){let i,o,n,a,s,d,[c,l,p]=t,[u,m,f,h,y,g,_,v,,b]=e,$=m,S=f,k=p??Vx(c.alg);"integrated-encryption"===k.mode?n=await P2(k,r,"encrypt"):[n,i,o]=await VF(k,l,r,c,g,v),o&&(b?S=S?{...S,...o}:o:$=$?{...$,...o}:o,V2($,S,h));let w=$?Pz(JSON.stringify($)):"",P=y?.byteLength?Pz(y):void 0,V=Pb(P?`${w}.${P}`:w),R=u;"DEF"===c.zip&&(R=await (async function(e){return VU("CompressionStream"),VH(new CompressionStream("deflate-raw"),e)})(R).catch(e=>{throw new Px("Failed to compress plaintext",{cause:e})})),"integrated-encryption"===k.mode?[i,a]=await k.encrypt(n,R,V,$,c,v):{ciphertext:a,tag:s,iv:d}=await Vh(l,R,n,_,V);let q={ciphertext:Pz(a)};return d&&(q.iv=Pz(d)),s&&(q.tag=Pz(s)),i?.byteLength&&(q.encrypted_key=Pz(i)),P&&(q.aad=P),$&&(q.protected=w),h&&(q.unprotected=h),S&&(q.header=S),q}async function V3(e,t,r){return V6(e,V4(e,r),t)}function V9(e){return[e.protected,e.encrypted_key,e.iv,e.ciphertext,e.tag].join(".")}class V5{#f;state;constructor(e,t,r){this.#f=e,this.state=[void 0,void 0,t,r]}setUnprotectedHeader(e){return PH(this.state[0],"setUnprotectedHeader"),this.state[0]=e,this}setKeyManagementParameters(e){return PH(this.state[1],"setKeyManagementParameters"),this.state[1]=e,this}addRecipient(...e){return this.#f.addRecipient(...e)}encrypt(...e){return this.#f.encrypt(...e)}done(){return this.#f}}class V8{#h;#y=[];#g;#_;#v;constructor(e){this.#h=e}addRecipient(e,t){let r=new V5(this,e,t?.crit);return this.#y.push(r),r}setProtectedHeader(e){return PH(this.#g,"setProtectedHeader"),this.#g=e,this}setSharedUnprotectedHeader(e){return PH(this.#_,"setSharedUnprotectedHeader"),this.#_=e,this}setAdditionalAuthenticatedData(e){return this.#v=e,this}async encrypt(){if(!this.#y.length)throw new Px("at least one recipient must be added");PD(this.#h,"plaintext");let e=this.#y.length>1,t,r=this.#g,i=this.#_,o=[];for(let n of this.#y){let[a,s,d,c]=n.state,l=[this.#h,r,a,i,this.#v,void 0,void 0,s,c,e],p=V4(l,void 0,o.length>0);o.length||(r=l[1],i=l[3]),o.push([l,p,d]);let[{alg:u,enc:m},,f]=p;if(e&&f&&!Vj(f))throw new Px(`"${u}" alg may only have a single recipient`);if(t){if(t!==m)throw new Px('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients')}else t=m}for(let[,e]of o)e[2]??=Vx(e[0].alg);let[n,a,s]=o[0],d=e?Vl(a[1]):void 0;n[5]=d;let{encrypted_key:c,header:l,...p}=await V6(n,a,s),u={...p,recipients:[{}]};c&&(u.recipients[0].encrypted_key=c),l&&(u.recipients[0].header=l);for(let e=1;e<o.length;e++){let[t,[r,i,n],a]=o[e],s=t[2],[,c,l]=await VF(n,i,a,r,d,t[7]),p={encrypted_key:Pz(c)};if(s||l){let e={...s,...l};l&&V2(t[1],e,t[3]),p.header=e}u.recipients.push(p)}return u}}let V7=[["verify"],["sign"]];function Re(e){let t={name:"HMAC",hash:`SHA-${e}`};return{kty:["oct"],secret:!0,subtle:t,signing:t,usages:V7}}function Rt(e,t){let r={name:t?"RSA-PSS":"RSASSA-PKCS1-v1_5",hash:`SHA-${e}`};return{kty:["RSA"],subtle:r,signing:t?{...r,saltLength:t}:r,usages:V7,minRsaBits:2048}}function Rr(e,t){return{kty:["EC"],crv:e,subtle:{name:"ECDSA",namedCurve:e},signing:{name:"ECDSA",hash:`SHA-${t}`},usages:V7}}function Ri(){let e={name:"Ed25519"};return{kty:["OKP"],crv:"Ed25519",subtle:e,signing:e,usages:V7}}function Ro(e){let t={name:`ML-DSA-${e}`};return{kty:["AKP"],subtle:t,signing:t,usages:V7}}let Rn=Vg({HS256:Re(256),HS384:Re(384),HS512:Re(512),RS256:Rt(256),RS384:Rt(384),RS512:Rt(512),PS256:Rt(256,32),PS384:Rt(384,48),PS512:Rt(512,64),ES256:Rr("P-256",256),ES384:Rr("P-384",384),ES512:Rr("P-521",512),EdDSA:Ri(),Ed25519:Ri(),"ML-DSA-44":Ro(44),"ML-DSA-65":Ro(65),"ML-DSA-87":Ro(87)});function Ra(e){let t="string"==typeof e?Rn[e]:void 0;if(!t)throw new Pq(`alg ${e} is not supported either by JOSE or your javascript runtime`);return t}function Rs(e,t){let r=e.protected,i=e.header,o=PF(i)?{...i}:i,n=t?t[0]:e.payload;!t&&n instanceof Uint8Array&&(n=new Uint8Array(n));let a=e.signature,s={payload:n,signature:a};if(void 0!==r&&(s.protected=r),void 0!==i&&(s.header=o),void 0===r&&void 0===o)throw new Pj('Flattened JWS must have either of the "protected" or "header" members');if(void 0!==r&&"string"!=typeof r)throw new Pj("JWS Protected Header incorrect type");if(void 0===n)throw new Pj("JWS Payload missing");if("string"!=typeof a)throw new Pj("JWS Signature missing or incorrect type");if(void 0!==o&&!PF(o))throw new Pj("JWS Unprotected Header incorrect type");return s}function Rd(e){return[e&&PQ("algorithms",e.algorithms),e?.crit]}function Rc(e){return void 0===e?{}:PK(e,Pj,"JWS Protected Header is invalid")}function Rl(e){let t=/[\p{Cs}\p{Cn}]/u.exec(e)?.[0];if(void 0!==t)throw new Pj(/\p{Cs}/u.test(t)?"JWS Payload must be a well-formed Unicode string":"JWS Payload must not contain unassigned Unicode code points");return Pu.encode(e)}function Rp(e){try{return Pb(e)}catch{throw new Pj("JWS Compact Serialization payload must use only ASCII characters")}}async function Ru(e,t,r,i,o){let{protected:n,header:a,payload:s}=e,d=o??Rc(n);if(!PU(d,a))throw new Pj("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");let c={...d,...a},l=P1(d,PY(Pj,PJ,t[1],d,c)),{alg:p}=c;if("string"!=typeof p||!p)throw new Pj('JWS "alg" (Algorithm) Header Parameter missing or invalid');if(t[0]&&!t[0].has(p))throw new PR('"alg" (Algorithm) Header Parameter value not allowed');if(l){if("string"!=typeof s)throw new Pj("JWS Payload must be a string")}else if("string"!=typeof s&&!(s instanceof Uint8Array))throw new Pj("JWS Payload must be a string or an Uint8Array instance");let u=l||"string"!=typeof s?s:i(s),m=!1;"function"==typeof r&&(r=await r(d,e),m=!0);let f=Ra(p),h=Ph(void 0!==n?Pb(n):new Uint8Array,Pb("."),"string"==typeof u?t[2]??=PB(u,"payload",Pj):u),y=PG(e.signature,"signature",Pj),g=await P2(f,r,"verify"),_=await Vc(g,f.subtle,"verify");f.minRsaBits&&Vi(f.alg,_);let v=!1;try{v=await crypto.subtle.verify(f.signing,_,y,h)}catch{}if(!v)throw new PM;let b={payload:"string"==typeof u?PG(u,"payload",Pj):u};return void 0!==n&&(b.protectedHeader=d),void 0!==a&&(b.unprotectedHeader=a),m?[{...b,key:g},l]:[b,l]}async function Rm(e,t,r){if(e instanceof Uint8Array&&(e=Pm.decode(e)),"string"!=typeof e)throw new Pj("Compact JWS must be a string or Uint8Array");let{0:i,1:o,2:n,length:a}=e.split(".");if(3!==a)throw new Pj("Invalid Compact JWS");return Ru({payload:o,protected:i,signature:n},t,r,Rp)}async function Rf(e,t,r){let[i]=await Rm(e,Rd(r),t);return i}async function Rh(e,t,r){if(!PF(e))throw new Pj("Flattened JWS must be an object");let i=Rs(e),[o]=await Ru(i,Rd(r),t,Rl);return o}async function Ry(e,t,r){let i;if(!PF(e))throw new Pj("General JWS must be an object");let{signatures:o,payload:n}=e;if(!Array.isArray(o))throw new Pj("JWS Signatures missing or incorrect type");let a=Array.from(o);if(!a.every(PF))throw new Pj("JWS Signatures missing or incorrect type");try{if(void 0===n)throw Error();i=Rd(r)}catch{throw new PM}let s=n instanceof Uint8Array?new Uint8Array(n):n,d=a.map(e=>(function(e,t){try{let r=Rs(e,[t]),i=Rc(r.protected),{b64:o,crit:n}=i;return[r,i,Array.isArray(n)&&n.includes("b64")?"boolean"==typeof o?o?1:2:0:1]}catch{return}})(e,s)).filter(e=>void 0!==e),c=0;for(let[,,e]of d)if(3==(c|=e))throw new Pj("inconsistent use of JWS Unencoded Payload (RFC7797)");for(let e of d)try{let[r]=await Ru(e[0],i,t,Rl,e[1]);return r}catch{}throw new PM}let Rg=e=>Math.floor(e.getTime()/1e3),R_={s:1,m:60,h:3600,d:86400,w:604800,y:0x1e187e0},Rv=/^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i,Rb="check_failed";function R$(){throw TypeError("Invalid time period format")}function RS(e){"string"!=typeof e&&R$();let t=Rv.exec(e);(!t||t[4]&&t[1])&&R$();let r=Math.round(parseFloat(t[2])*R_[t[3][0].toLowerCase()]);return Number.isFinite(r)||R$(),"-"===t[1]||"ago"===t[4]?-r:r}function Rk(e,t){if(!Number.isFinite(t))throw TypeError(`Invalid ${e} input`);return t}function Rw(e,t){if("string"!=typeof t)throw TypeError(`"${e}" claim must be a string`)}function RP(e,t){return"number"==typeof e?Rk(t,e):e instanceof Date?Rk(t,Rg(e)):Rg(new Date)+RS(e)}let RV=e=>{let t=e.toLowerCase();return e.includes("/")?t:`application/${t}`};function RR(e,t,r=!1){let i=e[t];if(!(void 0===i&&!r)){if("number"!=typeof i)throw new PP(`"${t}" claim must be a number`,e,t,"invalid");return i}}function Rq(e,t){throw new PP(`unexpected "${t}" claim value`,e,t,Rb)}function RI(e,t,r={}){let i,o,n;try{i=JSON.parse(Pf.decode(t))}catch{}if(!PF(i))throw new PC("JWT Claims Set must be a top-level JSON object");let{typ:a}=r;if(void 0!==a&&("string"!=typeof e.typ||RV(e.typ)!==RV(a)))throw new PP('unexpected "typ" JWT header value',i,"typ",Rb);let{requiredClaims:s=[],issuer:d,subject:c,audience:l,maxTokenAge:p}=r,u=[...s];for(let e of(void 0!==p&&u.push("iat"),void 0!==l&&u.push("aud"),void 0!==c&&u.push("sub"),void 0!==d&&u.push("iss"),new Set(u.reverse())))if(!Object.hasOwn(i,e))throw new PP(`missing required "${e}" claim`,i,e,"missing");void 0===d||(Array.isArray(d)?d:[d]).includes(i.iss)||Rq(i,"iss"),void 0!==c&&i.sub!==c&&Rq(i,"sub"),void 0===l||(o=i.aud,n="string"==typeof l?[l]:l,"string"==typeof o?n.includes(o):!!Array.isArray(o)&&n.some(e=>o.includes(e)))||Rq(i,"aud");let{clockTolerance:m}=r,f=0;if("string"==typeof m)f=RS(m);else if(void 0!==m){if("number"!=typeof m)throw TypeError("Invalid clockTolerance option type");f=m}Rk("clockTolerance option",f);let{currentDate:h}=r,y=Rk("currentDate option",Rg(void 0===h?new Date:h)),g=RR(i,"iat",void 0!==p),_=RR(i,"nbf");if(void 0!==_&&_>y+f)throw new PP('"nbf" claim timestamp check failed',i,"nbf",Rb);let v=RR(i,"exp");if(void 0!==v&&v<=y-f)throw new PV('"exp" claim timestamp check failed',i,"exp",Rb);if(void 0!==p){let e=y-g;if(e-f>Rk("maxTokenAge option","number"==typeof p?p:RS(p)))throw new PV('"iat" claim timestamp check failed (too far in the past)',i,"iat",Rb);if(e<-f)throw new PP('"iat" claim timestamp check failed (it should be in the past)',i,"iat",Rb)}return i}function Rx(e){return f.get(e)}function Rj(e){let t=Rx(e);for(let e of["iat","nbf","exp"]){let r=t[e];if("number"==typeof r&&!Number.isFinite(r))throw TypeError(`"${e}" claim must be a finite number`)}return Pu.encode(JSON.stringify(t))}class RC{constructor(e={}){if(!PF(e))throw TypeError("JWT Claims Set MUST be an object");(f||=new WeakMap).set(this,structuredClone(e))}setIssuer(e){return Rw("iss",e),Rx(this).iss=e,this}setSubject(e){return Rw("sub",e),Rx(this).sub=e,this}setAudience(e){return function(e){if("string"!=typeof e&&(!Array.isArray(e)||Array.from(e).some(e=>"string"!=typeof e)))throw TypeError('"aud" claim must be a string or an array of strings')}(e),Rx(this).aud=e,this}setJti(e){return Rw("jti",e),Rx(this).jti=e,this}setNotBefore(e){return Rx(this).nbf=RP(e,"setNotBefore"),this}setExpirationTime(e){return Rx(this).exp=RP(e,"setExpirationTime"),this}setIssuedAt(e){let t=Rx(this);return void 0===e?t.iat=Rg(new Date):"string"==typeof e?t.iat=Rk("setIssuedAt",Rg(new Date)+RS(e)):t.iat=RP(e,"setIssuedAt"),this}}async function RT(e,t,r){let[i,o]=await Rm(e,Rd(r),t);if(!o)throw new PC("JWTs MUST NOT use unencoded payload");let n=RI(i.protectedHeader,i.payload,r);return{...i,payload:n}}async function RO(e,t,r){let{plaintext:i,...o}=await VX(e,VZ(r),t),{protectedHeader:n}=o,a=RI(n,i,r);for(let e of["iss","sub","aud"])if(void 0!==n[e]&&("aud"===e?JSON.stringify(n.aud)!==JSON.stringify(a.aud):n[e]!==a[e]))throw new PP(`replicated "${e}" claim header parameter mismatch`,a,e,"mismatch");return{payload:a,...o}}class RE{#b;constructor(e){PD(e,"plaintext"),this.#b=[e]}setContentEncryptionKey(e){return PH(this.#b[5],"setContentEncryptionKey"),this.#b[5]=e,this}setInitializationVector(e){return PH(this.#b[6],"setInitializationVector"),this.#b[6]=e,this}setProtectedHeader(e){return PH(this.#b[1],"setProtectedHeader"),this.#b[1]=e,this}setKeyManagementParameters(e){return PH(this.#b[7],"setKeyManagementParameters"),this.#b[7]=e,this}async encrypt(e,t){return V9(await V3([...this.#b],e,t))}}class RA{#b;constructor(e){PD(e,"plaintext"),this.#b=[e]}setKeyManagementParameters(e){return PH(this.#b[7],"setKeyManagementParameters"),this.#b[7]=e,this}setProtectedHeader(e){return PH(this.#b[1],"setProtectedHeader"),this.#b[1]=e,this}setSharedUnprotectedHeader(e){return PH(this.#b[3],"setSharedUnprotectedHeader"),this.#b[3]=e,this}setUnprotectedHeader(e){return PH(this.#b[2],"setUnprotectedHeader"),this.#b[2]=e,this}setAdditionalAuthenticatedData(e){return this.#b[4]=e,this}setContentEncryptionKey(e){return PH(this.#b[5],"setContentEncryptionKey"),this.#b[5]=e,this}setInitializationVector(e){return PH(this.#b[6],"setInitializationVector"),this.#b[6]=e,this}async encrypt(e,t){return V3([...this.#b],e,t)}}async function RW(e,t,r){let[i,o,n,a]=e,s="";if(void 0!==o){let e=P0(Pj,o);o=e[0],s=Pz(e[1])}if(void 0!==n&&(n=P0(Pj,n)[0]),!o&&!n)throw new Pj("either setProtectedHeader or setUnprotectedHeader must be called before #sign()");if(!PU(o,n))throw new Pj("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");let d={...o,...n};PX(Pj,o);let c=P1(o,PY(Pj,PJ,a,o,d));c||r?.();let{alg:l}=d;if("string"!=typeof l||!l)throw new Pj('JWS "alg" (Algorithm) Header Parameter missing or invalid');let p=Ra(l),u="",m=i,f;if(c){let t=e[4];t?(u=t[0]??=Pz(i),m=t[1]??=Pb(u)):(u=Pz(i),f=Pu.encode(`${s}.${u}`))}f??=Ph(Pb(s),Pb("."),m);let h=await Vc(await P2(p,t,"sign"),p.subtle,"sign");p.minRsaBits&&Vi(p.alg,h);let y={signature:Pz(new Uint8Array(await crypto.subtle.sign(p.signing,h,f))),payload:u};return o&&(y.protected=s),n&&(y.header=n),[y,c]}async function RM(e,t,r,i,o){let[n]=await RW([e,t,void 0,r],i,o);return`${n.protected}.${n.payload}.${n.signature}`}class RN{#$;#g;constructor(e){PD(e,"payload"),this.#$=e}setProtectedHeader(e){return PH(this.#g,"setProtectedHeader"),this.#g=e,this}async sign(e,t){return RM(this.#$,this.#g,t?.crit,e,()=>{throw TypeError("use the flattened module for creating JWS with b64: false")})}}class Rz{#b;constructor(e){PD(e,"payload"),this.#b=[e]}setProtectedHeader(e){return PH(this.#b[1],"setProtectedHeader"),this.#b[1]=e,this}setUnprotectedHeader(e){return PH(this.#b[2],"setUnprotectedHeader"),this.#b[2]=e,this}async sign(e,t){let r=[...this.#b];r[3]=t?.crit;let[i]=await RW(r,e);return i}}class RD{#f;state;constructor(e,t,r){this.#f=e,this.state=[void 0,void 0,t,r?.crit]}setProtectedHeader(e){return PH(this.state[0],"setProtectedHeader"),this.state[0]=e,this}setUnprotectedHeader(e){return PH(this.state[1],"setUnprotectedHeader"),this.state[1]=e,this}addSignature(...e){return this.#f.addSignature(...e)}sign(...e){return this.#f.sign(...e)}done(){return this.#f}}class RF{#$;#S=[];constructor(e){this.#$=e}addSignature(e,t){let r=new RD(this,e,t);return this.#S.push(r),r}async sign(){let e;if(!this.#S.length)throw new Pj("at least one signature must be added");PD(this.#$,"payload");let t={signatures:[],payload:""},r=[];for(let i of this.#S){let[o,n,a,s]=i.state,[{payload:d,...c},l]=await RW([this.#$,o,n,s,r],a);if(void 0===e)e=l,t.payload=d;else if(e!==l)throw new Pj("inconsistent use of JWS Unencoded Payload (RFC7797)");t.signatures.push(c)}return t}}let RL=RC;class RU extends RL{#g;setProtectedHeader(e){return PH(this.#g,"setProtectedHeader"),this.#g=e,this}async sign(e,t){return RM(Rj(this),this.#g,t?.crit,e,()=>{throw new PC("JWTs MUST NOT use unencoded payload")})}}let RH=RC;class RG extends RH{#b=[void 0];#k;#w;#P;setProtectedHeader(e){return PH(this.#b[1],"setProtectedHeader"),this.#b[1]=e,this}setKeyManagementParameters(e){return PH(this.#b[7],"setKeyManagementParameters"),this.#b[7]=e,this}setContentEncryptionKey(e){return PH(this.#b[5],"setContentEncryptionKey"),this.#b[5]=e,this}setInitializationVector(e){return PH(this.#b[6],"setInitializationVector"),this.#b[6]=e,this}replicateIssuerAsHeader(){return this.#k=!0,this}replicateSubjectAsHeader(){return this.#w=!0,this}replicateAudienceAsHeader(){return this.#P=!0,this}async encrypt(e,t){let r=Rj(this);this.#b[1]&&(this.#k||this.#w||this.#P)&&(this.#b[1]={...this.#b[1],iss:this.#k?Rx(this).iss:void 0,sub:this.#w?Rx(this).sub:void 0,aud:this.#P?Rx(this).aud:void 0});let i=[...this.#b];return i[0]=r,V9(await V3(i,e,t))}}let RB='"alg" (Algorithm)';function RK(e='JWK "alg" (Algorithm) Parameter'){throw new Pq(`Invalid or unsupported ${e} value`)}function RJ(e,t){return("string"==typeof e?Rn[e]??VP[e]:void 0)??RK(t)}let RZ=async(e,t,r)=>{var i,o;let n;if(P9(r)){if(r.type!==e)throw TypeError(`key is not a ${e} key`);return r.export({format:"pem",type:t})}if(!P3(r))throw TypeError(P7(r,"CryptoKey","KeyObject"));if(!r.extractable)throw TypeError("CryptoKey is not extractable");if(r.type!==e)throw TypeError(`key is not a ${e} key`);return i=P$(new Uint8Array(await crypto.subtle.exportKey(t,r))),o=`${e.toUpperCase()} KEY`,n=(i.match(/.{1,64}/g)||[]).join(`
 `),`-----BEGIN ${o}-----
 ${n}
 -----END ${o}-----`},RQ=(e,t)=>{if(e.byteLength!==t.length)return!1;for(let r=0;r<e.byteLength;r++)if(e[r]!==t[r])return!1;return!0},RX=e=>({data:e,pos:0}),RY=e=>{let t=e.data[e.pos++];if(void 0===t)throw Error("Unexpected end of ASN.1 input");return t},R1=e=>{let t=RY(e);if(128&t){let r=127&t,i=0;for(let t=0;t<r;t++)i=i<<8|RY(e);return i}return t},R0=(e,t=1)=>{for(;t-- >0;){e.pos++;let t=R1(e);e.pos+=t}},R2=(e,t,r)=>{if(RY(e)!==t)throw Error(r)},R4=(e,t)=>{if(t<0||e.pos+t>e.data.length)throw Error("Unexpected end of ASN.1 input");let r=e.data.subarray(e.pos,e.pos+t);return e.pos+=t,r},R6=async(e,t,r,i)=>{let o,n=Vs(i?.extractable),a=RJ(r,RB);a.secret&&RK(RB);let s="spki"===e;if(a.resolve)try{let r=RX(t);(function(e,t){if(R2(e,48,`Invalid ${"spki"===t?"SPKI":"PKCS#8"} structure`),R1(e),"pkcs8"===t){R2(e,2,"Expected version field");let t=R1(e);e.pos+=t}R2(e,48,"Expected algorithm identifier"),R1(e)})(r,e),o=a.resolve({crv:(e=>{let t,r=(R2(e,6,"Expected algorithm OID"),t=R1(e),R4(e,t));if(RQ(r,[43,101,110]))return"X25519";if(!RQ(r,[42,134,72,206,61,2,1]))throw Error("Unsupported key algorithm");R2(e,6,"Expected curve OID");let i=R1(e),o=R4(e,i);if(RQ(o,[42,134,72,206,61,3,1,7]))return"P-256";if(RQ(o,[43,129,4,0,34]))return"P-384";if(RQ(o,[43,129,4,0,35]))return"P-521";throw Error("Unsupported named curve")})(r)})}catch{throw new Pq("Invalid or unsupported key format")}else o=a.subtle;return crypto.subtle.importKey(e,t,o,n??s,a.usages[+!s])},R3=(e,t)=>PS(e.replace(t,""));function R9(e){return RZ("public","spki",e)}function R5(e){return RZ("private","pkcs8",e)}async function R8(e){if(P9(e))if("secret"!==e.type)return e.export({format:"jwk"});else e=e.export();if(e instanceof Uint8Array)return{kty:"oct",k:Pz(e)};if(!P3(e))throw TypeError(P7(e,"CryptoKey","KeyObject","Uint8Array"));if(!e.extractable)throw TypeError("non-extractable CryptoKey cannot be exported as a JWK");let t=await crypto.subtle.exportKey("jwk",e);for(let e of(delete t.ext,delete t.key_ops,delete t.use,"AKP"!==t.kty&&delete t.alg,Object.keys(t)))void 0===t[e]&&delete t[e];return t}let R7=(e,t)=>{if("string"!=typeof e||!e)throw new PT(`${t} missing or invalid`)};async function qe(e,t){let r,i;if(PF(e)){if("string"!=typeof(r=Vn(e)).kty)throw TypeError(P7(e,"CryptoKey","KeyObject","JSON Web Key"))}else if(P5(e))r=Vn(await R8(e));else throw TypeError(P7(e,"CryptoKey","KeyObject","JSON Web Key"));if("sha256"!==(t??="sha256")&&"sha384"!==t&&"sha512"!==t)throw TypeError('digestAlgorithm must one of "sha256", "sha384", or "sha512"');switch(r.kty){case"AKP":R7(r.alg,'"alg" (Algorithm) Parameter'),R7(r.pub,'"pub" (Public key) Parameter'),i={alg:r.alg,kty:r.kty,pub:r.pub};break;case"EC":R7(r.crv,'"crv" (Curve) Parameter'),R7(r.x,'"x" (X Coordinate) Parameter'),R7(r.y,'"y" (Y Coordinate) Parameter'),i={crv:r.crv,kty:r.kty,x:r.x,y:r.y};break;case"OKP":R7(r.crv,'"crv" (Subtype of Key Pair) Parameter'),R7(r.x,'"x" (Public Key) Parameter'),i={crv:r.crv,kty:r.kty,x:r.x};break;case"RSA":R7(r.e,'"e" (Exponent) Parameter'),R7(r.n,'"n" (Modulus) Parameter'),i={e:r.e,kty:r.kty,n:r.n};break;case"oct":if("string"!=typeof r.k)throw new PT('"k" (Key Value) Parameter missing or invalid');i={k:r.k,kty:r.kty};break;default:throw new Pq('"kty" (Key Type) Parameter missing or unsupported')}let o=Pb(JSON.stringify(i));return Pz(await Pk(t,o))}async function qt(e,t){t??="sha256";let r=await qe(e,t);return`urn:ietf:params:oauth:jwk-thumbprint:sha-${t.slice(-3)}:${r}`}async function qr(e,t){let r,i={...e,...t?.header};if(!PF(i.jwk))throw new Pj('"jwk" (JSON Web Key) Header Parameter must be a JSON object');try{r=Va(i.jwk)}catch(e){throw new Pj("Invalid Embedded JWK",{cause:e})}let o=Ra(i.alg);if(void 0!==r.use&&"sig"!==r.use)throw new Pj('Invalid Embedded JWK, its "use" must be "sig" when present');if(void 0!==r.alg&&r.alg!==o.alg)throw new Pj(`Invalid Embedded JWK, its "alg" must be "${o.alg}" when present`);let n=await Vd(o,r,!0);if("public"!==n.type)throw new Pj('"jwk" (JSON Web Key) Header Parameter must be a public key');return n}async function qi(e,t,r){let i=e.get(t)||e.set(t,{}).get(t),{alg:o}=r;if(void 0===i[o]){let e=Vd(r,t,!0).then(e=>{if("public"!==e.type)throw new PO("JSON Web Key Set members must be public keys");return i[o]=e,e}).catch(t=>{throw i[o]===e&&delete i[o],t});i[o]=e}return i[o]}function qo(e){let t;try{t=structuredClone(e)}catch{}if(!PL(t))throw new PO("JSON Web Key Set malformed");let r=t.keys.map(e=>{let t=Vn(e);return Array.isArray(t.key_ops)&&(t.key_ops=[...t.key_ops]),t}),i=new WeakMap;return Object.defineProperty(async(e,o)=>{let{alg:n,kid:a}={...e,...o?.header},s="string"==typeof n?Rn[n]:void 0;if(!s||s.secret)throw new Pq('Unsupported "alg" value for a JSON Web Key Set');let d=t.keys.filter((e,t)=>(function(e,t,r,i){let{kty:o,key_ops:n,ext:a,kid:s,alg:d,use:c,crv:l}=e;return(void 0===a||"boolean"==typeof a)&&(void 0===n||Array.isArray(n)&&n.every((e,t)=>"string"==typeof e&&n.indexOf(e)===t)&&n.includes("verify"))&&t.kty.includes(o)&&(void 0===i||"string"==typeof i&&i===s)&&(void 0===d?"AKP"!==o:r===d)&&(void 0===c||"sig"===c)&&(!t.crv||l===t.crv)})(r[t],s,n,a)),{0:c,length:l}=d;if(!l)throw new PE;if(1!==l){let e=new PA;throw e[Symbol.asyncIterator]=async function*(){for(let e of d)try{yield await qi(i,e,s)}catch{}},e}return qi(i,c,s)},"jwks",{value:()=>structuredClone(t)})}(typeof navigator>"u"||!navigator.userAgent?.startsWith?.("Mozilla/5.0 "))&&(h="jose/v6.2.12");let qn=Symbol(),qa=Symbol();function qs(e,t){return Number.isFinite(e)&&Date.now()<e+t}function qd(e,t,r){if(Number.isNaN(e))throw TypeError(`"${r}" option must not be NaN`);return"number"==typeof e?e:t}function qc(e,t){if(!(e instanceof URL))throw TypeError("url must be an instance of URL");let r=new URL(e.href).href,i=t??{},o=i.timeoutDuration;if("number"==typeof o&&(!Number.isInteger(o)||o<0))throw TypeError('"timeoutDuration" option must be a non-negative integer');let n="number"==typeof o?o:5e3,a=qd(i.cooldownDuration,3e4,"cooldownDuration"),s=qd(i.cacheMaxAge,6e5,"cacheMaxAge"),d=new Headers(i.headers);h&&!d.has("User-Agent")&&d.set("User-Agent",h),d.has("accept")||d.set("accept","application/json, application/jwk-set+json");let c=i[qn],l=i[qa],p,u,m=0,f=0,y;if(l&&"object"==typeof l){let{uat:e,jwks:t}=l;qs(e,s)&&PL(t)&&(p=e,y=qo(t))}let g=async()=>{if(u&&("u">typeof WebSocketPair||"u">typeof navigator&&"Cloudflare-Workers"===navigator.userAgent||"u">typeof EdgeRuntime&&"vercel"===EdgeRuntime)&&(u=void 0),!u){let e=++m,t=u=(async function(e,t,r,i=fetch){let o=await i(e,{method:"GET",signal:r,redirect:"manual",headers:t}).catch(e=>{throw"TimeoutError"===e.name?new PW:e});if(200!==o.status)throw new Pw("Expected 200 OK from the JSON Web Key Set HTTP response");try{return await o.json()}catch{throw new Pw("Failed to parse the JSON Web Key Set HTTP response as JSON")}})(r,d,AbortSignal.timeout(n),c).then(t=>{let r=qo(t);if(e<=f)return;y=r;let i=Date.now();l&&(l.uat=i,l.jwks=t),p=i,f=e}).finally(()=>{u===t&&(u=void 0)})}await u};return Object.defineProperties(async(e,t)=>{y&&qs(p,s)||await g();try{return await y(e,t)}catch(r){if(r instanceof PE&&!qs(p,a))return await g(),y(e,t);throw r}},{coolingDown:{get:()=>qs(p,a),enumerable:!0},fresh:{get:()=>qs(p,s),enumerable:!0},reload:{value:g,enumerable:!0},reloading:{get:()=>!!u,enumerable:!0},jwks:{value:()=>y?.jwks(),enumerable:!0}})}let ql=RC;class qp extends ql{encode(){let e=Pz(JSON.stringify({alg:"none"})),t=Pz(Rj(this));return`${e}.${t}.`}static decode(e,t){let r,i;if("string"!=typeof e)throw new PC("Unsecured JWT must be a string");let{0:o,1:n,2:a,length:s}=e.split(".");if(3!==s||""!==a)throw new PC("Invalid Unsecured JWT");try{r=PK(o,Pj,"JWS Protected Header is invalid");let e=PY(Pj,PJ,void 0,r,r);i=P1(r,e)}catch(e){throw e instanceof Pj?new PC("Invalid Unsecured JWT",{cause:e}):e}if("none"!==r.alg)throw new PC("Invalid Unsecured JWT");if(!i)throw new PC("JWTs MUST NOT use unencoded payload");return{payload:RI(r,PG(n,"payload",PC),t),header:r}}}async function qu(e,t,r){if("string"!=typeof e||0!==e.indexOf("-----BEGIN PUBLIC KEY-----"))throw TypeError('"spki" must be SPKI formatted string');return R6("spki",R3(e,/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g),t,r)}async function qm(e,t,r){let i;if("string"!=typeof e||0!==e.indexOf("-----BEGIN CERTIFICATE-----"))throw TypeError('"x509" must be X.509 formatted string');try{let t=R3(e,/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g);i=function(e){let t=RX(e);R2(t,48,"Invalid certificate structure");let r=R1(t);if(r<0||t.pos+r>t.data.length)throw Error("Unexpected end of ASN.1 input");R2(t,48,"Invalid tbsCertificate structure"),R1(t),160===e[t.pos]?R0(t,6):R0(t,5);let i=t.pos;R2(t,48,"Invalid SPKI structure");let o=R1(t);return e.subarray(i,i+o+(t.pos-i))}(t)}catch(e){throw TypeError("Failed to parse the X.509 certificate",{cause:e})}return R6("spki",i,t,r)}async function qf(e,t,r){if("string"!=typeof e||0!==e.indexOf("-----BEGIN PRIVATE KEY-----"))throw TypeError('"pkcs8" must be PKCS#8 formatted string');return R6("pkcs8",R3(e,/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g),t,r)}async function qh(e,t,r){if(!PF(e))throw TypeError("JWK must be an object");let i=Va(e),o=Vs(r?.extractable),{alg:n}=i;if(t??=n,"oct"!==i.kty&&!t)throw TypeError('"alg" argument is required when "jwk.alg" is not present');switch(i.kty){case"oct":if("string"!=typeof i.k)throw TypeError('missing "k" (Key Value) Parameter value');return PN(i.k);case"AKP":if("string"!=typeof n||!n)throw TypeError('missing "alg" (Algorithm) Parameter value');if(t!==n)throw TypeError("JWK alg and alg option value mismatch");return Vd(RJ(t),i,o);case"RSA":case"EC":case"OKP":return Vd(RJ(t),i,o);default:throw new Pq('Unsupported "kty" (Key Type) Parameter value')}}function qy(e){let t;if("string"==typeof e){let r=e.split(".");(3===r.length||5===r.length)&&([t]=r)}else if("object"==typeof e&&e)if("protected"in e)t=e.protected;else throw TypeError("Token does not contain a Protected Header");let r="Invalid Token or Protected Header formatting";if("string"!=typeof t||!t)throw TypeError(r);return PK(t,TypeError,r)}function qg(e){let t,r;if("string"!=typeof e)throw new PC("JWTs must use Compact JWS serialization, JWT must be a string");let{1:i,length:o}=e.split(".");if(5===o)throw new PC("Only JWTs using Compact JWS serialization can be decoded");if(3!==o)throw new PC("Invalid JWT");if(!i)throw new PC("JWTs must contain a payload");try{t=PN(i)}catch{throw new PC("Failed to base64url decode the payload")}try{r=JSON.parse(Pf.decode(t))}catch{throw new PC("Failed to parse the decoded payload as JSON")}if(!PF(r))throw new PC("Invalid JWT Claims Set");return r}async function q_(e,t){let r,i=Vs(t?.extractable),o=RJ(e,RB);if(o.secret&&RK(RB),o.resolve){let e=t?.crv??"P-256";if(!["P-256","P-384","P-521","X25519"].includes(e))throw new Pq("Invalid or unsupported crv option provided, supported values are P-256, P-384, P-521, and X25519");r=o.resolve({crv:e})}else{if(void 0!==o.crv&&t?.crv!==void 0&&t.crv!==o.crv)throw new Pq(`Invalid or unsupported crv option provided, the only supported value for ${e} is ${o.crv}`);r="RSA"===o.kty[0]?{...o.subtle,publicExponent:Uint8Array.of(1,0,1),modulusLength:function(e){let t=e?.modulusLength??2048;if("number"!=typeof t||!Number.isInteger(t)||t<2048)throw new Pq("Invalid or unsupported modulusLength option provided, 2048 bits or larger keys must be used");return t}(t)}:o.subtle}return crypto.subtle.generateKey(r,i??!1,[...o.usages[1],...o.usages[0]])}async function qv(e,t){let r,i,o,n=Vs(t?.extractable);switch(e){case"HS256":case"HS384":case"HS512":r=+e.slice(-3),i={name:"HMAC",hash:`SHA-${r}`,length:r},o=["sign","verify"];break;case"A128CBC-HS256":case"A192CBC-HS384":case"A256CBC-HS512":return crypto.getRandomValues(new Uint8Array(e.slice(-3)>>3));case"A128KW":case"A192KW":case"A256KW":i={name:"AES-KW",length:r=+e.slice(1,4)},o=["wrapKey","unwrapKey"];break;case"A128GCMKW":case"A192GCMKW":case"A256GCMKW":case"A128GCM":case"A192GCM":case"A256GCM":i={name:"AES-GCM",length:r=+e.slice(1,4)},o=["encrypt","decrypt"];break;default:RK(RB)}return crypto.subtle.generateKey(i,n??!1,o)}let qb="WebCryptoAPI";var q$=kO(e=>{Object.defineProperty(e,"__esModule",{value:!0}),e.regexpCode=e.getEsmExportName=e.getProperty=e.safeStringify=e.stringify=e.strConcat=e.addCodeArg=e.str=e._=e.nil=e._Code=e.Name=e.IDENTIFIER=e._CodeOrName=void 0;var t=class{};e._CodeOrName=t,e.IDENTIFIER=/^[a-z$_][a-z$_0-9]*$/i;var r=class extends t{constructor(t){if(super(),!e.IDENTIFIER.test(t))throw Error("CodeGen: name must be a valid identifier");this.str=t}toString(){return this.str}emptyStr(){return!1}get names(){return{[this.str]:1}}};e.Name=r;var i=class extends t{constructor(e){super(),this._items="string"==typeof e?[e]:e}toString(){return this.str}emptyStr(){if(this._items.length>1)return!1;let e=this._items[0];return""===e||'""'===e}get str(){var e;return null!=(e=this._str)?e:this._str=this._items.reduce((e,t)=>`${e}${t}`,"")}get names(){var e;return null!=(e=this._names)?e:this._names=this._items.reduce((e,t)=>(t instanceof r&&(e[t.str]=(e[t.str]||0)+1),e),{})}};function o(e,...t){let r=[e[0]],n=0;for(;n<t.length;)s(r,t[n]),r.push(e[++n]);return new i(r)}e._Code=i,e.nil=new i(""),e._=o;let n=new i("+");function a(e,...t){let o=[d(e[0])],c=0;for(;c<t.length;)o.push(n),s(o,t[c]),o.push(n,d(e[++c]));return function(e){let t=1;for(;t<e.length-1;){if(e[t]===n){var i,o;let n=(i=e[t-1],'""'===(o=e[t+1])?i:'""'===i?o:"string"==typeof i?o instanceof r||'"'!==i[i.length-1]?void 0:"string"!=typeof o?`${i.slice(0,-1)}${o}"`:'"'===o[0]?i.slice(0,-1)+o.slice(1):void 0:"string"!=typeof o||'"'!==o[0]||i instanceof r?void 0:`"${i}${o.slice(1)}`);if(void 0!==n){e.splice(t-1,3,n);continue}e[t++]="+"}t++}}(o),new i(o)}function s(e,t){var o;t instanceof i?e.push(...t._items):t instanceof r?e.push(t):e.push("number"==typeof(o=t)||"boolean"==typeof o||null===o?o:d(Array.isArray(o)?o.join(","):o))}function d(e){return JSON.stringify(e).replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}e.str=a,e.addCodeArg=s,e.strConcat=function(e,t){return t.emptyStr()?e:e.emptyStr()?t:a`${e}${t}`},e.stringify=function(e){return new i(d(e))},e.safeStringify=d,e.getProperty=function(t){return"string"==typeof t&&e.IDENTIFIER.test(t)?new i(`.${t}`):o`[${t}]`},e.getEsmExportName=function(t){if("string"==typeof t&&e.IDENTIFIER.test(t))return new i(`${t}`);throw Error(`CodeGen: invalid export name: ${t}, use explicit $id name mapping`)},e.regexpCode=function(e){return new i(e.toString())}}),qS=kO(e=>{Object.defineProperty(e,"__esModule",{value:!0}),e.ValueScope=e.ValueScopeName=e.Scope=e.varKinds=e.UsedValueState=void 0;let t=q$();var r,i,o=class extends Error{constructor(e){super(`CodeGen: "code" for ${e} not defined`),this.value=e.value}};(r=i||(e.UsedValueState=i={}))[r.Started=0]="Started",r[r.Completed=1]="Completed",e.varKinds={const:new t.Name("const"),let:new t.Name("let"),var:new t.Name("var")};var n=class{constructor({prefixes:e,parent:t}={}){this._names={},this._prefixes=e,this._parent=t}toName(e){return e instanceof t.Name?e:this.name(e)}name(e){return new t.Name(this._newName(e))}_newName(e){let t=this._names[e]||this._nameGroup(e);return`${e}${t.index++}`}_nameGroup(e){var t,r;if((null==(r=null==(t=this._parent)?void 0:t._prefixes)?void 0:r.has(e))||this._prefixes&&!this._prefixes.has(e))throw Error(`CodeGen: prefix "${e}" is not allowed in this scope`);return this._names[e]={prefix:e,index:0}}};e.Scope=n;var a=class extends t.Name{constructor(e,t){super(t),this.prefix=e}setValue(e,{property:r,itemIndex:i}){this.value=e,this.scopePath=(0,t._)`.${new t.Name(r)}[${i}]`}};e.ValueScopeName=a;let s=(0,t._)`\n`;var d=class extends n{constructor(e){super(e),this._values={},this._scope=e.scope,this.opts={...e,_n:e.lines?s:t.nil}}get(){return this._scope}name(e){return new a(e,this._newName(e))}value(e,t){var r;if(void 0===t.ref)throw Error("CodeGen: ref must be passed in value");let i=this.toName(e),{prefix:o}=i,n=null!=(r=t.key)?r:t.ref,a=this._values[o];if(a){let e=a.get(n);if(e)return e}else a=this._values[o]=new Map;a.set(n,i);let s=this._scope[o]||(this._scope[o]=[]),d=s.length;return s[d]=t.ref,i.setValue(t,{property:o,itemIndex:d}),i}getValue(e,t){let r=this._values[e];if(r)return r.get(t)}scopeRefs(e,r=this._values){return this._reduceValues(r,r=>{if(void 0===r.scopePath)throw Error(`CodeGen: name "${r}" has no value`);return(0,t._)`${e}${r.scopePath}`})}scopeCode(e=this._values,t,r){return this._reduceValues(e,e=>{if(void 0===e.value)throw Error(`CodeGen: name "${e}" has no value`);return e.value.code},t,r)}_reduceValues(r,n,a={},s){let d=t.nil;for(let c in r){let l=r[c];if(!l)continue;let p=a[c]=a[c]||new Map;l.forEach(r=>{if(p.has(r))return;p.set(r,i.Started);let a=n(r);if(a){let i=this.opts.es5?e.varKinds.var:e.varKinds.const;d=(0,t._)`${d}${i} ${r} = ${a};${this.opts._n}`}else if(a=null==s?void 0:s(r))d=(0,t._)`${d}${a}${this.opts._n}`;else throw new o(r);p.set(r,i.Completed)})}return d}};e.ValueScope=d}),qk=kO(e=>{Object.defineProperty(e,"__esModule",{value:!0}),e.or=e.and=e.not=e.CodeGen=e.operators=e.varKinds=e.ValueScopeName=e.ValueScope=e.Scope=e.Name=e.regexpCode=e.stringify=e.getProperty=e.nil=e.strConcat=e.str=e._=void 0;let t=q$(),r=qS();var i=q$();Object.defineProperty(e,"_",{enumerable:!0,get:function(){return i._}}),Object.defineProperty(e,"str",{enumerable:!0,get:function(){return i.str}}),Object.defineProperty(e,"strConcat",{enumerable:!0,get:function(){return i.strConcat}}),Object.defineProperty(e,"nil",{enumerable:!0,get:function(){return i.nil}}),Object.defineProperty(e,"getProperty",{enumerable:!0,get:function(){return i.getProperty}}),Object.defineProperty(e,"stringify",{enumerable:!0,get:function(){return i.stringify}}),Object.defineProperty(e,"regexpCode",{enumerable:!0,get:function(){return i.regexpCode}}),Object.defineProperty(e,"Name",{enumerable:!0,get:function(){return i.Name}});var o=qS();Object.defineProperty(e,"Scope",{enumerable:!0,get:function(){return o.Scope}}),Object.defineProperty(e,"ValueScope",{enumerable:!0,get:function(){return o.ValueScope}}),Object.defineProperty(e,"ValueScopeName",{enumerable:!0,get:function(){return o.ValueScopeName}}),Object.defineProperty(e,"varKinds",{enumerable:!0,get:function(){return o.varKinds}}),e.operators={GT:new t._Code(">"),GTE:new t._Code(">="),LT:new t._Code("<"),LTE:new t._Code("<="),EQ:new t._Code("==="),NEQ:new t._Code("!=="),NOT:new t._Code("!"),OR:new t._Code("||"),AND:new t._Code("&&"),ADD:new t._Code("+")};var n=class{optimizeNodes(){return this}optimizeNames(e,t){return this}},a=class extends n{constructor(e,t,r){super(),this.varKind=e,this.name=t,this.rhs=r}render({es5:e,_n:t}){let i=e?r.varKinds.var:this.varKind,o=void 0===this.rhs?"":` = ${this.rhs}`;return`${i} ${this.name}${o};`+t}optimizeNames(e,t){if(e[this.name.str])return this.rhs&&(this.rhs=x(this.rhs,e,t)),this}get names(){return this.rhs instanceof t._CodeOrName?this.rhs.names:{}}},s=class extends n{constructor(e,t,r){super(),this.lhs=e,this.rhs=t,this.sideEffects=r}render({_n:e}){return`${this.lhs} = ${this.rhs};`+e}optimizeNames(e,r){if(!(this.lhs instanceof t.Name)||e[this.lhs.str]||this.sideEffects)return this.rhs=x(this.rhs,e,r),this}get names(){return I(this.lhs instanceof t.Name?{}:{...this.lhs.names},this.rhs)}},d=class extends s{constructor(e,t,r,i){super(e,r,i),this.op=t}render({_n:e}){return`${this.lhs} ${this.op}= ${this.rhs};`+e}},c=class extends n{constructor(e){super(),this.label=e,this.names={}}render({_n:e}){return`${this.label}:`+e}},l=class extends n{constructor(e){super(),this.label=e,this.names={}}render({_n:e}){return`break${this.label?` ${this.label}`:""};`+e}},p=class extends n{constructor(e){super(),this.error=e}render({_n:e}){return`throw ${this.error};`+e}get names(){return this.error.names}},u=class extends n{constructor(e){super(),this.code=e}render({_n:e}){return`${this.code};`+e}optimizeNodes(){return`${this.code}`?this:void 0}optimizeNames(e,t){return this.code=x(this.code,e,t),this}get names(){return this.code instanceof t._CodeOrName?this.code.names:{}}},m=class extends n{constructor(e=[]){super(),this.nodes=e}render(e){return this.nodes.reduce((t,r)=>t+r.render(e),"")}optimizeNodes(){let{nodes:e}=this,t=e.length;for(;t--;){let r=e[t].optimizeNodes();Array.isArray(r)?e.splice(t,1,...r):r?e[t]=r:e.splice(t,1)}return e.length>0?this:void 0}optimizeNames(e,t){let{nodes:r}=this,i=r.length;for(;i--;){let o=r[i];o.optimizeNames(e,t)||(function(e,t){for(let r in t)e[r]=(e[r]||0)-(t[r]||0)}(e,o.names),r.splice(i,1))}return r.length>0?this:void 0}get names(){return this.nodes.reduce((e,t)=>q(e,t.names),{})}},f=class extends m{render(e){return"{"+e._n+super.render(e)+"}"+e._n}},h=class extends m{},y=class extends f{};y.kind="else";var g=class e extends f{constructor(e,t){super(t),this.condition=e}render(e){let t=`if(${this.condition})`+super.render(e);return this.else&&(t+="else "+this.else.render(e)),t}optimizeNodes(){super.optimizeNodes();let t=this.condition;if(!0===t)return this.nodes;let r=this.else;if(r){let e=r.optimizeNodes();r=this.else=Array.isArray(e)?new y(e):e}return r?!1===t?r instanceof e?r:r.nodes:this.nodes.length?this:new e(j(t),r instanceof e?[r]:r.nodes):!1!==t&&this.nodes.length?this:void 0}optimizeNames(e,t){var r;if(this.else=null==(r=this.else)?void 0:r.optimizeNames(e,t),super.optimizeNames(e,t)||this.else)return this.condition=x(this.condition,e,t),this}get names(){let e=super.names;return I(e,this.condition),this.else&&q(e,this.else.names),e}};g.kind="if";var _=class extends f{};_.kind="for";var v=class extends _{constructor(e){super(),this.iteration=e}render(e){return`for(${this.iteration})`+super.render(e)}optimizeNames(e,t){if(super.optimizeNames(e,t))return this.iteration=x(this.iteration,e,t),this}get names(){return q(super.names,this.iteration.names)}},b=class extends _{constructor(e,t,r,i){super(),this.varKind=e,this.name=t,this.from=r,this.to=i}render(e){let t=e.es5?r.varKinds.var:this.varKind,{name:i,from:o,to:n}=this;return`for(${t} ${i}=${o}; ${i}<${n}; ${i}++)`+super.render(e)}get names(){return I(I(super.names,this.from),this.to)}},$=class extends _{constructor(e,t,r,i){super(),this.loop=e,this.varKind=t,this.name=r,this.iterable=i}render(e){return`for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})`+super.render(e)}optimizeNames(e,t){if(super.optimizeNames(e,t))return this.iterable=x(this.iterable,e,t),this}get names(){return q(super.names,this.iterable.names)}},S=class extends f{constructor(e,t,r){super(),this.name=e,this.args=t,this.async=r}render(e){return`${this.async?"async ":""}function ${this.name}(${this.args})`+super.render(e)}};S.kind="func";var k=class extends m{render(e){return"return "+super.render(e)}};k.kind="return";var w=class extends f{render(e){let t="try"+super.render(e);return this.catch&&(t+=this.catch.render(e)),this.finally&&(t+=this.finally.render(e)),t}optimizeNodes(){var e,t;return super.optimizeNodes(),null==(e=this.catch)||e.optimizeNodes(),null==(t=this.finally)||t.optimizeNodes(),this}optimizeNames(e,t){var r,i;return super.optimizeNames(e,t),null==(r=this.catch)||r.optimizeNames(e,t),null==(i=this.finally)||i.optimizeNames(e,t),this}get names(){let e=super.names;return this.catch&&q(e,this.catch.names),this.finally&&q(e,this.finally.names),e}},P=class extends f{constructor(e){super(),this.error=e}render(e){return`catch(${this.error})`+super.render(e)}};P.kind="catch";var V=class extends f{render(e){return"finally"+super.render(e)}};V.kind="finally";var R=class{constructor(e,t={}){this._values={},this._blockStarts=[],this._constants={},this.opts={...t,_n:t.lines?"\n":""},this._extScope=e,this._scope=new r.Scope({parent:e}),this._nodes=[new h]}toString(){return this._root.render(this.opts)}name(e){return this._scope.name(e)}scopeName(e){return this._extScope.name(e)}scopeValue(e,t){let r=this._extScope.value(e,t);return(this._values[r.prefix]||(this._values[r.prefix]=new Set)).add(r),r}getScopeValue(e,t){return this._extScope.getValue(e,t)}scopeRefs(e){return this._extScope.scopeRefs(e,this._values)}scopeCode(){return this._extScope.scopeCode(this._values)}_def(e,t,r,i){let o=this._scope.toName(t);return void 0!==r&&i&&(this._constants[o.str]=r),this._leafNode(new a(e,o,r)),o}const(e,t,i){return this._def(r.varKinds.const,e,t,i)}let(e,t,i){return this._def(r.varKinds.let,e,t,i)}var(e,t,i){return this._def(r.varKinds.var,e,t,i)}assign(e,t,r){return this._leafNode(new s(e,t,r))}add(t,r){return this._leafNode(new d(t,e.operators.ADD,r))}code(e){return"function"==typeof e?e():e!==t.nil&&this._leafNode(new u(e)),this}object(...e){let r=["{"];for(let[i,o]of e)r.length>1&&r.push(","),r.push(i),(i!==o||this.opts.es5)&&(r.push(":"),(0,t.addCodeArg)(r,o));return r.push("}"),new t._Code(r)}if(e,t,r){if(this._blockNode(new g(e)),t&&r)this.code(t).else().code(r).endIf();else if(t)this.code(t).endIf();else if(r)throw Error('CodeGen: "else" body without "then" body');return this}elseIf(e){return this._elseNode(new g(e))}else(){return this._elseNode(new y)}endIf(){return this._endBlockNode(g,y)}_for(e,t){return this._blockNode(e),t&&this.code(t).endFor(),this}for(e,t){return this._for(new v(e),t)}forRange(e,t,i,o,n=this.opts.es5?r.varKinds.var:r.varKinds.let){let a=this._scope.toName(e);return this._for(new b(n,a,t,i),()=>o(a))}forOf(e,i,o,n=r.varKinds.const){let a=this._scope.toName(e);if(this.opts.es5){let e=i instanceof t.Name?i:this.var("_arr",i);return this.forRange("_i",0,(0,t._)`${e}.length`,r=>{this.var(a,(0,t._)`${e}[${r}]`),o(a)})}return this._for(new $("of",n,a,i),()=>o(a))}forIn(e,i,o,n=this.opts.es5?r.varKinds.var:r.varKinds.const){if(this.opts.ownProperties)return this.forOf(e,(0,t._)`Object.keys(${i})`,o);let a=this._scope.toName(e);return this._for(new $("in",n,a,i),()=>o(a))}endFor(){return this._endBlockNode(_)}label(e){return this._leafNode(new c(e))}break(e){return this._leafNode(new l(e))}return(e){let t=new k;if(this._blockNode(t),this.code(e),1!==t.nodes.length)throw Error('CodeGen: "return" should have one node');return this._endBlockNode(k)}try(e,t,r){if(!t&&!r)throw Error('CodeGen: "try" without "catch" and "finally"');let i=new w;if(this._blockNode(i),this.code(e),t){let e=this.name("e");this._currNode=i.catch=new P(e),t(e)}return r&&(this._currNode=i.finally=new V,this.code(r)),this._endBlockNode(P,V)}throw(e){return this._leafNode(new p(e))}block(e,t){return this._blockStarts.push(this._nodes.length),e&&this.code(e).endBlock(t),this}endBlock(e){let t=this._blockStarts.pop();if(void 0===t)throw Error("CodeGen: not in self-balancing block");let r=this._nodes.length-t;if(r<0||void 0!==e&&r!==e)throw Error(`CodeGen: wrong number of nodes: ${r} vs ${e} expected`);return this._nodes.length=t,this}func(e,r=t.nil,i,o){return this._blockNode(new S(e,r,i)),o&&this.code(o).endFunc(),this}endFunc(){return this._endBlockNode(S)}optimize(e=1){for(;e-- >0;)this._root.optimizeNodes(),this._root.optimizeNames(this._root.names,this._constants)}_leafNode(e){return this._currNode.nodes.push(e),this}_blockNode(e){this._currNode.nodes.push(e),this._nodes.push(e)}_endBlockNode(e,t){let r=this._currNode;if(r instanceof e||t&&r instanceof t)return this._nodes.pop(),this;throw Error(`CodeGen: not in block "${t?`${e.kind}/${t.kind}`:e.kind}"`)}_elseNode(e){let t=this._currNode;if(!(t instanceof g))throw Error('CodeGen: "else" without "if"');return this._currNode=t.else=e,this}get _root(){return this._nodes[0]}get _currNode(){let e=this._nodes;return e[e.length-1]}set _currNode(e){let t=this._nodes;t[t.length-1]=e}};function q(e,t){for(let r in t)e[r]=(e[r]||0)+(t[r]||0);return e}function I(e,r){return r instanceof t._CodeOrName?q(e,r.names):e}function x(e,r,i){var o;if(e instanceof t.Name)return n(e);if(!((o=e)instanceof t._Code&&o._items.some(e=>e instanceof t.Name&&1===r[e.str]&&void 0!==i[e.str])))return e;return new t._Code(e._items.reduce((e,r)=>(r instanceof t.Name&&(r=n(r)),r instanceof t._Code?e.push(...r._items):e.push(r),e),[]));function n(e){let t=i[e.str];return void 0===t||1!==r[e.str]?e:(delete r[e.str],t)}}function j(e){return"boolean"==typeof e||"number"==typeof e||null===e?!e:(0,t._)`!${E(e)}`}e.CodeGen=R,e.not=j;let C=O(e.operators.AND);e.and=function(...e){return e.reduce(C)};let T=O(e.operators.OR);function O(e){return(r,i)=>r===t.nil?i:i===t.nil?r:(0,t._)`${E(r)} ${e} ${E(i)}`}function E(e){return e instanceof t.Name?e:(0,t._)`(${e})`}e.or=function(...e){return e.reduce(T)}}),qw=kO(e=>{var t,r;Object.defineProperty(e,"__esModule",{value:!0}),e.checkStrictMode=e.getErrorPath=e.Type=e.useFunc=e.setEvaluated=e.evaluatedPropsToName=e.mergeEvaluated=e.eachItem=e.unescapeJsonPointer=e.escapeJsonPointer=e.escapeFragment=e.unescapeFragment=e.schemaRefOrVal=e.schemaHasRulesButRef=e.schemaHasRules=e.checkUnknownRules=e.alwaysValidSchema=e.toHash=void 0;let i=qk(),o=q$();function n(e,t=e.schema){let{opts:r,self:i}=e;if(!r.strictSchema||"boolean"==typeof t)return;let o=i.RULES.keywords;for(let r in t)o[r]||m(e,`unknown keyword: "${r}"`)}function a(e,t){if("boolean"==typeof e)return!e;for(let r in e)if(t[r])return!0;return!1}function s(e){return"number"==typeof e?`${e}`:e.replace(/~/g,"~0").replace(/\//g,"~1")}function d(e){return e.replace(/~1/g,"/").replace(/~0/g,"~")}function c({mergeNames:e,mergeToName:t,mergeValues:r,resultToName:o}){return(n,a,s,d)=>{let c=void 0===s?a:s instanceof i.Name?(a instanceof i.Name?e(n,a,s):t(n,a,s),s):a instanceof i.Name?(t(n,s,a),a):r(a,s);return d!==i.Name||c instanceof i.Name?c:o(n,c)}}function l(e,t){if(!0===t)return e.var("props",!0);let r=e.var("props",(0,i._)`{}`);return void 0!==t&&p(e,r,t),r}function p(e,t,r){Object.keys(r).forEach(r=>e.assign((0,i._)`${t}${(0,i.getProperty)(r)}`,!0))}e.toHash=function(e){let t={};for(let r of e)t[r]=!0;return t},e.alwaysValidSchema=function(e,t){return"boolean"==typeof t?t:0===Object.keys(t).length||(n(e,t),!a(t,e.self.RULES.all))},e.checkUnknownRules=n,e.schemaHasRules=a,e.schemaHasRulesButRef=function(e,t){if("boolean"==typeof e)return!e;for(let r in e)if("$ref"!==r&&t.all[r])return!0;return!1},e.schemaRefOrVal=function({topSchemaRef:e,schemaPath:t},r,o,n){if(!n){if("number"==typeof r||"boolean"==typeof r)return r;if("string"==typeof r)return(0,i._)`${r}`}return(0,i._)`${e}${t}${(0,i.getProperty)(o)}`},e.unescapeFragment=function(e){return d(decodeURIComponent(e))},e.escapeFragment=function(e){return encodeURIComponent(s(e))},e.escapeJsonPointer=s,e.unescapeJsonPointer=d,e.eachItem=function(e,t){if(Array.isArray(e))for(let r of e)t(r);else t(e)},e.mergeEvaluated={props:c({mergeNames:(e,t,r)=>e.if((0,i._)`${r} !== true && ${t} !== undefined`,()=>{e.if((0,i._)`${t} === true`,()=>e.assign(r,!0),()=>e.assign(r,(0,i._)`${r} || {}`).code((0,i._)`Object.assign(${r}, ${t})`))}),mergeToName:(e,t,r)=>e.if((0,i._)`${r} !== true`,()=>{!0===t?e.assign(r,!0):(e.assign(r,(0,i._)`${r} || {}`),p(e,r,t))}),mergeValues:(e,t)=>!0===e||{...e,...t},resultToName:l}),items:c({mergeNames:(e,t,r)=>e.if((0,i._)`${r} !== true && ${t} !== undefined`,()=>e.assign(r,(0,i._)`${t} === true ? true : ${r} > ${t} ? ${r} : ${t}`)),mergeToName:(e,t,r)=>e.if((0,i._)`${r} !== true`,()=>e.assign(r,!0===t||(0,i._)`${r} > ${t} ? ${r} : ${t}`)),mergeValues:(e,t)=>!0===e||Math.max(e,t),resultToName:(e,t)=>e.var("items",t)})},e.evaluatedPropsToName=l,e.setEvaluated=p;let u={};function m(e,t,r=e.opts.strictSchema){if(r){if(t=`strict mode: ${t}`,!0===r)throw Error(t);e.self.logger.warn(t)}}e.useFunc=function(e,t){return e.scopeValue("func",{ref:t,code:u[t.code]||(u[t.code]=new o._Code(t.code))})},(r=t||(e.Type=t={}))[r.Num=0]="Num",r[r.Str=1]="Str",e.getErrorPath=function(e,r,o){if(e instanceof i.Name){let n=r===t.Num;return o?n?(0,i._)`"[" + ${e} + "]"`:(0,i._)`"['" + ${e} + "']"`:n?(0,i._)`"/" + ${e}`:(0,i._)`"/" + ${e}.replace(/~/g, "~0").replace(/\\//g, "~1")`}return o?(0,i.getProperty)(e).toString():"/"+s(e)},e.checkStrictMode=m}),qP=kO(e=>{Object.defineProperty(e,"__esModule",{value:!0});let t=qk();e.default={data:new t.Name("data"),valCxt:new t.Name("valCxt"),instancePath:new t.Name("instancePath"),parentData:new t.Name("parentData"),parentDataProperty:new t.Name("parentDataProperty"),rootData:new t.Name("rootData"),dynamicAnchors:new t.Name("dynamicAnchors"),vErrors:new t.Name("vErrors"),errors:new t.Name("errors"),this:new t.Name("this"),self:new t.Name("self"),scope:new t.Name("scope"),json:new t.Name("json"),jsonPos:new t.Name("jsonPos"),jsonLen:new t.Name("jsonLen"),jsonPart:new t.Name("jsonPart")}}),qV=kO(e=>{Object.defineProperty(e,"__esModule",{value:!0}),e.extendErrors=e.resetErrorsCount=e.reportExtraError=e.reportError=e.keyword$DataError=e.keywordError=void 0;let t=qk(),r=qw(),i=qP();function o(e,r){let o=e.const("err",r);e.if((0,t._)`${i.default.vErrors} === null`,()=>e.assign(i.default.vErrors,(0,t._)`[${o}]`),(0,t._)`${i.default.vErrors}.push(${o})`),e.code((0,t._)`${i.default.errors}++`)}function n(e,r){let{gen:i,validateName:o,schemaEnv:n}=e;n.$async?i.throw((0,t._)`new ${e.ValidationError}(${r})`):(i.assign((0,t._)`${o}.errors`,r),i.return(!1))}e.keywordError={message:({keyword:e})=>(0,t.str)`must pass "${e}" keyword validation`},e.keyword$DataError={message:({keyword:e,schemaType:r})=>r?(0,t.str)`"${e}" keyword must be ${r} ($data)`:(0,t.str)`"${e}" keyword is invalid ($data)`},e.reportError=function(r,i=e.keywordError,a,d){let{it:c}=r,{gen:l,compositeRule:p,allErrors:u}=c,m=s(r,i,a);(null!=d?d:p||u)?o(l,m):n(c,(0,t._)`[${m}]`)},e.reportExtraError=function(t,r=e.keywordError,a){let{it:d}=t,{gen:c,compositeRule:l,allErrors:p}=d;o(c,s(t,r,a)),l||p||n(d,i.default.vErrors)},e.resetErrorsCount=function(e,r){e.assign(i.default.errors,r),e.if((0,t._)`${i.default.vErrors} !== null`,()=>e.if(r,()=>e.assign((0,t._)`${i.default.vErrors}.length`,r),()=>e.assign(i.default.vErrors,null)))},e.extendErrors=function({gen:e,keyword:r,schemaValue:o,data:n,errsCount:a,it:s}){if(void 0===a)throw Error("ajv implementation error");let d=e.name("err");e.forRange("i",a,i.default.errors,a=>{e.const(d,(0,t._)`${i.default.vErrors}[${a}]`),e.if((0,t._)`${d}.instancePath === undefined`,()=>e.assign((0,t._)`${d}.instancePath`,(0,t.strConcat)(i.default.instancePath,s.errorPath))),e.assign((0,t._)`${d}.schemaPath`,(0,t.str)`${s.errSchemaPath}/${r}`),s.opts.verbose&&(e.assign((0,t._)`${d}.schema`,o),e.assign((0,t._)`${d}.data`,n))})};let a={keyword:new t.Name("keyword"),schemaPath:new t.Name("schemaPath"),params:new t.Name("params"),propertyName:new t.Name("propertyName"),message:new t.Name("message"),schema:new t.Name("schema"),parentSchema:new t.Name("parentSchema")};function s(e,o,n){let{createErrors:s}=e.it;return!1===s?(0,t._)`{}`:function(e,o,n={}){let{gen:s,it:d}=e,c=[function({errorPath:e},{instancePath:o}){let n=o?(0,t.str)`${e}${(0,r.getErrorPath)(o,r.Type.Str)}`:e;return[i.default.instancePath,(0,t.strConcat)(i.default.instancePath,n)]}(d,n),function({keyword:e,it:{errSchemaPath:i}},{schemaPath:o,parentSchema:n}){let s=n?i:(0,t.str)`${i}/${e}`;return o&&(s=(0,t.str)`${s}${(0,r.getErrorPath)(o,r.Type.Str)}`),[a.schemaPath,s]}(e,n)];return function(e,{params:r,message:o},n){let{keyword:s,data:d,schemaValue:c,it:l}=e,{opts:p,propertyName:u,topSchemaRef:m,schemaPath:f}=l;n.push([a.keyword,s],[a.params,"function"==typeof r?r(e):r||(0,t._)`{}`]),p.messages&&n.push([a.message,"function"==typeof o?o(e):o]),p.verbose&&n.push([a.schema,c],[a.parentSchema,(0,t._)`${m}${f}`],[i.default.data,d]),u&&n.push([a.propertyName,u])}(e,o,c),s.object(...c)}(e,o,n)}}),qR=kO(e=>{Object.defineProperty(e,"__esModule",{value:!0}),e.boolOrEmptySchema=e.topBoolOrEmptySchema=void 0;let t=qV(),r=qk(),i=qP(),o={message:"boolean schema is false"};function n(e,r){let{gen:i,data:n}=e;(0,t.reportError)({gen:i,keyword:"false schema",data:n,schema:!1,schemaCode:!1,schemaValue:!1,params:{},it:e},o,void 0,r)}e.topBoolOrEmptySchema=function(e){let{gen:t,schema:o,validateName:a}=e;!1===o?n(e,!1):"object"==typeof o&&!0===o.$async?t.return(i.default.data):(t.assign((0,r._)`${a}.errors`,null),t.return(!0))},e.boolOrEmptySchema=function(e,t){let{gen:r,schema:i}=e;!1===i?(r.var(t,!1),n(e)):r.var(t,!0)}}),qq=kO(e=>{Object.defineProperty(e,"__esModule",{value:!0}),e.getRules=e.isJSONType=void 0;let t=new Set(["string","number","integer","boolean","null","object","array"]);e.isJSONType=function(e){return"string"==typeof e&&t.has(e)},e.getRules=function(){let e={number:{type:"number",rules:[]},string:{type:"string",rules:[]},array:{type:"array",rules:[]},object:{type:"object",rules:[]}};return{types:{...e,integer:!0,boolean:!0,null:!0},rules:[{rules:[]},e.number,e.string,e.array,e.object],post:{rules:[]},all:{},keywords:{}}}}),qI=kO(e=>{function t(e,t){return t.rules.some(t=>r(e,t))}function r(e,t){var r;return void 0!==e[t.keyword]||(null==(r=t.definition.implements)?void 0:r.some(t=>void 0!==e[t]))}Object.defineProperty(e,"__esModule",{value:!0}),e.shouldUseRule=e.shouldUseGroup=e.schemaHasRulesForType=void 0,e.schemaHasRulesForType=function({schema:e,self:r},i){let o=r.RULES.types[i];return o&&!0!==o&&t(e,o)},e.shouldUseGroup=t,e.shouldUseRule=r}),qx=kO(e=>{var t,r;Object.defineProperty(e,"__esModule",{value:!0}),e.reportTypeError=e.checkDataTypes=e.checkDataType=e.coerceAndCheckDataType=e.getJSONTypes=e.getSchemaTypes=e.DataType=void 0;let i=qq(),o=qI(),n=qV(),a=qk(),s=qw();function d(e){let t=Array.isArray(e)?e:e?[e]:[];if(t.every(i.isJSONType))return t;throw Error("type must be JSONType or JSONType[]: "+t.join(","))}(r=t||(e.DataType=t={}))[r.Correct=0]="Correct",r[r.Wrong=1]="Wrong",e.getSchemaTypes=function(e){let t=d(e.type);if(t.includes("null")){if(!1===e.nullable)throw Error("type: null contradicts nullable: false")}else{if(!t.length&&void 0!==e.nullable)throw Error('"nullable" cannot be used without "type"');!0===e.nullable&&t.push("null")}return t},e.getJSONTypes=d,e.coerceAndCheckDataType=function(e,r){var i,n;let{gen:s,data:d,opts:l}=e,u=(i=r,(n=l.coerceTypes)?i.filter(e=>c.has(e)||"array"===n&&"array"===e):[]),f=r.length>0&&!(0===u.length&&1===r.length&&(0,o.schemaHasRulesForType)(e,r[0]));if(f){let i=p(r,d,l.strictNumbers,t.Wrong);s.if(i,()=>{u.length?function(e,t,r){let{gen:i,data:o,opts:n}=e,s=i.let("dataType",(0,a._)`typeof ${o}`),d=i.let("coerced",(0,a._)`undefined`);for(let e of("array"===n.coerceTypes&&i.if((0,a._)`${s} == 'object' && Array.isArray(${o}) && ${o}.length == 1`,()=>i.assign(o,(0,a._)`${o}[0]`).assign(s,(0,a._)`typeof ${o}`).if(p(t,o,n.strictNumbers),()=>i.assign(d,o))),i.if((0,a._)`${d} !== undefined`),r))(c.has(e)||"array"===e&&"array"===n.coerceTypes)&&function(e){switch(e){case"string":i.elseIf((0,a._)`${s} == "number" || ${s} == "boolean"`).assign(d,(0,a._)`"" + ${o}`).elseIf((0,a._)`${o} === null`).assign(d,(0,a._)`""`);return;case"number":i.elseIf((0,a._)`${s} == "boolean" || ${o} === null

From 51eeb22a38363d0b64a38c94e243138ada3eab40 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 15:02:12 -0800
Subject: [PATCH 37/80] test(extension): isolate staged CLI command discovery

---
 plugin/chatgpt-extension/test/extension.test.ts | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/plugin/chatgpt-extension/test/extension.test.ts b/plugin/chatgpt-extension/test/extension.test.ts
index bf08eff10f2..b4e97590729 100644
--- a/plugin/chatgpt-extension/test/extension.test.ts
+++ b/plugin/chatgpt-extension/test/extension.test.ts
@@ -150,8 +150,10 @@ describe("ChatGPT extension against a live TraceDecay daemon", () => {
   it("runs the receipt-staged explorer without relying on tracedecay on PATH", async () => {
     const packageRoot = path.resolve(import.meta.dirname, "..");
     const staged = path.join(fixture.home, ".tracedecay/host-bundle-stage/chatgpt/tracedecay");
+    // Leave the operator's installed CLI out of receipt command discovery.
+    const installerEnv = { ...fixture.env, PATH: "" };
     const install = spawnSync(fixture.binary, ["install", "--agent", "chatgpt"], {
-      env: fixture.env, cwd: fixture.home, encoding: "utf8",
+      env: installerEnv, cwd: fixture.home, encoding: "utf8",
     });
     expect(install.status, install.stderr).toBe(0);
     const manifest = JSON.parse(await readFile(path.join(staged, "mcp.json"), "utf8"));
@@ -195,7 +197,7 @@ describe("ChatGPT extension against a live TraceDecay daemon", () => {
     } finally {
       await packaged.close();
       const uninstall = spawnSync(fixture.binary, ["uninstall", "--agent", "chatgpt"], {
-        env: fixture.env, cwd: fixture.home, encoding: "utf8",
+        env: installerEnv, cwd: fixture.home, encoding: "utf8",
       });
       expect(uninstall.status, uninstall.stderr).toBe(0);
     }

From 873ae1915df2f3fecccba1bfee0b15f15b4803b3 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 16:54:01 -0800
Subject: [PATCH 38/80] fix(dashboard): retain committed native graph progress

Refs #4508

Keep inactive native page and verified segment counts visible only for
 the current sealed generation, without changing active polling. Do not
promote encoding-only observations or phase labels to durable work.

Add DOM regressions for both dashboard consumers, generated decoding,
writer completion, interrupted pages, stale-generation isolation and
idle HTTP polling. Local pnpm execution is blocked by registry DNS;
these new cases still require exact-head CI execution.
---
 .../CodeIndexNativeProgress.dom.test.tsx      | 236 ++++++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         |  16 +-
 2 files changed, 249 insertions(+), 3 deletions(-)
 create mode 100644 dashboard/src/workspaces/observatory/CodeIndexNativeProgress.dom.test.tsx

diff --git a/dashboard/src/workspaces/observatory/CodeIndexNativeProgress.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexNativeProgress.dom.test.tsx
new file mode 100644
index 00000000000..151ea9378c8
--- /dev/null
+++ b/dashboard/src/workspaces/observatory/CodeIndexNativeProgress.dom.test.tsx
@@ -0,0 +1,236 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, cleanup, render, screen } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { CodeIndexFreshnessPayloadV1Schema } from '../../contracts/generated.ts';
+import type {
+  CodeIndexFreshnessPayloadV1,
+  CodeIndexNativeGraphProgressV1,
+  CodeIndexWorktreeFreshnessV1,
+} from '../../contracts/generated.ts';
+import type { EnvelopeResult } from '../../data/query/envelope.ts';
+import { IndexFreshness } from '../code/IndexFreshness.tsx';
+import {
+  CodeIndexPipeline,
+  hasActiveCodeIndexBuild,
+  hasLiveWorktreeProgress,
+} from './CodeIndexPipeline.tsx';
+
+type FreshnessResult = Extract<
+  EnvelopeResult<CodeIndexFreshnessPayloadV1>,
+  { outcome: 'envelope' }
+>;
+
+const GENERATION = 'generation.native-milestones';
+const OBSERVED_AT = 1_753_003_600_000_000;
+const clients: QueryClient[] = [];
+
+function nativeProgress(
+  overrides: Partial<CodeIndexNativeGraphProgressV1> = {},
+): CodeIndexNativeGraphProgressV1 {
+  return {
+    generation_id: GENERATION,
+    sealed_graph_digest: 'sha256:sealed-graph',
+    daemon_incarnation: 2,
+    producer_incarnation: 3,
+    attempt_sequence: 4,
+    progress_epoch: 9,
+    phase: 'compact_segment_verified',
+    encoded_entities: 90,
+    total_entities: 90,
+    encoded_relations: 40,
+    total_relations: 40,
+    committed_stage_pages: 0,
+    committed_stage_mutations: 0,
+    committed_stage_bytes: 0,
+    committed_compact_segments: 1,
+    committed_compact_bytes: 4096,
+    last_progress_micros: OBSERVED_AT,
+    active: false,
+    ...overrides,
+  };
+}
+
+function freshness(
+  graph: CodeIndexNativeGraphProgressV1,
+  overrides: Partial<CodeIndexWorktreeFreshnessV1> = {},
+): FreshnessResult {
+  const worktree: CodeIndexWorktreeFreshnessV1 = {
+    worktree_root: '/project',
+    repository_id: 'repository.project',
+    worktree_id: 'worktree.primary',
+    source_reference: 'refs/heads/master',
+    source_revision: null,
+    latest_generation_id: GENERATION,
+    code_graph_serving: { state: 'ready' },
+    clone_index: null,
+    snapshot_content_identity: 'sha256:source',
+    sealed_at_micros: OBSERVED_AT,
+    last_reconcile_micros: OBSERVED_AT,
+    staleness_state: 'fresh',
+    rebuild_in_flight: false,
+    hook_hint_count: 0,
+    coverage: 'complete',
+    progress: null,
+    restore_progress: null,
+    parked: null,
+    native_graph_progress: graph,
+    ...overrides,
+  };
+  return {
+    outcome: 'envelope',
+    envelope: {
+      schema_revision: 1,
+      scope: { project_id: 'project', storage_mode: 'project', store_root: '/store' },
+      version: { entity_version: null, graph_version: null },
+      time: { valid_time_micros: null, observation_time_micros: OBSERVED_AT },
+      source_watermark: null,
+      authorization: { outcome: 'authorized' },
+      coverage: {
+        completeness: 'complete',
+        eligible: 1,
+        examined: 1,
+        matched: 1,
+        excluded: 0,
+        omitted: 0,
+        unknown: 0,
+        denominator: 1,
+        unit: 'mounted_worktree',
+        omission_reasons: [],
+      },
+      freshness: { state: 'fresh', observed_at_micros: OBSERVED_AT, watermark: null },
+      domain_state: 'ready',
+      legal_actions: [],
+      // Exercise the generated wire decoder as well as the React consumer.
+      payload: CodeIndexFreshnessPayloadV1Schema.parse({
+        worktrees: [worktree],
+        note: 'daemon scheduler state',
+      }),
+    },
+  };
+}
+
+const VERIFIED_READING =
+  'compact segment verified · 90 entities encoded · 40 relations encoded · 0 pages committed · 1 segments committed';
+
+function renderPipeline(result: FreshnessResult) {
+  return render(<CodeIndexPipeline result={result} pending={false} scopeKey="project" />);
+}
+
+afterEach(() => {
+  cleanup();
+  for (const client of clients.splice(0)) client.clear();
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+});
+
+describe('retained native graph milestones', () => {
+  it('keeps verified work visible after the same-generation writer finishes without live polling', () => {
+    const writing = freshness(nativeProgress({ active: true }));
+    const { rerender } = renderPipeline(writing);
+    expect(screen.getByText('Graph writer')).toBeTruthy();
+    expect(hasActiveCodeIndexBuild(writing)).toBe(true);
+
+    const finished = freshness(nativeProgress());
+    const original = structuredClone(finished);
+    rerender(<CodeIndexPipeline result={finished} pending={false} scopeKey="project" />);
+    expect(screen.getByText('Graph milestones')).toBeTruthy();
+    expect(screen.getByText(VERIFIED_READING)).toBeTruthy();
+    expect(screen.queryByText('Graph writer')).toBeNull();
+    expect(screen.getByText('no active code-index build')).toBeTruthy();
+    expect(hasLiveWorktreeProgress(finished.envelope.payload.worktrees[0]!)).toBe(false);
+    expect(hasActiveCodeIndexBuild(finished)).toBe(false);
+    expect(finished).toEqual(original);
+  });
+
+  it('retains actual stage pages after an interrupted writer without claiming a verified segment', () => {
+    const result = freshness(nativeProgress({
+      phase: 'stage_page_commit',
+      encoded_entities: 0,
+      encoded_relations: 0,
+      committed_stage_pages: 2,
+      committed_stage_mutations: 70,
+      committed_stage_bytes: 4096,
+      committed_compact_segments: 0,
+      committed_compact_bytes: 0,
+    }), {
+      code_graph_serving: { state: 'refused', reason: 'resident memory' },
+    });
+    renderPipeline(result);
+    expect(screen.getByText('Graph milestones')).toBeTruthy();
+    expect(screen.getByText(
+      'stage page commit · 0 entities encoded · 0 relations encoded · 2 pages committed · 0 segments committed',
+    )).toBeTruthy();
+    expect(screen.getByText('refused · resident memory')).toBeTruthy();
+    expect(hasActiveCodeIndexBuild(result)).toBe(false);
+  });
+
+  it.each(['generation.successor', null])(
+    'removes retained milestones when the current generation becomes %s',
+    (latestGeneration) => {
+      const { rerender } = renderPipeline(freshness(nativeProgress()));
+      expect(screen.getByText(VERIFIED_READING)).toBeTruthy();
+      rerender(<CodeIndexPipeline
+        result={freshness(nativeProgress(), { latest_generation_id: latestGeneration })}
+        pending={false}
+        scopeKey="project"
+      />);
+      expect(screen.queryByText('Graph milestones')).toBeNull();
+      expect(screen.queryByText(VERIFIED_READING)).toBeNull();
+    },
+  );
+
+  it.each(['compact_encoding', 'compact_segment_verified'] as const)(
+    'does not turn an inactive %s label or encoded rows into committed work',
+    (phase) => {
+      const result = freshness(nativeProgress({
+        phase,
+        committed_compact_segments: 0,
+        committed_compact_bytes: 0,
+      }));
+      renderPipeline(result);
+      expect(screen.queryByText('Graph milestones')).toBeNull();
+      expect(screen.queryByText(/entities encoded/)).toBeNull();
+      expect(hasActiveCodeIndexBuild(result)).toBe(false);
+    },
+  );
+
+  it('keeps an active successor visible while the previous generation is still current', () => {
+    const result = freshness(nativeProgress({
+      generation_id: 'generation.successor',
+      active: true,
+      phase: 'compact_encoding',
+      committed_compact_segments: 0,
+      committed_compact_bytes: 0,
+    }));
+    renderPipeline(result);
+    expect(screen.getByText('Graph writer')).toBeTruthy();
+    expect(screen.queryByText('Graph milestones')).toBeNull();
+    expect(screen.getByText(
+      'compact encoding · 90 entities encoded · 40 relations encoded · 0 pages committed · 0 segments committed',
+    )).toBeTruthy();
+    expect(hasActiveCodeIndexBuild(result)).toBe(true);
+  });
+
+  it('renders the same retained counts through the HTTP freshness panel on its idle cadence', async () => {
+    vi.useFakeTimers();
+    const result = freshness(nativeProgress());
+    const fetch = vi.fn(async () => new Response(JSON.stringify(result.envelope), { status: 200 }));
+    vi.stubGlobal('fetch', fetch);
+    const client = new QueryClient({
+      defaultOptions: { queries: { retry: false, gcTime: Infinity } },
+    });
+    clients.push(client);
+    render(<QueryClientProvider client={client}><IndexFreshness /></QueryClientProvider>);
+    await act(async () => { await vi.advanceTimersByTimeAsync(0); });
+    expect(screen.getByText('Graph milestones')).toBeTruthy();
+    expect(screen.getByText(VERIFIED_READING)).toBeTruthy();
+    expect(fetch).toHaveBeenCalledTimes(1);
+    await act(async () => { await vi.advanceTimersByTimeAsync(1_001); });
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(screen.getByText(VERIFIED_READING)).toBeTruthy();
+    await act(async () => { await vi.advanceTimersByTimeAsync(28_999); });
+    await act(async () => { await vi.advanceTimersByTimeAsync(0); });
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(screen.getByText(VERIFIED_READING)).toBeTruthy();
+  });
+});
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index 58dc453672a..0c0b85061ea 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -142,7 +142,15 @@ function CodeIndexReadinessList({
 export function CodeIndexAttemptReading({ worktree }: { worktree: CodeIndexWorktreeFreshnessV1 }) {
   const attempt = worktree.preseal_attempt;
   const graph = worktree.native_graph_progress;
-  if (!attempt?.active && !graph?.active) return null;
+  // An inactive writer is no longer live, but its committed milestones still
+  // belong to this generation. Encoding alone is not durable completion.
+  const showGraph = graph != null && (
+    graph.active || (
+      graph.generation_id === worktree.latest_generation_id &&
+      (graph.committed_stage_pages > 0 || graph.committed_compact_segments > 0)
+    )
+  );
+  if (!attempt?.active && !showGraph) return null;
   return (
     <dl className="grid grid-cols-2 gap-x-4 gap-y-1 text-sm">
       {attempt?.active && (
@@ -154,9 +162,11 @@ export function CodeIndexAttemptReading({ worktree }: { worktree: CodeIndexWorkt
           </dd>
         </>
       )}
-      {graph?.active && (
+      {showGraph && graph && (
         <>
-          <dt className="text-text-muted">Graph writer</dt>
+          <dt className="text-text-muted">
+            {graph.active ? 'Graph writer' : 'Graph milestones'}
+          </dt>
           <dd className="text-right text-text-secondary">
             {graph.phase?.replaceAll('_', ' ') ?? 'awaiting first update'} ·{' '}
             {formatCount(graph.encoded_entities)} entities encoded ·{' '}

From 90ce363ee7da965281635459f7ee94cc2e544fbb Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 17:00:07 -0800
Subject: [PATCH 39/80] test(mcp): check unreported progress on rebuilding
 searches

---
 .../src/mcp/tools/handlers/graph_search_dispatch_tests.rs       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/tracedecay/src/mcp/tools/handlers/graph_search_dispatch_tests.rs b/crates/tracedecay/src/mcp/tools/handlers/graph_search_dispatch_tests.rs
index fe250354ea1..a00db54f24e 100644
--- a/crates/tracedecay/src/mcp/tools/handlers/graph_search_dispatch_tests.rs
+++ b/crates/tracedecay/src/mcp/tools/handlers/graph_search_dispatch_tests.rs
@@ -374,7 +374,7 @@ async fn search_opens_with_a_freshness_verdict_from_typed_state_case() {
     assert_eq!(payload["freshness"]["state"], "possibly_stale");
     assert_eq!(
         payload["freshness"]["indexing"]["summary"],
-        "state=refreshing rebuild_in_flight=true served_generation=generation.mcp-verified-graph-fixture.1 latest_generation=generation.mcp-verified-graph-fixture.2"
+        "state=refreshing rebuild_in_flight=true served_generation=generation.mcp-verified-graph-fixture.1 latest_generation=generation.mcp-verified-graph-fixture.2 progress=unreported"
     );
     assert_eq!(
         payload["freshness"]["indexing"]["latest_generation"],

From 2a6530fb7f283068036d12ecded9f4f955079de0 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 17:00:26 -0800
Subject: [PATCH 40/80] test(cli): check the current first-generation stall
 diagnostic

---
 crates/tracedecay-cli/src/commands/index.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index bf8d9df4012..77be65598bb 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -1384,7 +1384,10 @@ mod daemon_precondition_tests {
         assert_eq!(reads, 2, "do not consume a later ready after a real stall");
         let (code, message) = refusal(result);
         assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
-        assert!(message.contains("no observed capture, parse, or committed text work"));
+        assert!(
+            message.contains("no observed capture, parse, text, or native graph work"),
+            "{message}"
+        );
         assert!(message.contains("40/6136 files"));
     }
 

From 394be3dd466a90226feb1ca9206202fc079f9102 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 17:00:27 -0800
Subject: [PATCH 41/80] fix(graph-db): report encoded windows from streamed
 graph rows

---
 .../tracedecay-graph-db/src/sealed_store.rs   | 116 ++++++++----------
 .../code_graph/sealed_publication_tests.rs    |  52 ++++----
 2 files changed, 81 insertions(+), 87 deletions(-)

diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index ff665c2e776..7b4f2251ef7 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -1923,12 +1923,8 @@ fn stage_sealed_artifact(
         SealedRowSource::Manifest(manifest) => (Some(manifest.row_sum(check)?), None, None),
         SealedRowSource::Staging(_) => (None, None, None),
     };
-    let container_rows = match rows {
-        SealedRowSource::Layered(layered) => SealedRowSource::Spilled(layered.delta()),
-        rows => rows,
-    };
     let (mut entities, mut relations) =
-        build_sealed_container_with_work(container_rows, identity, staging, check, observe)?;
+        build_sealed_container_with_work(rows, identity, staging, check, observe)?;
     if let Some(layered) = layered {
         layered.install_base_files(staging)?;
         (entities, relations) = layered.row_counts();
@@ -1990,6 +1986,28 @@ fn build_sealed_container_with_work(
 ) -> Result<(usize, usize), GraphDbError> {
     let physical_namespace = identity.physical_namespace()?;
     let mut sealed = SealedCompactRows::new(staging)?;
+    let report_window = |boundary: NativeCompactEncodeBoundaryV1| {
+        tracing::info!(
+            event = "graph_native_compact_rows_encoded",
+            generation = %identity.generation,
+            kind = match boundary.kind {
+                GraphNativeWorkKindV1::Entities => "entities",
+                GraphNativeWorkKindV1::Relations => "relations",
+            },
+            completed_rows = boundary.completed_rows,
+            total_rows = boundary.total_rows,
+            durable = false,
+            "native compact builder accepted a row window"
+        );
+        if let Some(observer) = observe {
+            observer(GraphNativeWorkV1::CompactRowsEncoded {
+                kind: boundary.kind,
+                completed_rows: u64::try_from(boundary.completed_rows).unwrap_or(u64::MAX),
+                total_rows: u64::try_from(boundary.total_rows).unwrap_or(u64::MAX),
+                total_relations: u64::try_from(boundary.total_relations).unwrap_or(u64::MAX),
+            });
+        }
+    };
     let (entity_count, relation_count, dependency_namespaces_written) = {
         let _span = tracing::trace_span!("code_index.seal.encode").entered();
         {
@@ -2004,39 +2022,7 @@ fn build_sealed_container_with_work(
                         &physical_namespace,
                         &mut sealed,
                         check,
-                        &|boundary| {
-                            // Direct sealing bypasses native staging pages.
-                            // Report each real row-window boundary while the
-                            // compact container is being assembled, but do
-                            // NOT count it as a committed native page/segment.
-                            tracing::info!(
-                                event = "graph_native_compact_rows_encoded",
-                                generation = %identity.generation,
-                                kind = boundary.kind.as_str(),
-                                completed_rows = boundary.completed_rows,
-                                total_rows = boundary.total_rows,
-                                durable = false,
-                                "native compact builder accepted a row window"
-                            );
-                            if let Some(observer) = observe {
-                                observer(GraphNativeWorkV1::CompactRowsEncoded {
-                                    kind: match boundary.kind {
-                                        NativeCompactEncodeKindV1::Entities => {
-                                            GraphNativeWorkKindV1::Entities
-                                        }
-                                        NativeCompactEncodeKindV1::Relations => {
-                                            GraphNativeWorkKindV1::Relations
-                                        }
-                                    },
-                                    completed_rows: u64::try_from(boundary.completed_rows)
-                                        .unwrap_or(u64::MAX),
-                                    total_rows: u64::try_from(boundary.total_rows)
-                                        .unwrap_or(u64::MAX),
-                                    total_relations: u64::try_from(manifest.relations.len())
-                                        .unwrap_or(u64::MAX),
-                                });
-                            }
-                        },
+                        &report_window,
                     )?;
                     Ok((counts.0, counts.1, BTreeMap::new()))
                 }
@@ -2047,6 +2033,7 @@ fn build_sealed_container_with_work(
                         &physical_namespace,
                         &mut sealed,
                         check,
+                        &report_window,
                     )?;
                     Ok((counts.0, counts.1, BTreeMap::new()))
                 }
@@ -2057,6 +2044,7 @@ fn build_sealed_container_with_work(
                         &physical_namespace,
                         &mut sealed,
                         check,
+                        &report_window,
                     )?;
                     Ok((counts.0, counts.1, BTreeMap::new()))
                 }
@@ -2101,26 +2089,12 @@ fn build_sealed_container_with_work(
 }
 
 /// An accepted in-memory row window, not a durable graph page or segment.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum NativeCompactEncodeKindV1 {
-    Entities,
-    Relations,
-}
-
-impl NativeCompactEncodeKindV1 {
-    const fn as_str(self) -> &'static str {
-        match self {
-            Self::Entities => "entities",
-            Self::Relations => "relations",
-        }
-    }
-}
-
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 struct NativeCompactEncodeBoundaryV1 {
-    kind: NativeCompactEncodeKindV1,
+    kind: GraphNativeWorkKindV1,
     completed_rows: usize,
     total_rows: usize,
+    total_relations: usize,
 }
 
 /// Pushes a dependency-free generation's rows straight from its verified
@@ -2188,9 +2162,10 @@ fn push_manifest_rows(
                 // This is actual accepted native builder work. The final
                 // compact container is not yet written, installed or verified.
                 observe(NativeCompactEncodeBoundaryV1 {
-                    kind: NativeCompactEncodeKindV1::Entities,
+                    kind: GraphNativeWorkKindV1::Entities,
                     completed_rows: start.saturating_add(window.len()),
                     total_rows: entities.len(),
+                    total_relations: manifest.relations.len(),
                 });
             }
             Ok::<(), GraphDbError>(())
@@ -2254,9 +2229,10 @@ fn push_manifest_rows(
                     sealed.push_prepared_relation(prepared, endpoints[0], endpoints[1])?;
                 }
                 observe(NativeCompactEncodeBoundaryV1 {
-                    kind: NativeCompactEncodeKindV1::Relations,
+                    kind: GraphNativeWorkKindV1::Relations,
                     completed_rows: start.saturating_add(window.len()),
                     total_rows: relations.len(),
+                    total_relations: relations.len(),
                 });
             }
             Ok::<(), GraphDbError>(())
@@ -2276,6 +2252,7 @@ fn push_spilled_rows(
     physical_namespace: &GraphNamespace,
     sealed: &mut SealedCompactRows,
     check: &dyn Fn() -> Result<(), GraphDbError>,
+    observe: &dyn Fn(NativeCompactEncodeBoundaryV1),
 ) -> Result<(usize, usize), GraphDbError> {
     let projection = &identity.projection.projection;
     let workers = rayon::current_thread_index().map_or(1, |_| rayon::current_num_threads());
@@ -2313,6 +2290,12 @@ fn push_spilled_rows(
                     }
                     pushed += 1;
                 }
+                observe(NativeCompactEncodeBoundaryV1 {
+                    kind: GraphNativeWorkKindV1::Entities,
+                    completed_rows: pushed,
+                    total_rows: entity_count,
+                    total_relations: relation_count,
+                });
             }
             if pushed != entity_count {
                 return Err(GraphDbError::Corrupt {
@@ -2372,6 +2355,12 @@ fn push_spilled_rows(
                     sealed.push_prepared_relation(prepared, nodes[0], nodes[1])?;
                     pushed += 1;
                 }
+                observe(NativeCompactEncodeBoundaryV1 {
+                    kind: GraphNativeWorkKindV1::Relations,
+                    completed_rows: pushed,
+                    total_rows: relation_count,
+                    total_relations: relation_count,
+                });
             }
             if pushed != relation_count {
                 return Err(GraphDbError::Corrupt {
@@ -2868,11 +2857,10 @@ mod build_tests {
     use rayon::ThreadPoolBuilder;
 
     use super::{
-        NativeCompactEncodeBoundaryV1, NativeCompactEncodeKindV1, SEALED_STORE_DATABASE_FILE,
-        SealedCompactRows, SealedRowSource, build_or_open_sealed_store,
-        build_or_open_sealed_store_with_work, build_sealed_container_with_work, push_manifest_rows,
-        sealed_artifact_database_options, sealed_copy_proof, sealed_generation_directory,
-        sealed_store_root,
+        NativeCompactEncodeBoundaryV1, SEALED_STORE_DATABASE_FILE, SealedCompactRows,
+        SealedRowSource, build_or_open_sealed_store, build_or_open_sealed_store_with_work,
+        build_sealed_container_with_work, push_manifest_rows, sealed_artifact_database_options,
+        sealed_copy_proof, sealed_generation_directory, sealed_store_root,
     };
     use tracedecay_store::runtime::{GraphNativeWorkKindV1, GraphNativeWorkV1};
 
@@ -3021,11 +3009,11 @@ mod build_tests {
         let recorded = rows.into_inner().unwrap();
         let entities: Vec<_> = recorded
             .iter()
-            .filter(|event| event.kind == NativeCompactEncodeKindV1::Entities)
+            .filter(|event| event.kind == GraphNativeWorkKindV1::Entities)
             .collect();
         let relations: Vec<_> = recorded
             .iter()
-            .filter(|event| event.kind == NativeCompactEncodeKindV1::Relations)
+            .filter(|event| event.kind == GraphNativeWorkKindV1::Relations)
             .collect();
         assert!(
             entities.len() >= 2,
@@ -3070,7 +3058,7 @@ mod build_tests {
         assert!(matches!(result, Err(GraphDbError::Cancelled)));
         let failed = failed.into_inner().unwrap();
         assert_eq!(failed.len(), 1, "only the first complete window advanced");
-        assert_eq!(failed[0].kind, NativeCompactEncodeKindV1::Entities);
+        assert_eq!(failed[0].kind, GraphNativeWorkKindV1::Entities);
         assert_eq!(failed[0].completed_rows, 512);
         assert_eq!(failed[0].total_rows, 1_101);
     }
diff --git a/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs b/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
index 8b70651b227..e7f9bf7292a 100644
--- a/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
+++ b/crates/tracedecay-store-runtime/src/session_registry/code_graph/sealed_publication_tests.rs
@@ -1302,30 +1302,36 @@ async fn sealed_graph_writer_reports_native_work_through_journal_commit_boundary
         .expect("real sealed graph publication");
     let first_head = first_snapshot.verified_head().clone();
     let first = observed.lock().expect("first native graph events").clone();
+    let Some((
+        GraphNativeWorkV1::CompactSegmentVerified {
+            entities,
+            relations,
+            canonical_bytes,
+        },
+        windows,
+    )) = first.split_last()
+    else {
+        panic!("native row windows must precede the verified durable segment: {first:?}");
+    };
+    assert!(*canonical_bytes > 0);
+    for (expected_kind, count) in [
+        (GraphNativeWorkKindV1::Entities, entities),
+        (GraphNativeWorkKindV1::Relations, relations),
+    ] {
+        assert!(
+            *count > 0,
+            "the fixture must write both entities and relations"
+        );
+        assert!(windows.iter().any(|work| matches!(
+            work, GraphNativeWorkV1::CompactRowsEncoded { kind, completed_rows, total_rows, total_relations }
+                if *kind == expected_kind && completed_rows == count && total_rows == count && total_relations == relations
+        )), "missing complete {expected_kind:?} window before segment verification: {first:?}");
+    }
     assert!(
-        first.iter().any(|work| matches!(
-            work,
-            GraphNativeWorkV1::CompactRowsEncoded {
-                kind: GraphNativeWorkKindV1::Entities,
-                completed_rows,
-                ..
-            } if *completed_rows > 0
-        )),
-        "native entity encoding must cross the nested commit context: {first:?}"
-    );
-    let verified_segments = first
-        .iter()
-        .filter(|work| {
-            matches!(
-                work,
-                GraphNativeWorkV1::CompactSegmentVerified { canonical_bytes, .. }
-                    if *canonical_bytes > 0
-            )
-        })
-        .count();
-    assert_eq!(
-        verified_segments, 1,
-        "exactly one installed and digest-verified graph segment must reach the observer: {first:?}"
+        !windows
+            .iter()
+            .any(|work| matches!(work, GraphNativeWorkV1::CompactSegmentVerified { .. })),
+        "the installed segment must be reported exactly once"
     );
 
     drop(first_snapshot);

From 7ed98f016dc0d9ee8132269a5df7d06a4fbd1ae5 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 17:44:44 -0800
Subject: [PATCH 42/80] fix(graph-db): observe staged compact copy windows

Refs #4508
---
 .../tracedecay-graph-db/src/sealed_store.rs   | 161 +++++++++++++++++-
 1 file changed, 158 insertions(+), 3 deletions(-)

diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index 7b4f2251ef7..7bc0fad0630 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -2012,9 +2012,14 @@ fn build_sealed_container_with_work(
         let _span = tracing::trace_span!("code_index.seal.encode").entered();
         {
             match rows {
-                SealedRowSource::Staging(source) => {
-                    push_staged_rows(source, identity, &physical_namespace, &mut sealed, check)
-                }
+                SealedRowSource::Staging(source) => push_staged_rows(
+                    source,
+                    identity,
+                    &physical_namespace,
+                    &mut sealed,
+                    check,
+                    &report_window,
+                ),
                 SealedRowSource::Manifest(manifest) => {
                     let counts = push_manifest_rows(
                         manifest,
@@ -2386,6 +2391,7 @@ fn push_staged_rows(
     physical_namespace: &GraphNamespace,
     rows: &mut SealedCompactRows,
     check: &dyn Fn() -> Result<(), GraphDbError>,
+    observe: &dyn Fn(NativeCompactEncodeBoundaryV1),
 ) -> Result<(usize, usize, BTreeMap<GraphNamespace, GraphProjectionId>), GraphDbError> {
     // Physical namespace -> projection identity for the generation and its
     // dependency closure; an endpoint outside this map escapes the closure.
@@ -2420,6 +2426,7 @@ fn push_staged_rows(
     let relation_count = relation_locators.len();
     // Staging entity handle -> sealed node, for endpoint resolution.
     let mut sealed_endpoints: HashMap<NodeId, NodeId> = HashMap::new();
+    let mut encoded_entities = 0usize;
 
     // 1. The generation's own entities, in recovered-digest order.
     {
@@ -2450,6 +2457,16 @@ fn push_staged_rows(
                         });
                     }
                 }
+                drop(guard);
+                encoded_entities += chunk.len();
+                // The compact builder accepted these exact staged rows; this
+                // is not another receipted staging-page transaction.
+                observe(NativeCompactEncodeBoundaryV1 {
+                    kind: GraphNativeWorkKindV1::Entities,
+                    completed_rows: encoded_entities,
+                    total_rows: entity_count,
+                    total_relations: relation_count,
+                });
             }
             Ok::<(), GraphDbError>(())
         }
@@ -2463,6 +2480,7 @@ fn push_staged_rows(
     let mut endpoint_cache = EndpointIdentityCache::default();
     let mut dependency_namespaces_written: BTreeMap<GraphNamespace, GraphProjectionId> =
         BTreeMap::new();
+    let mut encoded_relations = 0usize;
     {
         let _span = tracing::trace_span!("graph_db.sealed_store.copy.relations").entered();
         {
@@ -2519,6 +2537,14 @@ fn push_staged_rows(
                         endpoints[1],
                     )?;
                 }
+                drop(guard);
+                encoded_relations += chunk.len();
+                observe(NativeCompactEncodeBoundaryV1 {
+                    kind: GraphNativeWorkKindV1::Relations,
+                    completed_rows: encoded_relations,
+                    total_rows: relation_count,
+                    total_relations: relation_count,
+                });
             }
             Ok::<(), GraphDbError>(())
         }
@@ -3317,6 +3343,135 @@ mod build_tests {
         );
     }
 
+    /// Staging pages are already durable, but copying their rows into the
+    /// final compact builder is separate, non-durable work. Cancellation must
+    /// expose only accepted windows; retry must install one verified segment
+    /// and adoption must not report any new work.
+    #[test]
+    fn staged_compact_copy_reports_real_windows_without_forged_commits() {
+        let check: &dyn Fn() -> Result<(), GraphDbError> = &|| Ok(());
+        let temp = tempfile::tempdir().unwrap();
+        let database_path = temp.path().join("source.grafeo");
+        let database = open_source(&database_path);
+        let manifest = manifest(1_500, 1_600);
+        let identity = manifest.identity();
+        let expected = manifest.expected_recovered_digest(check).unwrap();
+        database
+            .apply_generation_unverified_with_digest(Arc::new(manifest), &expected, check)
+            .unwrap();
+
+        let accepted_entities = AtomicUsize::new(0);
+        let interrupted_work = Mutex::new(Vec::<GraphNativeWorkV1>::new());
+        let on_interrupted_window = |event: GraphNativeWorkV1| {
+            if let GraphNativeWorkV1::CompactRowsEncoded {
+                kind: GraphNativeWorkKindV1::Entities,
+                completed_rows,
+                ..
+            } = &event
+            {
+                accepted_entities.store(*completed_rows as usize, Ordering::Release);
+            }
+            interrupted_work.lock().unwrap().push(event);
+        };
+        let interrupt_after_window = || {
+            if accepted_entities.load(Ordering::Acquire) > 0 {
+                Err(GraphDbError::Cancelled)
+            } else {
+                Ok(())
+            }
+        };
+        let interrupted = build_or_open_sealed_store_with_work(
+            SealedRowSource::Staging(&database),
+            &identity,
+            &expected,
+            &database_path,
+            &interrupt_after_window,
+            Some(&on_interrupted_window),
+        );
+        assert!(matches!(interrupted, Err(GraphDbError::Cancelled)));
+        let interrupted_work = interrupted_work.lock().unwrap().clone();
+        assert!(
+            interrupted_work.iter().any(|event| matches!(
+                event,
+                GraphNativeWorkV1::CompactRowsEncoded {
+                    kind: GraphNativeWorkKindV1::Entities,
+                    completed_rows: 1..,
+                    ..
+                }
+            )),
+            "a real staged row window must precede the cancellation"
+        );
+        assert!(
+            interrupted_work.iter().all(|event| matches!(
+                event,
+                GraphNativeWorkV1::CompactRowsEncoded { .. }
+            )),
+            "failed compact copy cannot claim a verified segment or a new staging page"
+        );
+
+        let observed = Mutex::new(Vec::<GraphNativeWorkV1>::new());
+        let report = |event| observed.lock().unwrap().push(event);
+        let (installed, proof) = build_or_open_sealed_store_with_work(
+            SealedRowSource::Staging(&database),
+            &identity,
+            &expected,
+            &database_path,
+            check,
+            Some(&report),
+        )
+        .expect("retry staged copy and verify compact segment");
+        assert!(proof.is_some());
+        assert_eq!(installed.recovered_digest(), expected.as_str());
+        let completed = observed.lock().unwrap().clone();
+        assert!(completed.iter().any(|event| matches!(
+            event,
+            GraphNativeWorkV1::CompactRowsEncoded {
+                kind: GraphNativeWorkKindV1::Entities,
+                completed_rows: 1500,
+                total_rows: 1500,
+                total_relations: 1600,
+            }
+        )));
+        assert!(completed.iter().any(|event| matches!(
+            event,
+            GraphNativeWorkV1::CompactRowsEncoded {
+                kind: GraphNativeWorkKindV1::Relations,
+                completed_rows: 1600,
+                total_rows: 1600,
+                total_relations: 1600,
+            }
+        )));
+        assert!(matches!(
+            completed.last(),
+            Some(GraphNativeWorkV1::CompactSegmentVerified {
+                entities: 1500,
+                relations: 1600,
+                canonical_bytes: 1..,
+            })
+        ));
+        assert!(
+            completed.iter().all(|event| !matches!(
+                event,
+                GraphNativeWorkV1::StagePageApplied { .. }
+            )),
+            "compact copies are non-durable until their verified segment is installed"
+        );
+        let _ = installed.database().close();
+        let (reused, reuse_proof) = build_or_open_sealed_store_with_work(
+            SealedRowSource::Staging(&database),
+            &identity,
+            &expected,
+            &database_path,
+            check,
+            Some(&report),
+        )
+        .expect("reopen already installed compact segment");
+        assert!(reuse_proof.is_none());
+        assert_eq!(reused.recovered_digest(), expected.as_str());
+        assert_eq!(*observed.lock().unwrap(), completed);
+        let _ = reused.database().close();
+    }
+
     /// A competing writer's already installed segment is read-only evidence,
     /// not a new native write by this attempt. The loser must clean up its
     /// staging directory and can adopt only the digest-verified real segment.

From 416adbdb2209eb98bddc4cb5e41554466b995b92 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 18:39:31 -0800
Subject: [PATCH 43/80] style(graph-db): format compact window assertions

---
 crates/tracedecay-graph-db/src/sealed_store.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/crates/tracedecay-graph-db/src/sealed_store.rs b/crates/tracedecay-graph-db/src/sealed_store.rs
index 7bc0fad0630..161f95d96ad 100644
--- a/crates/tracedecay-graph-db/src/sealed_store.rs
+++ b/crates/tracedecay-graph-db/src/sealed_store.rs
@@ -3402,10 +3402,9 @@ mod build_tests {
             "a real staged row window must precede the cancellation"
         );
         assert!(
-            interrupted_work.iter().all(|event| matches!(
-                event,
-                GraphNativeWorkV1::CompactRowsEncoded { .. }
-            )),
+            interrupted_work
+                .iter()
+                .all(|event| matches!(event, GraphNativeWorkV1::CompactRowsEncoded { .. })),
             "failed compact copy cannot claim a verified segment or a new staging page"
         );
 
@@ -3450,10 +3449,9 @@ mod build_tests {
             })
         ));
         assert!(
-            completed.iter().all(|event| !matches!(
-                event,
-                GraphNativeWorkV1::StagePageApplied { .. }
-            )),
+            completed
+                .iter()
+                .all(|event| !matches!(event, GraphNativeWorkV1::StagePageApplied { .. })),
             "compact copies are non-durable until their verified segment is installed"
         );
         let _ = installed.database().close();

From 6dd6477b92ff44124b8fb4eccd4a4eb1efef1867 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 18:50:34 -0800
Subject: [PATCH 44/80] fix(cli): track preseal work behind retained text
 status

Refs #4508

Keep authentic preseal capture and parser observations visible to the
init waiter when a previous generation still reports a post-text phase.
Preserve measured bulk commits as higher-priority work and test frozen
and advancing successor attempts through typed wait responses.
---
 crates/tracedecay-cli/src/commands/index.rs | 115 ++++++++++++++++++--
 1 file changed, 105 insertions(+), 10 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 77be65598bb..8bcd43f7df0 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -531,16 +531,18 @@ impl FirstGenerationWorkMarker {
             }
             return Some(Self::native_graph(graph));
         }
-        if let Some(progress) = &worktree.progress {
-            match progress.phase {
-                CodeIndexBuildPhaseV1::BulkCommit => return Some(Self::text(progress)),
-                CodeIndexBuildPhaseV1::SourceScan => {}
-                // Graph publication, relational preparation, index builds
-                // and verification lack work observations on this wire. Do
-                // not infer a writer stall from their phase labels alone.
-                _ => return None,
-            }
+        // A real text bulk commit may be concurrent with the scoped preseal
+        // guard and remains the authority while its committed cursor moves.
+        if let Some(progress) = worktree
+            .progress
+            .as_ref()
+            .filter(|progress| progress.phase == CodeIndexBuildPhaseV1::BulkCommit)
+        {
+            return Some(Self::text(progress));
         }
+        // A retained generation may still report Ready or a post-text phase
+        // while the successor actually captures or parses. Those old phase
+        // projections must not hide its independently owned attempt work.
         if let Some(attempt) = worktree.preseal_attempt.as_ref().filter(|a| a.active) {
             return Some(Self::Preseal {
                 owner: (
@@ -554,6 +556,8 @@ impl FirstGenerationWorkMarker {
                 last_work_micros: attempt.last_progress_micros,
             });
         }
+        // Absent a live attempt, uninstrumented post-text phases remain
+        // unknown, not evidence that a writer has stalled.
         worktree
             .progress
             .as_ref()
@@ -1012,7 +1016,8 @@ mod daemon_precondition_tests {
         CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
         CodeGraphServingReadinessV1, CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1,
         CodeIndexBuildProgressV1, CodeIndexFreshnessLadderInputsV1, CodeIndexFreshnessLadderV1,
-        CodeIndexNativeGraphPhaseV1, CodeIndexReadinessTargetV1, CodeIndexReadinessV1,
+        CodeIndexNativeGraphPhaseV1, CodeIndexPresealWorkPhaseV1, CodeIndexReadinessTargetV1,
+        CodeIndexReadinessV1,
         CodeIndexReadinessWaitOutcomeV1, CodeIndexReadinessWaitReadV1, CodeIndexStalenessStateV1,
         CodeIndexWorktreeFreshnessV1,
     };
@@ -1195,6 +1200,96 @@ mod daemon_precondition_tests {
         result
     }
 
+    #[test]
+    fn retained_text_phases_cannot_hide_active_successor_capture() {
+        for phase in [
+            CodeIndexBuildPhaseV1::Ready,
+            CodeIndexBuildPhaseV1::GraphPublication,
+            CodeIndexBuildPhaseV1::IndexBuild,
+            CodeIndexBuildPhaseV1::Verification,
+            CodeIndexBuildPhaseV1::RelationalPreparation,
+        ] {
+            let mut worktree = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+            worktree.latest_generation_id = Some("generation.prior.sealed".to_owned());
+            let mut retained = progress(6_136, None);
+            retained.phase = phase;
+            worktree.progress = Some(retained);
+            assert!(
+                matches!(
+                    super::FirstGenerationWorkMarker::of(Some(&worktree)),
+                    Some(super::FirstGenerationWorkMarker::Preseal {
+                        owner: (3, 5, 2),
+                        epoch: 4,
+                        completed: 7,
+                        last_work_micros: Some(700),
+                        ..
+                    })
+                ),
+                "successor capture must outrank prior text phase {phase:?}"
+            );
+        }
+
+        // A real bulk commit can overlap the scoped capture guard. Its
+        // advancing durable cursor must still take precedence.
+        let mut writing = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+        let mut committed = progress(24, None);
+        committed.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        writing.progress = Some(committed);
+        assert!(matches!(
+            super::FirstGenerationWorkMarker::of(Some(&writing)),
+            Some(super::FirstGenerationWorkMarker::CommittedText { .. })
+        ));
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn wait_refuses_frozen_capture_even_when_old_generation_is_ready() {
+        let mut capture = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+        capture.latest_generation_id = Some("generation.prior.sealed".to_owned());
+        let mut retained = progress(6_136, None);
+        retained.phase = CodeIndexBuildPhaseV1::Ready;
+        capture.progress = Some(retained);
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(capture.clone())),
+                status(timed_out(), warming(capture)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2, "frozen capture must refuse before a later ready");
+        let (code, reason) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(
+            reason.contains("no observed capture, parse, text, or native graph work"),
+            "{reason}"
+        );
+        assert!(reason.contains("capturing 7/50 items"), "{reason}");
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn successor_parse_progress_survives_old_ready_generation() {
+        let mut first = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+        first.latest_generation_id = Some("generation.prior.sealed".to_owned());
+        let mut retained = progress(6_136, None);
+        retained.phase = CodeIndexBuildPhaseV1::Ready;
+        first.progress = Some(retained);
+        let mut parsed = first.clone();
+        parsed.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::ParseEvidence, 5, 1, 2).preseal_attempt;
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(first)),
+                status(timed_out(), warming(parsed)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert!(result.is_ok(), "new parse evidence is real work: {result:?}");
+        assert_eq!(reads, 3);
+    }
+
     #[test]
     fn active_capture_without_work_is_not_an_infinite_wait() {
         use tracedecay_contracts::code_index_freshness::CodeIndexPresealWorkPhaseV1::Capture;

From 2bdbdff750719ca671f96ead9f1950e378fb9b01 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 19:01:20 -0800
Subject: [PATCH 45/80] fix(code-index): retire preseal at durable publication

Refs #4508
---
 .../tracedecay-application/src/code_index.rs  | 16 +++++++
 crates/tracedecay-cli/src/commands/index.rs   | 21 +++++++++
 .../code_index_scheduler/attempt_progress.rs  | 43 +++++++++++++++++++
 .../src/code_index_scheduler/reconcile.rs     |  7 ++-
 .../src/production/mod.rs                     |  6 +++
 .../production/sparse_differential_tests.rs   | 20 ++++++++-
 6 files changed, 110 insertions(+), 3 deletions(-)

diff --git a/crates/tracedecay-application/src/code_index.rs b/crates/tracedecay-application/src/code_index.rs
index da11de85a0e..43ccb76f664 100644
--- a/crates/tracedecay-application/src/code_index.rs
+++ b/crates/tracedecay-application/src/code_index.rs
@@ -101,6 +101,7 @@ pub struct DaemonCodeIndexControlV1 {
     tripped: Arc<AtomicBool>,
     ignores_source_epoch: bool,
     preseal_observer: Option<Arc<dyn Fn(CodeIndexPresealWorkV1) + Send + Sync>>,
+    preseal_finisher: Option<Arc<dyn Fn() + Send + Sync>>,
 }
 
 impl Default for DaemonCodeIndexControlV1 {
@@ -123,6 +124,7 @@ impl DaemonCodeIndexControlV1 {
             tripped: Arc::new(AtomicBool::new(false)),
             ignores_source_epoch: false,
             preseal_observer: None,
+            preseal_finisher: None,
         }
     }
 
@@ -168,6 +170,14 @@ impl DaemonCodeIndexControlV1 {
         self
     }
 
+    /// End the matching pre-seal attempt when the durable publisher takes over.
+    /// Ending activity must not advance its last observed work time.
+    #[must_use]
+    pub fn with_preseal_finisher(mut self, finisher: Arc<dyn Fn() + Send + Sync>) -> Self {
+        self.preseal_finisher = Some(finisher);
+        self
+    }
+
     pub fn advance(epoch: &AtomicU64) {
         epoch.fetch_add(1, Ordering::AcqRel);
     }
@@ -216,6 +226,12 @@ impl CodeIndexExecutionControlV1 for DaemonCodeIndexControlV1 {
             observer(work);
         }
     }
+
+    fn finish_preseal_observation(&self) {
+        if let Some(finisher) = &self.preseal_finisher {
+            finisher();
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 8bcd43f7df0..4b603ed694d 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -1241,6 +1241,27 @@ mod daemon_precondition_tests {
         ));
     }
 
+    #[test]
+    fn retired_preseal_does_not_stall_slow_durable_publication() {
+        let now = Instant::now();
+        let mut window = super::FirstGenerationProgressWindow::new(Duration::from_secs(120));
+        let mut source = attempt(CodeIndexPresealWorkPhaseV1::Resolution, 6, 19, 2);
+        source.latest_generation_id = Some("generation.prior.sealed".to_owned());
+        let mut retained = progress(6_136, None);
+        retained.phase = CodeIndexBuildPhaseV1::Ready;
+        source.progress = Some(retained);
+        let marker = super::FirstGenerationWorkMarker::of(Some(&source));
+        assert!(marker.is_some());
+        assert!(!window.observe(marker, now));
+
+        // The scoped attempt was retired at the real publication handoff.
+        // An old Ready report is not successor work, even after 120 seconds.
+        source.preseal_attempt.as_mut().unwrap().active = false;
+        assert_eq!(super::FirstGenerationWorkMarker::of(Some(&source)), None);
+        assert!(!window.observe(None, now + Duration::from_secs(130)));
+        assert!(!window.observe(None, now + Duration::from_secs(260)));
+    }
+
     #[tokio::test(flavor = "current_thread")]
     async fn wait_refuses_frozen_capture_even_when_old_generation_is_ready() {
         let mut capture = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
index 4e3aa2f6e67..7e65fdda20b 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
@@ -145,6 +145,18 @@ impl CodeIndexPresealAttemptGuardV1 {
         Self { slot, identity }
     }
 
+    /// The real publication handoff fences late or stale work callbacks.
+    /// This transition does not claim a completed source item.
+    pub(super) fn finisher(&self) -> Arc<dyn Fn() + Send + Sync> {
+        let slot = Arc::clone(&self.slot);
+        let identity = self.identity;
+        Arc::new(move || {
+            slot.write()
+                .unwrap_or_else(PoisonError::into_inner)
+                .finish(identity);
+        })
+    }
+
     pub(super) fn observer(&self) -> Arc<dyn Fn(CodeIndexPresealWorkV1) + Send + Sync> {
         let slot = Arc::clone(&self.slot);
         let identity = self.identity;
@@ -168,6 +180,37 @@ impl Drop for CodeIndexPresealAttemptGuardV1 {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use tracedecay_application::code_index::DaemonCodeIndexControlV1;
+    use tracedecay_code_index::production::CodeIndexExecutionControlV1;
+
+    #[test]
+    fn durable_publication_handoff_retires_attempt_without_forging_work() {
+        let slot = Arc::new(RwLock::new(CodeIndexBuildAttemptSlotStateV1::default()));
+        let attempt = CodeIndexPresealAttemptGuardV1::begin(Arc::clone(&slot), 7, 11);
+        let control = DaemonCodeIndexControlV1::default()
+            .with_preseal_observer(attempt.observer())
+            .with_preseal_finisher(attempt.finisher());
+        control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::Capture, 3, None));
+        let before = slot.read().unwrap().snapshot().unwrap();
+        assert!(before.active);
+        assert_eq!(before.completed_items, 3);
+        assert!(before.last_progress_micros.is_some());
+
+        // The guard remains alive during durable publication. Retiring it
+        // must not renew the work clock, and late callbacks are fenced.
+        control.finish_preseal_observation();
+        let after = slot.read().unwrap().snapshot().unwrap();
+        assert!(!after.active);
+        assert_eq!(after.completed_items, 3);
+        assert_eq!(after.last_progress_micros, before.last_progress_micros);
+        assert!(after.progress_epoch > before.progress_epoch);
+        control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 1, None));
+        control.finish_preseal_observation();
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), after);
+        drop(attempt);
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), after);
+    }
+
 
     fn work(
         phase: CodeIndexPresealWorkPhaseV1,
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
index 6c81029062c..bb040937ef0 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/reconcile.rs
@@ -1796,6 +1796,7 @@ impl CodeIndexWorktreeSchedulerV1 {
             .publication
             .clone()
             .with_reconcile_publication_fence(Arc::clone(&self.hints), control.clone());
+        control.finish_preseal_observation();
         match store.commit(&mut pending.preparation, &pending.publication) {
             Ok(bytes) => {
                 let sealed =
@@ -2374,7 +2375,8 @@ impl CodeIndexWorktreeSchedulerV1 {
         );
         let control = self
             .reconcile_control()
-            .with_preseal_observer(attempt.observer());
+            .with_preseal_observer(attempt.observer())
+            .with_preseal_finisher(attempt.finisher());
         let captured = self
             .capture_authoritative_snapshot_without_active_generation_reuse(Some(&control))
             .map_err(|error| prefer_resident_memory_refusal(&control, error))?;
@@ -2995,7 +2997,8 @@ impl CodeIndexWorktreeSchedulerV1 {
             );
             let control = self
                 .reconcile_control()
-                .with_preseal_observer(attempt.observer());
+                .with_preseal_observer(attempt.observer())
+                .with_preseal_finisher(attempt.finisher());
             // Every earlier attempt was cancelled by a newer source epoch. A
             // source that changes faster than a pass lasts would cancel this
             // one too, so it seals what it captured; the epoch that
diff --git a/crates/tracedecay-code-index/src/production/mod.rs b/crates/tracedecay-code-index/src/production/mod.rs
index bb1d05496da..4032dd31f96 100644
--- a/crates/tracedecay-code-index/src/production/mod.rs
+++ b/crates/tracedecay-code-index/src/production/mod.rs
@@ -302,6 +302,10 @@ pub trait CodeIndexExecutionControlV1: Sync {
     /// Only a daemon-bound attempt has a progress owner. A benchmark,
     /// historical read or standalone extraction has none to update.
     fn observed_preseal_work(&self, _work: CodeIndexPresealWorkV1) {}
+
+    /// Construction has left capture, parsing and resolution for publication.
+    /// This ends pre-seal activity without inventing a completed work unit.
+    fn finish_preseal_observation(&self) {}
 }
 
 /// A control that never interrupts. Sealed seating uses it when the caller
@@ -2496,6 +2500,7 @@ where
                     Ok(sparse) => {
                         crate::observe::record_rebuild_state("increment");
                         lexical_page_source::checkpoint(control)?;
+                        control.finish_preseal_observation();
                         return self.publish(preparation, sparse);
                     }
                     Err(reason) => reason,
@@ -2523,6 +2528,7 @@ where
             control,
         )?;
         lexical_page_source::checkpoint(control)?;
+        control.finish_preseal_observation();
         self.publish(preparation, publication)
     }
 
diff --git a/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs b/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
index 894948bb504..7dd0e161a62 100644
--- a/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
+++ b/crates/tracedecay-code-index/src/production/sparse_differential_tests.rs
@@ -306,7 +306,7 @@ fn differential_counts(language: &str) -> DifferentialCounts {
 #[test]
 fn cold_resolution_index_publication_advances_actual_work_counts() {
     #[derive(Default)]
-    struct ResolutionWork(std::sync::Mutex<Vec<u64>>);
+    struct ResolutionWork(std::sync::Mutex<Vec<u64>>, std::sync::atomic::AtomicUsize);
 
     impl CodeIndexExecutionControlV1 for ResolutionWork {
         fn is_cancelled(&self) -> bool {
@@ -318,6 +318,11 @@ fn cold_resolution_index_publication_advances_actual_work_counts() {
         }
 
         fn observed_preseal_work(&self, work: CodeIndexPresealWorkV1) {
+            assert_eq!(
+                self.1.load(std::sync::atomic::Ordering::Acquire),
+                0,
+                "no pre-seal work may arrive after the durable handoff"
+            );
             if work.phase == CodeIndexPresealWorkPhaseV1::Resolution {
                 self.0
                     .lock()
@@ -325,6 +330,14 @@ fn cold_resolution_index_publication_advances_actual_work_counts() {
                     .push(work.completed_items);
             }
         }
+
+        fn finish_preseal_observation(&self) {
+            assert_eq!(
+                self.1.fetch_add(1, std::sync::atomic::Ordering::AcqRel),
+                0,
+                "publication must finish its pre-seal attempt exactly once"
+            );
+        }
     }
 
     let files = vec![
@@ -341,6 +354,11 @@ fn cold_resolution_index_publication_advances_actual_work_counts() {
     let published = owner
         .build_and_publish(fixture_request(&files, None, false, 1_500_000), &observer)
         .expect("real cold reference resolution");
+    assert_eq!(
+        observer.1.load(std::sync::atomic::Ordering::Acquire),
+        1,
+        "cold publication must retire pre-seal before the control is dropped"
+    );
     let manifest =
         super::partitioned_codec::parse_partitioned_manifest(published.manifest_bytes().as_ref())
             .expect("verified published index manifest");

From 6b4ff93636820bd95fb0367a1f39f7b46718cd03 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 20:09:48 -0800
Subject: [PATCH 46/80] style(code-index): format durable publication progress
 checks

---
 crates/tracedecay-cli/src/commands/index.rs            | 10 ++++++----
 .../src/code_index_scheduler/attempt_progress.rs       |  1 -
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 4b603ed694d..a1a0259090c 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -1017,9 +1017,8 @@ mod daemon_precondition_tests {
         CodeGraphServingReadinessV1, CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1,
         CodeIndexBuildProgressV1, CodeIndexFreshnessLadderInputsV1, CodeIndexFreshnessLadderV1,
         CodeIndexNativeGraphPhaseV1, CodeIndexPresealWorkPhaseV1, CodeIndexReadinessTargetV1,
-        CodeIndexReadinessV1,
-        CodeIndexReadinessWaitOutcomeV1, CodeIndexReadinessWaitReadV1, CodeIndexStalenessStateV1,
-        CodeIndexWorktreeFreshnessV1,
+        CodeIndexReadinessV1, CodeIndexReadinessWaitOutcomeV1, CodeIndexReadinessWaitReadV1,
+        CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
     };
     use tracedecay_contracts::retrieval::StatusCodeIndexFreshnessV1;
     use tracedecay_domain::errors::TraceDecayError;
@@ -1307,7 +1306,10 @@ mod daemon_precondition_tests {
             Duration::ZERO,
         )
         .await;
-        assert!(result.is_ok(), "new parse evidence is real work: {result:?}");
+        assert!(
+            result.is_ok(),
+            "new parse evidence is real work: {result:?}"
+        );
         assert_eq!(reads, 3);
     }
 
diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
index 7e65fdda20b..a7eb45b6dcb 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
@@ -211,7 +211,6 @@ mod tests {
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), after);
     }
 
-
     fn work(
         phase: CodeIndexPresealWorkPhaseV1,
         n: u64,

From b297d8dbfe0c38c625d9323332a861fa90e9d997 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 20:40:09 -0800
Subject: [PATCH 47/80] fix(cli): fence stale text refusals behind active index
 work

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 125 ++++++++++++++++++--
 1 file changed, 118 insertions(+), 7 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index a1a0259090c..4878b946efa 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -440,16 +440,38 @@ impl FirstGenerationStall {
             Ok(worktree) => worktree,
             Err(reason) => return Some(Self::Unavailable(reason.to_owned())),
         };
-        if let Some(reason) = worktree
-            .progress
+        let active_preseal = worktree
+            .preseal_attempt
             .as_ref()
-            .and_then(|progress| progress.blocked_reason)
-        {
-            return Some(Self::Blocked(reason));
+            .is_some_and(|attempt| attempt.active);
+        let active_graph = worktree
+            .native_graph_progress
+            .as_ref()
+            .filter(|graph| graph.active);
+        if let Some(progress) = worktree.progress.as_ref() {
+            if let Some(reason) = progress.blocked_reason {
+                // The previous sealed generation can remain visible while a
+                // successor captures or publishes native graph rows. Its old
+                // refusal is not a refusal by the new, active writer.
+                let retained_text = active_preseal
+                    && worktree.latest_generation_id.as_deref()
+                        == Some(progress.generation_id.as_str())
+                    && !matches!(
+                        progress.phase,
+                        CodeIndexBuildPhaseV1::SourceScan | CodeIndexBuildPhaseV1::BulkCommit
+                    );
+                let different_graph = active_graph
+                    .is_some_and(|graph| graph.generation_id != progress.generation_id);
+                if !retained_text && !different_graph {
+                    return Some(Self::Blocked(reason));
+                }
+            }
         }
-        // The canonical ladder excludes bounded restore and source
-        // verification from rebuilds; both still own readiness work.
+        // Active attempts remain readiness work even if the freshness ladder
+        // does not classify a source verification or restore as a rebuild.
         let readiness_in_flight = worktree.rebuild_in_flight
+            || active_preseal
+            || active_graph.is_some()
             || matches!(
                 worktree.staleness_state,
                 Some(CodeIndexStalenessStateV1::Restoring | CodeIndexStalenessStateV1::Verifying)
@@ -2105,6 +2127,95 @@ mod daemon_precondition_tests {
         }
     }
 
+    #[test]
+    fn retained_text_refusal_cannot_block_a_different_active_writer() {
+        let mut successor = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+        successor.latest_generation_id = Some("generation.v1.first".to_owned());
+        let mut retained = progress(6_136, Some(CodeIndexBuildBlockedReasonV1::ResidentMemory));
+        retained.phase = CodeIndexBuildPhaseV1::Ready;
+        successor.progress = Some(retained);
+        assert_eq!(
+            super::FirstGenerationStall::of(Ok(&successor)),
+            None,
+            "a blocked, retained Ready report must not refuse active successor capture"
+        );
+
+        let mut graph = native_graph_without_writes();
+        let mut old_text = progress(6_136, Some(CodeIndexBuildBlockedReasonV1::RetryBackoff));
+        old_text.phase = CodeIndexBuildPhaseV1::GraphPublication;
+        graph.progress = Some(old_text);
+        graph.native_graph_progress.as_mut().unwrap().generation_id =
+            "generation.successor".to_owned();
+        assert_eq!(
+            super::FirstGenerationStall::of(Ok(&graph)),
+            None,
+            "another generation's blocked text cannot refuse a live native writer"
+        );
+        graph.native_graph_progress.as_mut().unwrap().generation_id =
+            "generation.v1.first".to_owned();
+        assert_eq!(
+            super::FirstGenerationStall::of(Ok(&graph)),
+            Some(super::FirstGenerationStall::Blocked(
+                CodeIndexBuildBlockedReasonV1::RetryBackoff
+            )),
+            "a genuine same-generation refusal must still be observable"
+        );
+    }
+
+    #[test]
+    fn live_writer_owns_readiness_even_without_a_rebuild_flag() {
+        let now = Instant::now();
+        let mut capture = attempt(CodeIndexPresealWorkPhaseV1::Capture, 3, 1, 1);
+        capture.rebuild_in_flight = false;
+        let mut graph = native_graph_without_writes();
+        graph.rebuild_in_flight = false;
+        for active in [&capture, &graph] {
+            assert_eq!(super::FirstGenerationStall::of(Ok(active)), None);
+            let mut window = super::FirstGenerationIdleWindow::new(Duration::from_secs(120));
+            assert_eq!(
+                window.observe(super::FirstGenerationStall::of(Ok(active)), now),
+                None
+            );
+            assert_eq!(
+                window.observe(
+                    super::FirstGenerationStall::of(Ok(active)),
+                    now + Duration::from_secs(240)
+                ),
+                None,
+                "a real active writer is not an absent reconcile pass"
+            );
+        }
+        capture.preseal_attempt.as_mut().unwrap().active = false;
+        assert_eq!(
+            super::FirstGenerationStall::of(Ok(&capture)),
+            Some(super::FirstGenerationStall::NoPassInFlight),
+            "retiring the attempt restores no-pass stall detection"
+        );
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn wait_survives_stale_blocked_text_while_successor_parses() {
+        let mut capture = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+        capture.latest_generation_id = Some("generation.v1.first".to_owned());
+        let mut prior = progress(6_136, Some(CodeIndexBuildBlockedReasonV1::ResidentMemory));
+        prior.phase = CodeIndexBuildPhaseV1::Ready;
+        capture.progress = Some(prior);
+        let mut parsed = capture.clone();
+        parsed.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::ParseEvidence, 5, 1, 2).preseal_attempt;
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(capture)),
+                status(timed_out(), warming(parsed)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert!(result.is_ok(), "old blocked generation must not refuse new work: {result:?}");
+        assert_eq!(reads, 3, "only the actual ready receipt ends a moving wait");
+    }
+
     /// A stall shorter than the window is ridden out: the window restarts
     /// once the daemon reports work again.
     #[tokio::test(flavor = "current_thread")]

From 2f493ebd492130716b39b237e08e1d63eaafc6e5 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 20:56:38 -0800
Subject: [PATCH 48/80] fix(code-index): reject stage callbacks after verified
 graph seal

Refs #4508
---
 .../registry/graph_progress.rs                | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
index b481207ff8c..782090b874e 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/registry/graph_progress.rs
@@ -200,7 +200,10 @@ impl CodeIndexNativeGraphProgressSlotStateV1 {
                 live_bytes,
                 ..
             } => {
-                if mutations == 0 || self.last_stage_ordinal.is_some_and(|last| ordinal <= last) {
+                if mutations == 0
+                    || next.committed_compact_segments != 0
+                    || self.last_stage_ordinal.is_some_and(|last| ordinal <= last)
+                {
                     return false;
                 }
                 self.last_stage_ordinal = Some(ordinal);
@@ -398,6 +401,20 @@ mod tests {
         assert_eq!(installed.committed_compact_segments, 1);
         assert_eq!(installed.committed_compact_bytes, 67890);
         assert!(installed.progress_epoch > durable.progress_epoch);
+        // Publication was already installed and digest-verified. Even a
+        // previously unapplied ordinal arriving late cannot revive staging
+        // or renew the genuine last-work timestamp of this attempt.
+        observer(GraphNativeWorkV1::StagePageApplied {
+            ordinal: 1,
+            kind: GraphNativeWorkKindV1::Relations,
+            mutations: 1,
+            live_bytes: 128,
+        });
+        assert_eq!(
+            slot.read().unwrap().snapshot().unwrap(),
+            installed,
+            "late staging callbacks cannot regress verified compact publication"
+        );
         drop(attempt);
         let finished = slot.read().unwrap().snapshot().unwrap();
         assert!(!finished.active);

From 0dda36d127660427f5ce8ac7dd388c2db415ba64 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 21:34:13 -0800
Subject: [PATCH 49/80] fix(cli): remove the unused index phase import and
 format its checks

---
 crates/tracedecay-cli/src/commands/index.rs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 4878b946efa..2b34cc788a4 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -7,8 +7,8 @@ use tracedecay_project::project::TraceDecay;
 use tracedecay_contracts::code_index_freshness::{
     CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
     CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexBuildProgressV1,
-    CodeIndexNativeGraphPhaseV1, CodeIndexPresealWorkPhaseV1, CodeIndexReadinessWaitOutcomeV1,
-    CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
+    CodeIndexNativeGraphPhaseV1, CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1,
+    CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::graph_tool::GraphToolResultV1;
 use tracedecay_contracts::retrieval::{
@@ -460,8 +460,8 @@ impl FirstGenerationStall {
                         progress.phase,
                         CodeIndexBuildPhaseV1::SourceScan | CodeIndexBuildPhaseV1::BulkCommit
                     );
-                let different_graph = active_graph
-                    .is_some_and(|graph| graph.generation_id != progress.generation_id);
+                let different_graph =
+                    active_graph.is_some_and(|graph| graph.generation_id != progress.generation_id);
                 if !retained_text && !different_graph {
                     return Some(Self::Blocked(reason));
                 }
@@ -2212,7 +2212,10 @@ mod daemon_precondition_tests {
             Duration::ZERO,
         )
         .await;
-        assert!(result.is_ok(), "old blocked generation must not refuse new work: {result:?}");
+        assert!(
+            result.is_ok(),
+            "old blocked generation must not refuse new work: {result:?}"
+        );
         assert_eq!(reads, 3, "only the actual ready receipt ends a moving wait");
     }
 

From d424073ee27ceea791e74e5d49fb05312fe5da78 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 22:18:07 -0800
Subject: [PATCH 50/80] fix(dashboard): show parked index state and share
 activity polling

Refs #4508
---
 .../src/workspaces/code/IndexFreshness.tsx    | 23 ++--------
 .../CodeIndexPipeline.dom.test.tsx            | 44 +++++++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         | 36 ++++++++++-----
 3 files changed, 73 insertions(+), 30 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index 73f4fab87e1..95ee6e3c5f4 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -43,7 +43,7 @@ import {
   codeIndexPhaseLabel,
   codeIndexProgressPercentage,
   formatDurationMicros,
-  hasLiveWorktreeProgress,
+  worktreeHasActiveCodeIndexBuild,
   isCurrentOrNewerCodeIndexProgress,
 } from '../observatory/CodeIndexPipeline.tsx';
 import { formatBytes } from '../observatory/storageModel.ts';
@@ -316,24 +316,7 @@ function freshnessPollIntervalMs(
 
 function hasActiveBuild(result: EnvelopeResult<CodeIndexFreshnessPayloadV1> | undefined): boolean {
   if (result?.outcome !== 'envelope') return false;
-  return result.envelope.payload.worktrees.some(worktreeHasActiveBuild);
-}
-
-function worktreeHasActiveBuild(worktree: CodeIndexWorktreeFreshnessV1): boolean {
-  const initialIndexing =
-    worktree.latest_generation_id == null && worktree.staleness_state === 'indexing';
-  if (
-    !worktree.rebuild_in_flight &&
-    !hasLiveWorktreeProgress(worktree) &&
-    worktree.staleness_state !== 'verifying' &&
-    worktree.staleness_state !== 'restoring' &&
-    !initialIndexing
-  ) {
-    return false;
-  }
-  if (worktree.parked != null && !worktree.parked.retries_on_wake) return false;
-  if (worktree.progress?.blocked_reason === 'publication_authority_corrupt') return false;
-  return true;
+  return result.envelope.payload.worktrees.some(worktreeHasActiveCodeIndexBuild);
 }
 
 function allActiveBuildsQuiet(
@@ -342,7 +325,7 @@ function allActiveBuildsQuiet(
   if (result?.outcome !== 'envelope') return false;
   const observedAt = result.envelope.time.observation_time_micros;
   return result.envelope.payload.worktrees.every((worktree) => {
-    if (!worktreeHasActiveBuild(worktree)) return true;
+    if (!worktreeHasActiveCodeIndexBuild(worktree)) return true;
     const lastUpdates = [
       ...(worktree.preseal_attempt?.active ? [worktree.preseal_attempt.last_progress_micros] : []),
       ...(worktree.native_graph_progress?.active ? [worktree.native_graph_progress.last_progress_micros] : []),
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index eb57f1ca9e7..5f1447d3d96 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -250,3 +250,47 @@ describe('code-index progress transitions', () => {
     expect(hasActiveCodeIndexBuild(restored)).toBe(false);
   });
 });
+
+describe('code-index parked and recovered readers', () => {
+  it('renders the actual park refusal, idles polling, and clears it on recovery', () => {
+    const blocked = freshness({
+      rebuild_in_flight: true,
+      staleness_state: 'parked',
+      parked: {
+        reason: 'native graph publication authority unavailable',
+        remediation: 'restore the verified graph store',
+        parked_at_micros: OBSERVED_AT,
+        observed_passes: 2,
+        retries_on_wake: false,
+        blocked_reason: 'publication_authority_corrupt',
+      },
+    }, 'loading');
+    blocked.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(blocked.envelope.payload);
+    expect(hasActiveCodeIndexBuild(blocked)).toBe(false);
+    const view = render(<CodeIndexPipeline result={blocked} pending={false} scopeKey="project" />);
+    expect(screen.getByText(
+      'parked: native graph publication authority unavailable · restore the verified graph store',
+    )).toBeTruthy();
+
+    const recovered = freshness({ rebuild_in_flight: true, staleness_state: 'indexing' }, 'loading');
+    recovered.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(recovered.envelope.payload);
+    view.rerender(<CodeIndexPipeline result={recovered} pending={false} scopeKey="project" />);
+    expect(screen.queryByText(/parked: native graph publication authority unavailable/)).toBeNull();
+    expect(hasActiveCodeIndexBuild(recovered)).toBe(true);
+  });
+
+  it('distinguishes a cold indexing mount from an idle non-ready envelope', () => {
+    expect(hasActiveCodeIndexBuild(freshness({
+      latest_generation_id: null,
+      staleness_state: 'indexing',
+      rebuild_in_flight: false,
+    }, 'loading'))).toBe(true);
+    expect(hasActiveCodeIndexBuild(freshness({}, 'loading'))).toBe(false);
+    const failed = freshness({}, 'loading');
+    failed.envelope.payload.mount_failure = {
+      message: 'code-index scheduler mount failed',
+      remediation: 'retry the mount',
+    };
+    expect(hasActiveCodeIndexBuild(failed)).toBe(false);
+  });
+});
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index 0c0b85061ea..a6fed58912e 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -133,6 +133,11 @@ function CodeIndexReadinessList({
             </dd>
           </dl>
           <CodeIndexAttemptReading worktree={worktree} />
+          {worktree.parked ? (
+            <p className="mt-2 text-sm text-state-warning">
+              parked: {worktree.parked.reason} · {worktree.parked.remediation}
+            </p>
+          ) : null}
         </li>
       ))}
     </ul>
@@ -274,19 +279,30 @@ function CodeIndexBuildCard({ progress }: { progress: CodeIndexBuildProgressV1 }
 // Serving readiness can describe the previous generation while its successor
 // is still capturing sources, or while a lexical artifact is being restored.
 // Neither operation is required to have a committed build-progress report yet.
+/** One worktree's actual or admitted pending work, shared by both dashboard
+ * views. An inactive terminal park is not a one-second polling obligation. */
+export function worktreeHasActiveCodeIndexBuild(worktree: CodeIndexWorktreeFreshnessV1): boolean {
+  if (worktree.parked != null && !worktree.parked.retries_on_wake) return false;
+  if (worktree.progress?.blocked_reason === 'publication_authority_corrupt') return false;
+  return (
+    worktree.rebuild_in_flight ||
+    hasLiveWorktreeProgress(worktree) ||
+    worktree.staleness_state === 'verifying' ||
+    worktree.staleness_state === 'restoring' ||
+    (worktree.progress != null && worktree.progress.phase !== 'ready') ||
+    (worktree.latest_generation_id == null && worktree.staleness_state === 'indexing')
+  );
+}
+
 export function hasActiveCodeIndexBuild(
   result: EnvelopeResult<CodeIndexFreshnessPayloadV1> | undefined,
 ): boolean {
-  return (
-    result?.outcome === 'envelope' &&
-    (result.envelope.domain_state !== 'ready' ||
-      result.envelope.payload.worktrees.some(
-        (worktree) =>
-          worktree.rebuild_in_flight ||
-          hasLiveWorktreeProgress(worktree) ||
-          (worktree.progress != null && worktree.progress.phase !== 'ready'),
-      ))
-  );
+  if (result?.outcome !== 'envelope') return false;
+  const { domain_state, payload } = result.envelope;
+  if (payload.mount_failure) return false;
+  // A loading scope may not have enrolled its first worktree yet.
+  if (payload.worktrees.length === 0) return domain_state === 'loading';
+  return payload.worktrees.some(worktreeHasActiveCodeIndexBuild);
 }
 
 function useLatestCodeIndexProgress(

From abe2b55785c6d2220f64e9a2e11349ef125ebe63 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Sun, 8 Nov 2026 23:24:19 -0800
Subject: [PATCH 51/80] fix(dashboard): poll active successors behind stale
 refusals

Refs #4508
---
 .../code/IndexFreshness.dom.test.tsx          | 59 +++++++++++++++++++
 .../src/workspaces/code/IndexFreshness.tsx    |  7 ++-
 .../CodeIndexPipeline.dom.test.tsx            | 49 +++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         |  4 ++
 4 files changed, 117 insertions(+), 2 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index 69872062ad9..ab3f52be4a5 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -804,6 +804,65 @@ describe('Code index freshness', () => {
     expect(fetch).toHaveBeenCalledTimes(2);
   });
 
+  it('polls an active successor despite a retained terminal publication refusal', async () => {
+    vi.useFakeTimers();
+    const active = envelope('loading', {
+      worktrees: [{
+        ...worktree(),
+        progress: { ...progress(), phase: 'ready', blocked_reason: 'publication_authority_corrupt' },
+        rebuild_in_flight: false,
+        preseal_attempt: {
+          daemon_incarnation: 1, producer_incarnation: 3, attempt_sequence: 2,
+          progress_epoch: 4, phase: 'capture', completed_items: 2,
+          total_items: 5, last_progress_micros: NOW_MICROS, active: true,
+        },
+      }],
+      note: 'live daemon scheduler state',
+    });
+    const fetch = vi.fn(async () => new Response(JSON.stringify(active), { status: 200 }));
+    vi.stubGlobal('fetch', fetch);
+    renderWith();
+
+    await advanceTimers(0);
+    expect(screen.getByText('capture · 2 / 5 items')).toBeTruthy();
+    expect(fetch).toHaveBeenCalledTimes(1);
+    await advanceTimers(1_001);
+    await advanceTimers(0);
+    expect(fetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('polls an empty loading scope until its first actual worktree mounts', async () => {
+    vi.useFakeTimers();
+    const pending = envelope('loading', {
+      worktrees: [],
+      note: 'the scheduler is attaching its first worktree',
+    });
+    const mounted = envelope('loading', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: null,
+        snapshot_content_identity: null,
+        sealed_at_micros: null,
+        staleness_state: 'indexing',
+        rebuild_in_flight: true,
+      }],
+      note: 'live daemon scheduler state',
+    });
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(new Response(JSON.stringify(pending), { status: 200 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify(mounted), { status: 200 }));
+    vi.stubGlobal('fetch', fetch);
+    renderWith();
+
+    await advanceTimers(0);
+    expect(screen.getByText('the scheduler is attaching its first worktree')).toBeTruthy();
+    expect(fetch).toHaveBeenCalledTimes(1);
+    await advanceTimers(1_001);
+    await advanceTimers(0);
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(screen.getByText('no sealed generation yet')).toBeTruthy();
+  });
+
   it('keeps unsupported and unknown envelopes on the idle cadence', async () => {
     vi.useFakeTimers();
     const unsupported = envelope('unsupported', {
diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index 95ee6e3c5f4..c66e3801eda 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -43,6 +43,7 @@ import {
   codeIndexPhaseLabel,
   codeIndexProgressPercentage,
   formatDurationMicros,
+  hasActiveCodeIndexBuild,
   worktreeHasActiveCodeIndexBuild,
   isCurrentOrNewerCodeIndexProgress,
 } from '../observatory/CodeIndexPipeline.tsx';
@@ -315,14 +316,16 @@ function freshnessPollIntervalMs(
 }
 
 function hasActiveBuild(result: EnvelopeResult<CodeIndexFreshnessPayloadV1> | undefined): boolean {
-  if (result?.outcome !== 'envelope') return false;
-  return result.envelope.payload.worktrees.some(worktreeHasActiveCodeIndexBuild);
+  return hasActiveCodeIndexBuild(result);
 }
 
 function allActiveBuildsQuiet(
   result: EnvelopeResult<CodeIndexFreshnessPayloadV1> | undefined,
 ): boolean {
   if (result?.outcome !== 'envelope') return false;
+  // An initial loading scope may have no mounted worktree yet; it has no
+  // work clock to classify as quiet and must discover its first real mount.
+  if (result.envelope.payload.worktrees.length === 0) return false;
   const observedAt = result.envelope.time.observation_time_micros;
   return result.envelope.payload.worktrees.every((worktree) => {
     if (!worktreeHasActiveCodeIndexBuild(worktree)) return true;
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index 5f1447d3d96..6ef4c2e2d77 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -279,6 +279,55 @@ describe('code-index parked and recovered readers', () => {
     expect(hasActiveCodeIndexBuild(recovered)).toBe(true);
   });
 
+  it('keeps real successor work live despite the retained generation refusal', () => {
+    const parked: NonNullable<CodeIndexWorktreeFreshnessV1['parked']> = {
+      reason: 'old publication authority corrupt',
+      remediation: 'repair the old publication store',
+      parked_at_micros: OBSERVED_AT,
+      observed_passes: 2,
+      retries_on_wake: false,
+      blocked_reason: 'publication_authority_corrupt',
+    };
+    const retained = progress({ phase: 'ready', blocked_reason: 'publication_authority_corrupt' });
+    const capture = freshness({
+      progress: retained,
+      preseal_attempt: {
+        daemon_incarnation: 1, producer_incarnation: 3, attempt_sequence: 2,
+        progress_epoch: 4, phase: 'capture', completed_items: 2,
+        total_items: 5, last_progress_micros: OBSERVED_AT, active: true,
+      },
+    }, 'loading');
+    capture.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(capture.envelope.payload);
+    expect(hasActiveCodeIndexBuild(capture)).toBe(true);
+    const view = render(<CodeIndexPipeline result={capture} pending={false} scopeKey="project" />);
+    expect(screen.getByText('capture · 2 / 5 items')).toBeTruthy();
+
+    const native = freshness({
+      progress: retained,
+      native_graph_progress: {
+        generation_id: 'generation.successor',
+        sealed_graph_digest: 'sha256:successor-graph',
+        daemon_incarnation: 1, producer_incarnation: 4, attempt_sequence: 2,
+        progress_epoch: 3, phase: 'compact_encoding',
+        encoded_entities: 17, total_entities: 30,
+        encoded_relations: 0, total_relations: 9,
+        committed_stage_pages: 0, committed_stage_mutations: 0, committed_stage_bytes: 0,
+        committed_compact_segments: 0, committed_compact_bytes: 0,
+        last_progress_micros: OBSERVED_AT, active: true,
+      },
+    }, 'loading');
+    native.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(native.envelope.payload);
+    expect(hasActiveCodeIndexBuild(native)).toBe(true);
+    view.rerender(<CodeIndexPipeline result={native} pending={false} scopeKey="project" />);
+    expect(screen.getByText(/17 entities encoded/)).toBeTruthy();
+    expect(screen.getByText('Graph writer')).toBeTruthy();
+
+    // The original terminal refusal remains idle without the actual writer.
+    expect(hasActiveCodeIndexBuild(freshness({
+      parked, progress: retained, rebuild_in_flight: true,
+    }, 'loading'))).toBe(false);
+  });
+
   it('distinguishes a cold indexing mount from an idle non-ready envelope', () => {
     expect(hasActiveCodeIndexBuild(freshness({
       latest_generation_id: null,
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index a6fed58912e..0a2dfa4b1e4 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -282,6 +282,10 @@ function CodeIndexBuildCard({ progress }: { progress: CodeIndexBuildProgressV1 }
 /** One worktree's actual or admitted pending work, shared by both dashboard
  * views. An inactive terminal park is not a one-second polling obligation. */
 export function worktreeHasActiveCodeIndexBuild(worktree: CodeIndexWorktreeFreshnessV1): boolean {
+  // A real successor can already be working while the retained generation
+  // still carries an old terminal refusal. An active attempt owns its work;
+  // only an idle, refused generation should suppress live polling.
+  if (worktree.preseal_attempt?.active || worktree.native_graph_progress?.active) return true;
   if (worktree.parked != null && !worktree.parked.retries_on_wake) return false;
   if (worktree.progress?.blocked_reason === 'publication_authority_corrupt') return false;
   return (

From fa9727ba35929f3a99d1951628b29896cf5c4c37 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 00:42:37 -0800
Subject: [PATCH 52/80] fix(dashboard): retire stale code-index text cursors

Refs #4508
---
 .../code/IndexFreshness.dom.test.tsx          | 39 +++++++++++++++++++
 .../src/workspaces/code/IndexFreshness.tsx    |  8 +++-
 .../CodeIndexPipeline.dom.test.tsx            | 32 +++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         | 14 +++++--
 4 files changed, 87 insertions(+), 6 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index ab3f52be4a5..044f81f4815 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -210,6 +210,45 @@ describe('Code index freshness', () => {
     expect(text).not.toContain('0 B/s');
   });
 
+  it('retires the previous sealed generation cursor when its successor has no text report', async () => {
+    vi.useFakeTimers();
+    const before = envelope('loading', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: 'generation.catchup.01',
+        rebuild_in_flight: true,
+        staleness_state: 'indexing',
+        progress: progress(),
+      }],
+      note: 'live daemon scheduler state',
+    });
+    const after = envelope('ready', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: 'generation.catchup.02',
+        rebuild_in_flight: false,
+        staleness_state: 'fresh',
+        progress: null,
+      }],
+      note: 'live daemon scheduler state',
+    });
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(new Response(JSON.stringify(before), { status: 200 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify(after), { status: 200 }));
+    vi.stubGlobal('fetch', fetch);
+    renderWith();
+
+    await advanceTimers(0);
+    expect(screen.getAllByText('generation.catchup.01').length).toBeGreaterThan(0);
+    expect(screen.getByRole('progressbar', { name: 'Code progress' })).toBeTruthy();
+    await advanceTimers(1_001);
+    await advanceTimers(0);
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(screen.getByText('generation.catchup.02')).toBeTruthy();
+    expect(screen.queryByText('generation.catchup.01')).toBeNull();
+    expect(screen.queryByRole('progressbar', { name: 'Code progress' })).toBeNull();
+  });
+
   it('accepts a later replacement generation after epoch restart and rejects its delayed predecessor', async () => {
     vi.useFakeTimers();
     const first = envelope('loading', {
diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index c66e3801eda..2b42b2d9a5f 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -357,9 +357,13 @@ function useLatestBuildProgress(
         if (!incoming) {
           if (
             current &&
-            result.envelope.domain_state === 'ready' &&
-            worktree.latest_generation_id === current.generation_id
+            ((result.envelope.domain_state === 'ready' &&
+              worktree.latest_generation_id === current.generation_id) ||
+              (worktree.latest_generation_id != null &&
+                worktree.latest_generation_id !== current.generation_id))
           ) {
+            // The sealed successor is authoritative; do not display a
+            // previous generation's text cursor against its readiness.
             next.delete(worktree.worktree_root);
             changed = true;
           }
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index 6ef4c2e2d77..c1fbb13398b 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -233,6 +233,38 @@ describe('code-index progress transitions', () => {
     expect(screen.queryByRole('progressbar')).toBeNull();
   });
 
+  it('discards a retired text cursor after a different generation seals', async () => {
+    const building = freshness({
+      progress: progress({ progress_epoch: 41 }),
+      rebuild_in_flight: true,
+    }, 'loading');
+    const view = render(<CodeIndexPipeline result={building} pending={false} scopeKey="project" />);
+    expect(await screen.findByText('bulk commit · 20.0%')).toBeTruthy();
+
+    // Missing an intermediate sample is not proof that the same writer
+    // finished. Keep the real last cursor while this generation is current.
+    view.rerender(<CodeIndexPipeline
+      result={freshness({ progress: null, rebuild_in_flight: true }, 'loading')}
+      pending={false}
+      scopeKey="project"
+    />);
+    expect(screen.getByText('bulk commit · 20.0%')).toBeTruthy();
+
+    // The daemon now reports a different *sealed* generation, with no text
+    // report. The preceding generation's committed counters must disappear.
+    view.rerender(<CodeIndexPipeline
+      result={freshness({
+        latest_generation_id: 'generation.successor',
+        progress: null,
+      })}
+      pending={false}
+      scopeKey="project"
+    />);
+    expect(await screen.findByText('no active code-index build')).toBeTruthy();
+    expect(screen.queryByText('bulk commit · 20.0%')).toBeNull();
+    expect(screen.queryByRole('progressbar')).toBeNull();
+  });
+
   it('keeps restore checks separate from build counters and stops polling after restoration', async () => {
     const restoring = freshness({ restore_progress: restoreProgress });
     const view = render(<CodeIndexPipeline result={restoring} pending={false} scopeKey="project" />);
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index 0a2dfa4b1e4..ad22000f874 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -336,14 +336,20 @@ function useLatestCodeIndexProgress(
         const incoming = worktree.progress;
         const renderedProgress = current.get(worktree.worktree_root);
         if (!incoming) {
+          // A confirmed replacement seal makes the old text cursor stale.
+          // Retain only a transient missing sample for the same generation
+          // (or while no generation has sealed); neither is new work.
           if (
             renderedProgress &&
-            result.envelope.domain_state === 'ready' &&
-            worktree.latest_generation_id === renderedProgress.generation_id
+            (worktree.latest_generation_id == null ||
+              worktree.latest_generation_id === renderedProgress.generation_id) &&
+            !(
+              result.envelope.domain_state === 'ready' &&
+              worktree.latest_generation_id === renderedProgress.generation_id
+            )
           ) {
-            continue;
+            next.set(worktree.worktree_root, renderedProgress);
           }
-          if (renderedProgress) next.set(worktree.worktree_root, renderedProgress);
         } else if (
           !renderedProgress ||
           isCurrentOrNewerCodeIndexProgress(incoming, renderedProgress)

From be1d99c11b2953efd24daafb39de8eb3b4322a1d Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 01:27:28 -0800
Subject: [PATCH 53/80] fix(dashboard): isolate retained code-index progress by
 scope and mount

Refs #4508
---
 .../code/IndexFreshness.dom.test.tsx          | 89 +++++++++++++++++++
 .../src/workspaces/code/IndexFreshness.tsx    | 47 +++++-----
 2 files changed, 116 insertions(+), 20 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index 044f81f4815..874b4e9bd16 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -1,6 +1,7 @@
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { act, render, screen } from '@testing-library/react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
+import { useScope } from '../../data/scope/store.ts';
 import { IndexFreshness } from './IndexFreshness.tsx';
 
 /**
@@ -16,6 +17,7 @@ const NOW_MICROS = 1_753_003_600_000_000;
 afterEach(() => {
   vi.unstubAllGlobals();
   vi.useRealTimers();
+  act(() => useScope.getState().selectAllProjects());
 });
 
 describe('Code index freshness', () => {
@@ -249,6 +251,93 @@ describe('Code index freshness', () => {
     expect(screen.queryByRole('progressbar', { name: 'Code progress' })).toBeNull();
   });
 
+  it('does not resurrect text progress after its mount disappears and reappears', async () => {
+    vi.useFakeTimers();
+    const original = envelope('loading', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: null,
+        staleness_state: 'indexing',
+        rebuild_in_flight: true,
+        progress: progress(),
+      }],
+      note: 'original mounted scheduler',
+    });
+    const missing = envelope('unknown', {
+      worktrees: [],
+      note: 'scheduler unmounted',
+    });
+    const remounted = envelope('loading', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: null,
+        staleness_state: 'indexing',
+        rebuild_in_flight: true,
+        progress: null,
+      }],
+      note: 'scheduler remounted without a committed report',
+    });
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(new Response(JSON.stringify(original), { status: 200 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify(missing), { status: 200 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify(remounted), { status: 200 }));
+    vi.stubGlobal('fetch', fetch);
+    renderWith();
+
+    await advanceTimers(0);
+    expect(screen.getByText('250 / 500 files')).toBeTruthy();
+    await advanceTimers(1_001);
+    await advanceTimers(0);
+    expect(screen.getByText('scheduler unmounted')).toBeTruthy();
+    expect(screen.queryByRole('progressbar', { name: 'Code progress' })).toBeNull();
+    await advanceTimers(30_000);
+    await advanceTimers(0);
+    expect(screen.getByText('scheduler remounted without a committed report')).toBeTruthy();
+    expect(screen.queryByText('250 / 500 files')).toBeNull();
+    expect(screen.queryByRole('progressbar', { name: 'Code progress' })).toBeNull();
+    expect(fetch).toHaveBeenCalledTimes(3);
+  });
+
+  it('isolates retained text cursors between scoped project reads sharing a path', async () => {
+    const first = envelope('loading', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: null,
+        staleness_state: 'indexing',
+        rebuild_in_flight: true,
+        progress: progress(),
+      }],
+      note: 'first project observation',
+    });
+    first.scope.project_id = 'project-a';
+    const second = envelope('loading', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: null,
+        staleness_state: 'indexing',
+        rebuild_in_flight: true,
+        progress: null,
+      }],
+      note: 'second project observation',
+    });
+    second.scope.project_id = 'project-b';
+    const fetch = vi.fn(async (url: unknown) => new Response(
+      JSON.stringify(String(url).includes('project-a') ? first : second),
+      { status: 200 },
+    ));
+    vi.stubGlobal('fetch', fetch);
+    act(() => useScope.getState().selectProject('project-a', 'Project A'));
+    renderWith();
+
+    expect(await screen.findByText('first project observation')).toBeTruthy();
+    expect(screen.getByText('250 / 500 files')).toBeTruthy();
+    act(() => useScope.getState().selectProject('project-b', 'Project B'));
+    expect(await screen.findByText('second project observation')).toBeTruthy();
+    expect(screen.queryByText('250 / 500 files')).toBeNull();
+    expect(screen.queryByRole('progressbar', { name: 'Code progress' })).toBeNull();
+    expect(fetch).toHaveBeenCalledTimes(2);
+  });
+
   it('accepts a later replacement generation after epoch restart and rejects its delayed predecessor', async () => {
     vi.useFakeTimers();
     const first = envelope('loading', {
diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index 2b42b2d9a5f..1c7db689b9c 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -74,6 +74,7 @@ export function useIndexFreshness() {
 }
 
 export function IndexFreshness() {
+  const currentScopeKey = useScope((state) => scopeKey(state.scope));
   const freshness = useIndexFreshness();
 
   return (
@@ -87,7 +88,7 @@ export function IndexFreshness() {
       ) : freshness.data === undefined ? (
         <p className="text-2xs text-state-unknown">no response recorded</p>
       ) : (
-        <FreshnessReading result={freshness.data} />
+        <FreshnessReading key={currentScopeKey} result={freshness.data} />
       )}
     </section>
   );
@@ -335,43 +336,49 @@ function allActiveBuildsQuiet(
       ...(worktree.progress ? [worktree.progress.last_progress_micros] : []),
     ];
     return lastUpdates.length > 0 && lastUpdates.every(
-      (stamp) => stamp != null && observedAt - stamp >= QUIET_AFTER_SECONDS * 1_000_000,
-    );
-  });
-}
-
-function useLatestBuildProgress(
+      (stamp)function useLatestBuildProgress(
   result: EnvelopeResult<CodeIndexFreshnessPayloadV1>,
 ): ReadonlyMap<string, CodeIndexBuildProgress> {
   const [latestProgress, setLatestProgress] = useState<ReadonlyMap<string, CodeIndexBuildProgress>>(
     () => new Map(),
   );
   useEffect(() => {
-    if (result.outcome !== 'envelope') return;
+    if (result.outcome !== 'envelope') {
+      setLatestProgress((rendered) => rendered.size === 0 ? rendered : new Map());
+      return;
+    }
     setLatestProgress((rendered) => {
-      const next = new Map(rendered);
-      let changed = false;
+      // Only worktrees in this authoritative read may retain a cursor. If a
+      // mount disappears, its prior progress must not reappear on remount.
+      const next = new Map<string, CodeIndexBuildProgress>();
       for (const worktree of result.envelope.payload.worktrees) {
         const incoming = worktree.progress;
-        const current = next.get(worktree.worktree_root);
+        const current = rendered.get(worktree.worktree_root);
         if (!incoming) {
           if (
             current &&
-            ((result.envelope.domain_state === 'ready' &&
-              worktree.latest_generation_id === current.generation_id) ||
-              (worktree.latest_generation_id != null &&
-                worktree.latest_generation_id !== current.generation_id))
+            (worktree.latest_generation_id == null ||
+              worktree.latest_generation_id === current.generation_id) &&
+            !(result.envelope.domain_state === 'ready' &&
+              worktree.latest_generation_id === current.generation_id)
           ) {
-            // The sealed successor is authoritative; do not display a
-            // previous generation's text cursor against its readiness.
-            next.delete(worktree.worktree_root);
-            changed = true;
+            next.set(worktree.worktree_root, current);
           }
         } else if (!current || isCurrentOrNewerCodeIndexProgress(incoming, current)) {
           next.set(worktree.worktree_root, incoming);
-          changed = true;
+        } else {
+          next.set(worktree.worktree_root, current);
         }
       }
+      return next.size === rendered.size &&
+        [...next].every(([root, progress]) => rendered.get(root) === progress)
+        ? rendered
+        : next;
+    });
+  }, [result]);
+  return latestProgress;
+}
+
       return changed ? next : rendered;
     });
   }, [result]);

From 1a5aac13b07d90d4a4014cc2ac668532059f0262 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 01:28:45 -0800
Subject: [PATCH 54/80] fix(dashboard): preserve freshness polling function
 boundaries

Refs #4508
---
 dashboard/src/workspaces/code/IndexFreshness.tsx | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index 1c7db689b9c..c35cb236f5f 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -336,7 +336,12 @@ function allActiveBuildsQuiet(
       ...(worktree.progress ? [worktree.progress.last_progress_micros] : []),
     ];
     return lastUpdates.length > 0 && lastUpdates.every(
-      (stamp)function useLatestBuildProgress(
+      (stamp) => stamp != null && observedAt - stamp >= QUIET_AFTER_SECONDS * 1_000_000,
+    );
+  });
+}
+
+function useLatestBuildProgress(
   result: EnvelopeResult<CodeIndexFreshnessPayloadV1>,
 ): ReadonlyMap<string, CodeIndexBuildProgress> {
   const [latestProgress, setLatestProgress] = useState<ReadonlyMap<string, CodeIndexBuildProgress>>(
@@ -379,12 +384,6 @@ function allActiveBuildsQuiet(
   return latestProgress;
 }
 
-      return changed ? next : rendered;
-    });
-  }, [result]);
-  return latestProgress;
-}
-
 function formatDurationSeconds(seconds: number): string {
   if (seconds < 90) return `${Math.round(seconds)}s`;
   if (seconds < 5_400) return `${Math.round(seconds / 60)}m`;

From e7bbd014459f489fd3e5809ba256b6054128f9b4 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 02:00:29 -0800
Subject: [PATCH 55/80] fix(dashboard): distinguish progress for linked
 worktrees

Refs #4508
---
 .../CodeIndexPipeline.dom.test.tsx            | 49 +++++++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         | 20 ++++++--
 2 files changed, 64 insertions(+), 5 deletions(-)

diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index c1fbb13398b..cd940c53139 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -265,6 +265,55 @@ describe('code-index progress transitions', () => {
     expect(screen.queryByRole('progressbar')).toBeNull();
   });
 
+  it('keeps identical-generation progress separate for each mounted worktree', async () => {
+    // Linked worktrees can share a sealed generation ID but have independent
+    // build counters and must not share React list identity.
+    const first = freshness({
+      rebuild_in_flight: true,
+      progress: progress({ committed_pages: 2, completed_files: 2 }),
+    }, 'loading');
+    first.envelope.payload.worktrees.push(worktree({
+      worktree_root: '/project/linked',
+      rebuild_in_flight: true,
+      progress: progress({
+        committed_pages: 7,
+        completed_files: 7,
+        completed_lexical_units: 7,
+      }),
+    }));
+    first.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(first.envelope.payload);
+    const view = render(<CodeIndexPipeline result={first} pending={false} scopeKey="project" />);
+
+    const original = await screen.findByText('/project');
+    const linked = screen.getByText('/project/linked');
+    expect(original.closest('article[data-code-index-generation]')?.textContent)
+      .toContain('2 / 10 files');
+    expect(linked.closest('article[data-code-index-generation]')?.textContent)
+      .toContain('7 / 10 files');
+    expect(screen.getAllByRole('progressbar', { name: /Code progress for/ })).toHaveLength(2);
+
+    const updated = freshness({
+      rebuild_in_flight: true,
+      progress: progress({ committed_pages: 2, completed_files: 2 }),
+    }, 'loading');
+    updated.envelope.payload.worktrees.push(worktree({
+      worktree_root: '/project/linked',
+      rebuild_in_flight: true,
+      progress: progress({
+        progress_epoch: 2,
+        committed_pages: 9,
+        completed_files: 9,
+        completed_lexical_units: 9,
+      }),
+    }));
+    view.rerender(<CodeIndexPipeline result={updated} pending={false} scopeKey="project" />);
+    expect(await screen.findByText('9 / 10 files')).toBeTruthy();
+    expect(screen.getByText('/project').closest('article[data-code-index-generation]')?.textContent)
+      .toContain('2 / 10 files');
+    expect(screen.getByText('/project/linked').closest('article[data-code-index-generation]')?.textContent)
+      .toContain('9 / 10 files');
+  });
+
   it('keeps restore checks separate from build counters and stops polling after restoration', async () => {
     const restoring = freshness({ restore_progress: restoreProgress });
     const view = render(<CodeIndexPipeline result={restoring} pending={false} scopeKey="project" />);
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index ad22000f874..b37404742e6 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -82,8 +82,8 @@ export function CodeIndexPipeline({
         )
       ) : (
         <div className="mt-2 flex flex-col gap-2">
-          {progress.map((build) => (
-            <CodeIndexBuildCard key={build.generation_id} progress={build} />
+          {progress.map(([worktreeRoot, build]) => (
+            <CodeIndexBuildCard key={worktreeRoot} worktreeRoot={worktreeRoot} progress={build} />
           ))}
         </div>
       )}
@@ -220,7 +220,13 @@ export function graphServingLabel(
   }
 }
 
-function CodeIndexBuildCard({ progress }: { progress: CodeIndexBuildProgressV1 }) {
+function CodeIndexBuildCard({
+  progress,
+  worktreeRoot,
+}: {
+  progress: CodeIndexBuildProgressV1;
+  worktreeRoot: string;
+}) {
   const percentage = codeIndexProgressPercentage(progress);
   const hasRate =
     progress.files_per_second != null && progress.lexical_units_per_second != null;
@@ -245,6 +251,10 @@ function CodeIndexBuildCard({ progress }: { progress: CodeIndexBuildProgressV1 }
         <dd className="truncate text-right font-mono text-text-secondary" title={progress.generation_id}>
           {progress.generation_id}
         </dd>
+        <dt className="text-text-muted">worktree</dt>
+        <dd className="truncate text-right font-mono text-text-secondary" title={worktreeRoot}>
+          {worktreeRoot}
+        </dd>
         <dt className="text-text-muted">files</dt>
         <dd className="text-right text-text-secondary">
           {formatCount(progress.completed_files)} / {formatCount(progress.total_files)} files
@@ -312,7 +322,7 @@ export function hasActiveCodeIndexBuild(
 function useLatestCodeIndexProgress(
   result: EnvelopeResult<CodeIndexFreshnessPayloadV1> | undefined,
   currentScopeKey: string,
-): readonly CodeIndexBuildProgressV1[] {
+): ReadonlyArray<readonly [string, CodeIndexBuildProgressV1]> {
   const [latestProgress, setLatestProgress] = useState<ScopedCodeIndexProgress>(() => ({
     scopeKey: currentScopeKey,
     byWorktree: new Map(),
@@ -365,7 +375,7 @@ function useLatestCodeIndexProgress(
         : { scopeKey: currentScopeKey, byWorktree: next };
     });
   }, [currentScopeKey, result]);
-  return latestProgress.scopeKey === currentScopeKey ? [...latestProgress.byWorktree.values()] : [];
+  return latestProgress.scopeKey === currentScopeKey ? [...latestProgress.byWorktree] : [];
 }
 
 interface ScopedCodeIndexProgress {

From de02dc76680583a831f7e05b0f4c70160359358a Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 02:56:06 -0800
Subject: [PATCH 56/80] fix(code-index): isolate quiet polling to active writer
 clocks

Refs #4508. Retained ready text epochs do not refresh an active successor.
Keep authentic concurrent bulk-commit receipts eligible for live polling.
---
 .../code/IndexFreshness.dom.test.tsx          | 113 ++++++++++++++++++
 .../src/workspaces/code/IndexFreshness.tsx    |  17 ++-
 2 files changed, 127 insertions(+), 3 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index 874b4e9bd16..c04b7c6c551 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -626,6 +626,119 @@ describe('Code index freshness', () => {
     expect(fetch).toHaveBeenCalledTimes(3);
   });
 
+  it('does not let a fresh sealed predecessor clock disguise a frozen capture successor', async () => {
+    vi.useFakeTimers();
+    const attempt = {
+      daemon_incarnation: 1,
+      producer_incarnation: 2,
+      attempt_sequence: 3,
+      progress_epoch: 4,
+      phase: 'capture',
+      completed_items: 7,
+      total_items: 20,
+      last_progress_micros: NOW_MICROS,
+      active: true,
+    };
+    const staleText = {
+      ...progress(),
+      generation_id: 'generation.4f21c9',
+      phase: 'ready',
+      last_progress_micros: NOW_MICROS + 600_000_000,
+    };
+    const frozen = {
+      ...envelope('loading', {
+        worktrees: [{
+          ...worktree(),
+          rebuild_in_flight: true,
+          staleness_state: 'indexing',
+          progress: staleText,
+          preseal_attempt: attempt,
+        }],
+        note: 'authentic independent active capture attempt',
+      }),
+      time: { valid_time_micros: null, observation_time_micros: NOW_MICROS + 600_000_000 },
+    };
+    const moving = {
+      ...envelope('loading', {
+        worktrees: [{
+          ...worktree(),
+          rebuild_in_flight: true,
+          staleness_state: 'indexing',
+          progress: staleText,
+          preseal_attempt: {
+            ...attempt,
+            progress_epoch: 5,
+            completed_items: 8,
+            last_progress_micros: NOW_MICROS + 604_000_000,
+          },
+        }],
+        note: 'authentic independent active capture attempt',
+      }),
+      time: { valid_time_micros: null, observation_time_micros: NOW_MICROS + 604_000_000 },
+    };
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(new Response(JSON.stringify(frozen), { status: 200 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify(moving), { status: 200 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify(moving), { status: 200 }));
+    vi.stubGlobal('fetch', fetch);
+    renderWith();
+
+    await advanceTimers(0);
+    expect(screen.getByText('capture · 7 / 20 items')).toBeTruthy();
+    expect(fetch).toHaveBeenCalledTimes(1);
+    await advanceTimers(1_001);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    await advanceTimers(2_998);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    await advanceTimers(1);
+    await advanceTimers(0);
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(screen.getByText('capture · 8 / 20 items')).toBeTruthy();
+    await advanceTimers(1_001);
+    await advanceTimers(0);
+    expect(fetch).toHaveBeenCalledTimes(3);
+  });
+
+  it('still polls genuine concurrent text receipts while a preseal attempt is quiet', async () => {
+    vi.useFakeTimers();
+    const current = {
+      ...envelope('loading', {
+        worktrees: [{
+          ...worktree(),
+          rebuild_in_flight: true,
+          staleness_state: 'indexing',
+          progress: {
+            ...progress(),
+            phase: 'bulk_commit',
+            last_progress_micros: NOW_MICROS + 600_000_000,
+          },
+          preseal_attempt: {
+            daemon_incarnation: 1,
+            producer_incarnation: 2,
+            attempt_sequence: 3,
+            progress_epoch: 4,
+            phase: 'capture',
+            completed_items: 7,
+            total_items: 20,
+            last_progress_micros: NOW_MICROS,
+            active: true,
+          },
+        }],
+        note: 'concurrent durable text commit and preseal capture',
+      }),
+      time: { valid_time_micros: null, observation_time_micros: NOW_MICROS + 600_000_000 },
+    };
+    const fetch = vi.fn(async () => new Response(JSON.stringify(current), { status: 200 }));
+    vi.stubGlobal('fetch', fetch);
+    renderWith();
+
+    await advanceTimers(0);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    await advanceTimers(1_001);
+    await advanceTimers(0);
+    expect(fetch).toHaveBeenCalledTimes(2);
+  });
+
   it('keeps polling each second when a moving worktree shares a query with a quiet one', async () => {
     vi.useFakeTimers();
     const result = {
diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index c35cb236f5f..0792b905466 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -330,10 +330,21 @@ function allActiveBuildsQuiet(
   const observedAt = result.envelope.time.observation_time_micros;
   return result.envelope.payload.worktrees.every((worktree) => {
     if (!worktreeHasActiveCodeIndexBuild(worktree)) return true;
+    const preseal = worktree.preseal_attempt;
+    const native = worktree.native_graph_progress;
+    const presealActive = preseal?.active === true;
+    const nativeActive = native?.active === true;
+    // A retained sealed predecessor's recent ready/phase-only text stamp is
+    // not work from a frozen successor. Measure the active typed attempts,
+    // plus independently receipted bulk text commits when they overlap.
+    const text = worktree.progress;
+    const textCommitActive = text != null && text.phase === 'bulk_commit';
     const lastUpdates = [
-      ...(worktree.preseal_attempt?.active ? [worktree.preseal_attempt.last_progress_micros] : []),
-      ...(worktree.native_graph_progress?.active ? [worktree.native_graph_progress.last_progress_micros] : []),
-      ...(worktree.progress ? [worktree.progress.last_progress_micros] : []),
+      ...(presealActive ? [preseal.last_progress_micros] : []),
+      ...(nativeActive ? [native.last_progress_micros] : []),
+      ...(text && ((!presealActive && !nativeActive) || textCommitActive)
+        ? [text.last_progress_micros]
+        : []),
     ];
     return lastUpdates.length > 0 && lastUpdates.every(
       (stamp) => stamp != null && observedAt - stamp >= QUIET_AFTER_SECONDS * 1_000_000,

From 0c6c60ef9990683270684395a1231334a095c613 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 04:22:49 -0800
Subject: [PATCH 57/80] fix(dashboard): count independent text build boundaries

Refs #4508. Non-commit text index/verification work with a real producer progress epoch must keep freshness polling active even while successor capture is quiet. Preserve refusal of retained Ready and graph-publication stamps. Add two React Query DOM regressions.
---
 .../code/IndexFreshness.dom.test.tsx          | 46 +++++++++++++++++++
 .../src/workspaces/code/IndexFreshness.tsx    | 17 +++++--
 2 files changed, 58 insertions(+), 5 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index c04b7c6c551..98444551a88 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -739,6 +739,52 @@ describe('Code index freshness', () => {
     expect(fetch).toHaveBeenCalledTimes(2);
   });
 
+  it.each(['index_build', 'verification'] as const)(
+    'polls real concurrent %s text boundaries while successor capture is quiet',
+    async (phase) => {
+      vi.useFakeTimers();
+      const reading = {
+        ...envelope('loading', {
+          worktrees: [{
+            ...worktree(),
+            staleness_state: 'indexing',
+            rebuild_in_flight: true,
+            progress: {
+              ...progress(),
+              generation_id: 'generation.4f21c9',
+              phase,
+              progress_epoch: 9,
+              last_progress_micros: NOW_MICROS + 600_000_000,
+            },
+            preseal_attempt: {
+              daemon_incarnation: 1,
+              producer_incarnation: 2,
+              attempt_sequence: 3,
+              progress_epoch: 4,
+              phase: 'capture',
+              completed_items: 7,
+              total_items: 20,
+              last_progress_micros: NOW_MICROS,
+              active: true,
+            },
+          }],
+          note: 'independent text artifact boundary during quiet successor capture',
+        }),
+        time: { valid_time_micros: null, observation_time_micros: NOW_MICROS + 600_000_000 },
+      };
+      const fetch = vi.fn(async () => new Response(JSON.stringify(reading), { status: 200 }));
+      vi.stubGlobal('fetch', fetch);
+      renderWith();
+
+      await advanceTimers(0);
+      expect(screen.getByText('capture · 7 / 20 items')).toBeTruthy();
+      expect(fetch).toHaveBeenCalledTimes(1);
+      await advanceTimers(1_001);
+      await advanceTimers(0);
+      expect(fetch).toHaveBeenCalledTimes(2);
+    },
+  );
+
   it('keeps polling each second when a moving worktree shares a query with a quiet one', async () => {
     vi.useFakeTimers();
     const result = {
diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index 0792b905466..7ba4af07421 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -334,15 +334,22 @@ function allActiveBuildsQuiet(
     const native = worktree.native_graph_progress;
     const presealActive = preseal?.active === true;
     const nativeActive = native?.active === true;
-    // A retained sealed predecessor's recent ready/phase-only text stamp is
-    // not work from a frozen successor. Measure the active typed attempts,
-    // plus independently receipted bulk text commits when they overlap.
+    // A prior Ready or graph-publication phase stamp is not new work from a
+    // frozen successor. Concurrent text construction can independently make
+    // real progress through durable commits, index building, and verification.
+    // The producer-owned progress epoch is advanced only for an observed
+    // boundary, not for repeated reads of the same phase.
     const text = worktree.progress;
-    const textCommitActive = text != null && text.phase === 'bulk_commit';
+    const concurrentTextWork =
+      text != null &&
+      text.progress_epoch > 0 &&
+      (text.phase === 'bulk_commit' ||
+        text.phase === 'index_build' ||
+        text.phase === 'verification');
     const lastUpdates = [
       ...(presealActive ? [preseal.last_progress_micros] : []),
       ...(nativeActive ? [native.last_progress_micros] : []),
-      ...(text && ((!presealActive && !nativeActive) || textCommitActive)
+      ...(text && ((!presealActive && !nativeActive) || concurrentTextWork)
         ? [text.last_progress_micros]
         : []),
     ];

From 67d0eb364c0744df1b1531bbce877812be6ef620 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 05:02:57 -0800
Subject: [PATCH 58/80] fix(code-index): retire text cursors when no generation
 is sealed

---
 .../code/IndexFreshness.dom.test.tsx          | 40 +++++++++++++++++++
 .../src/workspaces/code/IndexFreshness.tsx    |  3 +-
 .../CodeIndexPipeline.dom.test.tsx            | 29 ++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         |  7 ++--
 4 files changed, 73 insertions(+), 6 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index 98444551a88..6ed8c443ec4 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -251,6 +251,46 @@ describe('Code index freshness', () => {
     expect(screen.queryByRole('progressbar', { name: 'Code progress' })).toBeNull();
   });
 
+  it('retires prior committed counters when a live mount has no sealed generation', async () => {
+    vi.useFakeTimers();
+    const building = envelope('loading', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: 'generation.catchup.01',
+        staleness_state: 'indexing',
+        rebuild_in_flight: true,
+        progress: progress(),
+      }],
+      note: 'previous sealed generation remains visible',
+    });
+    const restarted = envelope('loading', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: null,
+        sealed_at_micros: null,
+        snapshot_content_identity: null,
+        staleness_state: 'indexing',
+        rebuild_in_flight: true,
+        progress: null,
+      }],
+      note: 'no sealed generation in the current scheduler',
+    });
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(new Response(JSON.stringify(building), { status: 200 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify(restarted), { status: 200 }));
+    vi.stubGlobal('fetch', fetch);
+    renderWith();
+
+    await advanceTimers(0);
+    expect(screen.getByText('250 / 500 files')).toBeTruthy();
+    await advanceTimers(1_001);
+    await advanceTimers(0);
+    expect(fetch).toHaveBeenCalledTimes(2);
+    expect(screen.getByText('no sealed generation yet')).toBeTruthy();
+    expect(screen.queryByText('250 / 500 files')).toBeNull();
+    expect(screen.queryByRole('progressbar', { name: 'Code progress' })).toBeNull();
+  });
+
   it('does not resurrect text progress after its mount disappears and reappears', async () => {
     vi.useFakeTimers();
     const original = envelope('loading', {
diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index 7ba4af07421..0c63d73ddcf 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -380,8 +380,7 @@ function useLatestBuildProgress(
         if (!incoming) {
           if (
             current &&
-            (worktree.latest_generation_id == null ||
-              worktree.latest_generation_id === current.generation_id) &&
+            worktree.latest_generation_id === current.generation_id &&
             !(result.envelope.domain_state === 'ready' &&
               worktree.latest_generation_id === current.generation_id)
           ) {
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index cd940c53139..e41d0212b8a 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -233,6 +233,35 @@ describe('code-index progress transitions', () => {
     expect(screen.queryByRole('progressbar')).toBeNull();
   });
 
+  it('retires cached text when the daemon reports no sealed generation', async () => {
+    const building = freshness({
+      latest_generation_id: GENERATION,
+      rebuild_in_flight: true,
+      progress: progress({ progress_epoch: 9 }),
+    }, 'loading');
+    const view = render(<CodeIndexPipeline result={building} pending={false} scopeKey="project" />);
+    expect(await screen.findByText('bulk commit · 20.0%')).toBeTruthy();
+
+    // This is not an absent progress sample from the *same* durable
+    // generation: the mount now explicitly has no sealed generation.
+    view.rerender(<CodeIndexPipeline
+      result={freshness({
+        latest_generation_id: null,
+        sealed_at_micros: null,
+        snapshot_content_identity: null,
+        staleness_state: 'indexing',
+        rebuild_in_flight: true,
+        progress: null,
+      }, 'loading')}
+      pending={false}
+      scopeKey="project"
+    />);
+    expect(await screen.findByText('code-index build in progress; progress not yet reported'))
+      .toBeTruthy();
+    expect(screen.queryByText('bulk commit · 20.0%')).toBeNull();
+    expect(screen.queryByRole('progressbar')).toBeNull();
+  });
+
   it('discards a retired text cursor after a different generation seals', async () => {
     const building = freshness({
       progress: progress({ progress_epoch: 41 }),
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index b37404742e6..4477f5f3757 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -347,12 +347,11 @@ function useLatestCodeIndexProgress(
         const renderedProgress = current.get(worktree.worktree_root);
         if (!incoming) {
           // A confirmed replacement seal makes the old text cursor stale.
-          // Retain only a transient missing sample for the same generation
-          // (or while no generation has sealed); neither is new work.
+          // Retain only a transient missing sample for a still-sealed
+          // generation. No sealed generation means no text cursor to retain.
           if (
             renderedProgress &&
-            (worktree.latest_generation_id == null ||
-              worktree.latest_generation_id === renderedProgress.generation_id) &&
+            worktree.latest_generation_id === renderedProgress.generation_id &&
             !(
               result.envelope.domain_state === 'ready' &&
               worktree.latest_generation_id === renderedProgress.generation_id

From 4697f4b89707f88efa1ed4142dcddc7ba01ce309 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 06:46:06 -0800
Subject: [PATCH 59/80] fix(dashboard): discard observatory cursors after
 disconnect

---
 .../CodeIndexPipeline.dom.test.tsx            | 29 +++++++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         |  4 ++-
 2 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index e41d0212b8a..e69c887a52c 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -233,6 +233,35 @@ describe('code-index progress transitions', () => {
     expect(screen.queryByRole('progressbar')).toBeNull();
   });
 
+  it('does not resurrect text counters across a transport gap', async () => {
+    const building = freshness({
+      rebuild_in_flight: true,
+      progress: progress({ progress_epoch: 9 }),
+    }, 'loading');
+    building.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(building.envelope.payload);
+    const view = render(<CodeIndexPipeline result={building} pending={false} scopeKey="project" />);
+    expect(await screen.findByText('bulk commit · 20.0%')).toBeTruthy();
+
+    // The transport gap invalidates the old progress receipt. A subsequent
+    // reading can name the same sealed generation without reporting new work.
+    view.rerender(<CodeIndexPipeline
+      result={{ outcome: 'transport', state: 'error' }}
+      pending={false}
+      scopeKey="project"
+    />);
+    expect(screen.queryByRole('progressbar')).toBeNull();
+
+    view.rerender(<CodeIndexPipeline
+      result={freshness({ rebuild_in_flight: true, progress: null }, 'loading')}
+      pending={false}
+      scopeKey="project"
+    />);
+    expect(await screen.findByText('code-index build in progress; progress not yet reported'))
+      .toBeTruthy();
+    expect(screen.queryByText('bulk commit · 20.0%')).toBeNull();
+    expect(screen.queryByRole('progressbar')).toBeNull();
+  });
+
   it('retires cached text when the daemon reports no sealed generation', async () => {
     const building = freshness({
       latest_generation_id: GENERATION,
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index 4477f5f3757..d22d7921e49 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -329,8 +329,10 @@ function useLatestCodeIndexProgress(
   }));
   useEffect(() => {
     if (result?.outcome !== 'envelope') {
+      // Disconnect invalidates the old observation even if a later response
+      // names the same generation without receipted work.
       setLatestProgress((rendered) =>
-        rendered.scopeKey === currentScopeKey
+        rendered.scopeKey === currentScopeKey && rendered.byWorktree.size === 0
           ? rendered
           : { scopeKey: currentScopeKey, byWorktree: new Map() },
       );

From f2ba35b339712a4248fce2b3a4334246a34f09b0 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 07:28:49 -0800
Subject: [PATCH 60/80] fix(dashboard): show quiet preseal and native graph
 work

Refs #4508

Show observed writer inactivity only from typed producer work stamps and
the daemon observation clock. Retire warnings on actual progress or owner
inactivity; never manufacture a heartbeat for missing timestamps.
Add falsifiable canonical-schema React DOM regressions in both views.
---
 .../code/IndexFreshness.dom.test.tsx          | 28 +++++++++
 .../src/workspaces/code/IndexFreshness.tsx    |  2 +-
 .../CodeIndexPipeline.dom.test.tsx            | 62 +++++++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         | 50 ++++++++++++++-
 4 files changed, 138 insertions(+), 4 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index 6ed8c443ec4..ad2f530e0ca 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -153,6 +153,34 @@ describe('Code index freshness', () => {
     )).toBeTruthy();
   });
 
+  it('uses genuine preseal and native writer clocks for no-work warnings', async () => {
+    renderFreshness('loading', {
+      worktrees: [{
+        ...worktree(),
+        preseal_attempt: {
+          daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 3,
+          progress_epoch: 4, phase: 'parse_evidence', completed_items: 7,
+          total_items: 10, last_progress_micros: NOW_MICROS - 60_000_000, active: true,
+        },
+        native_graph_progress: {
+          generation_id: 'generation.4f21c9', sealed_graph_digest: 'sha256:graph',
+          daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 4,
+          progress_epoch: 6, phase: 'compact_encoding',
+          encoded_entities: 17, total_entities: 25,
+          encoded_relations: 3, total_relations: 9,
+          committed_stage_pages: 0, committed_stage_mutations: 0, committed_stage_bytes: 0,
+          committed_compact_segments: 0, committed_compact_bytes: 0,
+          last_progress_micros: NOW_MICROS - 120_000_000, active: true,
+        },
+      }],
+      note: 'live daemon scheduler state',
+    });
+    expect(await screen.findByText('parse evidence · 7 / 10 items')).toBeTruthy();
+    expect(screen.getByText('no observed preseal work for 60s')).toBeTruthy();
+    expect(screen.getByText('no observed native graph work for 2m')).toBeTruthy();
+    expect(screen.getByText(/17 entities encoded/)).toBeTruthy();
+  });
+
   it('renders bounded artifact restore progress separately from a rebuild', async () => {
     renderFreshness('loading', {
       worktrees: [
diff --git a/dashboard/src/workspaces/code/IndexFreshness.tsx b/dashboard/src/workspaces/code/IndexFreshness.tsx
index 0c63d73ddcf..2855e032f76 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.tsx
@@ -166,7 +166,7 @@ function WorktreeReading({
       {progress ? (
         <BuildProgressReading progress={progress} observedAtMicros={observedAtMicros} />
       ) : null}
-      <CodeIndexAttemptReading worktree={worktree} />
+      <CodeIndexAttemptReading worktree={worktree} observedAtMicros={observedAtMicros} />
       {worktree.restore_progress ? (
         <div className="border-b border-edge-subtle pb-1.5 text-3xs leading-snug">
           <div className="flex items-baseline justify-between gap-2">
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index e69c887a52c..3158daaf48d 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -132,6 +132,68 @@ describe('code-index activity polling', () => {
     expect(screen.queryByText('no active code-index build')).toBeNull();
   });
 
+  it('reports frozen writer clocks and clears warnings on real work or retirement', () => {
+    const frozen = freshness({
+      progress: progress({ phase: 'ready' }),
+      preseal_attempt: {
+        daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 3,
+        progress_epoch: 4, phase: 'capture', completed_items: 7,
+        total_items: 10, last_progress_micros: OBSERVED_AT - 60_000_000, active: true,
+      },
+    }, 'loading');
+    frozen.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(frozen.envelope.payload);
+    const view = render(<CodeIndexPipeline result={frozen} pending={false} scopeKey="project" />);
+    expect(screen.getByText('no observed preseal work for 60s')).toBeTruthy();
+    expect(screen.getByText('capture · 7 / 10 items')).toBeTruthy();
+
+    const recovered = freshness({
+      preseal_attempt: {
+        daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 3,
+        progress_epoch: 5, phase: 'parse_evidence', completed_items: 8,
+        total_items: 10, last_progress_micros: OBSERVED_AT, active: true,
+      },
+    }, 'loading');
+    recovered.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(recovered.envelope.payload);
+    view.rerender(<CodeIndexPipeline result={recovered} pending={false} scopeKey="project" />);
+    expect(screen.getByText('parse evidence · 8 / 10 items')).toBeTruthy();
+    expect(screen.queryByText(/no observed preseal work/)).toBeNull();
+
+    const nativeProgress: NonNullable<CodeIndexWorktreeFreshnessV1['native_graph_progress']> = {
+      generation_id: GENERATION, sealed_graph_digest: 'sha256:graph',
+      daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 4,
+      progress_epoch: 6, phase: 'stage_page_commit',
+      encoded_entities: 17, total_entities: 25,
+      encoded_relations: 3, total_relations: 9,
+      committed_stage_pages: 1, committed_stage_mutations: 3, committed_stage_bytes: 128,
+      committed_compact_segments: 0, committed_compact_bytes: 0,
+      last_progress_micros: OBSERVED_AT - 120_000_000, active: true,
+    };
+    const frozenGraph = freshness({ native_graph_progress: nativeProgress }, 'loading');
+    frozenGraph.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(frozenGraph.envelope.payload);
+    view.rerender(<CodeIndexPipeline result={frozenGraph} pending={false} scopeKey="project" />);
+    expect(screen.getByText('no observed native graph work for 2m')).toBeTruthy();
+
+    // A verified but inactive writer remains a milestone, not a stalled writer.
+    const completed = freshness({
+      native_graph_progress: {
+        ...nativeProgress, active: false,
+        phase: 'compact_segment_verified', committed_compact_segments: 1,
+      },
+    });
+    completed.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(completed.envelope.payload);
+    view.rerender(<CodeIndexPipeline result={completed} pending={false} scopeKey="project" />);
+    expect(screen.getByText('Graph milestones')).toBeTruthy();
+    expect(screen.queryByText(/no observed native graph work/)).toBeNull();
+
+    // Without a real work stamp, no elapsed no-work duration can be invented.
+    const unreported = freshness({
+      native_graph_progress: { ...nativeProgress, last_progress_micros: null },
+    }, 'loading');
+    unreported.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(unreported.envelope.payload);
+    view.rerender(<CodeIndexPipeline result={unreported} pending={false} scopeKey="project" />);
+    expect(screen.queryByText(/no observed native graph work/)).toBeNull();
+  });
+
   it('keeps polling an in-flight rebuild before its first committed report', () => {
     expect(hasActiveCodeIndexBuild(freshness({ rebuild_in_flight: true }))).toBe(true);
   });
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index d22d7921e49..269a7d6538e 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -24,6 +24,8 @@ export function CodeIndexPipeline({
   const progress = useLatestCodeIndexProgress(result, scopeKey);
   const payload = result?.outcome === 'envelope' ? result.envelope.payload : undefined;
   const worktrees = payload?.worktrees ?? [];
+  const observedAtMicros =
+    result?.outcome === 'envelope' ? result.envelope.time.observation_time_micros : null;
   if (pending) {
     return (
       <section className="mx-4 mt-3" aria-label="Code-index pipeline">
@@ -47,7 +49,7 @@ export function CodeIndexPipeline({
       {payload?.mount_failure ? (
         <CodeIndexMountFailureNotice className="mt-2" failure={payload.mount_failure} />
       ) : (
-        <CodeIndexReadinessList worktrees={worktrees} />
+        <CodeIndexReadinessList worktrees={worktrees} observedAtMicros={observedAtMicros} />
       )}
       {worktrees.some((worktree) => worktree.restore_progress != null) ? (
         <div className="mt-2 flex flex-col gap-2">
@@ -109,8 +111,10 @@ export function CodeIndexMountFailureNotice({
 
 function CodeIndexReadinessList({
   worktrees,
+  observedAtMicros,
 }: {
   worktrees: CodeIndexWorktreeFreshnessV1[];
+  observedAtMicros: number | null;
 }) {
   if (worktrees.length === 0) {
     return <p className="mt-2 text-body text-text-muted">no mounted code-index worktree</p>;
@@ -132,7 +136,7 @@ function CodeIndexReadinessList({
               {graphServingLabel(worktree.code_graph_serving)}
             </dd>
           </dl>
-          <CodeIndexAttemptReading worktree={worktree} />
+          <CodeIndexAttemptReading worktree={worktree} observedAtMicros={observedAtMicros} />
           {worktree.parked ? (
             <p className="mt-2 text-sm text-state-warning">
               parked: {worktree.parked.reason} · {worktree.parked.remediation}
@@ -144,9 +148,23 @@ function CodeIndexReadinessList({
   );
 }
 
-export function CodeIndexAttemptReading({ worktree }: { worktree: CodeIndexWorktreeFreshnessV1 }) {
+export function CodeIndexAttemptReading({
+  worktree,
+  observedAtMicros,
+}: {
+  worktree: CodeIndexWorktreeFreshnessV1;
+  observedAtMicros: number | null;
+}) {
   const attempt = worktree.preseal_attempt;
   const graph = worktree.native_graph_progress;
+  // Only the daemon's observation time and an actual producer work stamp
+  // can establish inactivity. Reading status is not a progress heartbeat.
+  const presealQuiet = attempt?.active
+    ? observedWorkQuietDuration(attempt.last_progress_micros, observedAtMicros)
+    : null;
+  const graphQuiet = graph?.active
+    ? observedWorkQuietDuration(graph.last_progress_micros, observedAtMicros)
+    : null;
   // An inactive writer is no longer live, but its committed milestones still
   // belong to this generation. Encoding alone is not durable completion.
   const showGraph = graph != null && (
@@ -165,6 +183,14 @@ export function CodeIndexAttemptReading({ worktree }: { worktree: CodeIndexWorkt
             {attempt.phase.replaceAll('_', ' ')} · {formatCount(attempt.completed_items)}
             {attempt.total_items != null && ` / ${formatCount(attempt.total_items)}`} items
           </dd>
+          {presealQuiet && (
+            <>
+              <dt className="text-state-warning">Preseal progress</dt>
+              <dd className="text-right text-state-warning">
+                no observed preseal work for {presealQuiet}
+              </dd>
+            </>
+          )}
         </>
       )}
       {showGraph && graph && (
@@ -179,12 +205,30 @@ export function CodeIndexAttemptReading({ worktree }: { worktree: CodeIndexWorkt
             {formatCount(graph.committed_stage_pages)} pages committed ·{' '}
             {formatCount(graph.committed_compact_segments)} segments committed
           </dd>
+          {graphQuiet && (
+            <>
+              <dt className="text-state-warning">Graph progress</dt>
+              <dd className="text-right text-state-warning">
+                no observed native graph work for {graphQuiet}
+              </dd>
+            </>
+          )}
         </>
       )}
     </dl>
   );
 }
 
+function observedWorkQuietDuration(
+  lastProgressMicros: number | null,
+  observedAtMicros: number | null,
+): string | null {
+  if (lastProgressMicros == null || observedAtMicros == null) return null;
+  const quietMicros = observedAtMicros - lastProgressMicros;
+  // No work stamp, or a stamp after the read, is not evidence of a stall.
+  return quietMicros >= 30_000_000 ? formatDurationMicros(quietMicros) : null;
+}
+
 export function hasLiveWorktreeProgress(worktree: CodeIndexWorktreeFreshnessV1): boolean {
   return (
     worktree.restore_progress != null ||

From 5b9d3a8463d818160a76b47b2c95c684ef19014a Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 08:29:20 -0800
Subject: [PATCH 61/80] test(dashboard): await decoded progress update after
 refetch

Refs #4508. The HTTP request count advances before the React Query response is decoded and committed. Await the rendered advancing capture receipt before checking resumed polling, keeping all cadence and counter assertions intact.
---
 dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index ad2f530e0ca..e9b99677c91 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -761,7 +761,7 @@ describe('Code index freshness', () => {
     await advanceTimers(1);
     await advanceTimers(0);
     expect(fetch).toHaveBeenCalledTimes(2);
-    expect(screen.getByText('capture · 8 / 20 items')).toBeTruthy();
+    expect(await screen.findByText('capture · 8 / 20 items')).toBeTruthy();
     await advanceTimers(1_001);
     await advanceTimers(0);
     expect(fetch).toHaveBeenCalledTimes(3);

From 32b36533e7b707624c7e45517d75f5eb78d8da9f Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 09:37:44 -0800
Subject: [PATCH 62/80] fix(code-index): distinguish admitted preseal from
 measured work

---
 .../code/IndexFreshness.dom.test.tsx          | 21 ++++++++++++-
 .../CodeIndexPipeline.dom.test.tsx            | 30 +++++++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         | 10 +++++--
 3 files changed, 58 insertions(+), 3 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index e9b99677c91..e10e9b01912 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -153,7 +153,26 @@ describe('Code index freshness', () => {
     )).toBeTruthy();
   });
 
-  it('uses genuine preseal and native writer clocks for no-work warnings', async () => {
+  it('does not present preseal admission as a measured capture', async () => {
+    renderFreshness('loading', {
+      worktrees: [{
+        ...worktree(),
+        latest_generation_id: null,
+        staleness_state: 'indexing',
+        preseal_attempt: {
+          daemon_incarnation: 7, producer_incarnation: 9, attempt_sequence: 1,
+          progress_epoch: 1, phase: 'capture', completed_items: 0,
+          total_items: null, last_progress_micros: null, active: true,
+        },
+      }],
+      note: 'live daemon scheduler state',
+    });
+    expect(await screen.findByText('awaiting first observed preseal work')).toBeTruthy();
+    expect(screen.queryByText('capture · 0 items')).toBeNull();
+    expect(screen.queryByText(/no observed preseal work for/)).toBeNull();
+  });
+
+  it('uses genuine preseal and native writer clocks for no-work warnings', async () {
     renderFreshness('loading', {
       worktrees: [{
         ...worktree(),
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index 3158daaf48d..1ffe2ab654e 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -119,6 +119,36 @@ const restoreProgress = {
 afterEach(cleanup);
 
 describe('code-index activity polling', () => {
+  it('does not turn an admitted first capture into observed work', () => {
+    const admitted = {
+      daemon_incarnation: 7, producer_incarnation: 9, attempt_sequence: 1,
+      progress_epoch: 1, phase: 'capture' as const, completed_items: 0,
+      total_items: null, last_progress_micros: null, active: true,
+    };
+    const initial = freshness({
+      latest_generation_id: null, code_graph_serving: { state: 'pending' },
+      staleness_state: 'indexing', preseal_attempt: admitted,
+    }, 'loading');
+    initial.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(initial.envelope.payload);
+    const view = render(<CodeIndexPipeline result={initial} pending={false} scopeKey="project" />);
+    expect(screen.getByText('awaiting first observed preseal work')).toBeTruthy();
+    expect(screen.queryByText('capture · 0 items')).toBeNull();
+    expect(screen.queryByText(/no observed preseal work for/)).toBeNull();
+
+    const observed = freshness({
+      latest_generation_id: null, code_graph_serving: { state: 'pending' },
+      staleness_state: 'indexing',
+      preseal_attempt: {
+        ...admitted, progress_epoch: 2, completed_items: 3,
+        total_items: 10, last_progress_micros: OBSERVED_AT,
+      },
+    }, 'loading');
+    observed.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(observed.envelope.payload);
+    view.rerender(<CodeIndexPipeline result={observed} pending={false} scopeKey="project" />);
+    expect(screen.getByText('capture · 3 / 10 items')).toBeTruthy();
+    expect(screen.queryByText('awaiting first observed preseal work')).toBeNull();
+  });
+
   it('shows pre-seal work before the first text page commits', () => {
     const result = freshness({ preseal_attempt: {
       daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 3,
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index 269a7d6538e..47ed83b4d41 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -180,8 +180,14 @@ export function CodeIndexAttemptReading({
         <>
           <dt className="text-text-muted">Before sealing</dt>
           <dd className="text-right text-text-secondary">
-            {attempt.phase.replaceAll('_', ' ')} · {formatCount(attempt.completed_items)}
-            {attempt.total_items != null && ` / ${formatCount(attempt.total_items)}`} items
+            {attempt.last_progress_micros == null ? (
+              'awaiting first observed preseal work'
+            ) : (
+              <>
+                {attempt.phase.replaceAll('_', ' ')} · {formatCount(attempt.completed_items)}
+                {attempt.total_items != null && ` / ${formatCount(attempt.total_items)}`} items
+              </>
+            )}
           </dd>
           {presealQuiet && (
             <>

From 4b259eefd7da06c77208d83a25daf558945fb960 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 10:13:34 -0800
Subject: [PATCH 63/80] fix(code-index): distinguish admitted native writer
 from observed work

---
 .../code/IndexFreshness.dom.test.tsx          | 21 +++++++++++
 .../CodeIndexPipeline.dom.test.tsx            | 37 +++++++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         | 16 +++++---
 3 files changed, 69 insertions(+), 5 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index e10e9b01912..3b7d0a54cc9 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -153,6 +153,27 @@ describe('Code index freshness', () => {
     )).toBeTruthy();
   });
 
+  it('does not report native graph encoding or durable pages before an actual writer callback', async () => {
+    renderFreshness('loading', {
+      worktrees: [{
+        ...worktree(),
+        native_graph_progress: {
+          generation_id: 'generation.4f21c9', sealed_graph_digest: 'sha256:graph',
+          daemon_incarnation: 7, producer_incarnation: 9, attempt_sequence: 1,
+          progress_epoch: 1, phase: null, active: true, last_progress_micros: null,
+          encoded_entities: 0, total_entities: null, encoded_relations: 0, total_relations: null,
+          committed_stage_pages: 0, committed_stage_mutations: 0, committed_stage_bytes: 0,
+          committed_compact_segments: 0, committed_compact_bytes: 0,
+        },
+      }],
+      note: 'live daemon scheduler state',
+    });
+    expect(await screen.findByText('awaiting first observed native graph work')).toBeTruthy();
+    expect(screen.queryByText(/0 entities encoded/)).toBeNull();
+    expect(screen.queryByText(/0 pages committed/)).toBeNull();
+    expect(screen.queryByText(/no observed native graph work for/)).toBeNull();
+  });
+
   it('does not present preseal admission as a measured capture', async () => {
     renderFreshness('loading', {
       worktrees: [{
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index 1ffe2ab654e..a95d9323745 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -149,6 +149,43 @@ describe('code-index activity polling', () => {
     expect(screen.queryByText('awaiting first observed preseal work')).toBeNull();
   });
 
+  it('does not treat a newly admitted native writer as encoded or committed work', () => {
+    // This is the exact admission shape from the real native graph slot begin:
+    // the producer has not observed any compact row or durable receipt.
+    const admitted: NonNullable<CodeIndexWorktreeFreshnessV1['native_graph_progress']> = {
+      generation_id: GENERATION, sealed_graph_digest: 'sha256:graph',
+      daemon_incarnation: 7, producer_incarnation: 9, attempt_sequence: 1,
+      progress_epoch: 1, phase: null,
+      encoded_entities: 0, total_entities: null,
+      encoded_relations: 0, total_relations: null,
+      committed_stage_pages: 0, committed_stage_mutations: 0, committed_stage_bytes: 0,
+      committed_compact_segments: 0, committed_compact_bytes: 0,
+      last_progress_micros: null, active: true,
+    };
+    const initial = freshness({ native_graph_progress: admitted }, 'loading');
+    initial.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(initial.envelope.payload);
+    const view = render(<CodeIndexPipeline result={initial} pending={false} scopeKey="project" />);
+    expect(screen.getByText('Graph writer')).toBeTruthy();
+    expect(screen.getByText('awaiting first observed native graph work')).toBeTruthy();
+    expect(screen.queryByText(/0 entities encoded/)).toBeNull();
+    expect(screen.queryByText(/0 pages committed/)).toBeNull();
+    expect(screen.queryByText(/no observed native graph work for/)).toBeNull();
+
+    const observed = freshness({
+      native_graph_progress: {
+        ...admitted, progress_epoch: 2, phase: 'compact_encoding',
+        encoded_entities: 3, total_entities: 10,
+        last_progress_micros: OBSERVED_AT,
+      },
+    }, 'loading');
+    observed.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(observed.envelope.payload);
+    view.rerender(<CodeIndexPipeline result={observed} pending={false} scopeKey="project" />);
+    expect(screen.getByText(
+      'compact encoding · 3 entities encoded · 0 relations encoded · 0 pages committed · 0 segments committed',
+    )).toBeTruthy();
+    expect(screen.queryByText('awaiting first observed native graph work')).toBeNull();
+  });
+
   it('shows pre-seal work before the first text page commits', () => {
     const result = freshness({ preseal_attempt: {
       daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 3,
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index 47ed83b4d41..827120e42b7 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -205,11 +205,17 @@ export function CodeIndexAttemptReading({
             {graph.active ? 'Graph writer' : 'Graph milestones'}
           </dt>
           <dd className="text-right text-text-secondary">
-            {graph.phase?.replaceAll('_', ' ') ?? 'awaiting first update'} ·{' '}
-            {formatCount(graph.encoded_entities)} entities encoded ·{' '}
-            {formatCount(graph.encoded_relations)} relations encoded ·{' '}
-            {formatCount(graph.committed_stage_pages)} pages committed ·{' '}
-            {formatCount(graph.committed_compact_segments)} segments committed
+            {graph.last_progress_micros == null ? (
+              'awaiting first observed native graph work'
+            ) : (
+              <>
+                {graph.phase?.replaceAll('_', ' ') ?? 'work phase not reported'} ·{' '}
+                {formatCount(graph.encoded_entities)} entities encoded ·{' '}
+                {formatCount(graph.encoded_relations)} relations encoded ·{' '}
+                {formatCount(graph.committed_stage_pages)} pages committed ·{' '}
+                {formatCount(graph.committed_compact_segments)} segments committed
+              </>
+            )}
           </dd>
           {graphQuiet && (
             <>

From 51b91384ca1434351223820926929f75469a6bf5 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 11:08:47 -0800
Subject: [PATCH 64/80] fix(code-index): retain observed preseal work through
 handoff

Refs #4508

The preseal observer retires at durable publication handoff. Keep its
last authentic resolution count visible while the rebuild remains in
flight, without implying ongoing progress or manufacturing a work clock.

Exercise both Observatory and HTTP-backed Index Freshness DOM readers,
including retirement after the rebuild ends.
---
 .../code/IndexFreshness.dom.test.tsx          | 20 +++++++++++++++
 .../CodeIndexPipeline.dom.test.tsx            | 25 +++++++++++++++++++
 .../observatory/CodeIndexPipeline.tsx         | 14 ++++++++---
 3 files changed, 56 insertions(+), 3 deletions(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index 3b7d0a54cc9..829b3354d4a 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -221,6 +221,26 @@ describe('Code index freshness', () => {
     expect(screen.getByText(/17 entities encoded/)).toBeTruthy();
   });
 
+  it('preserves recorded resolution work during the daemon publication handoff', async () => {
+    renderFreshness('loading', {
+      worktrees: [{
+        ...worktree(),
+        rebuild_in_flight: true,
+        preseal_attempt: {
+          daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 3,
+          progress_epoch: 7, phase: 'resolution', completed_items: 7,
+          total_items: null, last_progress_micros: NOW_MICROS - 90_000_000,
+          active: false,
+        },
+      }],
+      note: 'live daemon scheduler state',
+    });
+    expect(await screen.findByText('Last observed preseal work')).toBeTruthy();
+    expect(screen.getByText('resolution · 7 items')).toBeTruthy();
+    expect(screen.queryByText('Before sealing')).toBeNull();
+    expect(screen.queryByText(/no observed preseal work for/)).toBeNull();
+  });
+
   it('renders bounded artifact restore progress separately from a rebuild', async () => {
     renderFreshness('loading', {
       worktrees: [
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
index a95d9323745..996c95649b7 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx
@@ -199,6 +199,31 @@ describe('code-index activity polling', () => {
     expect(screen.queryByText('no active code-index build')).toBeNull();
   });
 
+  it('keeps last observed preseal work visible through durable handoff without calling it active', () => {
+    const lastAttempt: NonNullable<CodeIndexWorktreeFreshnessV1['preseal_attempt']> = {
+      daemon_incarnation: 1, producer_incarnation: 2, attempt_sequence: 3,
+      progress_epoch: 7, phase: 'resolution', completed_items: 7,
+      total_items: null, last_progress_micros: OBSERVED_AT - 90_000_000, active: false,
+    };
+    const handoff = freshness({
+      rebuild_in_flight: true,
+      preseal_attempt: lastAttempt,
+    }, 'loading');
+    handoff.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(handoff.envelope.payload);
+    const view = render(<CodeIndexPipeline result={handoff} pending={false} scopeKey="project" />);
+    expect(screen.getByText('Last observed preseal work')).toBeTruthy();
+    expect(screen.getByText('resolution · 7 items')).toBeTruthy();
+    expect(screen.queryByText('Before sealing')).toBeNull();
+    expect(screen.queryByText(/no observed preseal work for/)).toBeNull();
+
+    // The recorded attempt becomes historical once the rebuild ends.
+    const settled = freshness({ rebuild_in_flight: false, preseal_attempt: lastAttempt });
+    settled.envelope.payload = CodeIndexFreshnessPayloadV1Schema.parse(settled.envelope.payload);
+    view.rerender(<CodeIndexPipeline result={settled} pending={false} scopeKey="project" />);
+    expect(screen.queryByText('Last observed preseal work')).toBeNull();
+    expect(screen.queryByText('resolution · 7 items')).toBeNull();
+  });
+
   it('reports frozen writer clocks and clears warnings on real work or retirement', () => {
     const frozen = freshness({
       progress: progress({ phase: 'ready' }),
diff --git a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
index 827120e42b7..c8983f26340 100644
--- a/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
+++ b/dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx
@@ -157,6 +157,12 @@ export function CodeIndexAttemptReading({
 }) {
   const attempt = worktree.preseal_attempt;
   const graph = worktree.native_graph_progress;
+  // Retiring the source observer at durable handoff must not erase its last
+  // authentic work. Show the retired reading only while the rebuild remains
+  // in flight; it does not represent an active writer or renew its work clock.
+  const showPreseal = attempt != null && (
+    attempt.active || (worktree.rebuild_in_flight && attempt.last_progress_micros != null)
+  );
   // Only the daemon's observation time and an actual producer work stamp
   // can establish inactivity. Reading status is not a progress heartbeat.
   const presealQuiet = attempt?.active
@@ -173,12 +179,14 @@ export function CodeIndexAttemptReading({
       (graph.committed_stage_pages > 0 || graph.committed_compact_segments > 0)
     )
   );
-  if (!attempt?.active && !showGraph) return null;
+  if (!showPreseal && !showGraph) return null;
   return (
     <dl className="grid grid-cols-2 gap-x-4 gap-y-1 text-sm">
-      {attempt?.active && (
+      {showPreseal && attempt && (
         <>
-          <dt className="text-text-muted">Before sealing</dt>
+          <dt className="text-text-muted">
+            {attempt.active ? 'Before sealing' : 'Last observed preseal work'}
+          </dt>
           <dd className="text-right text-text-secondary">
             {attempt.last_progress_micros == null ? (
               'awaiting first observed preseal work'

From 36174dc74f0c3a75f62c409e1e5bed425448f579 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 12:27:16 -0800
Subject: [PATCH 65/80] test(dashboard): restore async freshness test callback

Refs #4508
---
 dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index 829b3354d4a..a109209c5b8 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -193,7 +193,7 @@ describe('Code index freshness', () => {
     expect(screen.queryByText(/no observed preseal work for/)).toBeNull();
   });
 
-  it('uses genuine preseal and native writer clocks for no-work warnings', async () {
+  it('uses genuine preseal and native writer clocks for no-work warnings', async () => {
     renderFreshness('loading', {
       worktrees: [{
         ...worktree(),

From e514005ffe2a7053b42fa19f7b326fe62c1d0cfe Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 12:45:07 -0800
Subject: [PATCH 66/80] fix(code-index): retire preseal progress at reconcile
 exit

Refs #4508
---
 .../code_index_scheduler/attempt_progress.rs  | 81 ++++++++++++++++++-
 1 file changed, 78 insertions(+), 3 deletions(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
index a7eb45b6dcb..1034779032d 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
@@ -120,13 +120,28 @@ impl CodeIndexBuildAttemptSlotStateV1 {
         }
     }
 
+    /// A reconcile's real work may remain visible during its own durable
+    /// publication handoff. Once its guard exits, the live status slot must
+    /// not reattribute that observation to a later source wake. The attempt
+    /// identity fence protects a newer guard from an older guard's drop.
+    fn retire(&mut self, identity: CodeIndexBuildAttemptIdentityV1) {
+        if self.snapshot.as_ref().is_some_and(|snapshot| {
+            snapshot.daemon_incarnation == identity.daemon_incarnation
+                && snapshot.producer_incarnation == identity.producer_incarnation
+                && snapshot.attempt_sequence == identity.sequence
+        }) {
+            self.snapshot = None;
+        }
+    }
+
     pub(crate) fn snapshot(&self) -> Option<CodeIndexPresealAttemptProgressV1> {
         self.snapshot.clone()
     }
 }
 
 /// A stale or unwinding reconcile can never publish into its successor.
-/// Dropping this guard on every cancellation, retry, panic or return fences it.
+/// Dropping this guard on cancellation, retry, panic or return fences it and
+/// retires its reading; only a still-owned durable handoff retains the counts.
 pub(super) struct CodeIndexPresealAttemptGuardV1 {
     slot: CodeIndexBuildAttemptSlotV1,
     identity: CodeIndexBuildAttemptIdentityV1,
@@ -173,7 +188,7 @@ impl Drop for CodeIndexPresealAttemptGuardV1 {
         self.slot
             .write()
             .unwrap_or_else(PoisonError::into_inner)
-            .finish(self.identity);
+            .retire(self.identity);
     }
 }
 
@@ -207,8 +222,68 @@ mod tests {
         control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 1, None));
         control.finish_preseal_observation();
         assert_eq!(slot.read().unwrap().snapshot().unwrap(), after);
+        // The completed reconcile no longer owns this progress. A later
+        // source hint must not make its old counts appear to be new work.
         drop(attempt);
-        assert_eq!(slot.read().unwrap().snapshot().unwrap(), after);
+        assert!(slot.read().unwrap().snapshot().is_none());
+    }
+
+
+    #[test]
+    fn completed_handoff_does_not_reappear_during_a_later_source_wake() {
+        let slot = Arc::new(RwLock::new(CodeIndexBuildAttemptSlotStateV1::default()));
+        let first = CodeIndexPresealAttemptGuardV1::begin(Arc::clone(&slot), 7, 11);
+        first.observer()(work(CodeIndexPresealWorkPhaseV1::Resolution, 7, None));
+        // A real preseal transition requires capture then parse before
+        // resolution. The first observed work must be an actual capture.
+        let initial = slot.read().unwrap().snapshot().unwrap();
+        assert_eq!(initial.completed_items, 0);
+        assert!(initial.last_progress_micros.is_none());
+
+        first.observer()(work(CodeIndexPresealWorkPhaseV1::Capture, 3, Some(3)));
+        first.observer()(work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 3, Some(3)));
+        first.observer()(work(CodeIndexPresealWorkPhaseV1::Resolution, 7, None));
+        first.finisher()();
+        let during_handoff = slot.read().unwrap().snapshot().unwrap();
+        assert!(!during_handoff.active);
+        assert_eq!(during_handoff.completed_items, 7);
+        assert!(during_handoff.last_progress_micros.is_some());
+
+        // Source admission may begin before the next producer guard. This
+        // slot is the authoritative value copied into a freshness response.
+        drop(first);
+        assert!(slot.read().unwrap().snapshot().is_none());
+
+        let next = CodeIndexPresealAttemptGuardV1::begin(Arc::clone(&slot), 7, 11);
+        let admitted = slot.read().unwrap().snapshot().unwrap();
+        assert!(admitted.active);
+        assert_eq!(admitted.completed_items, 0);
+        assert!(admitted.last_progress_micros.is_none());
+        next.observer()(work(CodeIndexPresealWorkPhaseV1::Capture, 2, Some(4)));
+        let actual = slot.read().unwrap().snapshot().unwrap();
+        assert_eq!(actual.completed_items, 2);
+        assert!(actual.last_progress_micros.is_some());
+        assert!(actual.attempt_sequence > during_handoff.attempt_sequence);
+    }
+
+    #[test]
+    fn out_of_order_guard_drop_never_erases_a_newer_attempt() {
+        let slot = Arc::new(RwLock::new(CodeIndexBuildAttemptSlotStateV1::default()));
+        let first = CodeIndexPresealAttemptGuardV1::begin(Arc::clone(&slot), 3, 5);
+        let old_observer = first.observer();
+        old_observer(work(CodeIndexPresealWorkPhaseV1::Capture, 4, Some(4)));
+        first.finisher()();
+
+        let second = CodeIndexPresealAttemptGuardV1::begin(Arc::clone(&slot), 3, 5);
+        second.observer()(work(CodeIndexPresealWorkPhaseV1::Capture, 2, Some(6)));
+        let current = slot.read().unwrap().snapshot().unwrap();
+        assert!(current.active);
+        drop(first);
+        old_observer(work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 2, Some(4)));
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), current);
+
+        drop(second);
+        assert!(slot.read().unwrap().snapshot().is_none());
     }
 
     fn work(

From 15743f70763f8b679a938a800de2bb0d1139d194 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 12:52:19 -0800
Subject: [PATCH 67/80] fix(code-index): satisfy Bazel rustfmt for attempt
 lifecycle test

---
 .../src/code_index_scheduler/attempt_progress.rs                 | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
index 1034779032d..52ff01c6cf9 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
@@ -228,7 +228,6 @@ mod tests {
         assert!(slot.read().unwrap().snapshot().is_none());
     }
 
-
     #[test]
     fn completed_handoff_does_not_reappear_during_a_later_source_wake() {
         let slot = Arc::new(RwLock::new(CodeIndexBuildAttemptSlotStateV1::default()));

From fc114119e82443c20945f25ea70e17164676b6d3 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 14:27:06 -0800
Subject: [PATCH 68/80] test(dashboard): await HTTP render with Vitest fake
 timers

Refs #4508
---
 dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
index a109209c5b8..6a995faa636 100644
--- a/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
+++ b/dashboard/src/workspaces/code/IndexFreshness.dom.test.tsx
@@ -821,7 +821,11 @@ describe('Code index freshness', () => {
     await advanceTimers(1);
     await advanceTimers(0);
     expect(fetch).toHaveBeenCalledTimes(2);
-    expect(await screen.findByText('capture · 8 / 20 items')).toBeTruthy();
+    // Vitest's waitFor advances fake timers; Testing Library findByText stalls
+    // when the HTTP response is still decoding under the virtual clock.
+    await vi.waitFor(() => {
+      expect(screen.getByText('capture · 8 / 20 items')).toBeTruthy();
+    });
     await advanceTimers(1_001);
     await advanceTimers(0);
     expect(fetch).toHaveBeenCalledTimes(3);

From a151169fcc516a99e8dccda93182972897c11007 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 15:21:11 -0800
Subject: [PATCH 69/80] fix(code-index): account for concurrent preseal and
 text work

---
 crates/tracedecay-cli/src/commands/index.rs | 137 +++++++++++++++++---
 1 file changed, 118 insertions(+), 19 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 2b34cc788a4..71fbf9f8676 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -7,7 +7,8 @@ use tracedecay_project::project::TraceDecay;
 use tracedecay_contracts::code_index_freshness::{
     CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
     CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexBuildProgressV1,
-    CodeIndexNativeGraphPhaseV1, CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1,
+    CodeIndexNativeGraphPhaseV1, CodeIndexPresealAttemptProgressV1,
+    CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1,
     CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::graph_tool::GraphToolResultV1;
@@ -405,8 +406,25 @@ where
                 ),
             ));
         }
-        if progress_window.observe(
-            FirstGenerationWorkMarker::of(worktree.as_deref().ok()),
+        let worktree_read = worktree.as_deref().ok();
+        let marker = FirstGenerationWorkMarker::of(worktree_read);
+        // A retained text bulk commit and a successor's live capture can
+        // advance independently. A frozen text cursor cannot hide real
+        // preseal work, nor can a quiet preseal hide actual durable commits.
+        let concurrent_preseal = if matches!(
+            marker.as_ref(),
+            Some(FirstGenerationWorkMarker::CommittedText { .. })
+        ) {
+            worktree_read
+                .and_then(|worktree| worktree.preseal_attempt.as_ref())
+                .filter(|attempt| attempt.active)
+                .map(FirstGenerationWorkMarker::preseal)
+        } else {
+            None
+        };
+        if progress_window.observe_with_concurrent_preseal(
+            marker,
+            concurrent_preseal,
             Instant::now(),
         ) {
             return Err(first_generation_wait_refusal(
@@ -566,17 +584,7 @@ impl FirstGenerationWorkMarker {
         // while the successor actually captures or parses. Those old phase
         // projections must not hide its independently owned attempt work.
         if let Some(attempt) = worktree.preseal_attempt.as_ref().filter(|a| a.active) {
-            return Some(Self::Preseal {
-                owner: (
-                    attempt.daemon_incarnation,
-                    attempt.producer_incarnation,
-                    attempt.attempt_sequence,
-                ),
-                epoch: attempt.progress_epoch,
-                phase: attempt.phase,
-                completed: attempt.completed_items,
-                last_work_micros: attempt.last_progress_micros,
-            });
+            return Some(Self::preseal(attempt));
         }
         // Absent a live attempt, uninstrumented post-text phases remain
         // unknown, not evidence that a writer has stalled.
@@ -587,6 +595,20 @@ impl FirstGenerationWorkMarker {
             .map(Self::text)
     }
 
+    fn preseal(attempt: &CodeIndexPresealAttemptProgressV1) -> Self {
+        Self::Preseal {
+            owner: (
+                attempt.daemon_incarnation,
+                attempt.producer_incarnation,
+                attempt.attempt_sequence,
+            ),
+            epoch: attempt.progress_epoch,
+            phase: attempt.phase,
+            completed: attempt.completed_items,
+            last_work_micros: attempt.last_progress_micros,
+        }
+    }
+
     fn native_graph(
         graph: &tracedecay_contracts::code_index_freshness::CodeIndexNativeGraphProgressV1,
     ) -> Self {
@@ -769,13 +791,28 @@ impl FirstGenerationProgressWindow {
     }
 
     fn observe(&mut self, marker: Option<FirstGenerationWorkMarker>, now: Instant) -> bool {
-        let Some(marker) = marker else {
+        self.observe_with_concurrent_preseal(marker, None, now)
+    }
+
+    fn observe_with_concurrent_preseal(
+        &mut self,
+        marker: Option<FirstGenerationWorkMarker>,
+        concurrent_preseal: Option<FirstGenerationWorkMarker>,
+        now: Instant,
+    ) -> bool {
+        if marker.is_none() && concurrent_preseal.is_none() {
             // Uninstrumented work is unknown, not stalled. Keep watermarks
             // so returning to an old report cannot fabricate new work.
             self.unchanged_since = None;
             return false;
-        };
-        let advanced = self.record(marker);
+        }
+        let mut advanced = false;
+        if let Some(marker) = marker {
+            advanced |= self.record(marker);
+        }
+        if let Some(preseal) = concurrent_preseal {
+            advanced |= self.record(preseal);
+        }
         if advanced || self.unchanged_since.is_none() {
             self.unchanged_since = Some(now);
             return false;
@@ -786,10 +823,12 @@ impl FirstGenerationProgressWindow {
 
     fn record(&mut self, marker: FirstGenerationWorkMarker) -> bool {
         let owner = marker.owner();
-        if self.owner.is_some_and(|current| owner < current) {
+        // Independently owned writers on one daemon may overlap. Fence an
+        // older daemon globally; each marker kind fences its own producer.
+        if self.owner.is_some_and(|current| owner.0 < current.0) {
             return false;
         }
-        self.owner = Some(owner);
+        self.owner = Some(self.owner.map_or(owner, |current| current.max(owner)));
         let previous = match &marker {
             FirstGenerationWorkMarker::Preseal { .. } => &mut self.preseal,
             FirstGenerationWorkMarker::NativeGraph { .. } => &mut self.native_graph,
@@ -1262,6 +1301,66 @@ mod daemon_precondition_tests {
         ));
     }
 
+    #[tokio::test(flavor = "current_thread")]
+    async fn concurrent_capture_and_text_receipts_each_renew_real_wait_progress() {
+        let mut capturing = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+        capturing.latest_generation_id = Some("generation.prior.sealed".to_owned());
+        let mut retained = progress(40, None);
+        retained.daemon_incarnation = 3;
+        retained.producer_incarnation = 4;
+        retained.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        capturing.progress = Some(retained);
+
+        let mut parsing = capturing.clone();
+        parsing.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::ParseEvidence, 5, 1, 2).preseal_attempt;
+
+        let mut committed = parsing.clone();
+        let text = committed.progress.as_mut().unwrap();
+        text.progress_epoch += 1;
+        text.committed_pages += 1;
+
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(capturing)),
+                status(timed_out(), warming(parsing)),
+                status(timed_out(), warming(committed)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert!(
+            result.is_ok(),
+            "a frozen text cursor must not hide new parsing, or vice versa: {result:?}"
+        );
+        assert_eq!(reads, 4);
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn duplicate_concurrent_writer_reports_still_refuse_before_ready() {
+        let mut capturing = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+        capturing.latest_generation_id = Some("generation.prior.sealed".to_owned());
+        let mut retained = progress(40, None);
+        retained.daemon_incarnation = 3;
+        retained.producer_incarnation = 4;
+        retained.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        capturing.progress = Some(retained);
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(capturing.clone())),
+                status(timed_out(), warming(capturing)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2, "neither producer advanced before the stall");
+        let (code, reason) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(reason.contains("no observed capture, parse, text, or native graph work"));
+    }
+
     #[test]
     fn retired_preseal_does_not_stall_slow_durable_publication() {
         let now = Instant::now();

From 8635be2fd7778d060be6c69365b0baf94d88bbe8 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 15:29:05 -0800
Subject: [PATCH 70/80] fix(cli): count successor work alongside active graph
 writes

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 53 ++++++++++++++++++++-
 1 file changed, 52 insertions(+), 1 deletion(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 71fbf9f8676..273bf18d74c 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -413,7 +413,10 @@ where
         // preseal work, nor can a quiet preseal hide actual durable commits.
         let concurrent_preseal = if matches!(
             marker.as_ref(),
-            Some(FirstGenerationWorkMarker::CommittedText { .. })
+            Some(
+                FirstGenerationWorkMarker::CommittedText { .. }
+                    | FirstGenerationWorkMarker::NativeGraph { .. }
+            )
         ) {
             worktree_read
                 .and_then(|worktree| worktree.preseal_attempt.as_ref())
@@ -1361,6 +1364,54 @@ mod daemon_precondition_tests {
         assert!(reason.contains("no observed capture, parse, text, or native graph work"));
     }
 
+    #[tokio::test(flavor = "current_thread")]
+    async fn successor_capture_advances_while_prior_native_writer_is_quiet() {
+        // The previously sealed graph may still be encoding when a new
+        // source pass begins. Both are independently owned, and an unchanged
+        // native counter must not conceal genuine successor parse work.
+        let mut capturing = native_graph_without_writes();
+        capturing.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2).preseal_attempt;
+        let mut parsing = capturing.clone();
+        parsing.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::ParseEvidence, 5, 1, 2).preseal_attempt;
+
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(capturing)),
+                status(timed_out(), warming(parsing)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert!(
+            result.is_ok(),
+            "real successor parsing must renew the wait despite a silent native writer: {result:?}"
+        );
+        assert_eq!(reads, 3, "only the reached receipt ends a progressing wait");
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn duplicate_graph_and_successor_attempts_cannot_mask_a_stall() {
+        let mut stalled = native_graph_without_writes();
+        stalled.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2).preseal_attempt;
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(stalled.clone())),
+                status(timed_out(), warming(stalled)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2, "neither independent writer advanced");
+        let (code, reason) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(reason.contains("no observed capture, parse, text, or native graph work"));
+    }
+
     #[test]
     fn retired_preseal_does_not_stall_slow_durable_publication() {
         let now = Instant::now();

From 2ad500048c4b62c03b4fd8e7c727d06e60712d05 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 16:28:15 -0800
Subject: [PATCH 71/80] fix(code-index): observe preseal work before guard
 retirement

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs   | 16 ++--
 .../tests/code_index_scheduler/reconcile.rs   | 79 ++++++++++++-------
 2 files changed, 59 insertions(+), 36 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 273bf18d74c..f3dd5d2af00 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -8,8 +8,7 @@ use tracedecay_contracts::code_index_freshness::{
     CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
     CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexBuildProgressV1,
     CodeIndexNativeGraphPhaseV1, CodeIndexPresealAttemptProgressV1,
-    CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1,
-    CodeIndexWorktreeFreshnessV1,
+    CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::graph_tool::GraphToolResultV1;
 use tracedecay_contracts::retrieval::{
@@ -425,11 +424,14 @@ where
         } else {
             None
         };
-        if progress_window.observe_with_concurrent_preseal(
-            marker,
-            concurrent_preseal,
-            Instant::now(),
-        ) {
+        let now = Instant::now();
+        let stalled = match concurrent_preseal {
+            Some(preseal) => {
+                progress_window.observe_with_concurrent_preseal(marker, Some(preseal), now)
+            }
+            None => progress_window.observe(marker, now),
+        };
+        if stalled {
             return Err(first_generation_wait_refusal(
                 CODE_INDEX_READINESS_WAIT_TIMED_OUT,
                 format!(
diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
index 61395cd0f3b..42b4918f2e5 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
@@ -124,33 +124,40 @@ fn cold_build_reports_actual_preseal_capture_and_parser_evidence() {
         slot.read().unwrap().snapshot().is_none(),
         "no fabricated cold progress"
     );
+
     published(
         owner
-            .reconcile_now()
-            .expect("real cold capture and publication"),
-    );
-    let observed = slot
-        .read()
-        .unwrap()
-        .snapshot()
-        .expect("pre-seal observation");
-    assert!(!observed.active, "a finished attempt cannot appear stalled");
-    assert_eq!(
-        observed.phase,
-        tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Resolution
-    );
-    assert!(
-        observed.completed_items >= 2,
-        "real cold resolution must process both files"
-    );
-    assert_eq!(
-        observed.total_items, None,
-        "heterogeneous resolution work has no denominator"
+            .reconcile_now_with_capture(|scheduler, control| {
+                // Read the actual production slot while its guard is alive.
+                // A completed pass must retire this live snapshot; observing
+                // only after reconcile returns would misattribute old work.
+                let captured = scheduler.capture_authoritative_snapshot(Some(control))?;
+                let observed = slot
+                    .read()
+                    .unwrap()
+                    .snapshot()
+                    .expect("real cold capture observation");
+                assert!(observed.active, "capture still owns its progress");
+                assert_eq!(
+                    observed.phase,
+                    tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Capture
+                );
+                assert!(
+                    observed.completed_items >= 2,
+                    "real cold capture must report both files"
+                );
+                assert!(observed.last_progress_micros.is_some_and(|at| at > 0));
+                assert!(
+                    observed.progress_epoch >= 3,
+                    "attempt admission and two real captured-file callbacks"
+                );
+                Ok(captured)
+            })
+            .expect("real cold capture, parse, resolution, and publication"),
     );
-    assert!(observed.last_progress_micros.is_some_and(|at| at > 0));
     assert!(
-        observed.progress_epoch >= 7,
-        "two captures, two parser-backed files, two resolution facts and attempt start"
+        slot.read().unwrap().snapshot().is_none(),
+        "a completed first generation cannot leave preseal work for a future source wake"
     );
 }
 
@@ -191,14 +198,28 @@ fn retained_restart_capture_publishes_and_fences_preseal_attempt() {
     assert!(observed.progress_epoch > 1);
     assert!(observed.last_progress_micros.is_some_and(|at| at > 0));
     drop(capture);
-    let finished = slot.read().unwrap().snapshot().expect("finished attempt");
     assert!(
-        !finished.active,
-        "dropping the retained owner fences callbacks"
+        slot.read().unwrap().snapshot().is_none(),
+        "the completed retained owner must retire its scoped work"
+    );
+    // A real subsequent retained capture must start a new attempt rather than
+    // inheriting the previous capture's work timestamp or sequence.
+    let next = reopened
+        .capture_retained_reconcile_attempt()
+        .expect("second retained capture succeeds")
+        .expect("second retained capture has a live owner");
+    let resumed = slot.read().unwrap().snapshot().expect("second real capture");
+    assert!(resumed.active);
+    assert_eq!(
+        resumed.phase,
+        tracedecay_code_index::production::CodeIndexPresealWorkPhaseV1::Capture
     );
-    assert_eq!(finished.completed_items, observed.completed_items);
-    assert_eq!(finished.last_progress_micros, observed.last_progress_micros);
-    assert!(finished.progress_epoch > observed.progress_epoch);
+    assert!(resumed.attempt_sequence > observed.attempt_sequence);
+    assert!(resumed.progress_epoch > observed.progress_epoch);
+    assert!(resumed.completed_items >= 2);
+    assert!(resumed.last_progress_micros.is_some_and(|at| at > 0));
+    drop(next);
+    assert!(slot.read().unwrap().snapshot().is_none());
 }
 
 #[test]

From 76f083f6e324e77cd4d49fe58abf4113849bbf88 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 17:26:02 -0800
Subject: [PATCH 72/80] style(code-index): format retained capture assertion

Refs #4508
---
 .../tests/code_index_scheduler/reconcile.rs                 | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
index 42b4918f2e5..cd35aeeef0f 100644
--- a/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
+++ b/crates/tracedecay-code-index-runtime/tests/code_index_scheduler/reconcile.rs
@@ -208,7 +208,11 @@ fn retained_restart_capture_publishes_and_fences_preseal_attempt() {
         .capture_retained_reconcile_attempt()
         .expect("second retained capture succeeds")
         .expect("second retained capture has a live owner");
-    let resumed = slot.read().unwrap().snapshot().expect("second real capture");
+    let resumed = slot
+        .read()
+        .unwrap()
+        .snapshot()
+        .expect("second real capture");
     assert!(resumed.active);
     assert_eq!(
         resumed.phase,

From 29ac2e51e1d088a5352f88fe4eafbb1cea30bd79 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 17:42:42 -0800
Subject: [PATCH 73/80] fix(cli): preserve successor progress through old text
 blocks

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 61 +++++++++++++++++++--
 1 file changed, 57 insertions(+), 4 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index f3dd5d2af00..4850ea7c146 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -479,10 +479,7 @@ impl FirstGenerationStall {
                 let retained_text = active_preseal
                     && worktree.latest_generation_id.as_deref()
                         == Some(progress.generation_id.as_str())
-                    && !matches!(
-                        progress.phase,
-                        CodeIndexBuildPhaseV1::SourceScan | CodeIndexBuildPhaseV1::BulkCommit
-                    );
+                    && progress.phase != CodeIndexBuildPhaseV1::SourceScan;
                 let different_graph =
                     active_graph.is_some_and(|graph| graph.generation_id != progress.generation_id);
                 if !retained_text && !different_graph {
@@ -2371,6 +2368,62 @@ mod daemon_precondition_tests {
         assert_eq!(reads, 3, "only the actual ready receipt ends a moving wait");
     }
 
+    #[tokio::test(flavor = "current_thread")]
+    async fn blocked_retained_bulk_commit_cannot_hide_successor_parse_work() {
+        // A new preseal attempt has not sealed an immutable generation yet.
+        // An older generation's blocked bulk writer must not suppress this
+        // separately owned successor's real capture and parse observations.
+        let mut capture = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+        capture.latest_generation_id = Some("generation.v1.first".to_owned());
+        let mut old_text = progress(40, Some(CodeIndexBuildBlockedReasonV1::ResidentMemory));
+        old_text.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        capture.progress = Some(old_text);
+        assert_eq!(super::FirstGenerationStall::of(Ok(&capture)), None);
+
+        let mut parsed = capture.clone();
+        parsed.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::ParseEvidence, 5, 1, 2).preseal_attempt;
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(capture)),
+                status(timed_out(), warming(parsed)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert!(
+            result.is_ok(),
+            "old blocked bulk commits must not refuse advancing successor work: {result:?}"
+        );
+        assert_eq!(reads, 3, "only a real ready receipt ends the wait");
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn blocked_retained_bulk_commit_does_not_hide_a_frozen_successor() {
+        let mut capture = attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2);
+        capture.latest_generation_id = Some("generation.v1.first".to_owned());
+        let mut old_text = progress(40, Some(CodeIndexBuildBlockedReasonV1::ResidentMemory));
+        old_text.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        capture.progress = Some(old_text);
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(capture.clone())),
+                status(timed_out(), warming(capture)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2, "neither retained text nor new capture advanced");
+        let (code, message) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(
+            message.contains("no observed capture, parse, text, or native graph work"),
+            "{message}"
+        );
+    }
+
     /// A stall shorter than the window is ridden out: the window restarts
     /// once the daemon reports work again.
     #[tokio::test(flavor = "current_thread")]

From 4af29660a8e5a21b2dffae535749faebcab086b7 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 18:04:25 -0800
Subject: [PATCH 74/80] test(code-index): cover cancelled and unwinding preseal
 owners

Exercise real task abort and panic unwinding of the preseal guard,
including inactive publication handoff, late callbacks and same-producer
retry isolation. Keep imports explicit and retain all existing tests.

Refs #4508
---
 .../code_index_scheduler/attempt_progress.rs  | 105 +++++++++++++++++-
 1 file changed, 103 insertions(+), 2 deletions(-)

diff --git a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
index 52ff01c6cf9..85f73ad95ac 100644
--- a/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
+++ b/crates/tracedecay-code-index-runtime/src/code_index_scheduler/attempt_progress.rs
@@ -194,9 +194,16 @@ impl Drop for CodeIndexPresealAttemptGuardV1 {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::future::pending;
+    use std::panic::catch_unwind;
+    use std::sync::{Arc, RwLock};
+
+    use super::{CodeIndexBuildAttemptSlotStateV1, CodeIndexPresealAttemptGuardV1};
+    use tokio::sync::oneshot;
     use tracedecay_application::code_index::DaemonCodeIndexControlV1;
-    use tracedecay_code_index::production::CodeIndexExecutionControlV1;
+    use tracedecay_code_index::production::{
+        CodeIndexExecutionControlV1, CodeIndexPresealWorkPhaseV1, CodeIndexPresealWorkV1,
+    };
 
     #[test]
     fn durable_publication_handoff_retires_attempt_without_forging_work() {
@@ -285,6 +292,100 @@ mod tests {
         assert!(slot.read().unwrap().snapshot().is_none());
     }
 
+    #[tokio::test]
+    async fn aborting_preseal_task_retires_work_and_fences_late_callbacks() {
+        let slot = Arc::new(RwLock::new(CodeIndexBuildAttemptSlotStateV1::default()));
+        let attempt = CodeIndexPresealAttemptGuardV1::begin(Arc::clone(&slot), 7, 11);
+        let control = DaemonCodeIndexControlV1::default()
+            .with_preseal_observer(attempt.observer())
+            .with_preseal_finisher(attempt.finisher());
+        control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::Capture, 3, Some(5)));
+        let captured = slot.read().unwrap().snapshot().unwrap();
+        assert!(captured.active);
+        assert_eq!(captured.completed_items, 3);
+        assert!(captured.last_progress_micros.is_some());
+
+        // Synchronize actual task ownership without a sleep or a fake clock.
+        // Keep the guard across suspension so abort must run its destructor.
+        let (started_tx, started_rx) = oneshot::channel();
+        let task = tokio::spawn(async move {
+            assert!(started_tx.send(()).is_ok());
+            pending::<()>().await;
+            drop(attempt);
+        });
+        started_rx.await.unwrap();
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), captured);
+        task.abort();
+        assert!(task.await.unwrap_err().is_cancelled());
+        assert!(slot.read().unwrap().snapshot().is_none());
+
+        // The cancelled worker's callbacks can outlive its guard. They must
+        // neither resurrect a reading nor write into a same-producer retry.
+        control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::Capture, 4, Some(5)));
+        control.finish_preseal_observation();
+        assert!(slot.read().unwrap().snapshot().is_none());
+        let retry = CodeIndexPresealAttemptGuardV1::begin(Arc::clone(&slot), 7, 11);
+        let admitted = slot.read().unwrap().snapshot().unwrap();
+        assert!(admitted.active);
+        assert!(admitted.attempt_sequence > captured.attempt_sequence);
+        assert!(admitted.progress_epoch > captured.progress_epoch);
+        assert_eq!(admitted.completed_items, 0);
+        assert!(admitted.last_progress_micros.is_none());
+        control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::Capture, 5, Some(5)));
+        control.finish_preseal_observation();
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), admitted);
+
+        retry.observer()(work(CodeIndexPresealWorkPhaseV1::Capture, 1, Some(2)));
+        let resumed = slot.read().unwrap().snapshot().unwrap();
+        assert!(resumed.active);
+        assert_eq!(resumed.attempt_sequence, admitted.attempt_sequence);
+        assert_eq!(resumed.completed_items, 1);
+        assert!(resumed.last_progress_micros.is_some());
+        assert!(resumed.progress_epoch > admitted.progress_epoch);
+        drop(retry);
+        assert!(slot.read().unwrap().snapshot().is_none());
+    }
+
+    #[test]
+    fn unwinding_publication_handoff_retires_inactive_owned_progress() {
+        let slot = Arc::new(RwLock::new(CodeIndexBuildAttemptSlotStateV1::default()));
+        let attempt = CodeIndexPresealAttemptGuardV1::begin(Arc::clone(&slot), 7, 11);
+        let control = DaemonCodeIndexControlV1::default()
+            .with_preseal_observer(attempt.observer())
+            .with_preseal_finisher(attempt.finisher());
+        control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::Capture, 3, Some(3)));
+        control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::ParseEvidence, 2, Some(2)));
+        let before = slot.read().unwrap().snapshot().unwrap();
+        control.finish_preseal_observation();
+        let handoff = slot.read().unwrap().snapshot().unwrap();
+        assert!(!handoff.active);
+        assert_eq!(handoff.completed_items, before.completed_items);
+        assert_eq!(handoff.last_progress_micros, before.last_progress_micros);
+        assert!(handoff.progress_epoch > before.progress_epoch);
+
+        let outcome = catch_unwind(move || {
+            let _owned_attempt = attempt;
+            panic!("interrupt publication while the preseal guard still owns its handoff");
+        });
+        assert!(outcome.is_err());
+        assert!(slot.read().unwrap().snapshot().is_none());
+        control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::Resolution, 1, None));
+        control.finish_preseal_observation();
+        assert!(slot.read().unwrap().snapshot().is_none());
+
+        let next = CodeIndexPresealAttemptGuardV1::begin(Arc::clone(&slot), 7, 11);
+        let admitted = slot.read().unwrap().snapshot().unwrap();
+        assert!(admitted.active);
+        assert!(admitted.attempt_sequence > handoff.attempt_sequence);
+        assert_eq!(admitted.completed_items, 0);
+        assert!(admitted.last_progress_micros.is_none());
+        control.observed_preseal_work(work(CodeIndexPresealWorkPhaseV1::Capture, 4, Some(4)));
+        control.finish_preseal_observation();
+        assert_eq!(slot.read().unwrap().snapshot().unwrap(), admitted);
+        drop(next);
+        assert!(slot.read().unwrap().snapshot().is_none());
+    }
+
     fn work(
         phase: CodeIndexPresealWorkPhaseV1,
         n: u64,

From b19884d9a1401b07cfdc7747c0b0bb80cd065832 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 18:26:47 -0800
Subject: [PATCH 75/80] fix(cli): track successor capture during final native
 graph writes

Do not let a prior completed native row stream or verified segment hide
a separate live preseal attempt. Preserve unknown final-container timing
without treating elapsed status reads as production work.

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 100 +++++++++++++++++++-
 1 file changed, 99 insertions(+), 1 deletion(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 4850ea7c146..a07ccbfa487 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -555,7 +555,14 @@ impl FirstGenerationWorkMarker {
             if encoding_finished
                 || graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified)
             {
-                return None;
+                // The final Grafeo container write has no row callbacks, but
+                // a separately owned successor can still capture or parse.
+                // Keep its observed work visible without timing the final write.
+                return worktree
+                    .preseal_attempt
+                    .as_ref()
+                    .filter(|attempt| attempt.active)
+                    .map(Self::preseal);
             }
             // Starting the native attempt proves only that there is an owner,
             // not that it has written any rows. A silent initial window must
@@ -1411,6 +1418,97 @@ mod daemon_precondition_tests {
         assert!(reason.contains("no observed capture, parse, text, or native graph work"));
     }
 
+    fn native_graph_after_all_encoding() -> CodeIndexWorktreeFreshnessV1 {
+        let mut worktree = native_graph_without_writes();
+        let graph = worktree.native_graph_progress.as_mut().unwrap();
+        graph.phase = Some(CodeIndexNativeGraphPhaseV1::CompactEncoding);
+        graph.encoded_entities = 3;
+        graph.total_entities = Some(3);
+        graph.encoded_relations = 2;
+        graph.total_relations = Some(2);
+        graph.progress_epoch = 5;
+        graph.last_progress_micros = Some(500);
+        worktree
+    }
+
+    #[test]
+    fn final_graph_write_does_not_hide_an_independent_source_attempt() {
+        let finished = native_graph_after_all_encoding();
+        // A final compact write has no observable per-row milestones.
+        assert_eq!(super::FirstGenerationWorkMarker::of(Some(&finished)), None);
+
+        let mut successor = finished.clone();
+        successor.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2).preseal_attempt;
+        assert!(matches!(
+            super::FirstGenerationWorkMarker::of(Some(&successor)),
+            Some(super::FirstGenerationWorkMarker::Preseal {
+                owner: (3, 5, 2),
+                epoch: 4,
+                completed: 7,
+                last_work_micros: Some(700),
+                ..
+            })
+        ));
+
+        // A digest-verified native completion also must not hide the separate
+        // source owner. Retiring that owner restores the unknown final phase.
+        successor.native_graph_progress.as_mut().unwrap().phase =
+            Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified);
+        assert!(matches!(
+            super::FirstGenerationWorkMarker::of(Some(&successor)),
+            Some(super::FirstGenerationWorkMarker::Preseal { .. })
+        ));
+        successor.preseal_attempt.as_mut().unwrap().active = false;
+        assert_eq!(super::FirstGenerationWorkMarker::of(Some(&successor)), None);
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn completed_native_encoding_cannot_hide_advancing_successor_capture() {
+        let mut capture = native_graph_after_all_encoding();
+        capture.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2).preseal_attempt;
+        let mut parse = capture.clone();
+        parse.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::ParseEvidence, 5, 1, 2).preseal_attempt;
+
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(capture)),
+                status(timed_out(), warming(parse)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert!(
+            result.is_ok(),
+            "real capture and parse must outlive the old final graph write: {result:?}"
+        );
+        assert_eq!(reads, 3);
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn completed_native_encoding_cannot_hide_a_frozen_successor() {
+        let mut capture = native_graph_after_all_encoding();
+        capture.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2).preseal_attempt;
+
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(capture.clone())),
+                status(timed_out(), warming(capture)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2, "a frozen source must refuse before later Ready");
+        let (code, reason) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(reason.contains("no observed capture, parse, text, or native graph work"));
+    }
+
     #[test]
     fn retired_preseal_does_not_stall_slow_durable_publication() {
         let now = Instant::now();

From 10dc2fc7ce91326169dbaf40b69a00a593bde798 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 19:26:17 -0800
Subject: [PATCH 76/80] fix(cli): preserve concurrent lexical commits during
 native work

Record genuine retained lexical page receipts alongside native graph
encoding and successor preseal work. Frozen clocks and epoch-only updates
remain stall-observable; leave final compact verification uninstrumented.

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 153 ++++++++++++++++++--
 1 file changed, 144 insertions(+), 9 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index a07ccbfa487..8f0c69c4b79 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -424,12 +424,34 @@ where
         } else {
             None
         };
+        // A separately owned retained lexical writer can commit pages while
+        // native graph encoding or successor source capture is quiet. Read
+        // its actual bulk receipts alongside the primary writer instead of
+        // letting a frozen native/preseal marker hide completed text work.
+        let concurrent_text = if matches!(
+            marker.as_ref(),
+            Some(
+                FirstGenerationWorkMarker::Preseal { .. }
+                    | FirstGenerationWorkMarker::NativeGraph { .. }
+            )
+        ) {
+            worktree_read
+                .and_then(|worktree| worktree.progress.as_ref())
+                .filter(|progress| progress.phase == CodeIndexBuildPhaseV1::BulkCommit)
+                .map(FirstGenerationWorkMarker::text)
+        } else {
+            None
+        };
         let now = Instant::now();
-        let stalled = match concurrent_preseal {
-            Some(preseal) => {
-                progress_window.observe_with_concurrent_preseal(marker, Some(preseal), now)
-            }
-            None => progress_window.observe(marker, now),
+        let stalled = if concurrent_preseal.is_some() || concurrent_text.is_some() {
+            progress_window.observe_with_concurrent_writers(
+                marker,
+                concurrent_preseal,
+                concurrent_text,
+                now,
+            )
+        } else {
+            progress_window.observe(marker, now)
         };
         if stalled {
             return Err(first_generation_wait_refusal(
@@ -776,7 +798,7 @@ impl FirstGenerationWorkMarker {
     }
 }
 
-/// Maintain independent watermarks for pre-seal and text work. Polling,
+/// Maintain independent preseal, native-graph and text watermarks. Polling,
 /// status changes and empty retries cannot renew an observed silence window.
 struct FirstGenerationProgressWindow {
     preseal: Option<FirstGenerationWorkMarker>,
@@ -800,16 +822,17 @@ impl FirstGenerationProgressWindow {
     }
 
     fn observe(&mut self, marker: Option<FirstGenerationWorkMarker>, now: Instant) -> bool {
-        self.observe_with_concurrent_preseal(marker, None, now)
+        self.observe_with_concurrent_writers(marker, None, None, now)
     }
 
-    fn observe_with_concurrent_preseal(
+    fn observe_with_concurrent_writers(
         &mut self,
         marker: Option<FirstGenerationWorkMarker>,
         concurrent_preseal: Option<FirstGenerationWorkMarker>,
+        concurrent_text: Option<FirstGenerationWorkMarker>,
         now: Instant,
     ) -> bool {
-        if marker.is_none() && concurrent_preseal.is_none() {
+        if marker.is_none() && concurrent_preseal.is_none() && concurrent_text.is_none() {
             // Uninstrumented work is unknown, not stalled. Keep watermarks
             // so returning to an old report cannot fabricate new work.
             self.unchanged_since = None;
@@ -822,6 +845,9 @@ impl FirstGenerationProgressWindow {
         if let Some(preseal) = concurrent_preseal {
             advanced |= self.record(preseal);
         }
+        if let Some(text) = concurrent_text {
+            advanced |= self.record(text);
+        }
         if advanced || self.unchanged_since.is_none() {
             self.unchanged_since = Some(now);
             return false;
@@ -1418,6 +1444,115 @@ mod daemon_precondition_tests {
         assert!(reason.contains("no observed capture, parse, text, or native graph work"));
     }
 
+    fn overlapping_native_and_text() -> CodeIndexWorktreeFreshnessV1 {
+        let mut worktree = native_graph_without_writes();
+        let graph = worktree.native_graph_progress.as_mut().unwrap();
+        graph.phase = Some(CodeIndexNativeGraphPhaseV1::CompactEncoding);
+        graph.encoded_entities = 512;
+        graph.total_entities = Some(1_024);
+        graph.total_relations = Some(8);
+        graph.progress_epoch = 4;
+        graph.last_progress_micros = Some(400);
+
+        let mut lexical = progress(35, None);
+        lexical.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        lexical.daemon_incarnation = 3;
+        lexical.producer_incarnation = 4;
+        worktree.progress = Some(lexical);
+        worktree
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn authentic_text_commits_advance_during_quiet_native_encoding() {
+        let initial = overlapping_native_and_text();
+        assert!(matches!(
+            super::FirstGenerationWorkMarker::of(Some(&initial)),
+            Some(super::FirstGenerationWorkMarker::NativeGraph { .. })
+        ));
+        let mut next = initial.clone();
+        let text = next.progress.as_mut().unwrap();
+        text.progress_epoch += 1;
+        text.committed_pages += 1;
+        text.last_progress_micros += 100;
+
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(initial)),
+                status(timed_out(), warming(next)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert!(
+            result.is_ok(),
+            "a real lexical page receipt must not disappear behind a quiet native writer: {result:?}"
+        );
+        assert_eq!(reads, 3);
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn completed_native_write_and_quiet_preseal_keep_real_text_receipts() {
+        let mut initial = native_graph_after_all_encoding();
+        initial.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2).preseal_attempt;
+        let mut lexical = progress(35, None);
+        lexical.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        lexical.daemon_incarnation = 3;
+        lexical.producer_incarnation = 4;
+        initial.progress = Some(lexical);
+        assert!(matches!(
+            super::FirstGenerationWorkMarker::of(Some(&initial)),
+            Some(super::FirstGenerationWorkMarker::Preseal { .. })
+        ));
+        let mut next = initial.clone();
+        let text = next.progress.as_mut().unwrap();
+        text.progress_epoch += 1;
+        text.committed_pages += 1;
+        text.last_progress_micros += 100;
+
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(initial)),
+                status(timed_out(), warming(next)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert!(
+            result.is_ok(),
+            "committed lexical pages must remain observable beside a final native write and successor capture: {result:?}"
+        );
+        assert_eq!(reads, 3);
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn epoch_only_changes_in_all_overlapping_writers_still_stall() {
+        let mut initial = overlapping_native_and_text();
+        initial.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2).preseal_attempt;
+        let mut repeated = initial.clone();
+        repeated.native_graph_progress.as_mut().unwrap().progress_epoch += 1;
+        repeated.progress.as_mut().unwrap().progress_epoch += 1;
+        repeated.progress.as_mut().unwrap().last_progress_micros += 100;
+        repeated.preseal_attempt.as_mut().unwrap().progress_epoch += 1;
+
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(initial)),
+                status(timed_out(), warming(repeated)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2, "no owner supplied any new completed work");
+        let (code, reason) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(reason.contains("no observed capture, parse, text, or native graph work"));
+    }
+
     fn native_graph_after_all_encoding() -> CodeIndexWorktreeFreshnessV1 {
         let mut worktree = native_graph_without_writes();
         let graph = worktree.native_graph_progress.as_mut().unwrap();

From 6edb4af07692ae0ae861f17f56b7fc04c83ab2d6 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 20:38:10 -0800
Subject: [PATCH 77/80] fix(cli): preserve parked cause and remedy during
 readiness wait

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 153 +++++++++++++++++++-
 1 file changed, 149 insertions(+), 4 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 8f0c69c4b79..aca599fba2f 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -340,9 +340,29 @@ where
             CodeIndexReadinessWaitOutcomeV1::Reached => return Ok(()),
             CodeIndexReadinessWaitOutcomeV1::TimedOut { last_state } => last_state,
             CodeIndexReadinessWaitOutcomeV1::Unavailable { reason } => {
+                // The wait carries an availability code. Preserve the actual
+                // daemon park's cause and remedy when its typed status exists.
+                let park_detail = payload
+                    .get("code_index_freshness")
+                    .cloned()
+                    .map(serde_json::from_value::<StatusCodeIndexFreshnessV1>)
+                    .transpose()?
+                    .and_then(|freshness| match freshness {
+                        StatusCodeIndexFreshnessV1::Parked { worktree } => worktree.parked,
+                        _ => None,
+                    })
+                    .map(|parked| {
+                        format!(
+                            "; parked cause: {}; remedy: {}; retries on wake: {}",
+                            parked.reason, parked.remediation, parked.retries_on_wake
+                        )
+                    })
+                    .unwrap_or_default();
                 return Err(first_generation_wait_refusal(
                     CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
-                    format!("init --wait cannot reach a ready first generation: {reason}"),
+                    format!(
+                        "init --wait cannot reach a ready first generation: {reason}{park_detail}"
+                    ),
                 ));
             }
         };
@@ -469,7 +489,7 @@ where
 }
 
 /// Why the daemon's reading shows no work toward the first generation.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 enum FirstGenerationStall {
     /// No code-index scheduler serves the project, for the given reason.
     Unavailable(String),
@@ -477,6 +497,8 @@ enum FirstGenerationStall {
     NoPassInFlight,
     /// The active build reports it cannot advance.
     Blocked(CodeIndexBuildBlockedReasonV1),
+    /// A terminal convergence park names the operator action required.
+    Parked { cause: String, remedy: String },
 }
 
 impl FirstGenerationStall {
@@ -493,6 +515,16 @@ impl FirstGenerationStall {
             .native_graph_progress
             .as_ref()
             .filter(|graph| graph.active);
+        // An old terminal park cannot be renewed by the rebuild flag.
+        // An independently active successor still owns its own work.
+        if let Some(parked) = worktree.parked.as_ref().filter(|parked| {
+            !parked.retries_on_wake && !active_preseal && active_graph.is_none()
+        }) {
+            return Some(Self::Parked {
+                cause: parked.reason.clone(),
+                remedy: parked.remediation.clone(),
+            });
+        }
         if let Some(progress) = worktree.progress.as_ref() {
             if let Some(reason) = progress.blocked_reason {
                 // The previous sealed generation can remain visible while a
@@ -931,6 +963,9 @@ impl std::fmt::Display for FirstGenerationStall {
             }
             Self::NoPassInFlight => formatter.write_str("no reconcile pass is in flight"),
             Self::Blocked(reason) => write!(formatter, "the build is blocked ({reason:?})"),
+            Self::Parked { cause, remedy } => {
+                write!(formatter, "convergence is parked ({cause}); remedy: {remedy}")
+            }
         }
     }
 }
@@ -1111,8 +1146,9 @@ mod daemon_precondition_tests {
     use tracedecay_contracts::code_index_freshness::{
         CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
         CodeGraphServingReadinessV1, CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1,
-        CodeIndexBuildProgressV1, CodeIndexFreshnessLadderInputsV1, CodeIndexFreshnessLadderV1,
-        CodeIndexNativeGraphPhaseV1, CodeIndexPresealWorkPhaseV1, CodeIndexReadinessTargetV1,
+        CodeIndexBuildProgressV1, CodeIndexConvergenceParkedV1,
+        CodeIndexFreshnessLadderInputsV1, CodeIndexFreshnessLadderV1, CodeIndexNativeGraphPhaseV1,
+        CodeIndexPresealWorkPhaseV1, CodeIndexReadinessTargetV1,
         CodeIndexReadinessV1, CodeIndexReadinessWaitOutcomeV1, CodeIndexReadinessWaitReadV1,
         CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
     };
@@ -1222,6 +1258,20 @@ mod daemon_precondition_tests {
         }
     }
 
+    fn terminal_parked_worktree() -> CodeIndexWorktreeFreshnessV1 {
+        let mut worktree = building(false);
+        worktree.staleness_state = Some(CodeIndexStalenessStateV1::Parked);
+        worktree.parked = Some(CodeIndexConvergenceParkedV1 {
+            reason: "corrupt durable publication authority".to_owned(),
+            blocked_reason: Some(CodeIndexBuildBlockedReasonV1::PublicationAuthorityCorrupt),
+            remediation: "repair the owner-private graph store".to_owned(),
+            parked_at_micros: 123,
+            observed_passes: 2,
+            retries_on_wake: false,
+        });
+        worktree
+    }
+
     fn readiness_worktree(state: CodeIndexStalenessStateV1) -> CodeIndexWorktreeFreshnessV1 {
         let restoring = state == CodeIndexStalenessStateV1::Restoring;
         let ladder = CodeIndexFreshnessLadderV1::project(CodeIndexFreshnessLadderInputsV1 {
@@ -2490,6 +2540,101 @@ mod daemon_precondition_tests {
         }
     }
 
+    #[tokio::test(flavor = "current_thread")]
+    async fn unavailable_parked_wait_preserves_the_daemon_operator_remedy() {
+        let parked = terminal_parked_worktree();
+        let (result, reads) = hold_over(
+            vec![
+                status(
+                    CodeIndexReadinessWaitOutcomeV1::Unavailable {
+                        reason: "code_index_convergence_parked".to_owned(),
+                    },
+                    Some(StatusCodeIndexFreshnessV1::Parked {
+                        worktree: Box::new(parked),
+                    }),
+                ),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 1, "unavailable cannot claim a later Ready");
+        let (code, message) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_UNAVAILABLE);
+        assert!(message.contains("code_index_convergence_parked"), "{message}");
+        assert!(message.contains("corrupt durable publication authority"), "{message}");
+        assert!(message.contains("repair the owner-private graph store"), "{message}");
+        assert!(message.contains("retries on wake: false"), "{message}");
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn timed_out_terminal_park_reports_cause_even_with_stale_rebuild_flag() {
+        let mut parked = terminal_parked_worktree();
+        parked.rebuild_in_flight = true;
+        let (result, reads) = hold_over(
+            vec![
+                status(
+                    timed_out(),
+                    Some(StatusCodeIndexFreshnessV1::Parked {
+                        worktree: Box::new(parked),
+                    }),
+                ),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 1);
+        let (code, message) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(message.contains("convergence is parked"), "{message}");
+        assert!(message.contains("corrupt durable publication authority"), "{message}");
+        assert!(message.contains("repair the owner-private graph store"), "{message}");
+    }
+
+    #[test]
+    fn terminal_park_is_fenced_from_a_live_successor_and_recovery() {
+        let mut parked = terminal_parked_worktree();
+        parked.rebuild_in_flight = true;
+        let expected = super::FirstGenerationStall::Parked {
+            cause: "corrupt durable publication authority".to_owned(),
+            remedy: "repair the owner-private graph store".to_owned(),
+        };
+        assert_eq!(
+            super::FirstGenerationStall::of(Ok(&parked)),
+            Some(expected.clone())
+        );
+
+        // A stale park cannot block a separately admitted live successor.
+        let mut recovered = parked.clone();
+        recovered.preseal_attempt =
+            attempt(CodeIndexPresealWorkPhaseV1::Capture, 2, 1, 5).preseal_attempt;
+        assert_eq!(super::FirstGenerationStall::of(Ok(&recovered)), None);
+
+        let started = Instant::now();
+        let mut window = super::FirstGenerationIdleWindow::new(Duration::from_secs(120));
+        assert_eq!(window.observe(Some(expected.clone()), started), None);
+        assert_eq!(
+            window.observe(Some(expected.clone()), started + Duration::from_secs(119)),
+            None
+        );
+        assert_eq!(
+            window.observe(
+                super::FirstGenerationStall::of(Ok(&recovered)),
+                started + Duration::from_secs(120),
+            ),
+            None
+        );
+        assert_eq!(
+            window.observe(Some(expected.clone()), started + Duration::from_secs(240)),
+            None
+        );
+        assert_eq!(
+            window.observe(Some(expected.clone()), started + Duration::from_secs(360)),
+            Some(expected)
+        );
+    }
+
     #[test]
     fn active_readiness_owner_does_not_mask_blocked_progress() {
         for mut worktree in [

From 78d33055e8b0ebb682541ca53fea1bd87c2cba12 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 20:55:33 -0800
Subject: [PATCH 78/80] fix(cli): retain measured text receipts during final
 graph write

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 95 ++++++++++++++++++++-
 1 file changed, 91 insertions(+), 4 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index aca599fba2f..6f9ee3ebd79 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -609,14 +609,21 @@ impl FirstGenerationWorkMarker {
             if encoding_finished
                 || graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified)
             {
-                // The final Grafeo container write has no row callbacks, but
-                // a separately owned successor can still capture or parse.
-                // Keep its observed work visible without timing the final write.
+                // The final Grafeo container write has no row callbacks.
+                // Independently owned source or lexical writers may still
+                // report real work; never hide their observations behind it.
                 return worktree
                     .preseal_attempt
                     .as_ref()
                     .filter(|attempt| attempt.active)
-                    .map(Self::preseal);
+                    .map(Self::preseal)
+                    .or_else(|| {
+                        worktree
+                            .progress
+                            .as_ref()
+                            .filter(|progress| progress.phase == CodeIndexBuildPhaseV1::BulkCommit)
+                            .map(Self::text)
+                    });
             }
             // Starting the native attempt proves only that there is an owner,
             // not that it has written any rows. A silent initial window must
@@ -1577,6 +1584,86 @@ mod daemon_precondition_tests {
         assert_eq!(reads, 3);
     }
 
+    #[tokio::test(flavor = "current_thread")]
+    async fn final_native_write_does_not_hide_independent_text_receipts() {
+        for verified in [false, true] {
+            let mut first = native_graph_after_all_encoding();
+            if verified {
+                let graph = first.native_graph_progress.as_mut().unwrap();
+                graph.phase = Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified);
+                graph.committed_compact_segments = 1;
+                graph.committed_compact_bytes = 60_000;
+                graph.progress_epoch += 1;
+            }
+            let mut lexical = progress(35, None);
+            lexical.phase = CodeIndexBuildPhaseV1::BulkCommit;
+            lexical.daemon_incarnation = 3;
+            lexical.producer_incarnation = 4;
+            first.progress = Some(lexical);
+            assert!(matches!(
+                super::FirstGenerationWorkMarker::of(Some(&first)),
+                Some(super::FirstGenerationWorkMarker::CommittedText { .. })
+            ));
+
+            let mut advanced = first.clone();
+            let text = advanced.progress.as_mut().unwrap();
+            text.progress_epoch += 1;
+            text.committed_pages += 1;
+            text.committed_payload_bytes += 1_024;
+            let (result, reads) = hold_over(
+                vec![
+                    status(timed_out(), warming(first.clone())),
+                    status(timed_out(), warming(advanced)),
+                    ready_status(),
+                ],
+                Duration::ZERO,
+            )
+            .await;
+            assert!(
+                result.is_ok(),
+                "real lexical page commits during final native work must reach Ready (verified={verified}): {result:?}"
+            );
+            assert_eq!(reads, 3);
+
+            // When the independent text writer is no longer committing, the
+            // final native container write stays unknown, not a fake stall.
+            first.progress.as_mut().unwrap().phase = CodeIndexBuildPhaseV1::Ready;
+            assert_eq!(super::FirstGenerationWorkMarker::of(Some(&first)), None);
+        }
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn final_native_write_does_not_credit_text_epoch_only_replays() {
+        let mut initial = native_graph_after_all_encoding();
+        let mut lexical = progress(35, None);
+        lexical.phase = CodeIndexBuildPhaseV1::BulkCommit;
+        lexical.daemon_incarnation = 3;
+        lexical.producer_incarnation = 4;
+        initial.progress = Some(lexical);
+        let mut repeated = initial.clone();
+        let text = repeated.progress.as_mut().unwrap();
+        text.progress_epoch += 1;
+        text.last_progress_micros += 1_000;
+        repeated.native_graph_progress.as_mut().unwrap().progress_epoch += 1;
+
+        let (result, reads) = hold_over(
+            vec![
+                status(timed_out(), warming(initial)),
+                status(timed_out(), warming(repeated)),
+                ready_status(),
+            ],
+            Duration::ZERO,
+        )
+        .await;
+        assert_eq!(reads, 2, "metadata alone cannot reach a later Ready");
+        let (code, reason) = refusal(result);
+        assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
+        assert!(
+            reason.contains("no observed capture, parse, text, or native graph work"),
+            "{reason}"
+        );
+    }
+
     #[tokio::test(flavor = "current_thread")]
     async fn epoch_only_changes_in_all_overlapping_writers_still_stall() {
         let mut initial = overlapping_native_and_text();

From e880e8e816aefcc42e8a380585af08e48a981f3e Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 21:52:22 -0800
Subject: [PATCH 79/80] fix(cli): keep final graph writes outside text silence
 timeout

Keep independent lexical watermarks without treating a retained BulkCommit
snapshot as silence evidence for the uninstrumented final graph write.
Preserve active preseal stall detection and require frozen text to refuse
once the native writer retires. Repair the reported Rust formatting.

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 145 ++++++++++++++++----
 1 file changed, 118 insertions(+), 27 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index 6f9ee3ebd79..baa1d16dd38 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -7,8 +7,8 @@ use tracedecay_project::project::TraceDecay;
 use tracedecay_contracts::code_index_freshness::{
     CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
     CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexBuildProgressV1,
-    CodeIndexNativeGraphPhaseV1, CodeIndexPresealAttemptProgressV1,
-    CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
+    CodeIndexNativeGraphPhaseV1, CodeIndexPresealAttemptProgressV1, CodeIndexReadinessWaitOutcomeV1,
+    CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::graph_tool::GraphToolResultV1;
 use tracedecay_contracts::retrieval::{
@@ -463,7 +463,23 @@ where
             None
         };
         let now = Instant::now();
-        let stalled = if concurrent_preseal.is_some() || concurrent_text.is_some() {
+        let unknown_native_only = worktree_read.is_some_and(|worktree| {
+            FirstGenerationWorkMarker::has_uninstrumented_native_write(worktree)
+                && !worktree
+                    .preseal_attempt
+                    .as_ref()
+                    .is_some_and(|attempt| attempt.active)
+        });
+        let stalled = if unknown_native_only {
+            // A retained text snapshot has no live-owner flag. Its frozen
+            // receipts cannot prove silence in the final native write. Keep
+            // real text watermarks, but pause this unobservable interval;
+            // neither polling nor this coverage change is producer work.
+            if let Some(marker) = marker {
+                progress_window.record(marker);
+            }
+            progress_window.observe(None, now)
+        } else if concurrent_preseal.is_some() || concurrent_text.is_some() {
             progress_window.observe_with_concurrent_writers(
                 marker,
                 concurrent_preseal,
@@ -517,9 +533,11 @@ impl FirstGenerationStall {
             .filter(|graph| graph.active);
         // An old terminal park cannot be renewed by the rebuild flag.
         // An independently active successor still owns its own work.
-        if let Some(parked) = worktree.parked.as_ref().filter(|parked| {
-            !parked.retries_on_wake && !active_preseal && active_graph.is_none()
-        }) {
+        if let Some(parked) = worktree
+            .parked
+            .as_ref()
+            .filter(|parked| !parked.retries_on_wake && !active_preseal && active_graph.is_none())
+        {
             return Some(Self::Parked {
                 cause: parked.reason.clone(),
                 remedy: parked.remediation.clone(),
@@ -581,6 +599,23 @@ enum FirstGenerationWorkMarker {
 }
 
 impl FirstGenerationWorkMarker {
+    fn has_uninstrumented_native_write(worktree: &CodeIndexWorktreeFreshnessV1) -> bool {
+        worktree
+            .native_graph_progress
+            .as_ref()
+            .filter(|graph| graph.active)
+            .is_some_and(|graph| {
+                let encoding_finished = graph.phase
+                    == Some(CodeIndexNativeGraphPhaseV1::CompactEncoding)
+                    && graph.total_entities == Some(graph.encoded_entities)
+                    && graph
+                        .total_relations
+                        .is_some_and(|total| total == graph.encoded_relations);
+                encoding_finished
+                    || graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified)
+            })
+    }
+
     fn of(worktree: Option<&CodeIndexWorktreeFreshnessV1>) -> Option<Self> {
         let worktree = worktree?;
         // Restoring and verifying are readiness work even when the canonical
@@ -600,15 +635,7 @@ impl FirstGenerationWorkMarker {
             // digest verification AFTER all accepted row windows. That work
             // has no intermediate native milestone. Never call a healthy
             // final write a stall merely because the last encode clock froze.
-            let encoding_finished = graph.phase
-                == Some(CodeIndexNativeGraphPhaseV1::CompactEncoding)
-                && graph.total_entities == Some(graph.encoded_entities)
-                && graph
-                    .total_relations
-                    .is_some_and(|total| total == graph.encoded_relations);
-            if encoding_finished
-                || graph.phase == Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified)
-            {
+            if Self::has_uninstrumented_native_write(worktree) {
                 // The final Grafeo container write has no row callbacks.
                 // Independently owned source or lexical writers may still
                 // report real work; never hide their observations behind it.
@@ -1153,11 +1180,10 @@ mod daemon_precondition_tests {
     use tracedecay_contracts::code_index_freshness::{
         CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
         CodeGraphServingReadinessV1, CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1,
-        CodeIndexBuildProgressV1, CodeIndexConvergenceParkedV1,
-        CodeIndexFreshnessLadderInputsV1, CodeIndexFreshnessLadderV1, CodeIndexNativeGraphPhaseV1,
-        CodeIndexPresealWorkPhaseV1, CodeIndexReadinessTargetV1,
-        CodeIndexReadinessV1, CodeIndexReadinessWaitOutcomeV1, CodeIndexReadinessWaitReadV1,
-        CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
+        CodeIndexBuildProgressV1, CodeIndexConvergenceParkedV1, CodeIndexFreshnessLadderInputsV1,
+        CodeIndexFreshnessLadderV1, CodeIndexNativeGraphPhaseV1, CodeIndexPresealWorkPhaseV1,
+        CodeIndexReadinessTargetV1, CodeIndexReadinessV1, CodeIndexReadinessWaitOutcomeV1,
+        CodeIndexReadinessWaitReadV1, CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
     };
     use tracedecay_contracts::retrieval::StatusCodeIndexFreshnessV1;
     use tracedecay_domain::errors::TraceDecayError;
@@ -1632,6 +1658,44 @@ mod daemon_precondition_tests {
         }
     }
 
+    #[tokio::test(flavor = "current_thread")]
+    async fn retained_text_cannot_time_out_an_uninstrumented_native_write() {
+        for verified in [false, true] {
+            let mut initial = native_graph_after_all_encoding();
+            if verified {
+                let graph = initial.native_graph_progress.as_mut().unwrap();
+                graph.phase = Some(CodeIndexNativeGraphPhaseV1::CompactSegmentVerified);
+                graph.committed_compact_segments = 1;
+                graph.committed_compact_bytes = 60_000;
+            }
+            let mut lexical = progress(35, None);
+            lexical.phase = CodeIndexBuildPhaseV1::BulkCommit;
+            lexical.daemon_incarnation = 3;
+            lexical.producer_incarnation = 4;
+            initial.progress = Some(lexical);
+            let mut repeated = initial.clone();
+            let text = repeated.progress.as_mut().unwrap();
+            text.progress_epoch += 1;
+            text.last_progress_micros += 1_000;
+
+            let (result, reads) = hold_over(
+                vec![
+                    status(timed_out(), warming(initial)),
+                    status(timed_out(), warming(repeated.clone())),
+                    status(timed_out(), warming(repeated)),
+                    ready_status(),
+                ],
+                Duration::ZERO,
+            )
+            .await;
+            assert!(
+                result.is_ok(),
+                "frozen lexical receipts do not prove a native stall: {result:?}"
+            );
+            assert_eq!(reads, 4, "only the actual readiness proof ends the wait");
+        }
+    }
+
     #[tokio::test(flavor = "current_thread")]
     async fn final_native_write_does_not_credit_text_epoch_only_replays() {
         let mut initial = native_graph_after_all_encoding();
@@ -1644,18 +1708,29 @@ mod daemon_precondition_tests {
         let text = repeated.progress.as_mut().unwrap();
         text.progress_epoch += 1;
         text.last_progress_micros += 1_000;
-        repeated.native_graph_progress.as_mut().unwrap().progress_epoch += 1;
+        repeated
+            .native_graph_progress
+            .as_mut()
+            .unwrap()
+            .progress_epoch += 1;
 
+        // Final native work has no bounded silence evidence. Once that
+        // owner retires, the same frozen text receipts must still stall;
+        // observing them during the unknown interval cannot credit work.
+        let mut retired = repeated.clone();
+        retired.native_graph_progress.as_mut().unwrap().active = false;
         let (result, reads) = hold_over(
             vec![
                 status(timed_out(), warming(initial)),
                 status(timed_out(), warming(repeated)),
+                status(timed_out(), warming(retired.clone())),
+                status(timed_out(), warming(retired)),
                 ready_status(),
             ],
             Duration::ZERO,
         )
         .await;
-        assert_eq!(reads, 2, "metadata alone cannot reach a later Ready");
+        assert_eq!(reads, 4, "frozen text must refuse after native work retires");
         let (code, reason) = refusal(result);
         assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
         assert!(
@@ -1670,7 +1745,11 @@ mod daemon_precondition_tests {
         initial.preseal_attempt =
             attempt(CodeIndexPresealWorkPhaseV1::Capture, 4, 7, 2).preseal_attempt;
         let mut repeated = initial.clone();
-        repeated.native_graph_progress.as_mut().unwrap().progress_epoch += 1;
+        repeated
+            .native_graph_progress
+            .as_mut()
+            .unwrap()
+            .progress_epoch += 1;
         repeated.progress.as_mut().unwrap().progress_epoch += 1;
         repeated.progress.as_mut().unwrap().last_progress_micros += 100;
         repeated.preseal_attempt.as_mut().unwrap().progress_epoch += 1;
@@ -2649,8 +2728,14 @@ mod daemon_precondition_tests {
         let (code, message) = refusal(result);
         assert_eq!(code, CODE_INDEX_READINESS_WAIT_UNAVAILABLE);
         assert!(message.contains("code_index_convergence_parked"), "{message}");
-        assert!(message.contains("corrupt durable publication authority"), "{message}");
-        assert!(message.contains("repair the owner-private graph store"), "{message}");
+        assert!(
+            message.contains("corrupt durable publication authority"),
+            "{message}"
+        );
+        assert!(
+            message.contains("repair the owner-private graph store"),
+            "{message}"
+        );
         assert!(message.contains("retries on wake: false"), "{message}");
     }
 
@@ -2675,8 +2760,14 @@ mod daemon_precondition_tests {
         let (code, message) = refusal(result);
         assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
         assert!(message.contains("convergence is parked"), "{message}");
-        assert!(message.contains("corrupt durable publication authority"), "{message}");
-        assert!(message.contains("repair the owner-private graph store"), "{message}");
+        assert!(
+            message.contains("corrupt durable publication authority"),
+            "{message}"
+        );
+        assert!(
+            message.contains("repair the owner-private graph store"),
+            "{message}"
+        );
     }
 
     #[test]

From 7218ed2638b0d30b4bfb34304be2ac9398387003 Mon Sep 17 00:00:00 2001
From: Zack Jackson <25274700+ScriptedAlchemy@users.noreply.github.com>
Date: Mon, 9 Nov 2026 23:33:14 -0800
Subject: [PATCH 80/80] fix(cli): align index progress with Bazel rustfmt

Apply exact formatting required by the current-head repository gate
without changing the CLI wait semantics or weakening the regressions.

Refs #4508
---
 crates/tracedecay-cli/src/commands/index.rs | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/crates/tracedecay-cli/src/commands/index.rs b/crates/tracedecay-cli/src/commands/index.rs
index baa1d16dd38..a623cf3405d 100644
--- a/crates/tracedecay-cli/src/commands/index.rs
+++ b/crates/tracedecay-cli/src/commands/index.rs
@@ -7,8 +7,8 @@ use tracedecay_project::project::TraceDecay;
 use tracedecay_contracts::code_index_freshness::{
     CODE_INDEX_READINESS_WAIT_TIMED_OUT, CODE_INDEX_READINESS_WAIT_UNAVAILABLE,
     CodeIndexBuildBlockedReasonV1, CodeIndexBuildPhaseV1, CodeIndexBuildProgressV1,
-    CodeIndexNativeGraphPhaseV1, CodeIndexPresealAttemptProgressV1, CodeIndexReadinessWaitOutcomeV1,
-    CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
+    CodeIndexNativeGraphPhaseV1, CodeIndexPresealAttemptProgressV1,
+    CodeIndexReadinessWaitOutcomeV1, CodeIndexStalenessStateV1, CodeIndexWorktreeFreshnessV1,
 };
 use tracedecay_contracts::graph_tool::GraphToolResultV1;
 use tracedecay_contracts::retrieval::{
@@ -998,7 +998,10 @@ impl std::fmt::Display for FirstGenerationStall {
             Self::NoPassInFlight => formatter.write_str("no reconcile pass is in flight"),
             Self::Blocked(reason) => write!(formatter, "the build is blocked ({reason:?})"),
             Self::Parked { cause, remedy } => {
-                write!(formatter, "convergence is parked ({cause}); remedy: {remedy}")
+                write!(
+                    formatter,
+                    "convergence is parked ({cause}); remedy: {remedy}"
+                )
             }
         }
     }
@@ -1730,7 +1733,10 @@ mod daemon_precondition_tests {
             Duration::ZERO,
         )
         .await;
-        assert_eq!(reads, 4, "frozen text must refuse after native work retires");
+        assert_eq!(
+            reads, 4,
+            "frozen text must refuse after native work retires"
+        );
         let (code, reason) = refusal(result);
         assert_eq!(code, CODE_INDEX_READINESS_WAIT_TIMED_OUT);
         assert!(
@@ -2727,7 +2733,10 @@ mod daemon_precondition_tests {
         assert_eq!(reads, 1, "unavailable cannot claim a later Ready");
         let (code, message) = refusal(result);
         assert_eq!(code, CODE_INDEX_READINESS_WAIT_UNAVAILABLE);
-        assert!(message.contains("code_index_convergence_parked"), "{message}");
+        assert!(
+            message.contains("code_index_convergence_parked"),
+            "{message}"
+        );
         assert!(
             message.contains("corrupt durable publication authority"),
             "{message}"