diff --git a/crates/tracedecay-api/src/configuration.rs b/crates/tracedecay-api/src/configuration.rs
index 5e7c81dcd6..92e75faa41 100644
--- a/crates/tracedecay-api/src/configuration.rs
+++ b/crates/tracedecay-api/src/configuration.rs
@@ -42,6 +42,8 @@ pub struct ProjectSettingsPatch {
     pub telemetry: Option<TelemetrySettingsPatch>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub sync: Option<SyncSettingsPatch>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub context_scout: Option<bool>,
 }
 
 /// Nested synchronization settings patch.
diff --git a/crates/tracedecay-dashboard-api/src/settings_api.rs b/crates/tracedecay-dashboard-api/src/settings_api.rs
index 6b7c72342b..4bb5f96073 100644
--- a/crates/tracedecay-dashboard-api/src/settings_api.rs
+++ b/crates/tracedecay-dashboard-api/src/settings_api.rs
@@ -30,7 +30,8 @@ use crate::application::configuration::{
 };
 use crate::application::settings_control::{
     ProjectSettingsPatchV1, ProjectSettingsPreviewErrorV1, SyncSettingsPatchV1,
-    TelemetrySettingsPatchV1, preview_project_settings,
+    TelemetrySettingsPatchV1, context_scout_settings_are_enabled, effective_context_scout_settings,
+    preview_project_settings,
 };
 use crate::config::TraceDecayConfig;
 use crate::request_identity::{GlobalRequestSurface, mint_global_request_id};
@@ -94,25 +95,32 @@ struct ProjectEditableSettingsV1 {
     git_ignore: bool,
     telemetry: TelemetrySettingsV1,
     sync: SyncSettingsV1,
-}
-
-impl From<&TraceDecayConfig> for ProjectEditableSettingsV1 {
-    fn from(config: &TraceDecayConfig) -> Self {
-        Self {
-            include: config.include.clone(),
-            exclude: config.exclude.clone(),
-            max_file_size: config.max_file_size,
-            extract_docstrings: config.extract_docstrings,
-            track_call_sites: config.track_call_sites,
-            git_ignore: config.git_ignore,
-            telemetry: TelemetrySettingsV1 {
-                timings: config.telemetry.timings,
-            },
-            sync: SyncSettingsV1 {
-                auto_track_pr_branches: config.sync.auto_track_pr_branches,
-                auto_track_pr_poll_secs: config.sync.auto_track_pr_poll_secs,
-            },
-        }
+    /// Rendered from the effective Plan 20 `context_scout.settings.v1` value;
+    /// the dashboard holds no Scout state of its own.
+    context_scout: bool,
+}
+
+fn project_editable_settings(
+    configuration: &crate::config::PinnedRuntimeConfiguration,
+) -> ProjectEditableSettingsV1 {
+    let config: &TraceDecayConfig = &configuration.config;
+    ProjectEditableSettingsV1 {
+        include: config.include.clone(),
+        exclude: config.exclude.clone(),
+        max_file_size: config.max_file_size,
+        extract_docstrings: config.extract_docstrings,
+        track_call_sites: config.track_call_sites,
+        git_ignore: config.git_ignore,
+        telemetry: TelemetrySettingsV1 {
+            timings: config.telemetry.timings,
+        },
+        sync: SyncSettingsV1 {
+            auto_track_pr_branches: config.sync.auto_track_pr_branches,
+            auto_track_pr_poll_secs: config.sync.auto_track_pr_poll_secs,
+        },
+        context_scout: context_scout_settings_are_enabled(&effective_context_scout_settings(
+            &configuration.snapshot,
+        )),
     }
 }
 
@@ -274,6 +282,7 @@ pub async fn patch_project_settings(
                 auto_track_pr_branches: sync.auto_track_pr_branches,
                 auto_track_pr_poll_secs: sync.auto_track_pr_poll_secs,
             }),
+            context_scout: patch.context_scout,
         },
     )
     .map_err(project_preview_error)?;
@@ -407,7 +416,7 @@ async fn settings_envelope(
                 .as_str()
                 .to_owned(),
             configuration_revision_id: project_configuration.revision_id.as_str().to_owned(),
-            config: ProjectEditableSettingsV1::from(&project_configuration.config),
+            config: project_editable_settings(&project_configuration),
             tracedecay_dir_gitignored: crate::config::is_in_gitignore(&state.project_root),
             pr_autotrack: pr_autotrack_payload(state),
         },
diff --git a/crates/tracedecay-usecases/src/settings_control.rs b/crates/tracedecay-usecases/src/settings_control.rs
index 1a01c00f83..303a2b16aa 100644
--- a/crates/tracedecay-usecases/src/settings_control.rs
+++ b/crates/tracedecay-usecases/src/settings_control.rs
@@ -8,11 +8,12 @@
 use serde::Deserialize;
 use tracedecay_domain::ProjectId;
 use tracedecay_domain::configuration::{
-    ConfigurationLayerIdV1, ConfigurationRevisionId, ConfigurationValueV1,
-    INDEX_EXCLUDE_SETTING_KEY, INDEX_EXTRACT_DOCSTRINGS_SETTING_KEY, INDEX_GIT_IGNORE_SETTING_KEY,
-    INDEX_INCLUDE_SETTING_KEY, INDEX_MAX_FILE_SIZE_SETTING_KEY, INDEX_TRACK_CALL_SITES_SETTING_KEY,
-    SYNC_AUTO_TRACK_PR_BRANCHES_SETTING_KEY, SYNC_AUTO_TRACK_PR_POLL_SECS_SETTING_KEY, SettingKey,
-    TELEMETRY_TIMINGS_SETTING_KEY,
+    CONTEXT_SCOUT_SETTINGS_SETTING_KEY, ConfigurationLayerIdV1, ConfigurationRevisionId,
+    ConfigurationSnapshotV1, ConfigurationValueV1, ContextScoutConfigurationStateV1,
+    ContextScoutSettingsV1, INDEX_EXCLUDE_SETTING_KEY, INDEX_EXTRACT_DOCSTRINGS_SETTING_KEY,
+    INDEX_GIT_IGNORE_SETTING_KEY, INDEX_INCLUDE_SETTING_KEY, INDEX_MAX_FILE_SIZE_SETTING_KEY,
+    INDEX_TRACK_CALL_SITES_SETTING_KEY, SYNC_AUTO_TRACK_PR_BRANCHES_SETTING_KEY,
+    SYNC_AUTO_TRACK_PR_POLL_SECS_SETTING_KEY, SettingKey, TELEMETRY_TIMINGS_SETTING_KEY,
 };
 
 use tracedecay_application::{ProjectSettingsPatchInputV1, validate_project_settings_patch};
@@ -42,6 +43,27 @@ pub struct ProjectSettingsPatchV1 {
     pub telemetry: Option<TelemetrySettingsPatchV1>,
     #[serde(default)]
     pub sync: Option<SyncSettingsPatchV1>,
+    #[serde(default)]
+    pub context_scout: Option<bool>,
+}
+
+/// The effective Plan 20 Context Scout value in one configuration snapshot.
+/// The registry always resolves this key; a snapshot predating the key reads
+/// as the canonical stock state, which is disabled.
+pub fn effective_context_scout_settings(
+    snapshot: &ConfigurationSnapshotV1,
+) -> ContextScoutSettingsV1 {
+    SettingKey::new(CONTEXT_SCOUT_SETTINGS_SETTING_KEY)
+        .ok()
+        .and_then(|key| match snapshot.effective_values.get(&key) {
+            Some(ConfigurationValueV1::ContextScoutSettings(settings)) => Some(settings.clone()),
+            _ => None,
+        })
+        .unwrap_or_else(ContextScoutSettingsV1::disabled)
+}
+
+pub fn context_scout_settings_are_enabled(settings: &ContextScoutSettingsV1) -> bool {
+    settings.state != ContextScoutConfigurationStateV1::Disabled
 }
 
 #[derive(Debug, Clone, Deserialize, Default)]
@@ -110,6 +132,7 @@ pub fn preview_project_settings(
     let layer = ConfigurationLayerIdV1::Project {
         project_id: project_id.clone(),
     };
+    let current_context_scout = effective_context_scout_settings(&current.snapshot);
     let expected_is_current = expected_revision == current.revision_id;
     let supplied_values_are_current = patch
         .include
@@ -142,6 +165,9 @@ pub fn preview_project_settings(
                 && sync
                     .auto_track_pr_poll_secs
                     .is_none_or(|value| value == current.config.sync.auto_track_pr_poll_secs)
+        })
+        && patch.context_scout.is_none_or(|value| {
+            value == context_scout_settings_are_enabled(&current_context_scout)
         });
     let mut mutations = Vec::new();
     push(
@@ -204,6 +230,22 @@ pub fn preview_project_settings(
                 .map(ConfigurationValueV1::Unsigned),
         )?;
     }
+    // The dashboard flag is only a state toggle: mode, limits, and model
+    // selection stay exactly as configured, and disabling never erases them.
+    push(
+        &mut mutations,
+        &layer,
+        CONTEXT_SCOUT_SETTINGS_SETTING_KEY,
+        patch.context_scout.map(|enabled| {
+            let mut settings = current_context_scout.clone();
+            settings.state = if enabled {
+                ContextScoutConfigurationStateV1::Active
+            } else {
+                ContextScoutConfigurationStateV1::Disabled
+            };
+            ConfigurationValueV1::ContextScoutSettings(settings)
+        }),
+    )?;
     if mutations.is_empty() && !expected_is_current {
         return Err(ProjectSettingsPreviewErrorV1::RevisionConflict {
             expected: expected_revision.as_str().to_owned(),
@@ -303,4 +345,82 @@ mod tests {
         assert_eq!(mutations.len(), 2);
         assert_eq!(current.config.max_file_size, 1_048_576);
     }
+
+    #[test]
+    fn context_scout_flag_toggles_only_the_state_of_the_effective_value() {
+        let project_id = ProjectId::new("project.settings.scout").unwrap();
+        let revision = ConfigurationRevisionId::new("configuration.revision.scout").unwrap();
+        let snapshot = ConfigurationSnapshotV1::new(
+            BTreeMap::new(),
+            BTreeMap::<SettingKey, Vec<ConfigurationCandidateV1>>::new(),
+        )
+        .unwrap();
+        let current = PinnedRuntimeConfiguration {
+            target: crate::config::RuntimeConfigurationTarget {
+                project_id: project_id.clone(),
+                project_root: PathBuf::from("/project"),
+            },
+            revision_id: revision.clone(),
+            snapshot,
+            config: crate::config::TraceDecayConfig::default(),
+        };
+        // A snapshot without the key renders the canonical stock state: off.
+        let current_settings = effective_context_scout_settings(&current.snapshot);
+        assert_eq!(current_settings, ContextScoutSettingsV1::disabled());
+        assert!(!context_scout_settings_are_enabled(&current_settings));
+
+        // Re-submitting the current state plans no mutation.
+        let unchanged = preview_project_settings(
+            &project_id,
+            &current,
+            ProjectSettingsPatchV1 {
+                expected_revision_id: revision.as_str().to_owned(),
+                context_scout: Some(false),
+                ..ProjectSettingsPatchV1::default()
+            },
+        )
+        .unwrap();
+        assert!(!unchanged.changed);
+
+        let preview = preview_project_settings(
+            &project_id,
+            &current,
+            ProjectSettingsPatchV1 {
+                expected_revision_id: revision.as_str().to_owned(),
+                context_scout: Some(true),
+                ..ProjectSettingsPatchV1::default()
+            },
+        )
+        .unwrap();
+        assert!(preview.changed);
+        let DirectConfigurationMutation::Batch { mutations } = preview.mutation else {
+            panic!("project settings must be atomic")
+        };
+        let [DirectConfigurationMutation::Set { key, value, .. }] = mutations.as_slice() else {
+            panic!("the flag must plan exactly one typed Set")
+        };
+        assert_eq!(key.as_str(), CONTEXT_SCOUT_SETTINGS_SETTING_KEY);
+        let ConfigurationValueV1::ContextScoutSettings(settings) = value.as_ref() else {
+            panic!("the flag must write the typed Context Scout value")
+        };
+        assert_eq!(settings.state, ContextScoutConfigurationStateV1::Active);
+        // Only the state toggles; mode, limits, and model fields are kept.
+        assert_eq!(
+            (
+                settings.mode,
+                settings.limits,
+                settings.model_path,
+                settings.model_id.as_deref(),
+                settings.model_timeout_secs,
+            ),
+            (
+                ContextScoutSettingsV1::disabled().mode,
+                ContextScoutSettingsV1::disabled().limits,
+                None,
+                None,
+                None,
+            )
+        );
+        settings.validate().expect("planned value stays canonical");
+    }
 }
diff --git a/dashboard/codegen/schemas/dashboard-contracts.schema.json b/dashboard/codegen/schemas/dashboard-contracts.schema.json
index 4bb7dcec48..3b09f93396 100644
--- a/dashboard/codegen/schemas/dashboard-contracts.schema.json
+++ b/dashboard/codegen/schemas/dashboard-contracts.schema.json
@@ -15284,6 +15284,10 @@
     },
     "ProjectEditableSettingsV1": {
       "properties": {
+        "context_scout": {
+          "description": "Rendered from the effective Plan 20 `context_scout.settings.v1` value;\nthe dashboard holds no Scout state of its own.",
+          "type": "boolean"
+        },
         "exclude": {
           "items": {
             "type": "string"
@@ -15325,7 +15329,8 @@
         "track_call_sites",
         "git_ignore",
         "telemetry",
-        "sync"
+        "sync",
+        "context_scout"
       ],
       "type": "object"
     },
@@ -15481,6 +15486,12 @@
       "additionalProperties": false,
       "description": "Project-scoped settings patch accepted by `PATCH /api/settings/project`.",
       "properties": {
+        "context_scout": {
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
         "exclude": {
           "items": {
             "type": "string"
diff --git a/dashboard/src/contracts/generated.ts b/dashboard/src/contracts/generated.ts
index 8669e70d19..214748c653 100644
--- a/dashboard/src/contracts/generated.ts
+++ b/dashboard/src/contracts/generated.ts
@@ -3554,6 +3554,7 @@ export const ProjectContextPayloadV1Schema = z.object({
 export type ProjectContextPayloadV1 = z.infer<typeof ProjectContextPayloadV1Schema>;
 
 export const ProjectEditableSettingsV1Schema = z.object({
+  context_scout: z.boolean(),
   exclude: z.array(z.string()),
   extract_docstrings: z.boolean(),
   git_ignore: z.boolean(),
@@ -3611,6 +3612,7 @@ export type ProjectRepoGroup = z.infer<typeof ProjectRepoGroupSchema>;
 
 /** Project-scoped settings patch accepted by `PATCH /api/settings/project`. */
 export const ProjectSettingsPatchSchema = z.object({
+  context_scout: z.boolean().nullable().optional(),
   exclude: z.array(z.string()).nullable().optional(),
   expected_revision_id: z.string(),
   extract_docstrings: z.boolean().nullable().optional(),
diff --git a/dashboard/src/workspaces/observatory/AnalyticsControls.dom.test.tsx b/dashboard/src/workspaces/observatory/AnalyticsControls.dom.test.tsx
index 2473c7d9ce..14c4216df6 100644
--- a/dashboard/src/workspaces/observatory/AnalyticsControls.dom.test.tsx
+++ b/dashboard/src/workspaces/observatory/AnalyticsControls.dom.test.tsx
@@ -290,6 +290,7 @@ function settingsPayload() {
         exclude: [],
         extract_docstrings: true,
         git_ignore: true,
+        context_scout: false,
         include: [],
         max_file_size: 1_048_576,
         sync: { auto_track_pr_branches: false, auto_track_pr_poll_secs: 300 },
diff --git a/dashboard/src/workspaces/settings/SettingsFields.tsx b/dashboard/src/workspaces/settings/SettingsFields.tsx
index f71e744f02..50029b217b 100644
--- a/dashboard/src/workspaces/settings/SettingsFields.tsx
+++ b/dashboard/src/workspaces/settings/SettingsFields.tsx
@@ -109,6 +109,12 @@ export function ProjectSettingsFields({
           error={errorFor(errors, 'auto_track_pr_branches')}
           onChange={(checked) => onChange({ ...values, auto_track_pr_branches: checked })}
         />
+        <SettingsCheckbox
+          label="Context Scout suggestions"
+          checked={values.context_scout}
+          error={errorFor(errors, 'context_scout')}
+          onChange={(checked) => onChange({ ...values, context_scout: checked })}
+        />
       </div>
       {writable.state === 'writable' ? (
         <button type="button" className={`${settingsButtonClass} mt-3`} onClick={onReview}>
diff --git a/dashboard/src/workspaces/settings/settingsEditorMachine.ts b/dashboard/src/workspaces/settings/settingsEditorMachine.ts
index e30b3bd18b..a5fba47ef5 100644
--- a/dashboard/src/workspaces/settings/settingsEditorMachine.ts
+++ b/dashboard/src/workspaces/settings/settingsEditorMachine.ts
@@ -663,6 +663,7 @@ function sameProjectValues(
     left.extract_docstrings === right.extract_docstrings &&
     left.track_call_sites === right.track_call_sites &&
     left.git_ignore === right.git_ignore &&
+    left.context_scout === right.context_scout &&
     left.telemetry_timings === right.telemetry_timings &&
     left.auto_track_pr_branches === right.auto_track_pr_branches &&
     left.auto_track_pr_poll_secs === right.auto_track_pr_poll_secs
diff --git a/dashboard/src/workspaces/settings/settingsModel.test.ts b/dashboard/src/workspaces/settings/settingsModel.test.ts
index 84937f4253..e205eccc9c 100644
--- a/dashboard/src/workspaces/settings/settingsModel.test.ts
+++ b/dashboard/src/workspaces/settings/settingsModel.test.ts
@@ -159,9 +159,9 @@ describe('Settings read model', () => {
     const config = project?.rows.find((row) => row.id === 'config');
     expect(config?.kind).toBe('group');
     // include, exclude, max_file_size, extract_docstrings, track_call_sites,
-    // git_ignore, telemetry.timings, sync.auto_track_pr_branches,
-    // sync.auto_track_pr_poll_secs
-    expect(config?.count).toBe(9);
+    // git_ignore, context_scout, telemetry.timings,
+    // sync.auto_track_pr_branches, sync.auto_track_pr_poll_secs
+    expect(config?.count).toBe(10);
     expect(countSettings(project?.rows ?? [])).toBe(project?.settingCount);
   });
 
@@ -325,6 +325,7 @@ describe('Settings authorized changes', () => {
         extract_docstrings: true,
         track_call_sites: true,
         git_ignore: true,
+        context_scout: false,
         telemetry_timings: false,
         auto_track_pr_branches: true,
         auto_track_pr_poll_secs: '120',
diff --git a/dashboard/src/workspaces/settings/settingsModel.ts b/dashboard/src/workspaces/settings/settingsModel.ts
index 11f9718868..e3a1a88d71 100644
--- a/dashboard/src/workspaces/settings/settingsModel.ts
+++ b/dashboard/src/workspaces/settings/settingsModel.ts
@@ -128,6 +128,7 @@ export interface ProjectSettingsValues {
   readonly extract_docstrings: boolean;
   readonly track_call_sites: boolean;
   readonly git_ignore: boolean;
+  readonly context_scout: boolean;
   readonly telemetry_timings: boolean;
   readonly auto_track_pr_branches: boolean;
   readonly auto_track_pr_poll_secs: string;
@@ -168,6 +169,7 @@ export interface ProjectSettingsChangeSet {
   extract_docstrings?: boolean;
   track_call_sites?: boolean;
   git_ignore?: boolean;
+  context_scout?: boolean;
   telemetry?: { timings?: boolean };
   sync?: {
     auto_track_pr_branches?: boolean;
@@ -384,6 +386,7 @@ export function buildSettingsEditor(payload: SettingsPayloadV1): SettingsEditor
       extract_docstrings: config.extract_docstrings,
       track_call_sites: config.track_call_sites,
       git_ignore: config.git_ignore,
+      context_scout: config.context_scout,
       telemetry_timings: config.telemetry.timings,
       auto_track_pr_branches: config.sync.auto_track_pr_branches,
       auto_track_pr_poll_secs: pollSecs,
@@ -446,7 +449,12 @@ export function planProjectChangeAgainst(
   if (maxFileSize !== Number(current.project.max_file_size)) {
     patch.max_file_size = maxFileSize;
   }
-  for (const field of ['extract_docstrings', 'track_call_sites', 'git_ignore'] as const) {
+  for (const field of [
+    'extract_docstrings',
+    'track_call_sites',
+    'git_ignore',
+    'context_scout',
+  ] as const) {
     if (values[field] !== current.project[field]) patch[field] = values[field];
   }
   if (values.telemetry_timings !== current.project.telemetry_timings) {
diff --git a/dashboard/stories/fixtures/data.ts b/dashboard/stories/fixtures/data.ts
index a74879aa7e..bc2d46a8ca 100644
--- a/dashboard/stories/fixtures/data.ts
+++ b/dashboard/stories/fixtures/data.ts
@@ -2267,6 +2267,7 @@ const settingsPayload: Record<string, unknown> = {
       extract_docstrings: true,
       track_call_sites: true,
       git_ignore: true,
+      context_scout: false,
       telemetry: { timings: false },
       sync: { auto_track_pr_branches: true, auto_track_pr_poll_secs: 120 },
     },
diff --git a/src/daemon.rs b/src/daemon.rs
index 602f4e24c7..f28664cfbc 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -158,6 +158,7 @@ use connection_serving::{
     await_project_owner_or_disconnect, serve_routed_rmcp_connection, serve_windows_broker_client,
     serve_windows_broker_client_with_class,
 };
+pub(crate) mod context_scout_lifecycle;
 mod core_admission;
 mod engine;
 #[cfg(unix)]
@@ -370,7 +371,7 @@ pub(crate) use service::invocation::{
     DaemonFeedbackRuntimeRegistrationError, DaemonInvocationService, DaemonLspOwnerRegistrar,
     DaemonPrimitiveRuntimeRegistrar, DaemonPrimitiveRuntimeRegistrationError,
     DaemonSemanticRuntimeRegistrar, DaemonSemanticRuntimeRegistrationError,
-    DaemonWorkRuntimeRegistrar, HookOrchestrationAdmissionV1, admit_hook_orchestration,
+    DaemonWorkRuntimeRegistrar, HookOrchestrationAdmissionV1, admit_registered_hook_orchestration,
     daemon_operation_event_authority,
 };
 pub use service::{
diff --git a/src/daemon/context_scout_lifecycle.rs b/src/daemon/context_scout_lifecycle.rs
new file mode 100644
index 0000000000..0be8f6fb93
--- /dev/null
+++ b/src/daemon/context_scout_lifecycle.rs
@@ -0,0 +1,515 @@
+//! Exact Context Scout lifecycle lookup from canonical durable observations.
+
+use std::collections::BTreeMap;
+use std::sync::{Mutex as StdMutex, OnceLock};
+
+use tracedecay_domain::{
+    AgentInstanceId, CanonicalObservationEnvelopeV1, DurableObservationV1, MessageId,
+    ObservationScopeV1, ProjectId, SessionId, ThreadId, TurnId, UserProfileId, WorktreeId,
+};
+use tracedecay_store::StoreShardScopeV1;
+
+use crate::agents::context_scout_ports::ContextScoutLifecycleAddressV1;
+use crate::global_db::{RegisteredGlobalDb, RegisteredGlobalDbLeaseV1};
+
+const MAX_CONTEXT_SCOUT_SESSION_OBSERVATIONS_V1: usize = 64;
+
+type ContextScoutLifecycleKeyV1 = ([u8; 16], [u8; 16]);
+
+struct RegisteredContextScoutLifecycleAuthorityV1 {
+    profile_id: UserProfileId,
+    project_id: ProjectId,
+    worktree_id: WorktreeId,
+    sessions: RegisteredGlobalDbLeaseV1,
+}
+
+type ContextScoutLifecycleAuthoritiesV1 =
+    StdMutex<BTreeMap<ContextScoutLifecycleKeyV1, RegisteredContextScoutLifecycleAuthorityV1>>;
+
+fn registered_context_scout_lifecycle_authorities() -> &'static ContextScoutLifecycleAuthoritiesV1 {
+    static AUTHORITIES: OnceLock<ContextScoutLifecycleAuthoritiesV1> = OnceLock::new();
+    AUTHORITIES.get_or_init(|| StdMutex::new(BTreeMap::new()))
+}
+
+/// Why a lifecycle authority registration was never admissible.
+///
+/// Distinct from [`AuthorityRegistrationV1::Conflict`]: nothing about the
+/// existing registry contents could have made these requests succeed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum AuthorityRejectionV1 {
+    ZeroHookProjectId,
+    ZeroHookWorktreeId,
+    InvalidProjectId,
+    InvalidWorktreeId,
+    NonProjectSessionScope,
+    ProjectNotOwnedByAuthority,
+}
+
+impl AuthorityRejectionV1 {
+    pub(crate) const fn as_str(self) -> &'static str {
+        match self {
+            Self::ZeroHookProjectId => "zero_hook_project_id",
+            Self::ZeroHookWorktreeId => "zero_hook_worktree_id",
+            Self::InvalidProjectId => "invalid_project_id",
+            Self::InvalidWorktreeId => "invalid_worktree_id",
+            Self::NonProjectSessionScope => "non_project_session_scope",
+            Self::ProjectNotOwnedByAuthority => "project_not_owned_by_authority",
+        }
+    }
+}
+
+/// Outcome of registering a Context Scout lifecycle authority.
+///
+/// Only [`Self::Conflict`] means "a different live authority already owns
+/// this hook key", which is an operator-visible misconfiguration rather than
+/// a validation failure.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum AuthorityRegistrationV1 {
+    /// A fresh authority was installed for this hook key.
+    Registered,
+    /// The live authority already binds exactly this identity and store.
+    AlreadyRegistered,
+    /// A different live authority owns this hook key; the request was refused
+    /// and the incumbent kept.
+    Conflict,
+    /// The request could never have been admitted.
+    Rejected(AuthorityRejectionV1),
+}
+
+pub(crate) fn register_context_scout_lifecycle_authority(
+    hook_project_id: [u8; 16],
+    hook_worktree_id: [u8; 16],
+    project_id: ProjectId,
+    worktree_id: WorktreeId,
+    sessions: &RegisteredGlobalDbLeaseV1,
+) -> AuthorityRegistrationV1 {
+    if hook_project_id == [0; 16] {
+        return AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::ZeroHookProjectId);
+    }
+    if hook_worktree_id == [0; 16] {
+        return AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::ZeroHookWorktreeId);
+    }
+    if project_id.validate().is_err() {
+        return AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::InvalidProjectId);
+    }
+    if worktree_id.validate().is_err() {
+        return AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::InvalidWorktreeId);
+    }
+    let profile_id = sessions.binding().shard_id.profile_id.clone();
+    let Some(authority_project_id) = (match &sessions.binding().shard_id.scope {
+        StoreShardScopeV1::ProjectSessions { project_id } => Some(project_id),
+        _ => None,
+    }) else {
+        return AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::NonProjectSessionScope);
+    };
+    if authority_project_id != &project_id {
+        return AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::ProjectNotOwnedByAuthority);
+    }
+    let key = (hook_project_id, hook_worktree_id);
+    let mut authorities = registered_context_scout_lifecycle_authorities()
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner);
+    if let Some(existing) = authorities.get(&key) {
+        let identical = existing.profile_id == profile_id
+            && existing.project_id == project_id
+            && existing.worktree_id == worktree_id
+            && existing.sessions.shares_client_with(sessions);
+        return if identical {
+            AuthorityRegistrationV1::AlreadyRegistered
+        } else {
+            AuthorityRegistrationV1::Conflict
+        };
+    }
+    authorities.insert(
+        key,
+        RegisteredContextScoutLifecycleAuthorityV1 {
+            profile_id,
+            project_id,
+            worktree_id,
+            sessions: sessions.clone(),
+        },
+    );
+    AuthorityRegistrationV1::Registered
+}
+
+/// Removes exactly the given session store's registration; a different live
+/// authority under the same locator pair is left untouched so a rolled-back
+/// advisory setup can never unregister its successor.
+pub(crate) fn unregister_context_scout_lifecycle_authority(
+    hook_project_id: [u8; 16],
+    hook_worktree_id: [u8; 16],
+    sessions: &RegisteredGlobalDbLeaseV1,
+) -> bool {
+    let key = (hook_project_id, hook_worktree_id);
+    let mut authorities = registered_context_scout_lifecycle_authorities()
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner);
+    if authorities
+        .get(&key)
+        .is_some_and(|existing| existing.sessions.shares_client_with(sessions))
+    {
+        authorities.remove(&key);
+        return true;
+    }
+    false
+}
+
+/// Looks up the registered lifecycle authority for a hook-scoped
+/// (project, worktree) pair.
+///
+/// Shared prologue for both replay entry points below: resolve the
+/// native profile/project/worktree identity and a session lease, or
+/// `None` if no authority is registered.
+fn resolve_authority(
+    hook_project_id: [u8; 16],
+    hook_worktree_id: [u8; 16],
+) -> Option<(
+    UserProfileId,
+    ProjectId,
+    WorktreeId,
+    RegisteredGlobalDbLeaseV1,
+)> {
+    let key = (hook_project_id, hook_worktree_id);
+    let authorities = registered_context_scout_lifecycle_authorities()
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner);
+    let Some(authority) = authorities.get(&key) else {
+        tracing::debug!(
+            target: "tracedecay::context_scout_lifecycle",
+            reason = "no_registered_authority",
+            "Context Scout lifecycle resolution failed closed"
+        );
+        return None;
+    };
+    Some((
+        authority.profile_id.clone(),
+        authority.project_id.clone(),
+        authority.worktree_id.clone(),
+        authority.sessions.clone(),
+    ))
+}
+
+pub(crate) async fn lookup_registered_context_scout_lifecycle(
+    hook_project_id: [u8; 16],
+    hook_worktree_id: [u8; 16],
+    session_id: &SessionId,
+) -> Option<ContextScoutLifecycleAddressV1> {
+    let (profile_id, project_id, worktree_id, sessions) =
+        resolve_authority(hook_project_id, hook_worktree_id)?;
+    lookup_context_scout_lifecycle(
+        &profile_id,
+        &project_id,
+        &worktree_id,
+        session_id,
+        &sessions,
+    )
+    .await
+    .into_address()
+}
+
+/// Re-resolves the native session behind a protected Hook V2 locator.
+///
+/// Replay has only the privacy-preserving locator carried by the validated
+/// envelope. The authoritative project-session shard supplies the native
+/// identity again; no hook payload or workspace path becomes durable replay
+/// identity.
+pub(crate) async fn lookup_registered_context_scout_native_session(
+    hook_project_id: [u8; 16],
+    hook_worktree_id: [u8; 16],
+    protected_session_id: [u8; 32],
+) -> Option<SessionId> {
+    if protected_session_id == [0; 32] {
+        return None;
+    }
+    let (profile_id, project_id, worktree_id, sessions) =
+        resolve_authority(hook_project_id, hook_worktree_id)?;
+    let session_id = {
+        let snapshot = sessions.read_snapshot().await.ok()?;
+        let mut rows = snapshot
+            .query(
+                "SELECT json_extract(
+                        observation_json,
+                        '$.identity.source.session_id'
+                    ) AS session_id
+                 FROM observations
+                 WHERE json_extract(
+                        observation_json,
+                        '$.__retention_released'
+                    ) IS NULL
+                   AND json_type(
+                        observation_json,
+                        '$.identity.source.session_id'
+                    ) = 'text'
+                 GROUP BY session_id
+                 ORDER BY MAX(sequence) DESC",
+                (),
+            )
+            .await
+            .ok()?;
+        let mut resolved: Option<SessionId> = None;
+        while let Some(row) = rows.next().await.ok()? {
+            let raw_session_id = row.get::<String>(0).ok()?;
+            if crate::hooks::protected_native_session_id(&raw_session_id) != protected_session_id {
+                continue;
+            }
+            let candidate = SessionId::new(raw_session_id).ok()?;
+            if resolved
+                .as_ref()
+                .is_some_and(|existing| existing != &candidate)
+            {
+                return None;
+            }
+            resolved = Some(candidate);
+        }
+        resolved?
+    };
+    lookup_context_scout_lifecycle(
+        &profile_id,
+        &project_id,
+        &worktree_id,
+        &session_id,
+        &sessions,
+    )
+    .await
+    .is_resolved()
+    .then_some(session_id)
+}
+
+/// Why an exact lifecycle lookup resolved nothing.
+///
+/// Every reason fails closed for the `Option`-shaped callers, but an
+/// unauthorized shard binding, a corrupt durable row, a blown evidence
+/// budget, and "this session simply has no complete tuple yet" stay
+/// distinguishable in logs and in tests.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum ContextScoutLifecycleLookupFailureV1 {
+    InvalidProfileId,
+    InvalidProjectId,
+    InvalidWorktreeId,
+    InvalidSessionId,
+    /// The session store is not the authority for the requested identity.
+    UnauthorizedBinding,
+    SnapshotUnavailable,
+    ObservationQueryFailed,
+    ObservationRowUnreadable,
+    /// More session evidence than the bounded scan admits.
+    ObservationBudgetExceeded,
+    MalformedDurableObservation,
+    /// Durable evidence bound another project scope or another session.
+    DurableScopeMismatch,
+    MalformedCanonicalEnvelope,
+    /// The canonical payload disagreed with its own durable source identity.
+    CanonicalEnvelopeMismatch,
+    /// Well-formed evidence exists, but none carries a complete tuple.
+    NoCompleteLifecycle,
+}
+
+impl ContextScoutLifecycleLookupFailureV1 {
+    const fn as_str(self) -> &'static str {
+        match self {
+            Self::InvalidProfileId => "invalid_profile_id",
+            Self::InvalidProjectId => "invalid_project_id",
+            Self::InvalidWorktreeId => "invalid_worktree_id",
+            Self::InvalidSessionId => "invalid_session_id",
+            Self::UnauthorizedBinding => "unauthorized_binding",
+            Self::SnapshotUnavailable => "snapshot_unavailable",
+            Self::ObservationQueryFailed => "observation_query_failed",
+            Self::ObservationRowUnreadable => "observation_row_unreadable",
+            Self::ObservationBudgetExceeded => "observation_budget_exceeded",
+            Self::MalformedDurableObservation => "malformed_durable_observation",
+            Self::DurableScopeMismatch => "durable_scope_mismatch",
+            Self::MalformedCanonicalEnvelope => "malformed_canonical_envelope",
+            Self::CanonicalEnvelopeMismatch => "canonical_envelope_mismatch",
+            Self::NoCompleteLifecycle => "no_complete_lifecycle",
+        }
+    }
+}
+
+/// Outcome of one exact Context Scout lifecycle lookup.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum ContextScoutLifecycleLookupV1 {
+    /// Boxed so the resolved tuple's ~216 bytes do not travel with every
+    /// one-byte failure reason.
+    Resolved(Box<ContextScoutLifecycleAddressV1>),
+    Unresolved(ContextScoutLifecycleLookupFailureV1),
+}
+
+impl ContextScoutLifecycleLookupV1 {
+    /// Collapses to the fail-closed `Option`, discarding the reason (which
+    /// the lookup already emitted to tracing).
+    fn into_address(self) -> Option<ContextScoutLifecycleAddressV1> {
+        match self {
+            Self::Resolved(address) => Some(*address),
+            Self::Unresolved(_) => None,
+        }
+    }
+
+    const fn is_resolved(&self) -> bool {
+        matches!(self, Self::Resolved(_))
+    }
+}
+
+/// Resolves one complete native lifecycle tuple from the registered
+/// project-session store.
+///
+/// The lookup is exact and bounded. It accepts only receipt-checked durable
+/// observations whose source identity, project scope, and canonical payload
+/// all bind the requested session. The newest complete tuple wins, so a later
+/// native tool call advances one session without making its prior turn
+/// ambiguous. Corrupt, released, or excessive evidence still fails closed.
+async fn lookup_context_scout_lifecycle(
+    profile_id: &UserProfileId,
+    project_id: &ProjectId,
+    worktree_id: &WorktreeId,
+    session_id: &SessionId,
+    sessions: &RegisteredGlobalDb,
+) -> ContextScoutLifecycleLookupV1 {
+    match lookup_context_scout_lifecycle_inner(
+        profile_id,
+        project_id,
+        worktree_id,
+        session_id,
+        sessions,
+    )
+    .await
+    {
+        Ok(address) => ContextScoutLifecycleLookupV1::Resolved(Box::new(address)),
+        Err(reason) => {
+            tracing::debug!(
+                target: "tracedecay::context_scout_lifecycle",
+                reason = reason.as_str(),
+                session_id = session_id.as_str(),
+                "Context Scout lifecycle lookup failed closed"
+            );
+            ContextScoutLifecycleLookupV1::Unresolved(reason)
+        }
+    }
+}
+
+/// Fail-closed body of [`lookup_context_scout_lifecycle`].
+///
+/// Every early return names the evidence that failed instead of collapsing
+/// into a bare `None`; the caller-visible contract is still "anything but
+/// `Ok` resolves nothing".
+async fn lookup_context_scout_lifecycle_inner(
+    profile_id: &UserProfileId,
+    project_id: &ProjectId,
+    worktree_id: &WorktreeId,
+    session_id: &SessionId,
+    sessions: &RegisteredGlobalDb,
+) -> std::result::Result<ContextScoutLifecycleAddressV1, ContextScoutLifecycleLookupFailureV1> {
+    use ContextScoutLifecycleLookupFailureV1 as Failure;
+
+    profile_id
+        .validate()
+        .map_err(|_| Failure::InvalidProfileId)?;
+    project_id
+        .validate()
+        .map_err(|_| Failure::InvalidProjectId)?;
+    worktree_id
+        .validate()
+        .map_err(|_| Failure::InvalidWorktreeId)?;
+    session_id
+        .validate()
+        .map_err(|_| Failure::InvalidSessionId)?;
+    let binding = sessions.binding();
+    if &binding.shard_id.profile_id != profile_id
+        || !matches!(
+            &binding.shard_id.scope,
+            StoreShardScopeV1::ProjectSessions {
+                project_id: bound_project_id
+            } if bound_project_id == project_id
+        )
+    {
+        return Err(Failure::UnauthorizedBinding);
+    }
+
+    let snapshot = sessions
+        .read_snapshot()
+        .await
+        .map_err(|_| Failure::SnapshotUnavailable)?;
+    let limit = i64::try_from(MAX_CONTEXT_SCOUT_SESSION_OBSERVATIONS_V1 + 1)
+        .map_err(|_| Failure::ObservationBudgetExceeded)?;
+    let mut rows = snapshot
+        .query(
+            "SELECT observation_json
+             FROM observations
+             WHERE json_extract(observation_json, '$.__retention_released') IS NULL
+               AND json_extract(
+                    observation_json,
+                    '$.identity.source.session_id'
+               ) = ?1
+             ORDER BY sequence DESC
+             LIMIT ?2",
+            crate::db::engine::params![session_id.as_str(), limit],
+        )
+        .await
+        .map_err(|_| Failure::ObservationQueryFailed)?;
+
+    let project_scope = ObservationScopeV1::Project {
+        project_id: project_id.clone(),
+    };
+    let mut count = 0usize;
+    while let Some(row) = rows
+        .next()
+        .await
+        .map_err(|_| Failure::ObservationRowUnreadable)?
+    {
+        count = count
+            .checked_add(1)
+            .ok_or(Failure::ObservationBudgetExceeded)?;
+        if count > MAX_CONTEXT_SCOUT_SESSION_OBSERVATIONS_V1 {
+            return Err(Failure::ObservationBudgetExceeded);
+        }
+        let observation_json = row
+            .get::<String>(0)
+            .map_err(|_| Failure::ObservationRowUnreadable)?;
+        let durable = serde_json::from_str::<DurableObservationV1>(&observation_json)
+            .map_err(|_| Failure::MalformedDurableObservation)?;
+        if durable.scope() != &project_scope || durable.source().session_id() != session_id {
+            return Err(Failure::DurableScopeMismatch);
+        }
+        let envelope =
+            serde_json::from_value::<CanonicalObservationEnvelopeV1>(durable.payload().clone())
+                .map_err(|_| Failure::MalformedCanonicalEnvelope)?;
+        if envelope.provider() != durable.source().provider()
+            || envelope.relations().session_id() != session_id
+        {
+            return Err(Failure::CanonicalEnvelopeMismatch);
+        }
+        if let Some(candidate) =
+            lifecycle_from_canonical(profile_id, project_id, worktree_id, session_id, &envelope)
+        {
+            return Ok(candidate);
+        }
+    }
+    Err(Failure::NoCompleteLifecycle)
+}
+
+fn lifecycle_from_canonical(
+    profile_id: &UserProfileId,
+    project_id: &ProjectId,
+    worktree_id: &WorktreeId,
+    session_id: &SessionId,
+    observation: &CanonicalObservationEnvelopeV1,
+) -> Option<ContextScoutLifecycleAddressV1> {
+    observation.validate().ok()?;
+    let relations = observation.relations();
+    if relations.session_id() != session_id {
+        return None;
+    }
+    Some(ContextScoutLifecycleAddressV1 {
+        profile_id: profile_id.clone(),
+        provider_id: observation.provider().clone(),
+        project_id: project_id.clone(),
+        worktree_id: worktree_id.clone(),
+        session_id: session_id.clone(),
+        thread_id: ThreadId::new(relations.thread_id()?.as_str().to_owned()).ok()?,
+        turn_id: TurnId::new(relations.turn_id()?.as_str().to_owned()).ok()?,
+        agent_id: AgentInstanceId::new(relations.agent_id()?.as_str().to_owned()).ok()?,
+        logical_message_id: MessageId::new(relations.message_id()?.as_str().to_owned()).ok()?,
+    })
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/src/daemon/context_scout_lifecycle/tests.rs b/src/daemon/context_scout_lifecycle/tests.rs
new file mode 100644
index 0000000000..55cc30884a
--- /dev/null
+++ b/src/daemon/context_scout_lifecycle/tests.rs
@@ -0,0 +1,726 @@
+use serde_json::Value;
+use tempfile::TempDir;
+use tracedecay_domain::{
+    CanonicalMessageRoleV1, CanonicalObservationEvidenceV1, CanonicalObservationFactV1,
+    CanonicalObservationRelationsV1, ComponentVersion, ObservationId,
+    ObservationIdentityMaterialV1, ObservationOrderingDomainV1, ObservationSourceCursorV1,
+    ObservationSourceGenerationV1, ObservationSourceIdentityV1, ObservationSourceRangeV1,
+    PayloadReferenceV1, ProjectionGenerationId, ProviderId, RetentionClass, SanitizationReceiptId,
+    SanitizationReceiptRefV1, SanitizationReceiptV1, SanitizerDispositionV1, SensitivityV1,
+    UtcMicros,
+};
+use tracedecay_store::{
+    AnchoredObservationWrite, ObservationStore, ObservationWrite,
+    build_observation_resolution_authorization_v1, build_observation_retrieval_anchor_v2,
+};
+
+use super::*;
+use crate::host_admission::HostAdmissionTestRuntimeV1;
+use tracedecay_usecases::host_admission::HostAdmissionScope;
+
+fn id<T: TryFrom<String>>(value: &str) -> T
+where
+    T::Error: std::fmt::Debug,
+{
+    T::try_from(value.to_owned()).unwrap()
+}
+
+fn complete_native_observation() -> CanonicalObservationEnvelopeV1 {
+    let relations = CanonicalObservationRelationsV1::new(id::<SessionId>("session.native.codex"))
+        .with_thread_id(id::<ObservationId>("thread.native.codex"))
+        .with_turn_id(id::<ObservationId>("turn.native.codex"))
+        .with_agent_id(id::<ObservationId>("agent.native.codex"))
+        .with_message_id(id::<ObservationId>("message.native.codex"));
+    CanonicalObservationEnvelopeV1::new(
+        id::<ProviderId>("codex"),
+        "event_msg",
+        id::<ObservationId>("record.native.codex"),
+        relations,
+        vec![CanonicalObservationFactV1::Message {
+            role: CanonicalMessageRoleV1::Assistant,
+            content: Value::String("saved".to_owned()),
+            model: None,
+            timestamp: None,
+        }],
+        CanonicalObservationEvidenceV1::new(
+            ObservationOrderingDomainV1::FileBytes,
+            ObservationSourceRangeV1::new(0, 1).unwrap(),
+        ),
+    )
+    .unwrap()
+}
+
+fn durable_native_observation(project_id: &ProjectId) -> AnchoredObservationWrite {
+    let envelope = complete_native_observation();
+    let payload = serde_json::to_value(&envelope).unwrap();
+    let range = ObservationSourceRangeV1::new(0, 1).unwrap();
+    let source = ObservationSourceIdentityV1::for_provider(
+        envelope.provider().clone(),
+        envelope.relations().session_id().clone(),
+    )
+    .unwrap();
+    let scope = ObservationScopeV1::Project {
+        project_id: project_id.clone(),
+    };
+    let generation = ObservationSourceGenerationV1::new(1).unwrap();
+    let record_id = ObservationId::new("record.native.codex").unwrap();
+    let receipt = SanitizationReceiptV1::new(
+        SanitizationReceiptRefV1::new(
+            SanitizationReceiptId::new("receipt.native.codex").unwrap(),
+            ComponentVersion::new("sanitizer.native-test.v1").unwrap(),
+        )
+        .unwrap(),
+        SanitizerDispositionV1::Accepted,
+        SensitivityV1::NonSensitive,
+        Some(PayloadReferenceV1::for_payload(&payload).unwrap()),
+    )
+    .unwrap();
+    let observation = DurableObservationV1::new(
+        ObservationIdentityMaterialV1::for_native_record(
+            source.clone(),
+            scope.clone(),
+            generation,
+            range,
+            ObservationOrderingDomainV1::FileBytes,
+            record_id,
+        )
+        .unwrap(),
+        receipt,
+        RetentionClass::new("retention.native-test").unwrap(),
+        payload,
+    )
+    .unwrap();
+    let cursor = ObservationSourceCursorV1::for_ordering(
+        source,
+        scope,
+        generation,
+        ObservationOrderingDomainV1::FileBytes,
+        1,
+    )
+    .unwrap();
+    let write = ObservationWrite::new(observation, None, cursor).unwrap();
+    let projection_generation = ProjectionGenerationId::new("projection.native-test.v1").unwrap();
+    let authorization =
+        build_observation_resolution_authorization_v1(write.observation(), "native-test").unwrap();
+    let anchor = build_observation_retrieval_anchor_v2(
+        write.observation(),
+        projection_generation.clone(),
+        UtcMicros(1),
+        authorization,
+    )
+    .unwrap();
+    AnchoredObservationWrite::new(write, anchor, projection_generation).unwrap()
+}
+
+/// Writes durable evidence straight into the shard, bypassing the
+/// runtime scope gate.
+///
+/// This is only ever correct for staging state the store contract
+/// forbids — a row scoped to another project — so that the reader-side
+/// guards can be exercised against it. Everything else must go through
+/// [`ObservationStore::persist_observation`].
+async fn stage_foreign_scoped_observation(
+    sessions: &RegisteredGlobalDb,
+    write: &AnchoredObservationWrite,
+) {
+    let observation = write.observation();
+    let receipt = observation.receipt();
+    let writer = sessions.writer_connection().unwrap();
+    writer
+        .execute(
+            "INSERT INTO sanitization_receipts
+                (receipt_id, sanitizer_version, payload_digest, receipt_json)
+             VALUES (?1, ?2, ?3, ?4)",
+            crate::db::engine::params![
+                receipt.receipt().receipt_id().as_str(),
+                receipt.receipt().sanitizer_version().as_str(),
+                observation.payload_reference().digest().as_str(),
+                serde_json::to_string(receipt).unwrap()
+            ],
+        )
+        .await
+        .unwrap();
+    writer
+        .execute(
+            "INSERT INTO observations
+                (observation_id, payload_digest, receipt_id, observation_json,
+                 committed_cursor_json)
+             VALUES (?1, ?2, ?3, ?4, ?5)",
+            crate::db::engine::params![
+                observation.observation_id().as_str(),
+                observation.payload_reference().digest().as_str(),
+                receipt.receipt().receipt_id().as_str(),
+                serde_json::to_string(observation).unwrap(),
+                serde_json::to_string(write.next_cursor()).unwrap()
+            ],
+        )
+        .await
+        .unwrap();
+}
+
+fn authority_is_registered(hook_project_id: [u8; 16], hook_worktree_id: [u8; 16]) -> bool {
+    registered_context_scout_lifecycle_authorities()
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner)
+        .contains_key(&(hook_project_id, hook_worktree_id))
+}
+
+/// Every test below registers under hook ids unique to that test: the
+/// authority registry is process-global, so overlapping keys would make
+/// parallel tests observe each other's entries.
+async fn project_runtime(
+    temporary: &TempDir,
+    project_id: &ProjectId,
+) -> HostAdmissionTestRuntimeV1 {
+    HostAdmissionTestRuntimeV1::project(
+        temporary.path().join("profile"),
+        temporary.path().join("project"),
+        project_id.clone(),
+    )
+    .await
+    .unwrap()
+}
+
+#[test]
+fn complete_canonical_native_lifecycle_is_admitted_without_hash_identity() {
+    let lifecycle = lifecycle_from_canonical(
+        &id("profile.native"),
+        &id("project.native"),
+        &id("worktree.native"),
+        &id("session.native.codex"),
+        &complete_native_observation(),
+    )
+    .unwrap();
+    assert_eq!(lifecycle.provider_id.as_str(), "codex");
+    assert_eq!(lifecycle.session_id.as_str(), "session.native.codex");
+    assert_eq!(lifecycle.thread_id.as_str(), "thread.native.codex");
+    assert_eq!(lifecycle.turn_id.as_str(), "turn.native.codex");
+    assert_eq!(lifecycle.agent_id.as_str(), "agent.native.codex");
+    assert_eq!(
+        lifecycle.logical_message_id.as_str(),
+        "message.native.codex"
+    );
+}
+
+#[test]
+fn wrong_session_fails_closed() {
+    assert!(
+        lifecycle_from_canonical(
+            &id("profile.native"),
+            &id("project.native"),
+            &id("worktree.native"),
+            &id("session.other"),
+            &complete_native_observation(),
+        )
+        .is_none()
+    );
+}
+
+#[test]
+fn checked_in_native_fixture_without_complete_lifecycle_fails_closed() {
+    let fixture = include_str!(
+        "../../../tests/fixtures/provider_normalization/codex/agent_message.expected_envelope.json"
+    )
+    .replace("$STABLE_RECORD_ID", "message.native.fixture");
+    let observation = serde_json::from_str::<CanonicalObservationEnvelopeV1>(&fixture).unwrap();
+    assert!(
+        lifecycle_from_canonical(
+            &id("profile.native"),
+            &id("project.native"),
+            &id("worktree.native"),
+            observation.relations().session_id(),
+            &observation,
+        )
+        .is_none()
+    );
+}
+
+#[tokio::test]
+async fn protected_replay_locator_re_resolves_the_authoritative_native_lifecycle() {
+    let temporary = TempDir::new().unwrap();
+    let project_id = id::<ProjectId>("project.native.replay");
+    let worktree_id = id::<WorktreeId>("worktree.native.replay");
+    let runtime = project_runtime(&temporary, &project_id).await;
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+    sessions
+        .observation_store()
+        .persist_observation(durable_native_observation(&project_id))
+        .await
+        .unwrap();
+    let hook_project_id = [211; 16];
+    let hook_worktree_id = [212; 16];
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            hook_project_id,
+            hook_worktree_id,
+            project_id,
+            worktree_id,
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Registered
+    );
+
+    let session_id = lookup_registered_context_scout_native_session(
+        hook_project_id,
+        hook_worktree_id,
+        crate::hooks::protected_native_session_id("session.native.codex"),
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(session_id.as_str(), "session.native.codex");
+}
+
+/// The cap is a fail-closed bound, not a tuning knob: it must stay small
+/// enough to keep one hook lookup bounded, and `cap + 1` must remain a
+/// valid `i64` SQL `LIMIT` (the `try_from` in the lookup returns `None`
+/// otherwise, silently failing every lookup closed).
+#[test]
+fn session_observation_cap_stays_bounded_and_expressible_as_a_sql_limit() {
+    assert_eq!(MAX_CONTEXT_SCOUT_SESSION_OBSERVATIONS_V1, 64);
+    assert!(i64::try_from(MAX_CONTEXT_SCOUT_SESSION_OBSERVATIONS_V1 + 1).is_ok());
+}
+
+#[tokio::test]
+async fn zero_hook_identifiers_are_rejected_before_registration() {
+    let temporary = TempDir::new().unwrap();
+    let project_id = id::<ProjectId>("project.native.zero-hook");
+    let worktree_id = id::<WorktreeId>("worktree.native.zero-hook");
+    let runtime = project_runtime(&temporary, &project_id).await;
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+
+    // The two zero locators are distinguishable: neither is a conflict, and
+    // each names the field that was never admissible.
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [0; 16],
+            [71; 16],
+            project_id.clone(),
+            worktree_id.clone(),
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::ZeroHookProjectId)
+    );
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [71; 16],
+            [0; 16],
+            project_id,
+            worktree_id,
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::ZeroHookWorktreeId)
+    );
+    assert!(!authority_is_registered([0; 16], [71; 16]));
+    assert!(!authority_is_registered([71; 16], [0; 16]));
+}
+
+#[tokio::test]
+async fn profile_scoped_session_authority_is_rejected() {
+    let temporary = TempDir::new().unwrap();
+    let project_id = id::<ProjectId>("project.native.profile-scope");
+    let worktree_id = id::<WorktreeId>("worktree.native.profile-scope");
+    let runtime = project_runtime(&temporary, &project_id).await;
+    // A profile shard carries `StoreShardScopeV1::ProfileSessions`, which
+    // can never authorize a project-scoped lifecycle lookup.
+    let profile_sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Profile)
+        .unwrap();
+
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [41; 16],
+            [42; 16],
+            project_id,
+            worktree_id,
+            &profile_sessions,
+        ),
+        AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::NonProjectSessionScope)
+    );
+    assert!(!authority_is_registered([41; 16], [42; 16]));
+}
+
+#[tokio::test]
+async fn registration_rejects_a_project_that_the_authority_does_not_own() {
+    let temporary = TempDir::new().unwrap();
+    let bound_project_id = id::<ProjectId>("project.native.bound");
+    let worktree_id = id::<WorktreeId>("worktree.native.bound");
+    let runtime = project_runtime(&temporary, &bound_project_id).await;
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [43; 16],
+            [44; 16],
+            id::<ProjectId>("project.native.unowned"),
+            worktree_id,
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Rejected(AuthorityRejectionV1::ProjectNotOwnedByAuthority)
+    );
+    assert!(!authority_is_registered([43; 16], [44; 16]));
+}
+
+#[tokio::test]
+async fn re_registration_is_idempotent_but_conflicting_identity_is_rejected() {
+    let temporary = TempDir::new().unwrap();
+    let project_id = id::<ProjectId>("project.native.rereg");
+    let worktree_id = id::<WorktreeId>("worktree.native.rereg");
+    let runtime = project_runtime(&temporary, &project_id).await;
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [31; 16],
+            [32; 16],
+            project_id.clone(),
+            worktree_id.clone(),
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Registered
+    );
+    // An exactly-matching re-registration is a no-op, and says so instead
+    // of being indistinguishable from the fresh install above.
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [31; 16],
+            [32; 16],
+            project_id.clone(),
+            worktree_id,
+            &sessions,
+        ),
+        AuthorityRegistrationV1::AlreadyRegistered
+    );
+    // Same hook key, different native worktree: the live entry wins, and
+    // the caller learns this was a conflict rather than bad input.
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [31; 16],
+            [32; 16],
+            project_id,
+            id::<WorktreeId>("worktree.native.rereg-conflict"),
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Conflict
+    );
+    assert!(authority_is_registered([31; 16], [32; 16]));
+}
+
+#[tokio::test]
+async fn unregistration_removes_only_the_exact_session_client() {
+    let temporary = TempDir::new().unwrap();
+    let project_id = id::<ProjectId>("project.native.unregister");
+    let worktree_id = id::<WorktreeId>("worktree.native.unregister");
+    let runtime = project_runtime(&temporary, &project_id).await;
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [11; 16],
+            [12; 16],
+            project_id.clone(),
+            worktree_id,
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Registered
+    );
+
+    // A different client under the same locator pair must not unregister
+    // the incumbent: a rolled-back setup can never remove its successor.
+    let foreign_temporary = TempDir::new().unwrap();
+    let foreign_runtime = project_runtime(&foreign_temporary, &project_id).await;
+    let foreign_sessions = foreign_runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+    assert!(!unregister_context_scout_lifecycle_authority(
+        [11; 16],
+        [12; 16],
+        &foreign_sessions,
+    ));
+    assert!(authority_is_registered([11; 16], [12; 16]));
+
+    assert!(unregister_context_scout_lifecycle_authority(
+        [11; 16], [12; 16], &sessions,
+    ));
+    assert!(!authority_is_registered([11; 16], [12; 16]));
+}
+
+#[tokio::test]
+async fn registered_lifecycle_lookup_resolves_the_authoritative_tuple() {
+    let temporary = TempDir::new().unwrap();
+    let project_id = id::<ProjectId>("project.native.registered-lookup");
+    let worktree_id = id::<WorktreeId>("worktree.native.registered-lookup");
+    let runtime = project_runtime(&temporary, &project_id).await;
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+    sessions
+        .observation_store()
+        .persist_observation(durable_native_observation(&project_id))
+        .await
+        .unwrap();
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [21; 16],
+            [22; 16],
+            project_id,
+            worktree_id,
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Registered
+    );
+    let session_id = id::<SessionId>("session.native.codex");
+
+    let lifecycle = lookup_registered_context_scout_lifecycle([21; 16], [22; 16], &session_id)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        lifecycle.project_id.as_str(),
+        "project.native.registered-lookup"
+    );
+    assert_eq!(
+        lifecycle.worktree_id.as_str(),
+        "worktree.native.registered-lookup"
+    );
+    assert_eq!(lifecycle.provider_id.as_str(), "codex");
+    assert_eq!(lifecycle.session_id.as_str(), "session.native.codex");
+    assert_eq!(lifecycle.thread_id.as_str(), "thread.native.codex");
+    assert_eq!(lifecycle.turn_id.as_str(), "turn.native.codex");
+    assert_eq!(lifecycle.agent_id.as_str(), "agent.native.codex");
+    assert_eq!(
+        lifecycle.logical_message_id.as_str(),
+        "message.native.codex"
+    );
+    assert_eq!(
+        lifecycle.profile_id.as_str(),
+        sessions.binding().shard_id.profile_id.as_str()
+    );
+
+    // An unregistered hook pair resolves nothing, even though the same
+    // observation is durable and the same session id is requested.
+    assert!(
+        lookup_registered_context_scout_lifecycle([51; 16], [52; 16], &session_id)
+            .await
+            .is_none()
+    );
+}
+
+#[tokio::test]
+async fn lookup_rejects_a_binding_that_does_not_match_the_requested_identity() {
+    let temporary = TempDir::new().unwrap();
+    let project_id = id::<ProjectId>("project.native.binding");
+    let worktree_id = id::<WorktreeId>("worktree.native.binding");
+    let runtime = project_runtime(&temporary, &project_id).await;
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+    sessions
+        .observation_store()
+        .persist_observation(durable_native_observation(&project_id))
+        .await
+        .unwrap();
+    let bound_profile_id = sessions.binding().shard_id.profile_id.clone();
+    let session_id = id::<SessionId>("session.native.codex");
+
+    // Control: the matching identity does resolve, so the rejections
+    // below are attributable to the binding checks and nothing else.
+    assert!(
+        lookup_context_scout_lifecycle(
+            &bound_profile_id,
+            &project_id,
+            &worktree_id,
+            &session_id,
+            &sessions,
+        )
+        .await
+        .is_resolved()
+    );
+    // Both rejections still fail closed, and both name the binding check
+    // rather than the absence of evidence.
+    assert_eq!(
+        lookup_context_scout_lifecycle(
+            &UserProfileId::new("profile.native.not-bound").unwrap(),
+            &project_id,
+            &worktree_id,
+            &session_id,
+            &sessions,
+        )
+        .await,
+        ContextScoutLifecycleLookupV1::Unresolved(
+            ContextScoutLifecycleLookupFailureV1::UnauthorizedBinding
+        ),
+        "a profile that does not own the shard must fail closed"
+    );
+    assert_eq!(
+        lookup_context_scout_lifecycle(
+            &bound_profile_id,
+            &id::<ProjectId>("project.native.not-bound"),
+            &worktree_id,
+            &session_id,
+            &sessions,
+        )
+        .await,
+        ContextScoutLifecycleLookupV1::Unresolved(
+            ContextScoutLifecycleLookupFailureV1::UnauthorizedBinding
+        ),
+        "a project the shard is not scoped to must fail closed"
+    );
+}
+
+/// Every lookup failure reason must have a distinct, stable tracing
+/// label: the reasons only earn their keep if a log line can tell an
+/// unauthorized binding apart from exhausted evidence.
+#[test]
+fn lookup_failure_reasons_have_distinct_tracing_labels() {
+    use ContextScoutLifecycleLookupFailureV1 as Failure;
+    let reasons = [
+        Failure::InvalidProfileId,
+        Failure::InvalidProjectId,
+        Failure::InvalidWorktreeId,
+        Failure::InvalidSessionId,
+        Failure::UnauthorizedBinding,
+        Failure::SnapshotUnavailable,
+        Failure::ObservationQueryFailed,
+        Failure::ObservationRowUnreadable,
+        Failure::ObservationBudgetExceeded,
+        Failure::MalformedDurableObservation,
+        Failure::DurableScopeMismatch,
+        Failure::MalformedCanonicalEnvelope,
+        Failure::CanonicalEnvelopeMismatch,
+        Failure::NoCompleteLifecycle,
+    ];
+    let labels = reasons
+        .iter()
+        .map(|reason| reason.as_str())
+        .collect::<std::collections::BTreeSet<_>>();
+    assert_eq!(labels.len(), reasons.len());
+    // Every reason still fails closed for the `Option`-shaped callers.
+    for reason in reasons {
+        assert!(
+            ContextScoutLifecycleLookupV1::Unresolved(reason)
+                .into_address()
+                .is_none()
+        );
+    }
+}
+
+/// Every registration rejection must keep a distinct, stable label too.
+#[test]
+fn registration_rejections_have_distinct_labels() {
+    let rejections = [
+        AuthorityRejectionV1::ZeroHookProjectId,
+        AuthorityRejectionV1::ZeroHookWorktreeId,
+        AuthorityRejectionV1::InvalidProjectId,
+        AuthorityRejectionV1::InvalidWorktreeId,
+        AuthorityRejectionV1::NonProjectSessionScope,
+        AuthorityRejectionV1::ProjectNotOwnedByAuthority,
+    ];
+    let labels = rejections
+        .iter()
+        .map(|rejection| rejection.as_str())
+        .collect::<std::collections::BTreeSet<_>>();
+    assert_eq!(labels.len(), rejections.len());
+}
+
+#[tokio::test]
+async fn durable_scope_and_session_mismatches_fail_closed() {
+    let temporary = TempDir::new().unwrap();
+    let project_id = id::<ProjectId>("project.native.durable-scope");
+    let worktree_id = id::<WorktreeId>("worktree.native.durable-scope");
+    let runtime = project_runtime(&temporary, &project_id).await;
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+    // Durable evidence carrying a foreign project scope, stored in the
+    // shard that the lookup is otherwise authorized against.
+    let foreign = durable_native_observation(&id::<ProjectId>("project.native.foreign-scope"));
+    // The store contract refuses to create this state: every observation
+    // operation is gated on the observation scope matching the bound
+    // shard family, so the runtime rejects the write before it reaches
+    // the shard. The row can therefore only arrive by corruption or a
+    // pre-contract import, which is exactly what the lookup's durable
+    // scope check has to survive.
+    assert!(
+        sessions
+            .observation_store()
+            .persist_observation(foreign.clone())
+            .await
+            .is_err(),
+        "the runtime must refuse a foreign-scoped write against this shard"
+    );
+    stage_foreign_scoped_observation(&sessions, &foreign).await;
+    let bound_profile_id = sessions.binding().shard_id.profile_id.clone();
+
+    // Foreign-scoped evidence and no evidence at all both fail closed,
+    // but they are not the same observable outcome.
+    assert_eq!(
+        lookup_context_scout_lifecycle(
+            &bound_profile_id,
+            &project_id,
+            &worktree_id,
+            &id::<SessionId>("session.native.codex"),
+            &sessions,
+        )
+        .await,
+        ContextScoutLifecycleLookupV1::Unresolved(
+            ContextScoutLifecycleLookupFailureV1::DurableScopeMismatch
+        ),
+        "an observation scoped to another project must never satisfy this lookup"
+    );
+    assert_eq!(
+        lookup_context_scout_lifecycle(
+            &bound_profile_id,
+            &project_id,
+            &worktree_id,
+            &id::<SessionId>("session.native.absent"),
+            &sessions,
+        )
+        .await,
+        ContextScoutLifecycleLookupV1::Unresolved(
+            ContextScoutLifecycleLookupFailureV1::NoCompleteLifecycle
+        ),
+        "a session with no durable evidence must fail closed"
+    );
+}
+
+#[tokio::test]
+async fn zero_protected_session_id_is_rejected_even_with_a_live_authority() {
+    let temporary = TempDir::new().unwrap();
+    let project_id = id::<ProjectId>("project.native.zero-protected");
+    let runtime = project_runtime(&temporary, &project_id).await;
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+    sessions
+        .observation_store()
+        .persist_observation(durable_native_observation(&project_id))
+        .await
+        .unwrap();
+    assert_eq!(
+        register_context_scout_lifecycle_authority(
+            [61; 16],
+            [62; 16],
+            project_id,
+            id::<WorktreeId>("worktree.native.zero-protected"),
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Registered
+    );
+
+    assert!(
+        lookup_registered_context_scout_native_session([61; 16], [62; 16], [0; 32])
+            .await
+            .is_none(),
+        "an all-zero protected locator is never a resolvable session"
+    );
+}
diff --git a/src/daemon/hook_v2_replay.rs b/src/daemon/hook_v2_replay.rs
index 260cc6ce9e..b0bd0e1d66 100644
--- a/src/daemon/hook_v2_replay.rs
+++ b/src/daemon/hook_v2_replay.rs
@@ -392,9 +392,17 @@ async fn drain_all_hosts(
         for envelope in hook_v2_pending_work_envelopes(data_root, *host, now) {
             let _ = admit_replayed_envelope_with_authoritative_session(
                 envelope,
-                |_, _, _| async move { None },
-                |envelope, _| async move {
-                    admit_hook_v2_envelope(graph, &envelope, hook_replay_now()).await
+                |project_id, worktree_id, protected_session_id| async move {
+                    crate::daemon::context_scout_lifecycle::lookup_registered_context_scout_native_session(
+                        project_id,
+                        worktree_id,
+                        protected_session_id,
+                    )
+                    .await
+                },
+                |envelope, native_session_id| async move {
+                    admit_hook_v2_envelope(graph, &envelope, native_session_id, hook_replay_now())
+                        .await
                 },
             )
             .await;
@@ -402,9 +410,17 @@ async fn drain_all_hosts(
         let report = drain_host_spool_once(data_root, *host, now, |envelope| async move {
             admit_replayed_envelope_with_authoritative_session(
                 envelope,
-                |_, _, _| async move { None },
-                |envelope, _| async move {
-                    admit_hook_v2_envelope(graph, &envelope, hook_replay_now()).await
+                |project_id, worktree_id, protected_session_id| async move {
+                    crate::daemon::context_scout_lifecycle::lookup_registered_context_scout_native_session(
+                        project_id,
+                        worktree_id,
+                        protected_session_id,
+                    )
+                    .await
+                },
+                |envelope, native_session_id| async move {
+                    admit_hook_v2_envelope(graph, &envelope, native_session_id, hook_replay_now())
+                        .await
                 },
             )
             .await
@@ -708,6 +724,72 @@ mod tests {
         assert_eq!(pending_records(root.path(), now), 0);
     }
 
+    #[tokio::test]
+    async fn live_failure_spools_then_replay_preserves_lifecycle_for_suggestion() {
+        let root = TestRoot::new("lifecycle-suggestion");
+        let now = UtcMicros(1_000);
+        let binding = binding(7);
+        publish_binding(root.path(), &binding, now);
+        let mut edit = envelope(9, &binding);
+        edit.protected_session_id =
+            crate::hooks::protected_native_session_id("session.native.replay");
+        edit.event = HookEventV2::SavedEdit {
+            file_id: [8; 16],
+            changed_range_count: 1,
+        };
+        // The synchronous admission failed, so the host retained only the
+        // validated, payload-free envelope for daemon replay.
+        spool_envelopes(root.path(), &binding, &[edit], now);
+        let suggestions = Arc::new(StdMutex::new(Vec::new()));
+        let captured = Arc::clone(&suggestions);
+
+        let report = drain_host_spool_once(root.path(), HOST, now, move |envelope| {
+            let captured = Arc::clone(&captured);
+            async move {
+                admit_replayed_envelope_with_authoritative_session(
+                    envelope,
+                    |project_id, worktree_id, protected_session_id| async move {
+                        assert_eq!(project_id, [1; 16]);
+                        assert_eq!(worktree_id, [3; 16]);
+                        assert_eq!(
+                            protected_session_id,
+                            crate::hooks::protected_native_session_id("session.native.replay")
+                        );
+                        Some(SessionId::new("session.native.replay".to_owned()).unwrap())
+                    },
+                    |_, native_session_id| async move {
+                        if native_session_id.as_ref().map(SessionId::as_str)
+                            == Some("session.native.replay")
+                        {
+                            captured
+                                .lock()
+                                .unwrap()
+                                .push("replayed lifecycle suggestion");
+                        }
+                        HookV2AdmissionOutcomeV1::Admitted {
+                            orchestration: crate::daemon::HookOrchestrationAdmissionV1::Enqueued,
+                            ready_guidance: serde_json::json!({
+                                "suggestion": "replayed lifecycle suggestion"
+                            }),
+                            feedback_notice: serde_json::Value::Null,
+                            github_stack_signal_available: false,
+                        }
+                    },
+                )
+                .await
+            }
+        })
+        .await
+        .unwrap();
+
+        assert_eq!(report.committed, 1);
+        assert_eq!(
+            suggestions.lock().unwrap().as_slice(),
+            ["replayed lifecycle suggestion"]
+        );
+        assert_eq!(pending_records(root.path(), now), 0);
+    }
+
     #[tokio::test]
     async fn async_admission_does_not_hold_the_spool_writer_lease() {
         let data_root = tempfile::tempdir().unwrap();
diff --git a/src/daemon/project_open_owners/advisory_runtime.rs b/src/daemon/project_open_owners/advisory_runtime.rs
index 3ed2c19bea..1e1cc8dc84 100644
--- a/src/daemon/project_open_owners/advisory_runtime.rs
+++ b/src/daemon/project_open_owners/advisory_runtime.rs
@@ -5,6 +5,7 @@ use std::process::Command;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
+use sha2::{Digest, Sha256};
 use tracedecay_application::feedback::{
     FeedbackRuntimeStatePort, GITHUB_REVIEW_INGEST_CAPABILITY_ID_V1,
     GITHUB_REVIEW_INGEST_USE_CASE_ID_V1, GitHubReviewReadRequestV1, ProximityEvaluationRequestV1,
@@ -15,9 +16,12 @@ use tracedecay_application::{
 };
 use tracedecay_domain::GitHeadStateV1;
 use tracedecay_domain::feedback::{
-    CiFailureParserIdentityV1, FeedbackScopeV1, GitHubPullRequestIdV1, GitHubReviewReadOperationV1,
+    CiFailureParserIdentityV1, FeedbackScopeV1, FeedbackTriggerV1, GitHubPullRequestIdV1,
+    GitHubReviewReadOperationV1,
+};
+use tracedecay_domain::{
+    CommitId, HostKindV1, ManifestDigest, ProviderId, UtcMicros, canonical_sha256,
 };
-use tracedecay_domain::{CommitId, HostKindV1, ProviderId, UtcMicros, canonical_sha256};
 use tracedecay_global_db::configuration::OwnedGlobalDbConfigurationControlStore;
 use tracedecay_hooks::{
     HookConfigurationFileReaderV1, HookConfigurationReadOutcomeV1, HookConfigurationSubscriberV1,
@@ -51,11 +55,16 @@ use tracedecay_usecases::delivery::{
     ProjectDeliveryReadOpenV1, ProjectDeliveryReviewBodySourceV1,
     gated_project_delivery_read_handle_v1, open_project_delivery_read_authority_v1,
 };
+use tracedecay_usecases::feedback::concrete::FeedbackRuntime;
+use tracedecay_usecases::feedback::observations::{
+    FeedbackDeliveryRouteV1, FeedbackObservationEmitterV1, FeedbackOperationV1, FeedbackOutcomeV1,
+    FeedbackSourceEventV1,
+};
 use tracedecay_usecases::feedback::{
-    FeedbackCycleLspInput, FeedbackCycleRuntime, ProductionFeedbackCycleAuthorizationFuture,
-    ProductionFeedbackCycleAuthorizationPort, ProductionFeedbackCycleOpenV1,
-    ProductionFeedbackRuntimeStateV1, resolve_production_feedback_cycle_parts,
-    resolve_project_feedback_scope_v1,
+    FeedbackCycleInvocation, FeedbackCycleLspInput, FeedbackCycleRuntime,
+    ProductionFeedbackCycleAuthorizationFuture, ProductionFeedbackCycleAuthorizationPort,
+    ProductionFeedbackCycleOpenV1, ProductionFeedbackRuntimeStateV1,
+    resolve_production_feedback_cycle_parts, resolve_project_feedback_scope_v1,
 };
 use tracedecay_usecases::lsp_runtime::DaemonLspSessionFactory;
 use tracedecay_usecases::operation_stream::OperationKind;
@@ -64,19 +73,38 @@ use super::{
     DaemonInvocationState, POLICY_REVISION_V1, daemon_owned_project_source_access_at,
     register_semantic_activation_owner,
 };
+use crate::agents::context_scout_owner::ProjectContextScoutOwnerV1;
+use crate::agents::context_scout_ports::{
+    ContextScoutAuthorityPinV1, ContextScoutCanonicalInputAssemblerV1,
+    ContextScoutConfigurationPinV1, ProjectContextScoutAddressRegistryV1,
+};
+use crate::agents::context_scout_v2::{
+    ContextScoutDeliverySelectionInputV1, ContextScoutOutcomeV1, ContextScoutRuntimeOutcomeV1,
+    ContextScoutServiceStateV1, ContextScoutTriggerV1,
+};
+use crate::daemon::context_scout_lifecycle::{
+    AuthorityRegistrationV1, register_context_scout_lifecycle_authority,
+    unregister_context_scout_lifecycle_authority,
+};
 use crate::daemon::service::invocation::{
-    DaemonAdvisoryCycleInvocationFuture, DaemonAdvisoryCycleInvocationOwner,
-    DaemonAdvisoryCycleInvocationPort, DaemonAdvisoryCycleInvocationRequest,
-    advisory_cycle_invocation_result, daemon_operation_event_authority,
+    BoundedHookOrchestratorV1, DaemonAdvisoryCycleInvocationFuture,
+    DaemonAdvisoryCycleInvocationOwner, DaemonAdvisoryCycleInvocationPort,
+    DaemonAdvisoryCycleInvocationRequest, HookOrchestrationRequestV1, HookOrchestrationTriggerV1,
+    HookOrchestrationWorkOutcomeV1, advisory_cycle_invocation_result,
+    daemon_operation_event_authority, register_hook_orchestration_runtime,
+    unregister_hook_orchestration_runtime,
 };
 use crate::daemon::service::project_runtime::RegisteredDeliveryReadAuthorityV1;
 use crate::errors::{Result, TraceDecayError};
+use crate::mcp::tools::handlers::hook_runtime::daemon_mint_hook_v2_file_id;
 
 mod deferred;
 mod model;
 pub(crate) use model::ProjectOpenDependentOwnerState;
 use model::advisory_monotonic_deadline;
 #[cfg(test)]
+mod scout_journey_tests;
+#[cfg(test)]
 mod tests;
 
 #[derive(Clone)]
@@ -93,11 +121,14 @@ struct ProjectOpenAdvisoryFeedbackCycleV1 {
 struct ProjectOpenAdvisoryCycleExecutionV1 {
     context: RequestContext,
     outcome: AdvisoryCycleOutcome,
+    observed_at: UtcMicros,
+    configuration_digest: ManifestDigest,
 }
 
 struct PublishedAdvisoryRuntimeV1 {
     _registration: Arc<AdvisoryProductionStartupRegistrationV1>,
     _hook_notices: AdvisoryHookNoticeRegistrationV1,
+    _scout_hooks: ScoutHookRegistrationV1,
 }
 
 struct AdvisoryHookNoticeRegistrationV1 {
@@ -116,14 +147,72 @@ impl Drop for AdvisoryHookNoticeRegistrationV1 {
     }
 }
 
+/// Retains this runtime's hook-cycle registrations: the bounded orchestrator
+/// published under the authenticated hook locators and, when this setup
+/// installed it, the Scout lifecycle authority. Dropping the lease removes
+/// exactly this runtime's entries; an incumbent registered by a live peer is
+/// never swept.
+struct ScoutHookRegistrationV1 {
+    hook_project_id: [u8; 16],
+    hook_worktree_id: [u8; 16],
+    lifecycle_sessions: crate::global_db::RegisteredGlobalDbLeaseV1,
+    lifecycle_registered_here: bool,
+    orchestrator: Arc<BoundedHookOrchestratorV1>,
+}
+
+impl Drop for ScoutHookRegistrationV1 {
+    fn drop(&mut self) {
+        unregister_hook_orchestration_runtime(
+            self.hook_project_id,
+            self.hook_worktree_id,
+            &self.orchestrator,
+        );
+        if self.lifecycle_registered_here {
+            unregister_context_scout_lifecycle_authority(
+                self.hook_project_id,
+                self.hook_worktree_id,
+                &self.lifecycle_sessions,
+            );
+        }
+    }
+}
+
 impl ProjectOpenAdvisoryFeedbackCycleV1 {
     async fn run_cycle(
         &self,
         request: FeedbackCycleRequest,
         deadline: MonotonicDeadline,
+        agent_stop_gate: bool,
+    ) -> std::result::Result<ProjectOpenAdvisoryCycleExecutionV1, LspRuntimeFailure> {
+        self.run_cycle_with_lsp_input(
+            Arc::clone(&self.lsp_input),
+            request,
+            deadline,
+            agent_stop_gate,
+        )
+        .await
+    }
+
+    async fn run_cycle_with_lsp_input(
+        &self,
+        lsp_input: FeedbackCycleLspInput,
+        request: FeedbackCycleRequest,
+        deadline: MonotonicDeadline,
+        agent_stop_gate: bool,
     ) -> std::result::Result<ProjectOpenAdvisoryCycleExecutionV1, LspRuntimeFailure> {
-        let invocation = (self.lsp_input)(request).await?;
+        let mut invocation = lsp_input(request).await?;
+        if agent_stop_gate {
+            invocation.request.input.request.trigger = FeedbackTriggerV1::AgentStopGate;
+            invocation = FeedbackCycleInvocation::new(invocation.context, invocation.request)
+                .map_err(|_| LspRuntimeFailure::new("feedback-cycle-advisory-stop-gate"))?;
+        }
         let observed_at = invocation.request.input.observed_at;
+        let configuration_digest = invocation
+            .request
+            .input
+            .request
+            .configuration_digest
+            .clone();
         let ci = match self.ci_discovery_config.as_ref() {
             Some(config) => {
                 discover_production_ci_failure_request_v1(
@@ -200,6 +289,8 @@ impl ProjectOpenAdvisoryFeedbackCycleV1 {
         Ok(ProjectOpenAdvisoryCycleExecutionV1 {
             context: invocation.context,
             outcome,
+            observed_at,
+            configuration_digest,
         })
     }
 
@@ -308,6 +399,7 @@ impl FeedbackCycleRuntimePort for ProjectOpenAdvisoryFeedbackCycleV1 {
                 .run_cycle(
                     request,
                     MonotonicDeadline::at(Instant::now() + Duration::from_secs(5)),
+                    false,
                 )
                 .await?;
             Ok(())
@@ -334,6 +426,7 @@ impl DaemonAdvisoryCycleInvocationPort for ProjectOpenAdvisoryFeedbackCycleV1 {
                         trigger: DiagnosticTrigger::ExplicitDocumentDiagnostics,
                     },
                     monotonic_deadline,
+                    false,
                 )
                 .await
                 .map_err(|failure| {
@@ -392,6 +485,422 @@ fn unavailable_advisory_hook_sink() -> Arc<AdvisoryHookNoticeSinkV1> {
     Arc::new(unavailable_advisory_hook_notice)
 }
 
+async fn install_project_open_context_scout_configuration(
+    owner: &ProjectContextScoutOwnerV1,
+    pin: ContextScoutConfigurationPinV1,
+    model_config: &tracedecay_agent_hosts::automation::config::AutomationConfig,
+) -> Result<()> {
+    let admitted_model_config = pin.control().model_path.and_then(|expected| {
+        (crate::agents::context_scout_model::context_scout_backend_from_automation_config(
+            model_config,
+        ) == expected)
+            .then_some(model_config)
+    });
+    owner
+        .install_configuration(pin, admitted_model_config)
+        .await
+        .map_err(|error| TraceDecayError::Config {
+            message: format!("project-open Context Scout configuration failed: {error}"),
+        })
+}
+
+/// Producer inputs retained for the bounded hook cycle: the durable Scout
+/// owner and address registry, the committed-publication read port, and the
+/// exact current-generation authority that maps saved-edit hooks back to
+/// indexed documents.
+struct ProjectOpenScoutProducerV1 {
+    graph: Arc<crate::tracedecay::TraceDecay>,
+    scout_owner: Arc<ProjectContextScoutOwnerV1>,
+    scout_registry: Arc<ProjectContextScoutAddressRegistryV1>,
+    feedback_runtime: Arc<FeedbackRuntime>,
+    project_root: std::path::PathBuf,
+    scope: tracedecay_application::ResolvedScope,
+    code_index_schedulers: crate::daemon::code_index_scheduler::CodeIndexSchedulerRegistryV1,
+    session_db: crate::global_db::RegisteredGlobalDbLeaseV1,
+    code_graph: Arc<dyn tracedecay_usecases::graph::CodeGraphProjectionReadPort>,
+    requester: tracedecay_domain::ActorId,
+    diagnostic_broker: Arc<tokio::sync::Mutex<tracedecay_lsp::analyzer::broker::DiagnosticBroker>>,
+}
+
+async fn current_feedback_lsp_input(
+    producer: &ProjectOpenScoutProducerV1,
+    indexed_files: &[String],
+) -> std::result::Result<FeedbackCycleLspInput, LspRuntimeFailure> {
+    let pinned_configuration = producer
+        .graph
+        .configuration_runtime()
+        .client()
+        .current()
+        .await
+        .map_err(|_| LspRuntimeFailure::new("feedback-cycle-current-configuration"))?;
+    let current_configuration = tracedecay_usecases::configuration::ConfigurationCurrentStateV1 {
+        revision_id: pinned_configuration.revision_id,
+        snapshot: pinned_configuration.snapshot,
+    };
+    let configuration_digest = current_configuration
+        .snapshot
+        .effective_behavior_digest
+        .clone();
+    let policy_digest = canonical_sha256(&(
+        "tracedecay.project-open.policy.v1",
+        &configuration_digest,
+        POLICY_REVISION_V1,
+    ))
+    .map_err(|_| LspRuntimeFailure::new("feedback-cycle-current-policy"))?;
+    let runtime_state: Arc<dyn FeedbackRuntimeStatePort + Send + Sync> =
+        Arc::new(ProductionFeedbackRuntimeStateV1::new(
+            Arc::clone(&producer.code_graph),
+            configuration_digest,
+            policy_digest,
+        ));
+    let authorization: Arc<dyn ProductionFeedbackCycleAuthorizationPort> =
+        Arc::new(ProjectOpenFeedbackCycleAuthorizationV1 {
+            project_root: producer.project_root.clone(),
+            scope: producer.scope.clone(),
+            configuration: Arc::clone(producer.graph.configuration_runtime()),
+        });
+    let mounted_providers = producer
+        .diagnostic_broker
+        .lock()
+        .await
+        .mounted_providers_for_files(indexed_files);
+    resolve_production_feedback_cycle_parts(ProductionFeedbackCycleOpenV1 {
+        project_root: producer.project_root.clone(),
+        scope: producer.scope.clone(),
+        access_configuration: current_configuration,
+        requester: producer.requester.clone(),
+        authorization,
+        code_graph: Arc::clone(&producer.code_graph),
+        project_runtime_db: producer.session_db.clone(),
+        runtime_state,
+        document_identity: Arc::new(producer.code_index_schedulers.clone()),
+        code_index_identity: Arc::new(producer.code_index_schedulers.clone()),
+        test_attribution: Arc::new(producer.code_index_schedulers.clone()),
+        mounted_providers,
+    })
+    .await
+    .map(|parts| parts.lsp_input)
+    .map_err(|_| LspRuntimeFailure::new("feedback-cycle-current-input"))
+}
+
+/// One admitted hook boundary's advisory-and-Scout cycle: the Plan 09
+/// one-shot advisory/hook-notice run, then the Scout producer tail —
+/// canonical input assembly from the latest committed publication, daemon-side
+/// delivery selection, `prepare_configured`, and a claim-authority mount for
+/// the enqueued generation. Every early return is a typed fail-closed state;
+/// none of them invents guidance.
+async fn run_production_hook_cycle(
+    cycle: Arc<ProjectOpenAdvisoryFeedbackCycleV1>,
+    producer: Arc<ProjectOpenScoutProducerV1>,
+    request: HookOrchestrationRequestV1,
+    work_cancellation: tracedecay_runtime_core::cancellation::CancellationToken,
+) -> HookOrchestrationWorkOutcomeV1 {
+    if work_cancellation.is_cancelled() {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    }
+    let Some(generation) = producer
+        .code_index_schedulers
+        .latest_complete_ready_decoded_for_root_scope(&producer.project_root, &producer.scope)
+        .await
+    else {
+        observe_hook_feedback_cycle_terminal(
+            &cycle.registration.host_delivery.source_observations,
+            &request,
+            FeedbackOutcomeV1::Unavailable,
+        );
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    };
+    let mut indexed_files = generation
+        .generation()
+        .snapshot()
+        .files
+        .iter()
+        .map(|file| file.logical_path.clone())
+        .collect::<Vec<_>>();
+    indexed_files.sort();
+    let Some(document_uri) = hook_feedback_document_uri_or_observe(
+        &producer.project_root,
+        &indexed_files,
+        &request,
+        &cycle.registration.host_delivery.source_observations,
+    ) else {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    };
+    let Ok(lsp_input) = current_feedback_lsp_input(&producer, &indexed_files).await else {
+        observe_hook_feedback_cycle_terminal(
+            &cycle.registration.host_delivery.source_observations,
+            &request,
+            FeedbackOutcomeV1::Unavailable,
+        );
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    };
+    let diagnostic_trigger = match request.trigger {
+        HookOrchestrationTriggerV1::SavedEdit => DiagnosticTrigger::DocumentSave,
+        HookOrchestrationTriggerV1::Stop | HookOrchestrationTriggerV1::Explicit => {
+            DiagnosticTrigger::ExplicitDocumentDiagnostics
+        }
+    };
+    let execution = match cycle
+        .run_cycle_with_lsp_input(
+            lsp_input,
+            FeedbackCycleRequest {
+                root_uri: cycle.root_uri.clone(),
+                document_uri,
+                trigger: diagnostic_trigger,
+            },
+            MonotonicDeadline::at(Instant::now() + Duration::from_secs(5)),
+            request.trigger == HookOrchestrationTriggerV1::Stop,
+        )
+        .await
+    {
+        Ok(execution) => execution,
+        Err(_) => {
+            observe_hook_feedback_cycle_terminal(
+                &cycle.registration.host_delivery.source_observations,
+                &request,
+                FeedbackOutcomeV1::Unavailable,
+            );
+            return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+        }
+    };
+    if work_cancellation.is_cancelled() {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    }
+    let observed_at = execution.observed_at;
+    // The Scout tail re-pins the current Plan 20 configuration: a revision
+    // that landed while the advisory half ran must not produce guidance
+    // under the superseded control state.
+    let Ok(pinned_configuration) = producer
+        .graph
+        .configuration_runtime()
+        .client()
+        .current()
+        .await
+    else {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    };
+    let current_configuration = tracedecay_usecases::configuration::ConfigurationCurrentStateV1 {
+        revision_id: pinned_configuration.revision_id.clone(),
+        snapshot: pinned_configuration.snapshot.clone(),
+    };
+    let Some(scout_configuration) =
+        ContextScoutConfigurationPinV1::from_current(&current_configuration)
+    else {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    };
+    if scout_configuration.configuration_digest() != &execution.configuration_digest {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    }
+    let Ok(model_config) = tracedecay_agent_hosts::automation::config::from_configuration_snapshot(
+        &pinned_configuration.snapshot,
+    ) else {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    };
+    if install_project_open_context_scout_configuration(
+        producer.scout_owner.as_ref(),
+        scout_configuration.clone(),
+        &model_config,
+    )
+    .await
+    .is_err()
+    {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    }
+    let Some(lifecycle) = request.lifecycle else {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    };
+    let Some(pin) = ContextScoutAuthorityPinV1::new(
+        &execution.context,
+        cycle.feedback_scope.clone(),
+        scout_configuration,
+        observed_at,
+    ) else {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    };
+    let assembler = ContextScoutCanonicalInputAssemblerV1::new(
+        producer.scout_registry.as_ref(),
+        producer.feedback_runtime.as_ref(),
+    );
+    let Some(canonical) = assembler
+        .bind_and_assemble(
+            &request.hook,
+            &pin,
+            lifecycle.clone(),
+            &execution.context,
+            observed_at,
+        )
+        .await
+    else {
+        return HookOrchestrationWorkOutcomeV1::RetryableFailure;
+    };
+    let trigger = match request.trigger {
+        HookOrchestrationTriggerV1::SavedEdit => ContextScoutTriggerV1::SavedEdit,
+        HookOrchestrationTriggerV1::Stop => ContextScoutTriggerV1::StopBoundary,
+        HookOrchestrationTriggerV1::Explicit => ContextScoutTriggerV1::ExplicitRequest,
+    };
+    let recent = producer
+        .scout_owner
+        .recent_exact(canonical.address, 32)
+        .await
+        .ok();
+    let has_recent_delivery = recent
+        .as_ref()
+        .is_some_and(|recent| !recent.deliveries.is_empty());
+    let has_unresolved_interaction = recent.as_ref().is_some_and(|recent| {
+        !recent.pending.is_empty()
+            || recent.deliveries.iter().any(|delivery| {
+                delivery.feedback.is_none()
+                    && matches!(
+                        delivery.receipt.outcome,
+                        ContextScoutOutcomeV1::Attempted
+                            | ContextScoutOutcomeV1::Delayed
+                            | ContextScoutOutcomeV1::Displayed
+                            | ContextScoutOutcomeV1::Expanded
+                            | ContextScoutOutcomeV1::Unknown
+                    )
+            })
+    });
+    let Some(selection) = canonical.selection_input(
+        &request.hook,
+        observed_at,
+        ContextScoutDeliverySelectionInputV1 {
+            trigger,
+            quiet_mode: canonical.control.state != ContextScoutServiceStateV1::Active,
+            has_recent_delivery,
+            has_unresolved_interaction,
+            critical_safety_evidence: false,
+            delivered_dedupe_keys: recent
+                .as_ref()
+                .into_iter()
+                .flat_map(|recent| recent.deliveries.iter())
+                .map(|delivery| delivery.entry.envelope.candidate.dedupe_key)
+                .collect(),
+        },
+    ) else {
+        return HookOrchestrationWorkOutcomeV1::Completed;
+    };
+    let outcome = producer
+        .scout_owner
+        .prepare_configured(
+            &selection,
+            MonotonicDeadline::at(Instant::now() + Duration::from_secs(5)),
+            work_cancellation.clone(),
+        )
+        .await;
+    match outcome {
+        Ok(ContextScoutRuntimeOutcomeV1::Enqueued { .. }) => producer
+            .graph
+            .mount_current_context_scout_claim_authority(
+                Arc::clone(&producer.scout_registry),
+                &request.hook,
+                pin,
+                execution.context,
+                lifecycle,
+                canonical.address,
+                selection.input_watermark,
+                observed_at,
+            )
+            .await
+            .then_some(HookOrchestrationWorkOutcomeV1::Completed)
+            .unwrap_or(HookOrchestrationWorkOutcomeV1::RetryableFailure),
+        Ok(ContextScoutRuntimeOutcomeV1::Suppressed { .. }) => {
+            HookOrchestrationWorkOutcomeV1::Completed
+        }
+        Ok(ContextScoutRuntimeOutcomeV1::Unavailable) | Err(_) => {
+            HookOrchestrationWorkOutcomeV1::RetryableFailure
+        }
+    }
+}
+
+fn observe_hook_feedback_cycle_terminal(
+    observations: &Arc<dyn FeedbackObservationEmitterV1 + Send + Sync>,
+    request: &HookOrchestrationRequestV1,
+    outcome: FeedbackOutcomeV1,
+) {
+    let envelope = request.hook.envelope();
+    let trigger = match request.trigger {
+        HookOrchestrationTriggerV1::SavedEdit => "saved_edit",
+        HookOrchestrationTriggerV1::Stop => "stop",
+        HookOrchestrationTriggerV1::Explicit => "explicit",
+    };
+    let Ok(subject) = canonical_sha256(&(
+        "tracedecay.feedback.accepted-hook-cycle.v1",
+        envelope.event_id,
+        envelope.project_id,
+        envelope.repository_id,
+        envelope.worktree_id,
+        &request.hook_configuration_revision,
+        trigger,
+    )) else {
+        return;
+    };
+    observations.observe_source_event_for_subject(
+        subject,
+        envelope.observed_at,
+        FeedbackSourceEventV1::Delivery {
+            operation: FeedbackOperationV1::FeedbackCycle,
+            route: FeedbackDeliveryRouteV1::HookV2,
+            outcome,
+            item_count: 0,
+            duration_micros: None,
+        },
+    );
+}
+
+fn hook_feedback_document_uri_or_observe(
+    project_root: &Path,
+    indexed_files: &[String],
+    request: &HookOrchestrationRequestV1,
+    observations: &Arc<dyn FeedbackObservationEmitterV1 + Send + Sync>,
+) -> Option<String> {
+    let document_uri = hook_feedback_document_uri(project_root, indexed_files, request);
+    if document_uri.is_none() {
+        observe_hook_feedback_cycle_terminal(
+            observations,
+            request,
+            if indexed_files.is_empty() {
+                FeedbackOutcomeV1::Unavailable
+            } else {
+                FeedbackOutcomeV1::Partial
+            },
+        );
+    }
+    document_uri
+}
+
+fn hook_feedback_document_uri(
+    project_root: &Path,
+    indexed_files: &[String],
+    request: &HookOrchestrationRequestV1,
+) -> Option<String> {
+    let logical_path = match &request.hook.envelope().event {
+        tracedecay_hooks::HookEventV2::SavedEdit { file_id, .. } => {
+            indexed_files.iter().find(|logical_path| {
+                let logical_file_id = daemon_mint_hook_v2_file_id(
+                    request.hook.envelope(),
+                    hash16(logical_path.as_bytes()),
+                );
+                let absolute_file_id = daemon_mint_hook_v2_file_id(
+                    request.hook.envelope(),
+                    hash16(project_root.join(logical_path).to_string_lossy().as_bytes()),
+                );
+                logical_file_id == *file_id || absolute_file_id == *file_id
+            })?
+        }
+        _ => indexed_files.first()?,
+    };
+    url::Url::from_file_path(project_root.join(logical_path))
+        .ok()
+        .map(Into::into)
+}
+
+fn hash16(value: &[u8]) -> [u8; 16] {
+    let digest = Sha256::digest(value);
+    let mut value = [0_u8; 16];
+    value.copy_from_slice(&digest[..16]);
+    value
+}
+
 pub(super) async fn register_production_feedback_and_advisory(
     invocation: &DaemonInvocationState,
     project_root: &Path,
@@ -611,6 +1120,59 @@ async fn register_production_advisory_owner(
     lsp_input: FeedbackCycleLspInput,
     lsp_session_factory: Arc<DaemonLspSessionFactory>,
 ) -> Result<()> {
+    let scout_configuration = ContextScoutConfigurationPinV1::from_current(
+        &state.scout_configuration,
+    )
+    .ok_or_else(|| TraceDecayError::Config {
+        message: "project-open Context Scout configuration is unavailable".to_owned(),
+    })?;
+    let scout_owner =
+        state
+            .graph
+            .context_scout_owner()
+            .cloned()
+            .ok_or_else(|| TraceDecayError::Config {
+                message: "project-open Context Scout owner is unavailable".to_owned(),
+            })?;
+    let configuration = state
+        .graph
+        .configuration_runtime()
+        .client()
+        .current()
+        .await
+        .map_err(|error| TraceDecayError::Config {
+            message: format!("project-open automation configuration is unavailable: {error}"),
+        })?;
+    let current_configuration = tracedecay_usecases::configuration::ConfigurationCurrentStateV1 {
+        revision_id: configuration.revision_id.clone(),
+        snapshot: configuration.snapshot.clone(),
+    };
+    if !scout_configuration.matches_current(&current_configuration) {
+        return Err(TraceDecayError::Config {
+            message: "project-open Context Scout configuration changed before model installation"
+                .to_owned(),
+        });
+    }
+    let model_config = tracedecay_agent_hosts::automation::config::from_configuration_snapshot(
+        &configuration.snapshot,
+    )?;
+    install_project_open_context_scout_configuration(
+        scout_owner.as_ref(),
+        scout_configuration,
+        &model_config,
+    )
+    .await?;
+    let scout_registry = invocation
+        .context_scout_runtime_registrar()
+        .get(
+            &state.session_db.binding().shard_id.profile_id,
+            &state.scope.project_id,
+            project_root,
+        )
+        .await
+        .ok_or_else(|| TraceDecayError::Config {
+            message: "project-open Context Scout address registry is unavailable".to_owned(),
+        })?;
     let remote =
         resolve_production_github_provider_config(invocation, project_root, state, &feedback_scope)
             .await;
@@ -679,11 +1241,6 @@ async fn register_production_advisory_owner(
         .map_err(|error| TraceDecayError::Config {
             message: format!("project-open advisory runtime construction failed: {error}"),
         })?;
-    let published_registration: Arc<dyn std::any::Any + Send + Sync> =
-        Arc::new(PublishedAdvisoryRuntimeV1 {
-            _registration: Arc::clone(&registration),
-            _hook_notices: hook_notice_registration,
-        });
     let advisory_cycle = Arc::new(ProjectOpenAdvisoryFeedbackCycleV1 {
         registration: Arc::clone(&registration),
         lsp_input,
@@ -693,6 +1250,78 @@ async fn register_production_advisory_owner(
         ci_discovery_config,
         hook_config_root: state.graph.hook_store_layout().data_root.clone(),
     });
+    let producer = Arc::new(ProjectOpenScoutProducerV1 {
+        graph: Arc::clone(&state.graph),
+        scout_owner,
+        scout_registry,
+        feedback_runtime: feedback_cycle.feedback_runtime(),
+        project_root: project_root.to_path_buf(),
+        scope: state.scope.clone(),
+        code_index_schedulers: invocation.code_index_schedulers.clone(),
+        session_db: state.session_db.clone(),
+        code_graph: Arc::clone(&state.code_graph),
+        requester: state.requester.clone(),
+        diagnostic_broker: Arc::clone(&state.diagnostic_broker),
+    });
+    let work_cycle = Arc::clone(&advisory_cycle);
+    let work =
+        move |request: HookOrchestrationRequestV1,
+              work_cancellation: tracedecay_runtime_core::cancellation::CancellationToken| {
+            let cycle = Arc::clone(&work_cycle);
+            let producer = Arc::clone(&producer);
+            async move { run_production_hook_cycle(cycle, producer, request, work_cancellation).await }
+        };
+    let orchestrator =
+        BoundedHookOrchestratorV1::new(1, work).ok_or_else(|| TraceDecayError::Config {
+            message: "project-open hook orchestration capacity is invalid".to_owned(),
+        })?;
+    let lifecycle_registration = register_context_scout_lifecycle_authority(
+        hook_project_id,
+        hook_worktree_id,
+        feedback_scope.project_id.clone(),
+        feedback_scope.worktree_id.clone(),
+        &state.session_db,
+    );
+    let lifecycle_registered_here = match lifecycle_registration {
+        AuthorityRegistrationV1::Registered => true,
+        AuthorityRegistrationV1::AlreadyRegistered => false,
+        // A live authority already owns this hook locator pair under a
+        // *different* native identity: the incumbent keeps serving lookups,
+        // so this setup must fail rather than silently route Scout lifecycle
+        // resolution at another project or worktree.
+        AuthorityRegistrationV1::Conflict => {
+            return Err(TraceDecayError::Config {
+                message: "Context Scout lifecycle authority conflicts with the admitted hook scope"
+                    .to_owned(),
+            });
+        }
+        AuthorityRegistrationV1::Rejected(reason) => {
+            return Err(TraceDecayError::Config {
+                message: format!(
+                    "Context Scout lifecycle authority registration failed: {}",
+                    reason.as_str()
+                ),
+            });
+        }
+    };
+    let scout_hook_registration = ScoutHookRegistrationV1 {
+        hook_project_id,
+        hook_worktree_id,
+        lifecycle_sessions: state.session_db.clone(),
+        lifecycle_registered_here,
+        orchestrator: Arc::clone(&orchestrator),
+    };
+    if !register_hook_orchestration_runtime(hook_project_id, hook_worktree_id, &orchestrator) {
+        return Err(TraceDecayError::Config {
+            message: "project-open hook orchestration authority is unavailable".to_owned(),
+        });
+    }
+    let published_registration: Arc<dyn std::any::Any + Send + Sync> =
+        Arc::new(PublishedAdvisoryRuntimeV1 {
+            _registration: Arc::clone(&registration),
+            _hook_notices: hook_notice_registration,
+            _scout_hooks: scout_hook_registration,
+        });
     let invocation_owner = DaemonAdvisoryCycleInvocationOwner::new(
         feedback_scope.project_id,
         Arc::clone(&advisory_cycle) as Arc<dyn DaemonAdvisoryCycleInvocationPort>,
diff --git a/src/daemon/project_open_owners/advisory_runtime/scout_journey_tests.rs b/src/daemon/project_open_owners/advisory_runtime/scout_journey_tests.rs
new file mode 100644
index 0000000000..3055c6f11d
--- /dev/null
+++ b/src/daemon/project_open_owners/advisory_runtime/scout_journey_tests.rs
@@ -0,0 +1,484 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::time::{Duration, Instant};
+
+use super::*;
+
+use crate::agents::context_scout_v2::{
+    ContextScoutDeliveryReceiptV1, ContextScoutDeliveryWindowV1, ContextScoutDurableStoreOutcomeV1,
+    ContextScoutEvidenceEnvelopeV1, ContextScoutEvidenceSourceKindV1,
+    ContextScoutEvidenceSourceReceiptV1, ContextScoutFeedbackKindV1, ContextScoutFeedbackV1,
+    ContextScoutRedactionReceiptV1, context_scout_delivery_receipt_id,
+};
+use tracedecay_application::{
+    AuthorityReceipt, CoverageCompleteness, CoverageDomainState, DisclosureClass, EvidenceCoverage,
+    EvidenceDomain, FreshnessState, PolicyDecisionRef, ResolvedScope, RetrieverContributionState,
+    TemporalState,
+};
+use tracedecay_domain::configuration::ConfigurationValueV1;
+use tracedecay_domain::feedback::FeedbackContentIdentityV1;
+use tracedecay_domain::{
+    CodeGenerationId, ComponentVersion, ManifestDigest, ProjectId, RefId, RetrievalAnchorId,
+    TemporalModeV1,
+};
+use tracedecay_runtime_core::cancellation::CancellationToken;
+
+fn typed_id<T>(value: &str) -> T
+where
+    T: TryFrom<String>,
+    T::Error: std::fmt::Debug,
+{
+    T::try_from(value.to_owned()).unwrap()
+}
+
+fn digest(character: char) -> ManifestDigest {
+    ManifestDigest::new(format!("sha256:{}", character.to_string().repeat(64))).unwrap()
+}
+
+fn configured_model_evidence(marker: u8) -> ContextScoutEvidenceEnvelopeV1 {
+    let scope = ResolvedScope::new(
+        typed_id("project.scout.configured-model"),
+        typed_id("repository.scout.configured-model"),
+        typed_id("worktree.scout.configured-model"),
+        Some(typed_id::<RefId>("refs/heads/main")),
+    )
+    .unwrap();
+    let generation =
+        typed_id::<CodeGenerationId>(&format!("generation.scout.configured-model.{marker}"));
+    ContextScoutEvidenceEnvelopeV1::claim(
+        FeedbackScopeV1 {
+            project_id: scope.project_id.clone(),
+            repository_id: scope.repository_id.clone(),
+            worktree_id: scope.worktree_id.clone(),
+            branch_ref: "refs/heads/main".to_owned(),
+            head_commit_id: typed_id("commit.scout.configured-model"),
+        },
+        scope.clone(),
+        FeedbackContentIdentityV1::SavedContent {
+            generation_digest: digest('c'),
+            file_digest: digest('d'),
+        },
+        generation.clone(),
+        AuthorityReceipt {
+            grant_id: typed_id("grant.scout.configured-model"),
+            grant_revision: 1,
+            grant_digest: digest('a'),
+            authorized_scope_digest: scope.scope_digest.clone(),
+            disclosure: DisclosureClass::Evidence,
+            policy: PolicyDecisionRef::new(
+                "policy.scout.configured-model",
+                1,
+                digest('b'),
+                ComponentVersion::new("policy.scout.configured-model.v1").unwrap(),
+            )
+            .unwrap(),
+            revalidated_at: UtcMicros(1),
+        },
+        ContextScoutRedactionReceiptV1::MetadataOnly {
+            disclosure: DisclosureClass::Evidence,
+        },
+        vec![ContextScoutEvidenceSourceReceiptV1 {
+            source: ContextScoutEvidenceSourceKindV1::Query,
+            contribution_state: RetrieverContributionState::Completed,
+            temporal: TemporalState {
+                requested_mode: TemporalModeV1::Current,
+                requested_at: UtcMicros(1),
+                resolved_at: UtcMicros(2),
+                source_generation: Some(generation),
+                watermark_digest: Some(digest('e')),
+                freshness: FreshnessState::Current,
+            },
+            coverage: EvidenceCoverage {
+                requested_domains: vec![EvidenceDomain::Anchor],
+                visited: Some(1),
+                eligible: Some(1),
+                returned: 1,
+                completeness: CoverageCompleteness::Complete,
+                domains: vec![CoverageDomainState {
+                    domain: EvidenceDomain::Anchor,
+                    completeness: CoverageCompleteness::Complete,
+                }],
+            },
+            anchors: vec![typed_id::<RetrievalAnchorId>(&format!(
+                "anchor.scout.configured-model.{marker}"
+            ))],
+        }],
+        UtcMicros(2),
+    )
+    .unwrap()
+}
+
+fn configured_model_input_at(
+    configuration_revision: [u8; 32],
+    marker: u8,
+    now: UtcMicros,
+    delivery_window: ContextScoutDeliveryWindowV1,
+) -> crate::agents::context_scout_v2::ContextScoutSelectionInputV1 {
+    crate::agents::context_scout_v2::ContextScoutSelectionInputV1 {
+        address: crate::agents::context_scout_v2::ContextScoutAddressV1 {
+            profile_id: [1; 16],
+            provider_id: [2; 16],
+            protected_session_id: [3; 32],
+            thread_id: [4; 16],
+            turn_id: [5; 16],
+            agent_id: [6; 16],
+            logical_message_id: [7; 16],
+            project_id: [8; 16],
+        },
+        input_watermark: [marker; 32],
+        configuration_revision,
+        envelope_id: [marker; 16],
+        now,
+        delivery_window,
+        delivered_dedupe_keys: BTreeSet::new(),
+        candidates: vec![crate::agents::context_scout_v2::ContextScoutCandidateV1 {
+            dedupe_key: [marker; 32],
+            category: crate::agents::context_scout_v2::ContextScoutCategoryV1::Retrieval,
+            relevance_score: 10,
+            suggestion_text: "Use the admitted evidence.".to_owned(),
+            evidence: configured_model_evidence(marker),
+            expires_at: UtcMicros(now.0.saturating_add(60 * 1_000_000)),
+        }],
+    }
+}
+
+fn configured_model_pin() -> ContextScoutConfigurationPinV1 {
+    let setting_key = tracedecay_domain::configuration::SettingKey::new(
+        tracedecay_domain::configuration::CONTEXT_SCOUT_SETTINGS_SETTING_KEY,
+    )
+    .expect("Scout setting key");
+    let revision =
+        tracedecay_domain::configuration::ConfigurationRevisionId::new("revision.scout.model")
+            .expect("configuration revision");
+    let settings = tracedecay_domain::configuration::ContextScoutSettingsV1 {
+        schema_version: tracedecay_domain::configuration::ContextScoutSettingsV1::SCHEMA_VERSION,
+        state: tracedecay_domain::configuration::ContextScoutConfigurationStateV1::Active,
+        mode: tracedecay_domain::configuration::ContextScoutConfigurationModeV1::ConfiguredModel,
+        limits:
+            tracedecay_domain::configuration::ContextScoutConfigurationLimitsV1::bounded_defaults(),
+        model_path: Some(
+            tracedecay_domain::configuration::ContextScoutConfiguredModelPathV1::CodexAppServer,
+        ),
+        model_id: Some("gpt-5.6-mini".to_owned()),
+        model_timeout_secs: Some(30),
+    };
+    settings.validate().expect("configured-model settings");
+    let snapshot = tracedecay_domain::configuration::ConfigurationSnapshotV1::new(
+        BTreeMap::from([(
+            setting_key.clone(),
+            ConfigurationValueV1::ContextScoutSettings(settings),
+        )]),
+        BTreeMap::from([(
+            setting_key,
+            vec![tracedecay_domain::configuration::ConfigurationCandidateV1 {
+                layer: tracedecay_domain::configuration::ConfigurationLayerIdV1::Project {
+                    project_id: ProjectId::new("project.scout.model").expect("project id"),
+                },
+                revision_id: revision.clone(),
+                disposition: tracedecay_domain::configuration::CandidateDispositionV1::Winning,
+                safe_reason: None,
+            }],
+        )]),
+    )
+    .expect("configuration snapshot");
+    ContextScoutConfigurationPinV1::from_current(
+        &tracedecay_usecases::configuration::ConfigurationCurrentStateV1 {
+            revision_id: revision,
+            snapshot,
+        },
+    )
+    .expect("configured-model pin")
+}
+
+async fn test_scout_owner(
+    temporary: &tempfile::TempDir,
+) -> Arc<crate::agents::context_scout_owner::ProjectContextScoutOwnerV1> {
+    crate::daemon::store_runtime::register_registered_schema_installer();
+    let database_path = temporary.path().join("edit-stop-feedback.db");
+    let database_authority =
+        crate::db::DatabaseAuthority::acquire_test(&database_path, "edit stop feedback")
+            .expect("database authority");
+    let database = crate::db::Database::publish_test_runtime(
+        &database_path,
+        &database_authority,
+        crate::db::TestDatabaseRuntimeMode::Initialize,
+    )
+    .await
+    .expect("project database")
+    .0;
+    crate::agents::context_scout_owner::ProjectContextScoutOwnerV1::startup(
+        database,
+        [8; 16],
+        UtcMicros(1),
+        None,
+    )
+    .await
+    .expect("Scout owner")
+}
+
+#[tokio::test]
+async fn project_open_edit_stop_and_explicit_feedback_preserve_privacy_and_supersession() {
+    use tracedecay_agent_hosts::automation::config::{AutomationBackend, AutomationConfig};
+
+    let temporary = tempfile::tempdir().expect("temporary directory");
+    let model_config = AutomationConfig {
+        enabled: true,
+        backend: AutomationBackend::CodexAppServer,
+        ..AutomationConfig::default()
+    };
+    let pin = configured_model_pin();
+    let control = pin.control();
+    let owner = test_scout_owner(&temporary).await;
+    install_project_open_context_scout_configuration(owner.as_ref(), pin, &model_config)
+        .await
+        .expect("install project-open Scout configuration");
+    let now = UtcMicros(
+        i64::try_from(
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .expect("system clock")
+                .as_micros(),
+        )
+        .expect("microsecond clock"),
+    );
+
+    let first_edit = configured_model_input_at(
+        control.configuration_revision,
+        20,
+        now,
+        ContextScoutDeliveryWindowV1::NextBoundary,
+    );
+    let ContextScoutRuntimeOutcomeV1::Enqueued {
+        entry: first,
+        store_outcome: ContextScoutDurableStoreOutcomeV1::Stored,
+    } = owner
+        .prepare_configured(
+            &first_edit,
+            MonotonicDeadline::at(Instant::now() + Duration::from_secs(1)),
+            CancellationToken::new(),
+        )
+        .await
+        .expect("first saved edit")
+    else {
+        panic!("first saved edit must enqueue");
+    };
+
+    let second_edit = configured_model_input_at(
+        control.configuration_revision,
+        21,
+        UtcMicros(now.0 + 1),
+        ContextScoutDeliveryWindowV1::NextBoundary,
+    );
+    let ContextScoutRuntimeOutcomeV1::Enqueued {
+        entry: second,
+        store_outcome: ContextScoutDurableStoreOutcomeV1::Stored,
+    } = owner
+        .prepare_configured(
+            &second_edit,
+            MonotonicDeadline::at(Instant::now() + Duration::from_secs(1)),
+            CancellationToken::new(),
+        )
+        .await
+        .expect("superseding saved edit")
+    else {
+        panic!("second saved edit must supersede the first");
+    };
+    assert!(matches!(
+        owner.cancel(first.work).await,
+        Err(crate::agents::context_scout_v2::ContextScoutErrorV1::StaleWork)
+    ));
+
+    let stop = configured_model_input_at(
+        control.configuration_revision,
+        22,
+        UtcMicros(now.0 + 2),
+        ContextScoutDeliveryWindowV1::Immediate,
+    );
+    let ContextScoutRuntimeOutcomeV1::Enqueued {
+        entry: stopped,
+        store_outcome: ContextScoutDurableStoreOutcomeV1::Stored,
+    } = owner
+        .prepare_configured(
+            &stop,
+            MonotonicDeadline::at(Instant::now() + Duration::from_secs(1)),
+            CancellationToken::new(),
+        )
+        .await
+        .expect("stop boundary")
+    else {
+        panic!("stop boundary must supersede delayed edit guidance");
+    };
+    assert_ne!(second.work, stopped.work);
+
+    let hook = tracedecay_hooks::HookEventEnvelopeV2 {
+        schema_version: tracedecay_hooks::HOOK_EVENT_SCHEMA_VERSION,
+        event_id: [60; 16],
+        producer: tracedecay_hooks::HookHostV1::Codex,
+        protected_session_id: stop.address.protected_session_id,
+        project_id: stop.address.project_id,
+        repository_id: [61; 16],
+        worktree_id: [62; 16],
+        worktree_epoch: 1,
+        binding_token: [63; 32],
+        ordering: tracedecay_hooks::HookOrderingV1::Unknown,
+        observed_at: UtcMicros(now.0 + 3),
+        event: tracedecay_hooks::HookEventV2::SessionBoundary {
+            boundary: tracedecay_hooks::HookBoundaryV1::TurnComplete,
+        },
+    };
+    let (guidance, claim) = owner
+        .claim_ready_guidance_exact(
+            &hook,
+            stop.address,
+            stop.input_watermark,
+            1,
+            UtcMicros(now.0 + 3),
+        )
+        .await
+        .expect("exact stop guidance claim");
+    assert_eq!(claim.entry, *stopped);
+    assert_eq!(guidance.text, "Use the admitted evidence.");
+    assert_eq!(
+        claim.entry.envelope.candidate.evidence.redaction,
+        ContextScoutRedactionReceiptV1::MetadataOnly {
+            disclosure: DisclosureClass::Evidence,
+        }
+    );
+
+    let receipt = ContextScoutDeliveryReceiptV1 {
+        receipt_id: context_scout_delivery_receipt_id(
+            hook.event_id,
+            claim.entry.envelope.envelope_id,
+        ),
+        envelope_id: claim.entry.envelope.envelope_id,
+        delivered_at: UtcMicros(now.0 + 4),
+        outcome: ContextScoutOutcomeV1::Displayed,
+    };
+    assert_eq!(
+        owner.record_delivery(&claim, &receipt).await,
+        ContextScoutDurableStoreOutcomeV1::Stored
+    );
+    let before_feedback = owner
+        .recent_exact(stop.address, 8)
+        .await
+        .expect("recent delivery");
+    assert!(before_feedback.deliveries[0].feedback.is_none());
+
+    let feedback = ContextScoutFeedbackV1 {
+        receipt_id: receipt.receipt_id,
+        kind: ContextScoutFeedbackKindV1::ExplicitlyAccepted,
+    };
+    assert_eq!(
+        owner
+            .record_feedback_exact(stop.address, &receipt, feedback)
+            .await,
+        ContextScoutDurableStoreOutcomeV1::Stored
+    );
+    let recent = owner
+        .recent_exact(stop.address, 8)
+        .await
+        .expect("explicit feedback receipt");
+    assert_eq!(recent.pending.len(), 0);
+    assert_eq!(recent.deliveries.len(), 1);
+    assert_eq!(recent.deliveries[0].feedback, Some(feedback));
+    let serialized = serde_json::to_string(&recent).expect("serialize bounded recent state");
+    assert!(!serialized.contains("raw source"));
+    assert!(!serialized.contains("prompt"));
+    assert!(!serialized.contains("secret-token"));
+}
+
+/// Disabled is the only stock state: the registry default renders the flag
+/// off and a disabled pin suppresses the producer without enqueueing work.
+#[tokio::test]
+async fn stock_disabled_configuration_produces_nothing() {
+    let temporary = tempfile::tempdir().expect("temporary directory");
+    let owner = test_scout_owner(&temporary).await;
+    let setting_key = tracedecay_domain::configuration::SettingKey::new(
+        tracedecay_domain::configuration::CONTEXT_SCOUT_SETTINGS_SETTING_KEY,
+    )
+    .expect("Scout setting key");
+    let revision =
+        tracedecay_domain::configuration::ConfigurationRevisionId::new("revision.scout.disabled")
+            .expect("configuration revision");
+    let snapshot = tracedecay_domain::configuration::ConfigurationSnapshotV1::new(
+        BTreeMap::from([(
+            setting_key.clone(),
+            ConfigurationValueV1::ContextScoutSettings(
+                tracedecay_domain::configuration::ContextScoutSettingsV1::disabled(),
+            ),
+        )]),
+        BTreeMap::from([(
+            setting_key,
+            vec![tracedecay_domain::configuration::ConfigurationCandidateV1 {
+                layer: tracedecay_domain::configuration::ConfigurationLayerIdV1::Project {
+                    project_id: ProjectId::new("project.scout.disabled").expect("project id"),
+                },
+                revision_id: revision.clone(),
+                disposition: tracedecay_domain::configuration::CandidateDispositionV1::Winning,
+                safe_reason: None,
+            }],
+        )]),
+    )
+    .expect("configuration snapshot");
+    let pin = ContextScoutConfigurationPinV1::from_current(
+        &tracedecay_usecases::configuration::ConfigurationCurrentStateV1 {
+            revision_id: revision,
+            snapshot,
+        },
+    )
+    .expect("disabled pin");
+    let control = pin.control();
+    install_project_open_context_scout_configuration(
+        owner.as_ref(),
+        pin,
+        &tracedecay_agent_hosts::automation::config::AutomationConfig::default(),
+    )
+    .await
+    .expect("install disabled Scout configuration");
+
+    let input = configured_model_input_at(
+        control.configuration_revision,
+        30,
+        UtcMicros(1_000),
+        ContextScoutDeliveryWindowV1::NextBoundary,
+    );
+    let outcome = owner
+        .prepare_configured(
+            &input,
+            MonotonicDeadline::at(Instant::now() + Duration::from_secs(1)),
+            CancellationToken::new(),
+        )
+        .await
+        .expect("disabled prepare");
+    assert!(matches!(
+        outcome,
+        ContextScoutRuntimeOutcomeV1::Suppressed { .. }
+    ));
+    assert!(
+        owner
+            .claim_ready_guidance_exact(
+                &tracedecay_hooks::HookEventEnvelopeV2 {
+                    schema_version: tracedecay_hooks::HOOK_EVENT_SCHEMA_VERSION,
+                    event_id: [64; 16],
+                    producer: tracedecay_hooks::HookHostV1::Codex,
+                    protected_session_id: input.address.protected_session_id,
+                    project_id: input.address.project_id,
+                    repository_id: [61; 16],
+                    worktree_id: [62; 16],
+                    worktree_epoch: 1,
+                    binding_token: [63; 32],
+                    ordering: tracedecay_hooks::HookOrderingV1::Unknown,
+                    observed_at: UtcMicros(1_001),
+                    event: tracedecay_hooks::HookEventV2::SessionBoundary {
+                        boundary: tracedecay_hooks::HookBoundaryV1::TurnComplete,
+                    },
+                },
+                input.address,
+                input.input_watermark,
+                1,
+                UtcMicros(1_001),
+            )
+            .await
+            .is_none(),
+        "a disabled configuration must never surface guidance"
+    );
+}
diff --git a/src/daemon/service/invocation.rs b/src/daemon/service/invocation.rs
index d2288a284d..e5bfde0c7d 100644
--- a/src/daemon/service/invocation.rs
+++ b/src/daemon/service/invocation.rs
@@ -13,12 +13,12 @@ use std::path::{Path, PathBuf};
 use std::pin::Pin;
 #[cfg(test)]
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Arc, Mutex as StdMutex, OnceLock, RwLock};
+use std::sync::{Arc, Mutex as StdMutex, OnceLock, RwLock, Weak};
 use std::time::Duration;
 
 use serde::Serialize;
 use thiserror::Error;
-use tokio::sync::Mutex;
+use tokio::sync::{Mutex, Semaphore};
 use tracedecay_application::feedback::{
     FeedbackReadPort, FeedbackRouteAuthorizationPort, FeedbackRuntimeStatePort,
 };
@@ -80,7 +80,8 @@ use super::project_runtime::{
     ProjectRuntimeRegistryV1, RegisteredObservabilityProducerV1,
 };
 use crate::agents::context_scout_ports::{
-    AdmittedContextScoutHookV1, ProjectContextScoutAddressRegistryV1,
+    AdmittedContextScoutHookV1, ContextScoutLifecycleAddressV1,
+    ProjectContextScoutAddressRegistryV1,
 };
 use crate::application_surface::{
     ContextScoutSurfaceRequest, GitApplySurfaceRequest, GitPreviewSurfaceRequest,
@@ -238,7 +239,10 @@ pub(crate) use primitive::{
     DaemonPrimitiveRuntimeRegistrar, DaemonPrimitiveRuntimeRegistrationError,
 };
 pub(crate) use types::{
-    DaemonLspInvocationOwner, HookOrchestrationAdmissionV1, admit_hook_orchestration,
+    BoundedHookOrchestratorV1, DaemonLspInvocationOwner, HookOrchestrationAdmissionV1,
+    HookOrchestrationRequestV1, HookOrchestrationTriggerV1, HookOrchestrationWorkOutcomeV1,
+    admit_registered_hook_orchestration, register_hook_orchestration_runtime,
+    unregister_hook_orchestration_runtime,
 };
 // `pub(super)` on these shapes, in their original flat-file home, meant
 // "visible to `daemon::service`" (their home's actual parent); nesting them
diff --git a/src/daemon/service/invocation/tests/mod.rs b/src/daemon/service/invocation/tests/mod.rs
index 2a7c994ad9..07d5330623 100644
--- a/src/daemon/service/invocation/tests/mod.rs
+++ b/src/daemon/service/invocation/tests/mod.rs
@@ -173,6 +173,64 @@ fn unavailable_feedback_cycle(
     )
 }
 
+fn hook_envelope(event: HookEventV2) -> HookEventEnvelopeV2 {
+    HookEventEnvelopeV2 {
+        schema_version: tracedecay_hooks::HOOK_EVENT_SCHEMA_VERSION,
+        event_id: [1; 16],
+        producer: tracedecay_hooks::HookHostV1::Codex,
+        protected_session_id: [2; 32],
+        project_id: [3; 16],
+        repository_id: [4; 16],
+        worktree_id: [5; 16],
+        worktree_epoch: 1,
+        binding_token: [6; 32],
+        ordering: tracedecay_hooks::HookOrderingV1::Unknown,
+        observed_at: UtcMicros(1),
+        event,
+    }
+}
+
+fn hook_binding() -> HookScopeBindingV1 {
+    HookScopeBindingV1 {
+        host: tracedecay_hooks::HookHostV1::Codex,
+        project_id: [3; 16],
+        repository_id: [4; 16],
+        worktree_id: [5; 16],
+        worktree_epoch: 1,
+        binding_token: [6; 32],
+        capabilities: [
+            tracedecay_hooks::HookEventFamily::SessionBoundary,
+            tracedecay_hooks::HookEventFamily::PromptBoundary,
+            tracedecay_hooks::HookEventFamily::ToolLifecycle,
+            tracedecay_hooks::HookEventFamily::SavedEdit,
+            tracedecay_hooks::HookEventFamily::TestLifecycle,
+        ]
+        .into_iter()
+        .map(|family| tracedecay_hooks::HookCapabilityV1 {
+            family,
+            support: tracedecay_hooks::stock_event_support(
+                tracedecay_hooks::HookHostV1::Codex,
+                family,
+            ),
+        })
+        .collect(),
+    }
+}
+
+fn hook_lifecycle() -> ContextScoutLifecycleAddressV1 {
+    ContextScoutLifecycleAddressV1 {
+        profile_id: tracedecay_domain::UserProfileId::new("profile.advisory-hook").unwrap(),
+        provider_id: tracedecay_domain::ProviderId::new("codex").unwrap(),
+        project_id: ProjectId::new("project.advisory-hook").unwrap(),
+        worktree_id: tracedecay_domain::WorktreeId::new("worktree.advisory-hook").unwrap(),
+        session_id: tracedecay_domain::SessionId::new("session.advisory-hook").unwrap(),
+        thread_id: tracedecay_domain::ThreadId::new("thread.advisory-hook").unwrap(),
+        turn_id: tracedecay_domain::TurnId::new("turn.advisory-hook").unwrap(),
+        agent_id: tracedecay_domain::AgentInstanceId::new("agent.advisory-hook").unwrap(),
+        logical_message_id: tracedecay_domain::MessageId::new("message.advisory-hook").unwrap(),
+    }
+}
+
 mod configuration_registrars_tests;
 mod configuration_tests;
 mod dispatch_tests;
diff --git a/src/daemon/service/invocation/tests/types_tests.rs b/src/daemon/service/invocation/tests/types_tests.rs
index eb00ebbb94..9261b661c3 100644
--- a/src/daemon/service/invocation/tests/types_tests.rs
+++ b/src/daemon/service/invocation/tests/types_tests.rs
@@ -3,6 +3,699 @@
 
 use super::*;
 
+#[test]
+fn hook_orchestration_admits_only_saved_edit_stop_and_explicit() {
+    let saved = HookOrchestrationRequestV1::from_envelope(
+        hook_envelope(HookEventV2::SavedEdit {
+            file_id: [7; 16],
+            changed_range_count: 1,
+        }),
+        &hook_binding(),
+        Some(hook_lifecycle()),
+        1,
+        false,
+    )
+    .unwrap();
+    assert_eq!(saved.trigger, HookOrchestrationTriggerV1::SavedEdit);
+
+    let stop = HookOrchestrationRequestV1::from_envelope(
+        hook_envelope(HookEventV2::SessionBoundary {
+            boundary: HookBoundaryV1::TurnComplete,
+        }),
+        &hook_binding(),
+        Some(hook_lifecycle()),
+        1,
+        false,
+    )
+    .unwrap();
+    assert_eq!(stop.trigger, HookOrchestrationTriggerV1::Stop);
+
+    let without_scout_lifecycle = HookOrchestrationRequestV1::from_envelope(
+        hook_envelope(HookEventV2::SavedEdit {
+            file_id: [7; 16],
+            changed_range_count: 1,
+        }),
+        &hook_binding(),
+        None,
+        1,
+        false,
+    )
+    .unwrap();
+    assert_eq!(
+        without_scout_lifecycle.trigger,
+        HookOrchestrationTriggerV1::SavedEdit
+    );
+    assert!(without_scout_lifecycle.lifecycle.is_none());
+
+    assert!(
+        HookOrchestrationRequestV1::from_envelope(
+            hook_envelope(HookEventV2::TestLifecycle {
+                test_run_id: [8; 16],
+                test_count: 1,
+                phase: tracedecay_hooks::HookLifecyclePhaseV1::Completed,
+                receipt_id: Some([9; 16]),
+            }),
+            &hook_binding(),
+            Some(hook_lifecycle()),
+            1,
+            false,
+        )
+        .is_none()
+    );
+    assert_eq!(
+        HookOrchestrationRequestV1::from_envelope(
+            hook_envelope(HookEventV2::SessionBoundary {
+                boundary: HookBoundaryV1::Start,
+            }),
+            &hook_binding(),
+            Some(hook_lifecycle()),
+            1,
+            true,
+        )
+        .unwrap()
+        .trigger,
+        HookOrchestrationTriggerV1::Explicit
+    );
+}
+
+#[tokio::test]
+async fn hook_orchestration_backpressures_without_waiting() {
+    let release = Arc::new(tokio::sync::Notify::new());
+    let work_release = Arc::clone(&release);
+    let work = move |_, _| {
+        let release = Arc::clone(&work_release);
+        async move { release.notified().await }
+    };
+    let runtime = BoundedHookOrchestratorV1::new(1, work).unwrap();
+    let completions = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+    let observed_completions = Arc::clone(&completions);
+    let completed = Arc::new(tokio::sync::Notify::new());
+    let completion_notification = Arc::clone(&completed);
+    let mut request = HookOrchestrationRequestV1::from_envelope(
+        hook_envelope(HookEventV2::SavedEdit {
+            file_id: [7; 16],
+            changed_range_count: 1,
+        }),
+        &hook_binding(),
+        None,
+        1,
+        false,
+    )
+    .unwrap();
+    request.completion = Some(Arc::new(move || {
+        observed_completions.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        completion_notification.notify_one();
+    }));
+    // A distinct hook event at a distinct work address is real new work, so it
+    // must contend for the single permit rather than join or supersede the
+    // admitted boundary.
+    let mut other_envelope = hook_envelope(HookEventV2::SavedEdit {
+        file_id: [8; 16],
+        changed_range_count: 1,
+    });
+    other_envelope.event_id = [2; 16];
+    let other_request = HookOrchestrationRequestV1::from_envelope(
+        other_envelope,
+        &hook_binding(),
+        Some(hook_lifecycle()),
+        1,
+        false,
+    )
+    .unwrap();
+
+    assert_eq!(
+        runtime.admit(request),
+        HookOrchestrationAdmissionV1::Enqueued
+    );
+    assert_eq!(
+        runtime.admit(other_request),
+        HookOrchestrationAdmissionV1::Backpressured
+    );
+    assert_eq!(completions.load(std::sync::atomic::Ordering::Relaxed), 0);
+    release.notify_one();
+    tokio::time::timeout(std::time::Duration::from_secs(1), completed.notified())
+        .await
+        .expect("producer work completion");
+    assert_eq!(
+        completions.load(std::sync::atomic::Ordering::Relaxed),
+        1,
+        "only completed producer work may clear the durable outbox"
+    );
+}
+
+#[tokio::test]
+async fn hook_orchestration_runs_feedback_work_without_scout_lifecycle() {
+    let ran_synchronously = Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let work_ran_synchronously = Arc::clone(&ran_synchronously);
+    let ran = Arc::new(tokio::sync::Notify::new());
+    let work_ran = Arc::clone(&ran);
+    let runtime = BoundedHookOrchestratorV1::new(1, move |_, _| {
+        let ran = Arc::clone(&work_ran);
+        let ran_synchronously = Arc::clone(&work_ran_synchronously);
+        async move {
+            ran_synchronously.store(true, std::sync::atomic::Ordering::Release);
+            ran.notify_one();
+        }
+    })
+    .unwrap();
+    assert!(register_hook_orchestration_runtime(
+        [3; 16], [5; 16], &runtime
+    ));
+
+    assert_eq!(
+        admit_registered_hook_orchestration(
+            hook_envelope(HookEventV2::SavedEdit {
+                file_id: [7; 16],
+                changed_range_count: 1,
+            }),
+            hook_binding(),
+            None,
+            1,
+            false,
+            None,
+        ),
+        HookOrchestrationAdmissionV1::Enqueued
+    );
+    assert!(
+        !ran_synchronously.load(std::sync::atomic::Ordering::Acquire),
+        "hook admission must return before daemon-owned provider or model work begins"
+    );
+    ran.notified().await;
+    unregister_hook_orchestration_runtime([3; 16], [5; 16], &runtime);
+}
+
+#[tokio::test]
+async fn hook_orchestration_registry_refuses_a_foreign_live_incumbent() {
+    let incumbent = BoundedHookOrchestratorV1::new(1, |_, _| async {}).unwrap();
+    let successor = BoundedHookOrchestratorV1::new(1, |_, _| async {}).unwrap();
+    assert!(register_hook_orchestration_runtime(
+        [13; 16], [15; 16], &incumbent
+    ));
+    assert!(
+        !register_hook_orchestration_runtime([13; 16], [15; 16], &successor),
+        "a live incumbent must keep its hook locator pair"
+    );
+    // A foreign runtime never unregisters the incumbent.
+    unregister_hook_orchestration_runtime([13; 16], [15; 16], &successor);
+    assert!(register_hook_orchestration_runtime(
+        [13; 16], [15; 16], &incumbent
+    ));
+    unregister_hook_orchestration_runtime([13; 16], [15; 16], &incumbent);
+    assert!(register_hook_orchestration_runtime(
+        [13; 16], [15; 16], &successor
+    ));
+    unregister_hook_orchestration_runtime([13; 16], [15; 16], &successor);
+}
+
+#[tokio::test]
+async fn hook_orchestration_coalesces_duplicate_work_and_completes_every_admission() {
+    let release = Arc::new(tokio::sync::Notify::new());
+    let work_release = Arc::clone(&release);
+    let work_calls = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+    let observed_work_calls = Arc::clone(&work_calls);
+    let runtime = BoundedHookOrchestratorV1::new(1, move |_, _| {
+        let release = Arc::clone(&work_release);
+        let work_calls = Arc::clone(&observed_work_calls);
+        async move {
+            work_calls.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+            release.notified().await;
+        }
+    })
+    .unwrap();
+    let completions = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+    let completed = Arc::new(tokio::sync::Notify::new());
+    let mut request = HookOrchestrationRequestV1::from_envelope(
+        hook_envelope(HookEventV2::SavedEdit {
+            file_id: [7; 16],
+            changed_range_count: 1,
+        }),
+        &hook_binding(),
+        Some(hook_lifecycle()),
+        1,
+        false,
+    )
+    .unwrap();
+    let first_completions = Arc::clone(&completions);
+    let first_completed = Arc::clone(&completed);
+    request.completion = Some(Arc::new(move || {
+        first_completions.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        first_completed.notify_one();
+    }));
+    let mut duplicate = request.clone();
+    let duplicate_completions = Arc::clone(&completions);
+    let duplicate_completed = Arc::clone(&completed);
+    duplicate.completion = Some(Arc::new(move || {
+        duplicate_completions.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        duplicate_completed.notify_one();
+    }));
+
+    assert_eq!(
+        runtime.admit(request),
+        HookOrchestrationAdmissionV1::Enqueued
+    );
+    tokio::task::yield_now().await;
+    assert_eq!(
+        runtime.admit(duplicate),
+        HookOrchestrationAdmissionV1::Enqueued,
+        "an exact duplicate must join the admitted work instead of consuming capacity"
+    );
+    assert_eq!(work_calls.load(std::sync::atomic::Ordering::Relaxed), 1);
+    release.notify_one();
+    tokio::time::timeout(std::time::Duration::from_secs(1), async {
+        while completions.load(std::sync::atomic::Ordering::Relaxed) != 2 {
+            completed.notified().await;
+        }
+    })
+    .await
+    .expect("both joined admissions complete");
+    assert_eq!(work_calls.load(std::sync::atomic::Ordering::Relaxed), 1);
+}
+
+#[tokio::test]
+async fn hook_orchestration_supersedes_same_address_without_replay_delay() {
+    struct WorkGuard {
+        dropped: Arc<std::sync::atomic::AtomicBool>,
+    }
+
+    impl Drop for WorkGuard {
+        fn drop(&mut self) {
+            self.dropped
+                .store(true, std::sync::atomic::Ordering::Release);
+        }
+    }
+
+    let first_started = Arc::new(tokio::sync::Notify::new());
+    let observed_first_started = Arc::clone(&first_started);
+    let first_dropped = Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let observed_first_drop = Arc::clone(&first_dropped);
+    let runtime = BoundedHookOrchestratorV1::new(1, move |request, cancellation| {
+        let first_started = Arc::clone(&observed_first_started);
+        let first_dropped = Arc::clone(&observed_first_drop);
+        async move {
+            if request.hook.envelope().event_id == [1; 16] {
+                let _guard = WorkGuard {
+                    dropped: first_dropped,
+                };
+                first_started.notify_one();
+                cancellation.cancelled().await;
+            }
+        }
+    })
+    .unwrap();
+    let first_completions = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+    let observed_first_completions = Arc::clone(&first_completions);
+    let mut first = HookOrchestrationRequestV1::from_envelope(
+        hook_envelope(HookEventV2::SavedEdit {
+            file_id: [7; 16],
+            changed_range_count: 1,
+        }),
+        &hook_binding(),
+        Some(hook_lifecycle()),
+        1,
+        false,
+    )
+    .unwrap();
+    first.completion = Some(Arc::new(move || {
+        observed_first_completions.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    }));
+    assert_eq!(runtime.admit(first), HookOrchestrationAdmissionV1::Enqueued);
+    first_started.notified().await;
+
+    let second_completions = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+    let observed_second_completions = Arc::clone(&second_completions);
+    let second_completed = Arc::new(tokio::sync::Notify::new());
+    let observed_second_completed = Arc::clone(&second_completed);
+    let mut second_envelope = hook_envelope(HookEventV2::SessionBoundary {
+        boundary: HookBoundaryV1::TurnComplete,
+    });
+    second_envelope.event_id = [2; 16];
+    let mut second = HookOrchestrationRequestV1::from_envelope(
+        second_envelope,
+        &hook_binding(),
+        Some(ContextScoutLifecycleAddressV1 {
+            turn_id: tracedecay_domain::TurnId::new("turn.advisory-hook.next").unwrap(),
+            logical_message_id: tracedecay_domain::MessageId::new("message.advisory-hook.next")
+                .unwrap(),
+            ..hook_lifecycle()
+        }),
+        1,
+        false,
+    )
+    .unwrap();
+    second.completion = Some(Arc::new(move || {
+        observed_second_completions.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        observed_second_completed.notify_one();
+    }));
+    assert_eq!(
+        runtime.admit(second),
+        HookOrchestrationAdmissionV1::Enqueued,
+        "a newer edit/stop event at the same address must replace queued work"
+    );
+    tokio::time::timeout(
+        std::time::Duration::from_secs(1),
+        second_completed.notified(),
+    )
+    .await
+    .expect("superseding event runs as soon as the cancelled worker releases capacity");
+    assert!(first_dropped.load(std::sync::atomic::Ordering::Acquire));
+    assert_eq!(
+        first_completions.load(std::sync::atomic::Ordering::Relaxed),
+        1,
+        "the successful successor acknowledges coalesced obsolete work"
+    );
+    assert_eq!(
+        second_completions.load(std::sync::atomic::Ordering::Relaxed),
+        1
+    );
+}
+
+#[tokio::test]
+async fn retryable_hook_work_does_not_acknowledge_the_durable_admission() {
+    let attempted = Arc::new(tokio::sync::Notify::new());
+    let observed_attempted = Arc::clone(&attempted);
+    let runtime = BoundedHookOrchestratorV1::new(1, move |_, _| {
+        let attempted = Arc::clone(&observed_attempted);
+        async move {
+            attempted.notify_one();
+            HookOrchestrationWorkOutcomeV1::RetryableFailure
+        }
+    })
+    .unwrap();
+    let completions = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+    let observed_completions = Arc::clone(&completions);
+    let mut request = HookOrchestrationRequestV1::from_envelope(
+        hook_envelope(HookEventV2::SavedEdit {
+            file_id: [7; 16],
+            changed_range_count: 1,
+        }),
+        &hook_binding(),
+        Some(hook_lifecycle()),
+        1,
+        false,
+    )
+    .unwrap();
+    request.completion = Some(Arc::new(move || {
+        observed_completions.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    }));
+
+    assert_eq!(
+        runtime.admit(request),
+        HookOrchestrationAdmissionV1::Enqueued
+    );
+    attempted.notified().await;
+    tokio::task::yield_now().await;
+    assert_eq!(
+        completions.load(std::sync::atomic::Ordering::Relaxed),
+        0,
+        "retryable producer failure must leave the durable hook pending for replay"
+    );
+}
+
+#[tokio::test]
+async fn superseded_blocking_work_is_joined_before_its_receipt_terminal() {
+    let (blocking_started, blocking_started_receiver) = tokio::sync::oneshot::channel();
+    let blocking_started = Arc::new(std::sync::Mutex::new(Some(blocking_started)));
+    let blocking_gate = Arc::new((std::sync::Mutex::new(false), std::sync::Condvar::new()));
+    let blocking_finished = Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let successor_release = Arc::new(tokio::sync::Notify::new());
+    let work_started = Arc::clone(&blocking_started);
+    let work_gate = Arc::clone(&blocking_gate);
+    let work_finished = Arc::clone(&blocking_finished);
+    let work_successor_release = Arc::clone(&successor_release);
+    let runtime = BoundedHookOrchestratorV1::new(1, move |request, _cancellation| {
+        let started = Arc::clone(&work_started);
+        let gate = Arc::clone(&work_gate);
+        let finished = Arc::clone(&work_finished);
+        let successor_release = Arc::clone(&work_successor_release);
+        async move {
+            if request.hook.envelope().event_id == [1; 16] {
+                let task = tokio::task::spawn_blocking(move || {
+                    if let Some(started) = started
+                        .lock()
+                        .unwrap_or_else(std::sync::PoisonError::into_inner)
+                        .take()
+                    {
+                        let _ = started.send(());
+                    }
+                    let (released, changed) = &*gate;
+                    let mut released = released
+                        .lock()
+                        .unwrap_or_else(std::sync::PoisonError::into_inner);
+                    while !*released {
+                        released = changed
+                            .wait(released)
+                            .unwrap_or_else(std::sync::PoisonError::into_inner);
+                    }
+                    finished.store(true, std::sync::atomic::Ordering::Release);
+                });
+                let _ = task.await;
+            } else {
+                successor_release.notified().await;
+            }
+        }
+    })
+    .unwrap();
+    let first_terminal = Arc::new(tokio::sync::Notify::new());
+    let observed_first_terminal = Arc::clone(&first_terminal);
+    let nested_finished_at_terminal = Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let observed_nested_finished = Arc::clone(&nested_finished_at_terminal);
+    let completion_finished = Arc::clone(&blocking_finished);
+    let mut first = HookOrchestrationRequestV1::from_envelope(
+        hook_envelope(HookEventV2::SavedEdit {
+            file_id: [7; 16],
+            changed_range_count: 1,
+        }),
+        &hook_binding(),
+        Some(hook_lifecycle()),
+        1,
+        false,
+    )
+    .unwrap();
+    first.completion = Some(Arc::new(move || {
+        observed_nested_finished.store(
+            completion_finished.load(std::sync::atomic::Ordering::Acquire),
+            std::sync::atomic::Ordering::Release,
+        );
+        observed_first_terminal.notify_one();
+    }));
+    assert_eq!(runtime.admit(first), HookOrchestrationAdmissionV1::Enqueued);
+    blocking_started_receiver
+        .await
+        .expect("blocking provider work started");
+
+    let mut successor_envelope = hook_envelope(HookEventV2::SessionBoundary {
+        boundary: HookBoundaryV1::TurnComplete,
+    });
+    successor_envelope.event_id = [2; 16];
+    let successor = HookOrchestrationRequestV1::from_envelope(
+        successor_envelope,
+        &hook_binding(),
+        Some(hook_lifecycle()),
+        1,
+        false,
+    )
+    .unwrap();
+    assert_eq!(
+        runtime.admit(successor),
+        HookOrchestrationAdmissionV1::Enqueued
+    );
+    let (released, changed) = &*blocking_gate;
+    *released
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner) = true;
+    changed.notify_all();
+    let terminal = tokio::time::timeout(
+        std::time::Duration::from_millis(250),
+        first_terminal.notified(),
+    )
+    .await;
+    successor_release.notify_one();
+    assert!(
+        terminal.is_ok(),
+        "the superseded operation must emit its own receipt terminal"
+    );
+    assert!(
+        nested_finished_at_terminal.load(std::sync::atomic::Ordering::Acquire),
+        "the receipt terminal must follow settlement of nested blocking work"
+    );
+}
+
+#[tokio::test]
+async fn superseded_queued_work_emits_its_own_receipt_terminal() {
+    let first_started = Arc::new(tokio::sync::Notify::new());
+    let work_started = Arc::clone(&first_started);
+    let first_release = Arc::new(tokio::sync::Notify::new());
+    let work_release = Arc::clone(&first_release);
+    let runtime = BoundedHookOrchestratorV1::new(1, move |request, cancellation| {
+        let started = Arc::clone(&work_started);
+        let release = Arc::clone(&work_release);
+        async move {
+            if request.hook.envelope().event_id == [1; 16] {
+                started.notify_one();
+                cancellation.cancelled().await;
+                release.notified().await;
+            }
+        }
+    })
+    .unwrap();
+    let request = |event_id, completion| {
+        let mut envelope = hook_envelope(HookEventV2::SavedEdit {
+            file_id: [7; 16],
+            changed_range_count: 1,
+        });
+        envelope.event_id = event_id;
+        let mut request = HookOrchestrationRequestV1::from_envelope(
+            envelope,
+            &hook_binding(),
+            Some(hook_lifecycle()),
+            1,
+            false,
+        )
+        .unwrap();
+        request.completion = completion;
+        request
+    };
+    assert_eq!(
+        runtime.admit(request([1; 16], None)),
+        HookOrchestrationAdmissionV1::Enqueued
+    );
+    first_started.notified().await;
+
+    let queued_terminal = Arc::new(tokio::sync::Notify::new());
+    let observed_queued_terminal = Arc::clone(&queued_terminal);
+    assert_eq!(
+        runtime.admit(request(
+            [2; 16],
+            Some(Arc::new(move || observed_queued_terminal.notify_one())),
+        )),
+        HookOrchestrationAdmissionV1::Enqueued
+    );
+    assert_eq!(
+        runtime.admit(request([3; 16], None)),
+        HookOrchestrationAdmissionV1::Enqueued
+    );
+    let terminal = tokio::time::timeout(
+        std::time::Duration::from_millis(250),
+        queued_terminal.notified(),
+    )
+    .await;
+    first_release.notify_one();
+    assert!(
+        terminal.is_ok(),
+        "superseded work that never acquired capacity must settle its own receipt"
+    );
+}
+
+#[tokio::test]
+async fn hook_orchestration_bounds_coalesced_completion_waiters() {
+    let release = Arc::new(tokio::sync::Notify::new());
+    let work_release = Arc::clone(&release);
+    let runtime = BoundedHookOrchestratorV1::new(1, move |_, _| {
+        let release = Arc::clone(&work_release);
+        async move {
+            release.notified().await;
+        }
+    })
+    .unwrap();
+    let completion = Arc::new(|| {}) as Arc<dyn Fn() + Send + Sync>;
+    let request = |completion| {
+        let mut request = HookOrchestrationRequestV1::from_envelope(
+            hook_envelope(HookEventV2::SavedEdit {
+                file_id: [7; 16],
+                changed_range_count: 1,
+            }),
+            &hook_binding(),
+            Some(hook_lifecycle()),
+            1,
+            false,
+        )
+        .unwrap();
+        request.completion = Some(completion);
+        request
+    };
+    let first = request(Arc::clone(&completion));
+    assert_eq!(runtime.admit(first), HookOrchestrationAdmissionV1::Enqueued);
+    for _ in 1..MAX_COALESCED_HOOK_COMPLETIONS {
+        let duplicate = request(Arc::clone(&completion));
+        assert_eq!(
+            runtime.admit(duplicate),
+            HookOrchestrationAdmissionV1::Enqueued
+        );
+    }
+    let overflow = request(completion);
+    assert_eq!(
+        runtime.admit(overflow),
+        HookOrchestrationAdmissionV1::Backpressured
+    );
+    release.notify_one();
+}
+
+#[tokio::test]
+async fn dropping_hook_orchestrator_cancels_daemon_owned_work_without_false_completion() {
+    struct PendingWork {
+        dropped: Arc<std::sync::atomic::AtomicBool>,
+    }
+
+    impl std::future::Future for PendingWork {
+        type Output = ();
+
+        fn poll(
+            self: std::pin::Pin<&mut Self>,
+            _context: &mut std::task::Context<'_>,
+        ) -> std::task::Poll<Self::Output> {
+            std::task::Poll::Pending
+        }
+    }
+
+    impl Drop for PendingWork {
+        fn drop(&mut self) {
+            self.dropped
+                .store(true, std::sync::atomic::Ordering::Release);
+        }
+    }
+
+    let work_dropped = Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let observed_work_drop = Arc::clone(&work_dropped);
+    let runtime = BoundedHookOrchestratorV1::new(1, move |_, _| PendingWork {
+        dropped: Arc::clone(&observed_work_drop),
+    })
+    .unwrap();
+    let completions = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+    let observed_completions = Arc::clone(&completions);
+    let mut request = HookOrchestrationRequestV1::from_envelope(
+        hook_envelope(HookEventV2::SavedEdit {
+            file_id: [7; 16],
+            changed_range_count: 1,
+        }),
+        &hook_binding(),
+        Some(hook_lifecycle()),
+        1,
+        false,
+    )
+    .unwrap();
+    request.completion = Some(Arc::new(move || {
+        observed_completions.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    }));
+    assert_eq!(
+        runtime.admit(request),
+        HookOrchestrationAdmissionV1::Enqueued
+    );
+    tokio::task::yield_now().await;
+    drop(runtime);
+    tokio::time::timeout(std::time::Duration::from_secs(1), async {
+        while !work_dropped.load(std::sync::atomic::Ordering::Acquire) {
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .expect("retiring the retained owner cancels its worker");
+    assert_eq!(
+        completions.load(std::sync::atomic::Ordering::Relaxed),
+        0,
+        "cancelled work is not reported as completed"
+    );
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn feedback_admission_conflicts_construct_zero_losing_producers() {
     #[derive(Clone, Copy, Debug)]
diff --git a/src/daemon/service/invocation/types.rs b/src/daemon/service/invocation/types.rs
index 3d5b63749a..bfd91cc1c4 100644
--- a/src/daemon/service/invocation/types.rs
+++ b/src/daemon/service/invocation/types.rs
@@ -6,32 +6,413 @@ use tracedecay_application::RegisteredRootLocatorV1;
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub(crate) enum HookOrchestrationAdmissionV1 {
+    Enqueued,
+    Backpressured,
     UnsupportedTrigger,
     Unavailable,
 }
 
-pub(crate) fn admit_hook_orchestration(
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum HookOrchestrationTriggerV1 {
+    SavedEdit,
+    Stop,
+    Explicit,
+}
+
+#[derive(Clone)]
+pub(crate) struct HookOrchestrationRequestV1 {
+    pub hook: AdmittedContextScoutHookV1,
+    pub lifecycle: Option<ContextScoutLifecycleAddressV1>,
+    pub hook_configuration_revision: u64,
+    pub trigger: HookOrchestrationTriggerV1,
+    pub(super) completion: Option<Arc<dyn Fn() + Send + Sync + 'static>>,
+}
+
+impl HookOrchestrationRequestV1 {
+    pub(in crate::daemon) fn from_envelope(
+        envelope: HookEventEnvelopeV2,
+        binding: &HookScopeBindingV1,
+        lifecycle: Option<ContextScoutLifecycleAddressV1>,
+        configuration_revision: u64,
+        explicit: bool,
+    ) -> Option<Self> {
+        let hook = AdmittedContextScoutHookV1::new(envelope, binding)?;
+        let trigger = if explicit {
+            HookOrchestrationTriggerV1::Explicit
+        } else {
+            match &hook.envelope().event {
+                HookEventV2::SavedEdit { .. } => HookOrchestrationTriggerV1::SavedEdit,
+                HookEventV2::SessionBoundary {
+                    boundary: HookBoundaryV1::End | HookBoundaryV1::TurnComplete,
+                } => HookOrchestrationTriggerV1::Stop,
+                _ => return None,
+            }
+        };
+        Some(Self {
+            hook,
+            lifecycle,
+            hook_configuration_revision: configuration_revision,
+            trigger,
+            completion: None,
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum HookOrchestrationWorkOutcomeV1 {
+    Completed,
+    RetryableFailure,
+}
+
+impl From<()> for HookOrchestrationWorkOutcomeV1 {
+    fn from((): ()) -> Self {
+        Self::Completed
+    }
+}
+
+type HookOrchestrationFutureV1 =
+    Pin<Box<dyn Future<Output = HookOrchestrationWorkOutcomeV1> + Send + 'static>>;
+type HookOrchestrationWorkV1 = dyn Fn(
+        HookOrchestrationRequestV1,
+        tracedecay_runtime_core::cancellation::CancellationToken,
+    ) -> HookOrchestrationFutureV1
+    + Send
+    + Sync;
+/// Exact hook identity: one project, one worktree, one hook event. Two
+/// admissions that agree on all three describe the same boundary, so they must
+/// share one cycle rather than start a second.
+type HookOrchestrationEventKeyV1 = ([u8; 16], [u8; 16], [u8; 16]);
+/// Stable per-session work address. A newer boundary at the same address
+/// supersedes the running one instead of queueing behind it.
+type HookOrchestrationAddressV1 = String;
+type HookOrchestrationCompletionV1 = Arc<dyn Fn() + Send + Sync + 'static>;
+
+struct HookOrchestrationInFlightEntryV1 {
+    event: HookOrchestrationEventKeyV1,
+    cancellation: tracedecay_runtime_core::cancellation::CancellationToken,
+    superseded: std::sync::atomic::AtomicBool,
+    completions: StdMutex<Vec<HookOrchestrationCompletionV1>>,
+}
+
+#[derive(Default)]
+struct HookOrchestrationInFlightV1 {
+    addresses: BTreeMap<HookOrchestrationAddressV1, Arc<HookOrchestrationInFlightEntryV1>>,
+    events: BTreeMap<HookOrchestrationEventKeyV1, Arc<HookOrchestrationInFlightEntryV1>>,
+}
+
+/// Upper bound on admissions that may join one in-flight cycle. Beyond it the
+/// caller is backpressured instead of queued, so a hook storm can never grow
+/// unbounded retained state behind a single bounded operation.
+pub(in crate::daemon::service) const MAX_COALESCED_HOOK_COMPLETIONS: usize = 32;
+
+/// Bounded owner of one project's advisory-and-Scout hook cycles: exact
+/// duplicate boundaries join the running cycle, a newer boundary at the same
+/// stable session address supersedes the incumbent, and everything beyond the
+/// permit and coalescing bounds is backpressured instead of queued.
+pub(crate) struct BoundedHookOrchestratorV1 {
+    permits: Arc<Semaphore>,
+    work: Arc<HookOrchestrationWorkV1>,
+    in_flight: Arc<StdMutex<HookOrchestrationInFlightV1>>,
+    cancellation: tracedecay_runtime_core::cancellation::CancellationToken,
+}
+
+impl BoundedHookOrchestratorV1 {
+    pub(crate) fn new<F, Fut>(max_concurrent: usize, work: F) -> Option<Arc<Self>>
+    where
+        F: Fn(
+                HookOrchestrationRequestV1,
+                tracedecay_runtime_core::cancellation::CancellationToken,
+            ) -> Fut
+            + Send
+            + Sync
+            + 'static,
+        Fut: Future + Send + 'static,
+        Fut::Output: Into<HookOrchestrationWorkOutcomeV1>,
+    {
+        let work: Arc<HookOrchestrationWorkV1> = Arc::new(move |request, cancellation| {
+            let future = work(request, cancellation);
+            Box::pin(async move { future.await.into() })
+        });
+        (max_concurrent > 0).then(|| {
+            Arc::new(Self {
+                permits: Arc::new(Semaphore::new(max_concurrent)),
+                work,
+                in_flight: Arc::new(StdMutex::new(HookOrchestrationInFlightV1::default())),
+                cancellation: tracedecay_runtime_core::cancellation::CancellationToken::new(),
+            })
+        })
+    }
+
+    fn stable_address(request: &HookOrchestrationRequestV1) -> Option<HookOrchestrationAddressV1> {
+        let envelope = request.hook.envelope();
+        canonical_sha256(&(
+            "tracedecay.advisory-hook-address.v1",
+            envelope.project_id,
+            envelope.repository_id,
+            envelope.worktree_id,
+            envelope.protected_session_id,
+        ))
+        .ok()
+        .map(|digest| digest.as_str().to_owned())
+    }
+
+    fn settle_operation(
+        in_flight: &StdMutex<HookOrchestrationInFlightV1>,
+        address: &HookOrchestrationAddressV1,
+        operation: &Arc<HookOrchestrationInFlightEntryV1>,
+        emit_terminal: bool,
+    ) {
+        let completions = {
+            let mut in_flight = in_flight
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner);
+            let completions = {
+                let mut completions = operation
+                    .completions
+                    .lock()
+                    .unwrap_or_else(std::sync::PoisonError::into_inner);
+                std::mem::take(&mut *completions)
+            };
+            if in_flight
+                .addresses
+                .get(address)
+                .is_some_and(|current| Arc::ptr_eq(current, operation))
+            {
+                in_flight.addresses.remove(address);
+            }
+            if in_flight
+                .events
+                .get(&operation.event)
+                .is_some_and(|current| Arc::ptr_eq(current, operation))
+            {
+                in_flight.events.remove(&operation.event);
+            }
+            completions
+        };
+        if emit_terminal {
+            for completion in completions {
+                completion();
+            }
+        }
+    }
+
+    pub(crate) fn admit(
+        &self,
+        mut request: HookOrchestrationRequestV1,
+    ) -> HookOrchestrationAdmissionV1 {
+        let Ok(handle) = tokio::runtime::Handle::try_current() else {
+            return HookOrchestrationAdmissionV1::Unavailable;
+        };
+        let envelope = request.hook.envelope();
+        let event = (envelope.project_id, envelope.worktree_id, envelope.event_id);
+        let Some(address) = Self::stable_address(&request) else {
+            return HookOrchestrationAdmissionV1::Unavailable;
+        };
+        let completion = request.completion.take();
+        let (permit, operation) = {
+            let Ok(mut in_flight) = self.in_flight.lock() else {
+                return HookOrchestrationAdmissionV1::Unavailable;
+            };
+            if let Some(incumbent) = in_flight.events.get(&event).cloned() {
+                // The exact boundary is already running. Join it: one cycle
+                // terminates once and every joined admission observes that one
+                // terminal, so a duplicate never consumes a second permit.
+                if let Some(completion) = completion {
+                    let Ok(mut completions) = incumbent.completions.lock() else {
+                        return HookOrchestrationAdmissionV1::Unavailable;
+                    };
+                    if completions.len() >= MAX_COALESCED_HOOK_COMPLETIONS {
+                        return HookOrchestrationAdmissionV1::Backpressured;
+                    }
+                    completions.push(completion);
+                }
+                return HookOrchestrationAdmissionV1::Enqueued;
+            }
+            let permit = if let Some(incumbent) = in_flight.addresses.remove(&address) {
+                // A newer boundary at the same stable address supersedes the
+                // incumbent: cancel it and inherit its permit once it settles.
+                incumbent
+                    .superseded
+                    .store(true, std::sync::atomic::Ordering::Release);
+                incumbent.cancellation.cancel();
+                None
+            } else {
+                let Ok(permit) = Arc::clone(&self.permits).try_acquire_owned() else {
+                    return HookOrchestrationAdmissionV1::Backpressured;
+                };
+                Some(permit)
+            };
+            let work_cancellation = tracedecay_runtime_core::cancellation::CancellationToken::new();
+            let operation = Arc::new(HookOrchestrationInFlightEntryV1 {
+                event,
+                cancellation: work_cancellation,
+                superseded: std::sync::atomic::AtomicBool::new(false),
+                completions: StdMutex::new(completion.into_iter().collect()),
+            });
+            in_flight
+                .addresses
+                .insert(address.clone(), Arc::clone(&operation));
+            in_flight.events.insert(event, Arc::clone(&operation));
+            (permit, operation)
+        };
+        let work = Arc::clone(&self.work);
+        let in_flight = Arc::clone(&self.in_flight);
+        let cancellation = self.cancellation.clone();
+        let permits = Arc::clone(&self.permits);
+        handle.spawn(async move {
+            let work_cancellation = operation.cancellation.clone();
+            let permit = match permit {
+                Some(permit) => Some(permit),
+                None => tokio::select! {
+                    biased;
+                    () = work_cancellation.cancelled() => None,
+                    () = cancellation.cancelled() => None,
+                    permit = permits.acquire_owned() => permit.ok(),
+                },
+            };
+            let Some(permit) = permit else {
+                let superseded = operation
+                    .superseded
+                    .load(std::sync::atomic::Ordering::Acquire);
+                Self::settle_operation(&in_flight, &address, &operation, superseded);
+                return;
+            };
+            if cancellation.is_cancelled() || work_cancellation.is_cancelled() {
+                let superseded = operation
+                    .superseded
+                    .load(std::sync::atomic::Ordering::Acquire);
+                Self::settle_operation(&in_flight, &address, &operation, superseded);
+                return;
+            }
+            let mut work_future = (work)(request, work_cancellation.clone());
+            // Only completed or superseded work emits terminals. Owner-level
+            // cancellation reports nothing: silence is a normal result, and an
+            // adapter must never invent a termination reason. Cancellation
+            // drops the work future instead of awaiting it: pending work must
+            // stop when its owner retires, not run to completion.
+            let outcome = tokio::select! {
+                biased;
+                () = work_cancellation.cancelled() => None,
+                () = cancellation.cancelled() => {
+                    work_cancellation.cancel();
+                    None
+                },
+                outcome = &mut work_future => Some(outcome),
+            };
+            let emit_terminal = match outcome {
+                Some(HookOrchestrationWorkOutcomeV1::Completed) => true,
+                Some(HookOrchestrationWorkOutcomeV1::RetryableFailure) => false,
+                None => {
+                    drop(work_future);
+                    operation
+                        .superseded
+                        .load(std::sync::atomic::Ordering::Acquire)
+                }
+            };
+            Self::settle_operation(&in_flight, &address, &operation, emit_terminal);
+            drop(permit);
+        });
+        HookOrchestrationAdmissionV1::Enqueued
+    }
+}
+
+impl Drop for BoundedHookOrchestratorV1 {
+    fn drop(&mut self) {
+        // Retiring the owner cancels every worker it still holds. The workers
+        // drop their in-flight entry without firing completions.
+        self.cancellation.cancel();
+        if let Ok(in_flight) = self.in_flight.lock() {
+            for entry in in_flight.events.values() {
+                entry.cancellation.cancel();
+            }
+        }
+    }
+}
+
+type HookOrchestrationRegistryKey = ([u8; 16], [u8; 16]);
+type HookOrchestrationRegistry =
+    StdMutex<BTreeMap<HookOrchestrationRegistryKey, Weak<BoundedHookOrchestratorV1>>>;
+
+fn hook_orchestration_registry() -> &'static HookOrchestrationRegistry {
+    static REGISTRY: OnceLock<HookOrchestrationRegistry> = OnceLock::new();
+    REGISTRY.get_or_init(|| StdMutex::new(BTreeMap::new()))
+}
+
+/// Publishes one project's hook orchestrator under its authenticated hook
+/// locators. A different live incumbent keeps the key: admission must never
+/// route one project's boundaries at another project's cycle owner.
+pub(crate) fn register_hook_orchestration_runtime(
+    hook_project_id: [u8; 16],
+    hook_worktree_id: [u8; 16],
+    runtime: &Arc<BoundedHookOrchestratorV1>,
+) -> bool {
+    let key = (hook_project_id, hook_worktree_id);
+    let Ok(mut registry) = hook_orchestration_registry().lock() else {
+        return false;
+    };
+    if let Some(existing) = registry.get(&key).and_then(Weak::upgrade) {
+        return Arc::ptr_eq(&existing, runtime);
+    }
+    registry.retain(|_, runtime| runtime.strong_count() > 0);
+    registry.insert(key, Arc::downgrade(runtime));
+    true
+}
+
+/// Removes exactly the given orchestrator's registration; a different live
+/// runtime under the same locator pair is left untouched so a rolled-back
+/// setup can never unregister its successor.
+pub(crate) fn unregister_hook_orchestration_runtime(
+    hook_project_id: [u8; 16],
+    hook_worktree_id: [u8; 16],
+    runtime: &Arc<BoundedHookOrchestratorV1>,
+) {
+    let key = (hook_project_id, hook_worktree_id);
+    if let Ok(mut registry) = hook_orchestration_registry().lock()
+        && registry
+            .get(&key)
+            .and_then(Weak::upgrade)
+            .is_some_and(|existing| Arc::ptr_eq(&existing, runtime))
+    {
+        registry.remove(&key);
+    }
+}
+
+pub(crate) fn admit_registered_hook_orchestration(
     envelope: HookEventEnvelopeV2,
     binding: HookScopeBindingV1,
+    lifecycle: Option<ContextScoutLifecycleAddressV1>,
+    configuration_revision: u64,
     explicit: bool,
+    completion: Option<Arc<dyn Fn() + Send + Sync + 'static>>,
 ) -> HookOrchestrationAdmissionV1 {
-    let Some(hook) = AdmittedContextScoutHookV1::new(envelope, &binding) else {
+    let Some(mut request) = HookOrchestrationRequestV1::from_envelope(
+        envelope,
+        &binding,
+        lifecycle,
+        configuration_revision,
+        explicit,
+    ) else {
+        return HookOrchestrationAdmissionV1::UnsupportedTrigger;
+    };
+    let Some(runtime) = hook_orchestration_registry()
+        .lock()
+        .ok()
+        .and_then(|registry| {
+            registry
+                .get(&(
+                    request.hook.envelope().project_id,
+                    request.hook.envelope().worktree_id,
+                ))
+                .cloned()
+        })
+        .and_then(|runtime| runtime.upgrade())
+    else {
         return HookOrchestrationAdmissionV1::Unavailable;
     };
-    if explicit
-        || matches!(
-            hook.envelope().event,
-            HookEventV2::SavedEdit { .. }
-                | HookEventV2::SessionBoundary {
-                    boundary: HookBoundaryV1::End | HookBoundaryV1::TurnComplete,
-                }
-        )
-    {
-        HookOrchestrationAdmissionV1::Unavailable
-    } else {
-        HookOrchestrationAdmissionV1::UnsupportedTrigger
-    }
+    request.completion = completion;
+    runtime.admit(request)
 }
+
 pub(in crate::daemon::service) struct SwitchableFeedbackCycleRuntimeV1 {
     current: RwLock<Arc<dyn FeedbackCycleRuntimePort>>,
 }
diff --git a/src/hooks/mod.rs b/src/hooks/mod.rs
index d8f6b0c71d..4dd8d73526 100644
--- a/src/hooks/mod.rs
+++ b/src/hooks/mod.rs
@@ -31,7 +31,6 @@ pub(crate) use dispatch::NativeContextScoutLifecycleV1;
 pub use dispatch::native_capture_material;
 pub(crate) use dispatch::project_and_worktree_locators_for_scope as hook_scope_locators;
 pub(crate) use dispatch::project_id_for_layout as hook_project_id_for_layout;
-#[cfg(test)]
 pub(crate) use dispatch::protected_session_id_for_native as protected_native_session_id;
 pub(crate) use dispatch::publish_daemon_bindings as publish_hook_bindings;
 
diff --git a/src/mcp/tools/handlers/hook_runtime/admission.rs b/src/mcp/tools/handlers/hook_runtime/admission.rs
index 0164679a67..be70a8eaec 100644
--- a/src/mcp/tools/handlers/hook_runtime/admission.rs
+++ b/src/mcp/tools/handlers/hook_runtime/admission.rs
@@ -6,15 +6,16 @@ use sha2::{Digest, Sha256};
 use std::collections::BTreeMap;
 use std::path::Path;
 use std::sync::{Arc, Mutex as StdMutex, OnceLock};
-use tracedecay_domain::{ProviderId, UtcMicros};
+use tracedecay_domain::{ProviderId, SessionId, UtcMicros};
 
 use super::context_scout::{
-    admit_native_context_scout_lifecycle, hook_v2_native_context_scout_lifecycle,
-    lookup_hook_v2_delivery_claim, remove_hook_v2_delivery_claim, retain_hook_v2_delivery_claim,
+    admit_native_context_scout_lifecycle, hook_v2_context_scout_lifecycle_for_session,
+    hook_v2_native_context_scout_lifecycle, lookup_hook_v2_delivery_claim,
+    remove_hook_v2_delivery_claim, retain_hook_v2_delivery_claim,
 };
 use super::envelope::{
     daemon_mint_hook_v2_envelope, hook_now, hook_v2_envelope, hook_v2_family_label,
-    hook_v2_lifecycle_range, hook_v2_requires_producer_work,
+    hook_v2_lifecycle_range, hook_v2_native_session_id, hook_v2_requires_producer_work,
 };
 
 pub(super) enum HookV2BindingAdmission {
@@ -260,14 +261,16 @@ fn cursor_stack_wakeup_allowed(
 pub(crate) async fn admit_hook_v2_envelope(
     cg: &TraceDecay,
     envelope: &tracedecay_hooks::HookEventEnvelopeV2,
+    native_session_id: Option<SessionId>,
     now: UtcMicros,
 ) -> HookV2AdmissionOutcomeV1 {
-    admit_hook_v2_envelope_with_lifecycle(cg, envelope, None, None, now).await
+    admit_hook_v2_envelope_with_lifecycle(cg, envelope, native_session_id, None, None, now).await
 }
 
 async fn admit_hook_v2_envelope_with_lifecycle(
     cg: &TraceDecay,
     envelope: &tracedecay_hooks::HookEventEnvelopeV2,
+    native_session_id: Option<SessionId>,
     native_lifecycle: Option<crate::hooks::NativeContextScoutLifecycleV1>,
     project_sessions: Option<&RegisteredGlobalDb>,
     now: UtcMicros,
@@ -367,7 +370,20 @@ async fn admit_hook_v2_envelope_with_lifecycle(
         )
         .await;
     }
-    let claim_authority = None;
+    let lifecycle = hook_v2_context_scout_lifecycle_for_session(envelope, native_session_id).await;
+    let claim_authority = match (
+        crate::agents::context_scout_ports::AdmittedContextScoutHookV1::new(
+            envelope.clone(),
+            &snapshot.binding,
+        ),
+        lifecycle.as_ref(),
+    ) {
+        (Some(hook), Some(lifecycle)) => {
+            cg.resolve_current_context_scout_claim_authority(&hook, lifecycle, now)
+                .await
+        }
+        _ => None,
+    };
     let ready_guidance = match (first_admission, cg.context_scout_owner(), claim_authority) {
         (true, Some(owner), Some((address, input_watermark))) => match owner
             .claim_ready_guidance_exact(envelope, address, input_watermark, snapshot.revision, now)
@@ -398,11 +414,14 @@ async fn admit_hook_v2_envelope_with_lifecycle(
         },
         _ => Value::Null,
     };
-    let orchestration =
-        crate::daemon::admit_hook_orchestration(envelope.clone(), snapshot.binding.clone(), false);
-    if let Some(completion) = completion {
-        completion();
-    }
+    let orchestration = crate::daemon::admit_registered_hook_orchestration(
+        envelope.clone(),
+        snapshot.binding.clone(),
+        lifecycle,
+        snapshot.revision,
+        false,
+        completion,
+    );
     let feedback_notice = if first_admission {
         tracedecay_usecases::advisory::peek_advisory_hook_notice(
             envelope.project_id,
@@ -452,11 +471,13 @@ pub(super) async fn hook_v2_admit(
 ) -> Result<Value> {
     let envelope = hook_v2_envelope(args, action)?;
     let now = hook_now();
+    let native_session_id = hook_v2_native_session_id(args, &envelope);
     let native_lifecycle = hook_v2_native_context_scout_lifecycle(args, &envelope);
     Ok(
         match admit_hook_v2_envelope_with_lifecycle(
             cg,
             &envelope,
+            native_session_id,
             native_lifecycle,
             Some(project_sessions),
             now,
diff --git a/src/mcp/tools/handlers/hook_runtime/context_scout.rs b/src/mcp/tools/handlers/hook_runtime/context_scout.rs
index c181f25e64..16fdd6214b 100644
--- a/src/mcp/tools/handlers/hook_runtime/context_scout.rs
+++ b/src/mcp/tools/handlers/hook_runtime/context_scout.rs
@@ -11,7 +11,7 @@ use tracedecay_domain::{
     CanonicalObservationFactV1, CanonicalObservationRelationsV1, ObservationId,
     ObservationIdentityMaterialV1, ObservationOrderingDomainV1, ObservationScopeV1,
     ObservationSourceGenerationV1, ObservationSourceIdentityV1, ObservationSourceRangeV1,
-    ProviderId, RetentionClass, UtcMicros,
+    ProviderId, RetentionClass, SessionId, UtcMicros,
 };
 use tracedecay_store::{ObservationPersistOutcome, StoreShardScopeV1};
 use tracedecay_usecases::host_admission::{HostAdmissionAuthorities, HostAdmissionFacade};
@@ -22,9 +22,30 @@ use tracedecay_usecases::observation::{
 use super::admission::{
     HookV2BindingAdmission, hook_v2_binding_admission, hook_v2_catchup_response,
 };
-use super::envelope::{hook_now, hook_v2_envelope};
+use super::envelope::{hook_now, hook_v2_envelope, hook_v2_native_session_id};
 use super::required_value;
 
+async fn hook_v2_context_scout_lifecycle(
+    args: &Value,
+    envelope: &tracedecay_hooks::HookEventEnvelopeV2,
+) -> Option<crate::agents::context_scout_ports::ContextScoutLifecycleAddressV1> {
+    hook_v2_context_scout_lifecycle_for_session(envelope, hook_v2_native_session_id(args, envelope))
+        .await
+}
+
+pub(super) async fn hook_v2_context_scout_lifecycle_for_session(
+    envelope: &tracedecay_hooks::HookEventEnvelopeV2,
+    session_id: Option<SessionId>,
+) -> Option<crate::agents::context_scout_ports::ContextScoutLifecycleAddressV1> {
+    let session_id = session_id?;
+    crate::daemon::context_scout_lifecycle::lookup_registered_context_scout_lifecycle(
+        envelope.project_id,
+        envelope.worktree_id,
+        &session_id,
+    )
+    .await
+}
+
 pub(super) fn hook_v2_native_context_scout_lifecycle(
     args: &Value,
     envelope: &tracedecay_hooks::HookEventEnvelopeV2,
@@ -235,9 +256,17 @@ pub(super) async fn hook_v2_scout_prepare(cg: &TraceDecay, args: &Value) -> Resu
             return Ok(hook_v2_catchup_response("hook_v2_scout_prepare"));
         }
     };
+    let lifecycle = hook_v2_context_scout_lifecycle(args, &envelope).await;
     Ok(orchestration_response(
         "hook_v2_scout_prepare",
-        crate::daemon::admit_hook_orchestration(envelope.clone(), snapshot.binding, true),
+        crate::daemon::admit_registered_hook_orchestration(
+            envelope.clone(),
+            snapshot.binding,
+            lifecycle,
+            snapshot.revision,
+            true,
+            None,
+        ),
     ))
 }
 
@@ -247,6 +276,8 @@ fn orchestration_response(
 ) -> Value {
     use crate::daemon::HookOrchestrationAdmissionV1 as Admission;
     match outcome {
+        Admission::Enqueued => json!({ "action": action, "status": "accepted" }),
+        Admission::Backpressured => json!({ "action": action, "status": "deferred" }),
         Admission::UnsupportedTrigger => json!({ "action": action, "status": "unsupported" }),
         Admission::Unavailable => json!({
             "action": action,
@@ -398,16 +429,75 @@ pub(super) async fn hook_v2_scout_read(
     args: &Value,
     action: &str,
 ) -> Result<Value> {
-    ContextScoutReadSurfaceV1::from_action(action)
+    let surface = ContextScoutReadSurfaceV1::from_action(action)
         .ok_or_else(|| config_error("unknown Context Scout read surface"))?;
     let envelope = hook_v2_envelope(args, action)?;
-    match hook_v2_binding_admission(cg, &envelope, hook_now()) {
-        HookV2BindingAdmission::Bound(_) | HookV2BindingAdmission::Unavailable => {
-            Ok(json!({ "action": action, "status": "unavailable" }))
+    let observed_at = hook_now();
+    let snapshot = match hook_v2_binding_admission(cg, &envelope, observed_at) {
+        HookV2BindingAdmission::Bound(snapshot) => snapshot,
+        HookV2BindingAdmission::Unavailable => {
+            return Ok(json!({ "action": action, "status": "unavailable" }));
         }
-        HookV2BindingAdmission::CatchupRequired => Ok(hook_v2_catchup_response(action)),
+        HookV2BindingAdmission::CatchupRequired => {
+            return Ok(hook_v2_catchup_response(action));
+        }
+    };
+    let Some(lifecycle) = hook_v2_context_scout_lifecycle(args, &envelope).await else {
+        return Ok(json!({ "action": action, "status": "unavailable" }));
+    };
+    let Some(hook) = crate::agents::context_scout_ports::AdmittedContextScoutHookV1::new(
+        envelope,
+        &snapshot.binding,
+    ) else {
+        return Ok(json!({ "action": action, "status": "unavailable" }));
+    };
+    let Some((address, _)) = cg
+        .resolve_current_context_scout_claim_authority(&hook, &lifecycle, observed_at)
+        .await
+    else {
+        return Ok(json!({ "action": action, "status": "unavailable" }));
+    };
+    let Some(owner) = cg.context_scout_owner() else {
+        return Ok(json!({ "action": action, "status": "unavailable" }));
+    };
+    let limit = args
+        .get("limit")
+        .and_then(Value::as_u64)
+        .and_then(|limit| usize::try_from(limit).ok())
+        .unwrap_or(8);
+    let value = match surface {
+        ContextScoutReadSurfaceV1::Recent => {
+            owner.recent_exact(address, limit).await.and_then(|recent| {
+                serde_json::to_value(recent).map_err(|_| {
+                    crate::agents::context_scout_v2::ContextScoutErrorV1::InvalidLimits
+                })
+            })
+        }
+        ContextScoutReadSurfaceV1::Explain => {
+            owner
+                .explain_exact(address, limit)
+                .await
+                .and_then(|explanation| {
+                    serde_json::to_value(explanation).map_err(|_| {
+                        crate::agents::context_scout_v2::ContextScoutErrorV1::InvalidLimits
+                    })
+                })
+        }
+        ContextScoutReadSurfaceV1::Capability => owner.capability().await.and_then(|capability| {
+            serde_json::to_value(capability)
+                .map_err(|_| crate::agents::context_scout_v2::ContextScoutErrorV1::InvalidLimits)
+        }),
+        ContextScoutReadSurfaceV1::Budget => owner.budget().await.and_then(|budget| {
+            serde_json::to_value(budget)
+                .map_err(|_| crate::agents::context_scout_v2::ContextScoutErrorV1::InvalidLimits)
+        }),
+    };
+    match value {
+        Ok(value) => Ok(json!({ "action": action, "status": "ready", "value": value })),
+        Err(_) => Ok(json!({ "action": action, "status": "unavailable" })),
     }
 }
+
 fn scout_store_outcome(
     outcome: crate::agents::context_scout_v2::ContextScoutDurableStoreOutcomeV1,
 ) -> &'static str {
diff --git a/src/mcp/tools/handlers/hook_runtime/context_scout/tests.rs b/src/mcp/tools/handlers/hook_runtime/context_scout/tests.rs
index 7e5e6bd8e7..4174d5a75e 100644
--- a/src/mcp/tools/handlers/hook_runtime/context_scout/tests.rs
+++ b/src/mcp/tools/handlers/hook_runtime/context_scout/tests.rs
@@ -1,7 +1,11 @@
 use std::sync::Mutex as StdMutex;
 
-use tracedecay_domain::UtcMicros;
+use crate::daemon::context_scout_lifecycle::AuthorityRegistrationV1;
+use serde_json::json;
+use tracedecay_domain::{ObservationSourceRangeV1, ProjectId, ProviderId, SessionId, UtcMicros};
+use tracedecay_usecases::host_admission::HostAdmissionScope;
 
+use super::super::envelope::hook_v2_native_session_id;
 use super::super::test_support::*;
 use super::*;
 
@@ -101,3 +105,106 @@ fn hook_v2_scout_prepare_accepts_no_caller_candidates() {
     assert!(!response.to_string().contains("candidate"));
     assert!(!response.to_string().contains("control"));
 }
+
+#[test]
+fn hook_v2_native_session_requires_exact_protected_locator() {
+    let session_id = "native-session-1";
+    let mut envelope = hook_v2_envelope_for_test();
+    envelope.protected_session_id = crate::hooks::protected_native_session_id(session_id);
+    assert_eq!(
+        hook_v2_native_session_id(&json!({ "native_session_id": session_id }), &envelope)
+            .as_ref()
+            .map(SessionId::as_str),
+        Some(session_id)
+    );
+
+    envelope.protected_session_id = [9; 32];
+    assert!(
+        hook_v2_native_session_id(&json!({ "native_session_id": session_id }), &envelope).is_none()
+    );
+}
+
+#[tokio::test]
+async fn kimi_and_opencode_queued_lifecycle_delivery_prepares_scout_lookup() {
+    let temporary = tempfile::tempdir().unwrap();
+    let project_id = ProjectId::new("project.native-hook-scout").unwrap();
+    let runtime = crate::host_admission::HostAdmissionTestRuntimeV1::project(
+        temporary.path().join("profile"),
+        temporary.path().join("project"),
+        project_id.clone(),
+    )
+    .await
+    .unwrap();
+    let sessions = runtime
+        .registered_database_arc(HostAdmissionScope::Project)
+        .unwrap();
+    let worktree_id = tracedecay_domain::WorktreeId::new("worktree.native-hook-scout").unwrap();
+    let hook_project_id = [71; 16];
+    let hook_worktree_id = [72; 16];
+    assert_eq!(
+        crate::daemon::context_scout_lifecycle::register_context_scout_lifecycle_authority(
+            hook_project_id,
+            hook_worktree_id,
+            project_id,
+            worktree_id,
+            &sessions,
+        ),
+        AuthorityRegistrationV1::Registered
+    );
+
+    for (provider, session, first_call, latest_call) in [
+        (
+            "kimi",
+            "session.kimi.native",
+            "call.kimi.first",
+            "call.kimi.latest",
+        ),
+        (
+            "opencode",
+            "session.opencode.native",
+            "call.opencode.first",
+            "call.opencode.latest",
+        ),
+    ] {
+        for (order, call) in [first_call, latest_call].into_iter().enumerate() {
+            let identity =
+                crate::hooks::NativeContextScoutLifecycleV1::new(session, call, [1; 16]).unwrap();
+            let range = ObservationSourceRangeV1::new(
+                u64::try_from(order).unwrap() + 1,
+                u64::try_from(order).unwrap() + 2,
+            )
+            .unwrap();
+            assert!(
+                admit_native_context_scout_lifecycle(
+                    &sessions,
+                    ProviderId::new(provider).unwrap(),
+                    &identity,
+                    range,
+                )
+                .await
+            );
+            assert!(
+                admit_native_context_scout_lifecycle(
+                    &sessions,
+                    ProviderId::new(provider).unwrap(),
+                    &identity,
+                    range,
+                )
+                .await
+            );
+        }
+        let lifecycle =
+            crate::daemon::context_scout_lifecycle::lookup_registered_context_scout_lifecycle(
+                hook_project_id,
+                hook_worktree_id,
+                &SessionId::new(session.to_owned()).unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(lifecycle.provider_id.as_str(), provider);
+        assert_eq!(lifecycle.thread_id.as_str(), session);
+        assert_eq!(lifecycle.agent_id.as_str(), session);
+        assert_eq!(lifecycle.turn_id.as_str(), latest_call);
+        assert_eq!(lifecycle.logical_message_id.as_str(), latest_call);
+    }
+}
diff --git a/src/mcp/tools/handlers/hook_runtime/envelope.rs b/src/mcp/tools/handlers/hook_runtime/envelope.rs
index 19efe5238d..14d1c43a79 100644
--- a/src/mcp/tools/handlers/hook_runtime/envelope.rs
+++ b/src/mcp/tools/handlers/hook_runtime/envelope.rs
@@ -3,7 +3,7 @@ use serde_json::Value;
 use sha2::{Digest, Sha256};
 use std::time::{SystemTime, UNIX_EPOCH};
 use tracedecay_agent_hosts::automation::config_error;
-use tracedecay_domain::{ObservationSourceRangeV1, UtcMicros};
+use tracedecay_domain::{ObservationSourceRangeV1, SessionId, UtcMicros};
 
 pub(super) fn hook_now() -> UtcMicros {
     UtcMicros(
@@ -30,6 +30,15 @@ pub(super) fn hook_v2_envelope(
     Ok(envelope)
 }
 
+pub(super) fn hook_v2_native_session_id(
+    args: &Value,
+    envelope: &tracedecay_hooks::HookEventEnvelopeV2,
+) -> Option<SessionId> {
+    let session = SessionId::new(args.get("native_session_id")?.as_str()?.to_owned()).ok()?;
+    (crate::hooks::protected_native_session_id(session.as_str()) == envelope.protected_session_id)
+        .then_some(session)
+}
+
 pub(super) fn hook_v2_requires_producer_work(
     envelope: &tracedecay_hooks::HookEventEnvelopeV2,
 ) -> bool {
diff --git a/src/mcp/tools/handlers/hook_runtime/mod.rs b/src/mcp/tools/handlers/hook_runtime/mod.rs
index 79ad38c66d..45d0980f1f 100644
--- a/src/mcp/tools/handlers/hook_runtime/mod.rs
+++ b/src/mcp/tools/handlers/hook_runtime/mod.rs
@@ -28,6 +28,7 @@ mod test_support;
 pub(crate) use admission::{
     HookV2AdmissionOutcomeV1, admit_hook_v2_envelope, hook_v2_pending_work_envelopes,
 };
+pub(crate) use envelope::daemon_mint_hook_v2_file_id;
 pub(crate) use errors::structured_hook_error_data;
 pub(crate) use hermes::replay_projectless_hermes_host_admission;
 
diff --git a/src/tracedecay.rs b/src/tracedecay.rs
index 5a7f9fcfca..6c39f27ee8 100644
--- a/src/tracedecay.rs
+++ b/src/tracedecay.rs
@@ -58,11 +58,24 @@ pub struct TraceDecay {
     db_path_cache: OnceLock<PathBuf>,
     context_scout_owner:
         Option<Arc<crate::agents::context_scout_owner::ProjectContextScoutOwnerV1>>,
+    context_scout_claim_authorities: tokio::sync::RwLock<Vec<MountedContextScoutClaimAuthorityV1>>,
     #[cfg(any(test, feature = "test-transport"))]
     test_runtime_guard: Option<Arc<crate::host_admission::HostAdmissionTestRuntimeV1>>,
     _standalone_maintenance_scope: Option<Arc<crate::db::OwnedMaintenanceDatabaseScope>>,
 }
 
+const MAX_MOUNTED_CONTEXT_SCOUT_CLAIM_AUTHORITIES: usize = 256;
+
+#[derive(Clone)]
+struct MountedContextScoutClaimAuthorityV1 {
+    registry: Arc<crate::agents::context_scout_ports::ProjectContextScoutAddressRegistryV1>,
+    pin: crate::agents::context_scout_ports::ContextScoutAuthorityPinV1,
+    context: tracedecay_application::RequestContext,
+    lifecycle: crate::agents::context_scout_ports::ContextScoutLifecycleAddressV1,
+    address: crate::agents::context_scout_v2::ContextScoutAddressV1,
+    input_watermark: [u8; 32],
+}
+
 impl TraceDecay {
     pub(crate) fn storage_telemetry_handle(&self) -> Result<DatabaseStorageTelemetryHandle> {
         self.db.storage_telemetry_handle()
@@ -105,6 +118,123 @@ impl TraceDecay {
     ) -> Option<&Arc<crate::agents::context_scout_owner::ProjectContextScoutOwnerV1>> {
         self.context_scout_owner.as_ref()
     }
+
+    /// Publishes one hook-admissible Context Scout claim authority for an
+    /// enqueued producer generation. The mount re-validates the durable
+    /// address registry and the current Plan 20 configuration before the
+    /// authority becomes claimable; a stale pin or a foreign address never
+    /// mounts.
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) async fn mount_current_context_scout_claim_authority(
+        &self,
+        registry: Arc<crate::agents::context_scout_ports::ProjectContextScoutAddressRegistryV1>,
+        hook: &crate::agents::context_scout_ports::AdmittedContextScoutHookV1,
+        pin: crate::agents::context_scout_ports::ContextScoutAuthorityPinV1,
+        context: tracedecay_application::RequestContext,
+        lifecycle: crate::agents::context_scout_ports::ContextScoutLifecycleAddressV1,
+        address: crate::agents::context_scout_v2::ContextScoutAddressV1,
+        input_watermark: [u8; 32],
+        observed_at: tracedecay_domain::UtcMicros,
+    ) -> bool {
+        if input_watermark == [0; 32]
+            || !self.context_scout_configuration_is_current(&pin).await
+            || registry
+                .resolve_current_exact(hook, &pin, &lifecycle, &context, observed_at)
+                .await
+                != crate::agents::context_scout_ports::ContextScoutAddressResolveOutcomeV1::Resolved(
+                    address,
+                )
+        {
+            return false;
+        }
+        let mounted = MountedContextScoutClaimAuthorityV1 {
+            registry,
+            pin,
+            context,
+            lifecycle,
+            address,
+            input_watermark,
+        };
+        let mut authorities = self.context_scout_claim_authorities.write().await;
+        if let Some(existing) = authorities
+            .iter_mut()
+            .find(|existing| existing.lifecycle == mounted.lifecycle)
+        {
+            *existing = mounted;
+            return true;
+        }
+        if authorities.len() == MAX_MOUNTED_CONTEXT_SCOUT_CLAIM_AUTHORITIES {
+            authorities.remove(0);
+        }
+        authorities.push(mounted);
+        true
+    }
+
+    /// Resolves the claim authority mounted for one exact lifecycle, or
+    /// `None` when nothing was mounted, the Plan 20 configuration moved past
+    /// the mounted pin, or the durable address registry no longer resolves
+    /// the mounted address for this hook.
+    pub(crate) async fn resolve_current_context_scout_claim_authority(
+        &self,
+        hook: &crate::agents::context_scout_ports::AdmittedContextScoutHookV1,
+        lifecycle: &crate::agents::context_scout_ports::ContextScoutLifecycleAddressV1,
+        observed_at: tracedecay_domain::UtcMicros,
+    ) -> Option<(
+        crate::agents::context_scout_v2::ContextScoutAddressV1,
+        [u8; 32],
+    )> {
+        let mounted = self
+            .context_scout_claim_authorities
+            .read()
+            .await
+            .iter()
+            .find(|mounted| mounted.lifecycle == *lifecycle)
+            .cloned()?;
+        if !self
+            .context_scout_configuration_is_current(&mounted.pin)
+            .await
+        {
+            return None;
+        }
+        let resolved = mounted
+            .registry
+            .resolve_current_exact(hook, &mounted.pin, lifecycle, &mounted.context, observed_at)
+            .await;
+        let resolved = (resolved
+            == crate::agents::context_scout_ports::ContextScoutAddressResolveOutcomeV1::Resolved(
+                mounted.address,
+            ))
+        .then_some((mounted.address, mounted.input_watermark));
+        // Re-check currentness after the registry read: a configuration
+        // revision that lands mid-resolve must not hand out a stale claim.
+        if resolved.is_some()
+            && self
+                .context_scout_configuration_is_current(&mounted.pin)
+                .await
+        {
+            resolved
+        } else {
+            None
+        }
+    }
+
+    async fn context_scout_configuration_is_current(
+        &self,
+        pin: &crate::agents::context_scout_ports::ContextScoutAuthorityPinV1,
+    ) -> bool {
+        self.configuration_runtime
+            .client()
+            .current()
+            .await
+            .ok()
+            .map(
+                |pinned| tracedecay_usecases::configuration::ConfigurationCurrentStateV1 {
+                    revision_id: pinned.revision_id,
+                    snapshot: pinned.snapshot,
+                },
+            )
+            .is_some_and(|current| pin.configuration().matches_current(&current))
+    }
 }
 
 #[derive(Debug, Clone, Default)]
diff --git a/src/tracedecay/lifecycle/branches.rs b/src/tracedecay/lifecycle/branches.rs
index f85471d45a..3230dc447a 100644
--- a/src/tracedecay/lifecycle/branches.rs
+++ b/src/tracedecay/lifecycle/branches.rs
@@ -261,6 +261,7 @@ impl TraceDecay {
             read_only,
             db_path_cache: OnceLock::new(),
             context_scout_owner: None,
+            context_scout_claim_authorities: tokio::sync::RwLock::new(Vec::new()),
             #[cfg(any(test, feature = "test-transport"))]
             test_runtime_guard: None,
             _standalone_maintenance_scope: None,
diff --git a/src/tracedecay/lifecycle/mod.rs b/src/tracedecay/lifecycle/mod.rs
index 56bf81e8d5..25f2b27d7d 100644
--- a/src/tracedecay/lifecycle/mod.rs
+++ b/src/tracedecay/lifecycle/mod.rs
@@ -369,6 +369,7 @@ impl TraceDecay {
             read_only: false,
             db_path_cache: OnceLock::new(),
             context_scout_owner: None,
+            context_scout_claim_authorities: tokio::sync::RwLock::new(Vec::new()),
             #[cfg(any(test, feature = "test-transport"))]
             test_runtime_guard: None,
             _standalone_maintenance_scope: None,
@@ -595,6 +596,7 @@ impl TraceDecay {
             read_only: false,
             db_path_cache: OnceLock::new(),
             context_scout_owner: None,
+            context_scout_claim_authorities: tokio::sync::RwLock::new(Vec::new()),
             #[cfg(any(test, feature = "test-transport"))]
             test_runtime_guard: None,
             _standalone_maintenance_scope: None,
@@ -796,6 +798,7 @@ impl TraceDecay {
             read_only: true,
             db_path_cache: OnceLock::new(),
             context_scout_owner: None,
+            context_scout_claim_authorities: tokio::sync::RwLock::new(Vec::new()),
             #[cfg(any(test, feature = "test-transport"))]
             test_runtime_guard: None,
             _standalone_maintenance_scope: None,