Legal AI, not a coding agent with scaffolding.

let mut pattern: &[String] = &chunk.old_lines;

let mut found =
    seek_sequence::seek_sequence(original_lines, pattern, line_index, chunk.is_end_of_file);

if let Some(start_idx) = found {
    replacements.push((start_idx, pattern.len(), new_slice.to_vec()));
    line_index = start_idx + pattern.len();
} else {
    return Err(ApplyPatchError::ComputeReplacements(format!(
        "Failed to find expected lines in {}:\n{}",
        path,
        chunk.old_lines.join("\n"),
    )));
}

def _completed_cross_reference_terms(ctx: ToolUseContext) -> set[str]:
    terms: set[str] = set()
    for row in getattr(ctx.document_state, "tool_call_log", None) or []:
        if str(row.get("tool_name") or "") != "get_cross_references":
            continue
        if str(row.get("status") or "").lower() != "ok" or row.get("is_error"):
            continue
        raw_input = row.get("raw_input")
        if not isinstance(raw_input, dict):
            raw_input = row.get("input_preview")
        if not isinstance(raw_input, dict):
            continue
        term = _normalized_reference_term(raw_input.get("term"))
        if term:
            terms.add(term)
    return terms

def _cross_reference_advisories(
    *,
    ctx: ToolUseContext,
    original_text: str,
    new_text: str,
) -> List[Dict[str, Any]]:
    if not original_text.strip() or new_text.strip():
        return []

    label = _section_reference_label(original_text)
    if not label or _normalized_reference_term(label) in _completed_cross_reference_terms(ctx):
        return []

    return [
        {
            "code": "cross_reference_review_not_recorded",
            "severity": "warning",
            "message": (
                f"No completed structured cross-reference review for {label} "
                "was recorded before this deletion. The deletion remains staged "
                "for your decision."
            ),
            "source": "deterministic_legal_review",
            "details": {"section_label": label},
        }
    ]

let history_snapshot = sess.clone_history().await;
let history_items = history_snapshot.raw_items();
let summary_suffix = get_last_assistant_message_from_turn(history_items).unwrap_or_default();
let summary_text = format!("{SUMMARY_PREFIX}\n{summary_suffix}");
let user_messages = collect_user_messages(history_items);

let mut new_history = build_compacted_history(Vec::new(), &user_messages, &summary_text);

# Marker template — note the {tool_use_id} placeholder is filled per
# tool result so the model can call read_tool_result with the right
# argument without searching for the id. Format string, not f-string,
# so callers that import this module can introspect it.
TOOL_RESULT_CLEARED_MARKER_TEMPLATE = (
    "[Tool result cleared during compaction — full content available "
    'via read_tool_result(tool_use_id="{tool_use_id}") if needed.]'
)

path = Path(RESULT_PERSIST_DIR) / process_id / f"{input_data.tool_use_id}.txt"
if not path.exists():
    return ToolResult(
        is_error=True,
        assistant_text=(
            f"No persisted result found for tool_use_id="
            f"{input_data.tool_use_id!r}. Either the id is wrong "
            "or the result was small enough to ship inline (no "
            "truncation notice = no persisted file). Check the "
            "tool result you copied the id from."
        ),
        summary="not found",
    )

bounded_len = min(int(input_data.length), MAX_FETCH_CHARS)
try:
    with path.open("r", encoding="utf-8") as f:
        f.seek(int(input_data.offset))
        chunk = f.read(bounded_len)

# Result-size cap: oversized rendered text is persisted to
# disk and the model-facing block becomes a head/tail preview
# with the tool_use_id. Skipped when the tool itself opts out
# via max_result_size_chars=math.inf (read_tool_result, where
# persisting a fetched chunk would create a circular loop) or
# when the result is an error (errors are usually small and
# already structured for the model — persisting them just adds
# a layer of indirection). The persisted file is cleaned up
# at end-of-run by routers/agentic.py.

/// Tracks the net text diff for the current turn from committed apply_patch
/// mutations, without rereading the workspace filesystem.
pub struct TurnDiffTracker {
    valid: bool,
    display_roots_by_environment: HashMap<String, PathBuf>,
    baseline_by_path: HashMap<TrackedPath, TrackedContent>,
    current_by_path: HashMap<TrackedPath, TrackedContent>,
    origin_by_current_path: HashMap<TrackedPath, TrackedPath>,
    next_revision: u64,
    rendered_diffs: HashMap<DiffCacheKey, Option<String>>,
    unified_diff: Option<String>,

pub fn track_delta(&mut self, environment_id: &str, delta: &AppliedPatchDelta) {
    if !self.valid {
        return;
    }

    if !delta.is_exact() {
        self.invalidate();
        return;
    }

    for change in delta.changes() {
        self.apply_change(environment_id, change);
    }
    self.refresh_unified_diff();
}

if should_emit_turn_diff {
    let unified_diff = {
        let tracker = turn_diff_tracker.lock().await;
        tracker.get_unified_diff()
    };
    if let Some(unified_diff) = unified_diff {
        let msg = EventMsg::TurnDiff(TurnDiffEvent { unified_diff });
        sess.clone().send_event(&turn_context, msg).await;
    }
}

#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema, TS)]
pub struct TurnDiffEvent {
    pub unified_diff: String,
}

# Walk the parent chain rather than blindly sorting by version
# number. Branched versions (e.g. user reverted to v3 then applied
# changes to produce v6 with parent=3) describe their delta against
# their explicit parent, not against v(N-1). Following the parent
# field gives the true evolution graph of the current document.
chain = _walk_parent_chain(versions)
all_registered: List[Dict[str, Any]] = []
for i in range(len(chain) - 1):
    registered = register_pair_diffcites(
        ctx.document_state,
        version_a=chain[i],
        version_b=chain[i + 1],
    )

def _extract_apply_time_hunks(
    version_a: Dict[str, Any],
    version_b: Dict[str, Any],
) -> List[Dict[str, Any]]:
    """Tier 0: authoritative hunks from ``versions[N].changes``.

    The apply route (`routers/changes.py:3158`) writes one entry per
    accepted edit on the resulting version, capturing the exact
    pre-edit and post-edit text strings BEFORE the post-apply re-parse
    that renumbers section IDs. Reading that array gives us
    position-blind, intent-bearing hunks for free — no LCS, no
    section-id-equality join, no positional drift.

hunks.append(
    {
        "from_version": from_v,
        "to_version": to_v,
        "from_date": from_date,
        "to_date": to_date,
        "section_id": sid,
        "section_heading": heading,
        "change_kind": change_kind,
        "removed_text": original,
        "added_text": new_text,
        "explanation": (
            str(entry.get("explanation") or "").strip() or None
        ),
        "prompt_text": (
            str(source_prompt_text or "").strip() or None
        ),
        "request_user": (
            str(request_user or "").strip() or None
        ),
        "applied_at": applied_at,
        "run_id": str(run_id or "").strip() or None,
        "edit_id": str(edit_id).strip() if edit_id else None,
        "confidence": "high",
        "source": "apply_time",
    }
)

class RiskDiffcite(BaseModel):
    """One atomic hunk between two persisted document versions.

    Two `source` paths populate this:

    - ``apply_time``: built from ``versions[N].changes`` — the exact
      ``original``/``new`` strings captured at the moment the user
      clicked Accept. Position-blind by construction (no re-derivation
      from post-apply structure). Carries apply-time provenance
      (explanation, triggering request, who applied, when).
      ``confidence`` is "high".
    - ``line_diff``: a fallback hunk computed via
      ``difflib.unified_diff`` over the version's flat text content.
      Position-blind via LCS (same approach as the version-history
      panel's Monaco diff). Used when ``versions[N].changes`` is
      missing (legacy versions, manual editor edits that bypass the
      apply route, the v1 baseline). ``confidence`` is "medium".

def sanitize_diff_markers(text: Optional[str], valid_diff_ids: Iterable[str]) -> str:
    """Drop every ``[[diff_X]]`` whose id is not in the registry. Collapse
    whitespace introduced by the removals so the prose still reads
    cleanly. Identical surface to `sanitize_pin_markers`."""
    if not text:
        return ""
    valid = set(valid_diff_ids)

    def _replace(match: re.Match[str]) -> str:
        diff_id = match.group(1)
        return match.group(0) if diff_id in valid else ""

    cleaned = DIFF_ID_PATTERN.sub(_replace, text)