@@ -82,7 +82,9 @@ Implementation plan: [`PLAN.md`](./PLAN.md).
 
 ### Milestone 2: Scoped Guidance
 
-Status: Planned
+Status: Complete
+
+Completed: 2026-09-01
 
 Extend the root-focused model to repositories with nested guidance files and
 resource-constrained local AI harnesses.
@@ -110,7 +112,8 @@ maintenance behavior first.
   GitHub Actions are covered by tests and locked verification passes.
 - **Scoped Guidance:** Nested-document fixtures demonstrate correct scope
   discovery, inheritance, precedence, conflict reporting, deduplication,
-  fallback, migration, signature configuration, and budget enforcement.
+  fallback, migration, signature configuration, and budget profile selection
+  with evidence bounding.
 
 ## Release-Wide Success Criteria
 
@@ -140,8 +143,6 @@ Markdown generation in Rust.
 
 ## Open Risks And Decisions
 
-- Define the migration experience for existing documents that lack provenance
-  or a `## Free Region`.
 - Confirm how malformed `agentskill.toml` is surfaced to the LLM workflow while
   preserving safe default behavior.
 - Keep workflow-level signature overrides temporary and ensure post-write
 
@@ -188,6 +188,31 @@ fn scope_manifest_and_budgeted_evidence_are_deterministic() {
     assert_eq!(paths, vec![".", "packages/api"]);
 
     let selected = ["packages/api".to_string()];
+
+    for (mode, input_tokens, output_tokens, follow_up_rounds) in [
+        ("compact", 4_000, 512, 1),
+        ("standard", 8_000, 1_000, 2),
+        ("deep", 16_000, 2_000, 4),
+    ] {
+        let profile =
+            agentskill_analyzers::run_evidence_scoped(&repo, None, Some(&selected), Some(mode))
+                .unwrap();
+
+        assert_eq!(profile["budget"]["mode"], mode);
+        assert_eq!(profile["budget"]["input_tokens"], input_tokens);
+        assert_eq!(profile["budget"]["output_tokens"], output_tokens);
+        assert_eq!(profile["budget"]["follow_up_rounds"], follow_up_rounds);
+        let tree_len = profile["analyzers"]["scan"]["tree"]
+            .as_array()
+            .unwrap()
+            .len();
+        if mode == "compact" {
+            assert!(tree_len <= 32);
+        } else {
+            assert!(tree_len > 32);
+        }
+    }
+
     let evidence =
         agentskill_analyzers::run_evidence_scoped(&repo, None, Some(&selected), Some("compact"))
             .unwrap();
@@ -235,6 +260,18 @@ fn scope_manifest_and_budgeted_evidence_are_deterministic() {
             .len()
             <= 32
     );
+    assert!(
+        evidence["analyzers"]["scan"]["read_order"]
+            .as_array()
+            .unwrap()
+            .len()
+            <= 16
+    );
+    for result in evidence["analyzers"]["graph"].as_object().unwrap().values() {
+        if let Some(edges) = result["edges"].as_array() {
+            assert!(edges.len() <= 32);
+        }
+    }
 
     let standard =
         agentskill_analyzers::run_evidence_scoped(&repo, None, Some(&selected), Some("standard"))
@@ -248,6 +285,22 @@ fn scope_manifest_and_budgeted_evidence_are_deterministic() {
             > 32
     );
 
+    let deep =
+        agentskill_analyzers::run_evidence_scoped(&repo, None, Some(&selected), Some("deep"))
+            .unwrap();
+    assert!(deep["analyzers"]["scan"]["tree"].as_array().unwrap().len() > 32);
+    assert!(
+        deep["analyzers"]["scan"]["tree"].as_array().unwrap().len()
+            >= standard["analyzers"]["scan"]["tree"]
+                .as_array()
+                .unwrap()
+                .len()
+    );
+    assert!(
+        agentskill_analyzers::run_evidence_scoped(&repo, None, Some(&selected), Some("unknown"))
+            .is_err()
+    );
+
     let explicit = ["src".to_string()];
     let explicit_manifest = agentskill_analyzers::run_scopes(&repo, Some(&explicit)).unwrap();
     assert_eq!(explicit_manifest["scopes"][0]["path"], "src");
 
@@ -103,6 +103,11 @@ Validation and drift report unsupported or low-confidence evidence, duplicate
 inherited rules, and contradictory inherited rules; semantic rule authorship
 remains with the LLM.
 
+The Rust runtime bounds evidence detail for the selected profile. The invoking
+LLM harness owns actual input-context, output-token, and follow-up-round
+ceilings using the profile metadata; the runtime does not perform token
+counting.
+
 ## Crate Responsibilities
 
 ### Core
 
@@ -1026,6 +1026,21 @@ fn validate_markdown(
         ));
     }
 
+    let is_operational = path.file_name().and_then(|name| name.to_str()) == Some("AGENTS.md");
+    let reference = path.with_file_name("AGENTS.reference.md");
+    if is_operational && reference.is_file() && !content.contains("AGENTS.reference.md") {
+        let message = "AGENTS.md must reference local AGENTS.reference.md when it exists";
+        errors.push(format!("{}: {message}", display_path(root, path).display()));
+
+        findings.push(finding(
+            "unreferenced_reference_document",
+            "error",
+            &display_path(root, path).to_string_lossy(),
+            message,
+            Some("AGENTS.reference.md"),
+        ));
+    }
+
     for referenced in referenced_paths(&content) {
         if referenced != "."
             && !is_optional_reference(root, &referenced)
 
@@ -33,6 +33,24 @@ fn validates_operational_and_reference_documents() {
     let result = validate(directory.path().to_string_lossy().as_ref()).unwrap();
 
     assert_eq!(result["valid"], true);
+
+    let without_reference_link = fs::read_to_string(directory.path().join("AGENTS.md"))
+        .unwrap()
+        .replace("\nRead `AGENTS.reference.md`.", "");
+    fs::write(directory.path().join("AGENTS.md"), without_reference_link).unwrap();
+
+    let unreferenced = validate(directory.path().to_string_lossy().as_ref()).unwrap();
+    assert_eq!(unreferenced["valid"], false);
+    assert!(
+        unreferenced["findings"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|finding| {
+                finding["kind"] == "unreferenced_reference_document"
+                    && finding["document"] == "AGENTS.md"
+            })
+    );
 }
 
 #[test]
@@ -489,6 +507,153 @@ fn validates_nested_scopes_and_reports_missing_candidates_advisory() {
     );
 }
 
+#[test]
+fn validates_nested_references_with_inherited_signature_configuration() {
+    let directory = tempdir().unwrap();
+    fs::write(
+        directory.path().join("agentskill.toml"),
+        "signature = false\n",
+    )
+    .unwrap();
+    fs::write(
+        directory.path().join("AGENTS.md"),
+        "# Root Guidance\n\n## Free Region\n\nRoot custom instructions.\n",
+    )
+    .unwrap();
+    fs::create_dir_all(directory.path().join("packages/api/src")).unwrap();
+    fs::write(
+        directory.path().join("packages/api/src/lib.rs"),
+        "pub fn api() {}\n",
+    )
+    .unwrap();
+    fs::write(
+        directory.path().join("packages/api/AGENTS.md"),
+        "# API Guidance\n\n## Scope\n\n- Path: packages/api\n- Parent: .\n- Inheritance: additive; nearest scope wins.\n\n## Mission\n\nRead `src/lib.rs`.\n\nRead `AGENTS.reference.md` for local API context.\n\n## Free Region\n\nAPI custom instructions.\n",
+    )
+    .unwrap();
+    fs::write(
+        directory.path().join("packages/api/AGENTS.reference.md"),
+        "# API Reference\n\n## Provenance And Decisions\n\n- Agentskill Version: `2.0.0`.\n- Evidence Schema Version: `4`.\n- Repository Revision: `fixture-revision`.\n- Configuration: inherited signature disabled.\n- Maintainer-Confirmed Decisions: Scope uses local API instructions.\n- Unresolved Uncertainty: None recorded.\n\nLocal API reference context.\n",
+    )
+    .unwrap();
+
+    let root = fs::read_to_string(directory.path().join("AGENTS.md")).unwrap();
+    let scoped = fs::read_to_string(directory.path().join("packages/api/AGENTS.md")).unwrap();
+    let repo = directory.path().to_string_lossy().into_owned();
+
+    let report = validate_with_mode_and_scopes(&repo, SignatureMode::Auto, None).unwrap();
+    assert_eq!(report["valid"], true);
+    assert_eq!(report["configuration"]["signature"], false);
+    assert!(
+        report["validated_scopes"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|path| path == "packages/api")
+    );
+
+    let root_free = parse(&root)
+        .sections
+        .into_iter()
+        .find(|section| section.heading == "Free Region")
+        .unwrap()
+        .body;
+    let scoped_free = parse(&scoped)
+        .sections
+        .into_iter()
+        .find(|section| section.heading == "Free Region")
+        .unwrap()
+        .body;
+    assert_ne!(root_free, scoped_free);
+
+    let without_reference_link =
+        scoped.replace("\nRead `AGENTS.reference.md` for local API context.", "");
+    fs::write(
+        directory.path().join("packages/api/AGENTS.md"),
+        without_reference_link,
+    )
+    .unwrap();
+
+    let unreferenced = validate_with_mode_and_scopes(&repo, SignatureMode::Auto, None).unwrap();
+    assert_eq!(unreferenced["valid"], false);
+    assert!(
+        unreferenced["findings"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|finding| {
+                finding["kind"] == "unreferenced_reference_document"
+                    && finding["document"] == "AGENTS.md"
+            })
+    );
+
+    fs::write(directory.path().join("packages/api/AGENTS.md"), &scoped).unwrap();
+
+    let overridden = validate_with_mode_and_scopes(&repo, SignatureMode::On, None).unwrap();
+    assert_eq!(overridden["valid"], false);
+    assert!(
+        overridden["findings"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|finding| finding["kind"] == "missing_signature")
+    );
+
+    let disabled = validate_with_mode_and_scopes(&repo, SignatureMode::Off, None).unwrap();
+    assert_eq!(disabled["valid"], true);
+}
+
+#[test]
+fn legacy_scoped_documents_are_advisory_until_explicitly_adopted() {
+    let directory = tempdir().unwrap();
+    fs::write(
+        directory.path().join("AGENTS.md"),
+        "# Root Guidance\n\n## Free Region\n\nRoot custom instructions.\n",
+    )
+    .unwrap();
+    fs::create_dir_all(directory.path().join("packages/api")).unwrap();
+    fs::write(
+        directory.path().join("packages/api/AGENTS.md"),
+        "# Legacy API Guidance\n\n## Free Region\n\nLegacy custom instructions.\n",
+    )
+    .unwrap();
+
+    let path = directory.path().join("packages/api/AGENTS.md");
+    let before = fs::read_to_string(&path).unwrap();
+    let repo = directory.path().to_string_lossy().into_owned();
+    let scopes = agentskill_analyzers::run_scopes(&repo, None).unwrap();
+    let legacy = scopes["scopes"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|scope| scope["path"] == "packages/api")
+        .unwrap();
+
+    assert_eq!(legacy["status"], "legacy");
+
+    let report = validate_with_mode_and_scopes(&repo, SignatureMode::Off, None).unwrap();
+    assert_eq!(report["valid"], true);
+    assert!(
+        report["findings"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|finding| {
+                finding["kind"] == "legacy_scoped_document"
+                    && finding["severity"] == "warning"
+                    && finding["document"] == "packages/api"
+            })
+    );
+    assert!(
+        !report["validated_scopes"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|path| path == "packages/api")
+    );
+    assert_eq!(fs::read_to_string(&path).unwrap(), before);
+}
+
 #[test]
 fn scoped_validation_rejects_incorrect_parent_metadata() {
     let directory = tempdir().unwrap();
 
@@ -24,9 +24,12 @@ finished document.
 7. Write compact managed `AGENTS.md` guidance and reference context when
    provenance or decisions require it. Scoped documents include local `## Scope`
    metadata, an independent `## Free Region`, and an explicit parent link.
-8. Present the complete semantic plan and diff before writing. Never create
+8. Treat legacy scoped documents as read-only advisory candidates. Adopt or
+   migrate one only after explicit, reviewed LLM workflow selection; never
+   rewrite it automatically.
+9. Present the complete semantic plan and diff before writing. Never create
    documents for merely suggested candidates.
-9. Run `agentskill validate <repo> --signature <mode>` and show the semantic
+10. Run `agentskill validate <repo> --signature <mode>` and show the semantic
    diff. Use `auto` unless the workflow request explicitly selects `on` or
    `off`.
 
 
@@ -61,6 +61,10 @@ uncertainty. The Agentskill version determines freshness; the repository
 revision records exact source provenance and may change without making
 guidance stale.
 
+Safe legacy migration means read-only detection followed by explicit, reviewed
+adoption through the LLM skill. Legacy scoped documents are advisory candidates;
+the Rust CLI never rewrites or automatically adopts them.
+
 ## Generation Modes
 
 The packaged skill provides the complete LLM workflow. The model reads the
@@ -72,8 +76,8 @@ sections directly.
 The skill supports `init`, `enrich`, `scope`, `update`, `audit`, and
 `explain` workflows. `operational` and `reference` are depth views over one
 repository understanding, not competing sources of truth. Milestone 1
-formalizes `init`, `update`, `audit`, and `explain`; the other workflows remain
-compatible but are not expanded here.
+formalizes `init`, `update`, `audit`, and `explain`; Milestone 2 formalizes
+`scope`. The `enrich` workflow remains compatible but is not expanded here.
 
 ## Managed Signature
 
@@ -100,6 +104,11 @@ harnesses and preserves high-confidence operational guidance before dropping
 low-confidence details, examples, history, or deep references. `deep` permits
 broader reference loading.
 
+The Rust runtime directly bounds repository evidence detail, especially in
+compact mode. The invoking LLM harness owns actual input-context, output-token,
+and follow-up-round ceilings using the profile metadata; the Rust runtime does
+not perform token counting.
+
 The fixed ceilings are:
 
 | Mode | Input context | Output | Follow-up rounds |