Sync

Parse the invocation text for scope only. The level is already set by the profile.

Examples:

• /sync recall backend algorithm choices → scope: recall backend, axis: algorithm selection
• /sync (no text) → scope: full project, axis: whatever profile says matters

Step 3: Clarify If Necessary (Optional)

Only ask if ALL of these are true:

1. Scope is genuinely ambiguous AND that ambiguity would change what you report
2. The question can be framed in the user's cognitive vocabulary — no implementation-level terms

Ask exactly 1 question. Frame at design or trade-off level:

• Good: "Are you asking about the interface contract (what goes in/out) or the implementation strategy (how it achieves it)?"
• Bad: "Should I include the sentence-transformer version differences?"

If you cannot frame the question without code-level terms: decide yourself, proceed, note the assumption at the end.

Step 4: Declare the Lens (Phase 1)

Output 2-3 lines before the full report:

Profile: [user's cognitive level + concern domains]
Scope: [what you are syncing on]
Angle: [which axis of their concern domains applies here]

If the invocation text carried a specific concern: proceed immediately to Step 5. If the scope was vague or bare /sync: pause here and wait for user confirmation or redirection.

Step 5: Explore

In this order:

1. Profile (already read in Step 1)
2. Project memory: MEMORY.md index, then files relevant to scope
3. Session context: what has been discussed in this conversation
4. Codebase: targeted reads driven by the concern axis, not an exhaustive scan

Step 6: Report

Generate from the declared perspective. Cover what is relevant to the user's specific concern:

• Current state: done / in progress / pending — pure facts, no interpretation
• Technical decisions: current approaches in the user's concern domains
• Open items: unresolved design questions, unmade decisions
• Model observations: anomalies, risks, misalignment with preferences expressed in profile or session

Output Format

For each mechanism or component, use this two-layer structure:

Algorithm layer (lead with this): Pure concept — what the mechanism does, what flows in, how it computes, what flows out. Zero code vocabulary: no function names, variable names, or file paths in this layer.

Code mapping layer (immediately after, in parentheses): Function or class name, followed by only the significant parameters mapped to their algorithm concepts, followed by where the output goes.

Example:

Confidence filtering — drops candidates below a reliability threshold to reduce noise in retrieval results
  (RecallBackend._filter_by_confidence:
   ranked_list = sorted candidates from the previous ranking step,
   threshold = 0.75 (configured value),
   → returns only entries with score > threshold, passed to the caller)

Causal Completeness Principle

Whenever a statement implies a dependency or relationship — "A is embedded in B", "A is passed to B", "A is loaded by B", "A depends on B" — immediately answer: where does B come from? Where does it go?

Do not leave implied relationships unresolved. Every artifact that is "used by" or "embedded in" something must have its source and destination visible in the same statement.

Self-Refine Loop

Step 6A — Draft: Write the initial report following the two-layer format above.

Step 6B — Critique (adopt the user's perspective from Profile): Re-read the draft. Mark every location where someone unfamiliar with this codebase would naturally ask:

• "Where is this defined or configured?"
• "Who loads this, and when?"
• "What triggers this?"
• "Where does this output go next?"

If knowledge_state is present in the project profile, skip questions about mechanisms the user already knows.

Step 6C — Refine: For each marked location, add one sentence — inline or parenthetical — that resolves the question.

Step 6D — Verify: Repeat Step 6B. If no new gaps remain: output the result. If new gaps appear: return to Step 6C.

Step 7: Close

End with one line:

[Reported at [level] on [scope]. Profile: [concern domains]. Redirect with 'go deeper into X' or 'I care more about Y'.]