Rust Router

---

Rust Question Router

Version: 2.0.0 | Last Updated: 2025-01-22

>

v2.0: Context optimized - detailed examples moved to sub-files

Meta-Cognition Framework

Core Principle

Don't answer directly. Trace through the cognitive layers first.

Layer 3: Domain Constraints (WHY)
├── Business rules, regulatory requirements
├── domain-fintech, domain-web, domain-cli, etc.
└── "Why is it designed this way?"

Layer 2: Design Choices (WHAT)
├── Architecture patterns, DDD concepts
├── m09-m15 skills
└── "What pattern should I use?"

Layer 1: Language Mechanics (HOW)
├── Ownership, borrowing, lifetimes, traits
├── m01-m07 skills
└── "How do I implement this in Rust?"

Routing by Entry Point

CRITICAL: Dual-Skill Loading

When domain keywords are present, you MUST load BOTH skills:

---

INSTRUCTIONS FOR CLAUDE

CRITICAL: Negotiation Protocol Trigger

BEFORE answering, check if negotiation is required:

When negotiation is required, include:

## Negotiation Analysis

**Query Type:** [Comparative | Cross-domain | Synthesis | Ambiguous]
**Negotiation:** Enabled

### Source: [Agent/Skill Name]
**Confidence:** HIGH | MEDIUM | LOW | UNCERTAIN
**Gaps:** [What's missing]

## Synthesized Answer
[Answer]

**Overall Confidence:** [Level]
**Disclosed Gaps:** [Gaps user should know]

详细协议见: patterns/negotiation.md

---

Default Project Settings

When creating new Rust projects or Cargo.toml files, ALWAYS use:

[package]
edition = "2024"  # ALWAYS use latest stable edition
rust-version = "1.85"

[lints.rust]
unsafe_code = "warn"

[lints.clippy]
all = "warn"
pedantic = "warn"

---

Layer 1 Skills (Language Mechanics)

Layer 2 Skills (Design Choices)

Layer 3 Skills (Domain Constraints)

---

Error Code Routing

---

Functional Routing Table

---

Priority Order

1. Identify cognitive layer (L1/L2/L3) 2. Load entry skill (m0x/m1x/domain) 3. Trace through layers (UP or DOWN) 4. Cross-reference skills as indicated in "Trace" sections 5. Answer with reasoning chain

Keyword Conflict Resolution

Priority Hierarchy:

1. Error codes (E0xxx) → Direct lookup, highest priority
2. Negotiation triggers (compare, vs, best practice) → Enable negotiation
3. Domain keywords + error → Load BOTH domain + error skills
4. Specific crate keywords → Route to crate-specific skill if exists
5. General concept keywords → Route to meta-question skill

---

Sub-Files Reference

Workflow Examples

rust-router 的工作流程示例

Example 1: Error Code with Domain Context

User: "Why am I getting E0382 in my trading system?"

Analysis:
1. Entry: Layer 1 (E0382 = ownership/move error)
2. Load: m01-ownership skill
3. Context: "trading system" → domain-fintech

Trace UP ↑:
- E0382 in trading context
- Check domain-fintech: "immutable audit records"
- Finding: Trading data should be shared, not moved

Response:
"E0382 indicates a value was moved when still needed.
In a trading system (domain-fintech), transaction records
should be immutable and shareable for audit purposes.

Instead of cloning, consider:
- Arc<TradeRecord> for shared immutable access
- This aligns with financial audit requirements

See: m01-ownership (Trace Up section),
     domain-fintech (Audit Requirements)"

Example 2: Design Question

User: "How should I handle user authentication?"

1. Entry: Layer 2 (design question)
2. Trace UP to Layer 3: domain-web constraints
3. Load: domain-web skill (security, stateless HTTP)
4. Trace DOWN: m06-error-handling, m07-concurrency
5. Answer: JWT with proper error types, async handlers

Example 3: Comparative Query

User: "Compare tokio and async-std"

1. Detect: "compare" → Enable negotiation
2. Load both runtime knowledge sources
3. Assess confidence for each
4. Synthesize with disclosed gaps
5. Answer: Structured comparison table

Example 4: Multi-Layer Trace

User: "My web API reports Rc cannot be sent between threads"

1. Entry: Layer 1 (Send/Sync error)
2. Load: m07-concurrency
3. Detect: "web API" → domain-web
4. Dual-skill loading:
   - m07: Explain Send/Sync bounds
   - domain-web: Web state management patterns
5. Answer: Use Arc instead of Rc, or move to thread-local

Example 5: Intent Analysis Request

User: "Analyze this question: How do I share state in actix-web?"

Analysis Steps:
1. Extract Keywords: share, state, actix-web
2. Identify Entry Layer: Layer 1 (sharing = concurrency) + Layer 3 (actix-web = web)
3. Map to Skills: m07-concurrency, domain-web
4. Report:
   - Layer 1: Concurrency (state sharing mechanisms)
   - Layer 3: Web domain (HTTP handler patterns)
   - Suggested trace: L1 → L3
5. Invoke: m07-concurrency first, then domain-web

OS-Checker Integration

代码审查和安全审计工具集成

Available Commands

When to Suggest OS-Checker

Tool Descriptions

clippy

Standard Rust linter for code style and common mistakes.

cargo audit

Security vulnerability scanner for dependencies.

geiger

Counts unsafe code usage in dependencies.

miri

Interprets MIR to detect undefined behavior.

rudra

Memory safety bug detector.

lockbud

Deadlock and concurrency bug detector.

Integration Flow

User: "Review my unsafe code"
     │
     ▼
Router detects: unsafe + review
     │
     ├── Load: unsafe-checker skill (for manual review)
     │
     └── Suggest: `/audit safety` (for automated check)

Negotiation Protocol

比较查询和跨领域问题的处理协议

When to Enable Negotiation

For complex queries requiring structured agent responses, enable negotiation mode.

Negotiation Decision Flow

Query Received
     │
     ▼
┌─────────────────────────────┐
│ Is query single-lookup?     │
│ (version, error code, def)  │
└─────────────────────────────┘
     │
     ├── Yes → Direct dispatch (no negotiation)
     │
     ▼ No
┌─────────────────────────────┐
│ Does query require:         │
│ - Comparison?               │
│ - Cross-domain context?     │
│ - Synthesis/aggregation?    │
│ - Multiple sources?         │
└─────────────────────────────┘
     │
     ├── Yes → Dispatch with negotiation: true
     │
     ▼ No
┌─────────────────────────────┐
│ Is scope ambiguous?         │
└─────────────────────────────┘
     │
     ├── Yes → Dispatch with negotiation: true
     │
     ▼ No
     └── Direct dispatch (no negotiation)

Negotiation Dispatch

When dispatching with negotiation:

1. Set `negotiation: true`
2. Include original query context
3. Expect structured response:
   - Findings
   - Confidence (HIGH/MEDIUM/LOW/UNCERTAIN)
   - Gaps identified
   - Context questions (if any)
4. Evaluate response against original intent

Orchestrator Evaluation

After receiving negotiation response:

Refinement Loop

If response insufficient:

Round 1: Initial query
  │
  ▼ (LOW confidence or gaps block intent)
Round 2: Refined query with:
  - Answers to agent's context questions
  - Narrowed scope
  │
  ▼ (still insufficient)
Round 3: Final attempt with:
  - Alternative agent/source
  - Maximum context provided
  │
  ▼ (still insufficient)
Synthesize best-effort answer with disclosed gaps

Integration with 3-Strike Rule

Negotiation follows the 3-Strike escalation:

Strike 1: Initial query returns LOW confidence
  → Refine with more context

Strike 2: Refined query still LOW
  → Try alternative agent/source

Strike 3: Still insufficient
  → Synthesize best-effort answer
  → Report gaps to user explicitly

See _meta/error-protocol.md for full escalation rules.

Negotiation Routing Examples

Example 1: No Negotiation Needed

Query: "What is tokio's latest version?"
Analysis: Single lookup
Action: Direct dispatch to crate-researcher

Example 2: Negotiation Required

Query: "Compare tokio and async-std for a web server"
Analysis: Comparative + domain context
Action: Dispatch with negotiation: true
Expected: Structured responses from both runtime lookups
Evaluation: Check if web-server specific data found

Example 3: Cross-Domain Negotiation

Query: "E0382 in my trading system"
Analysis: Error code + domain context
Action:
  - Dispatch m01-ownership (standard - error is defined)
  - Dispatch domain-fintech (negotiation: true - domain context)
Synthesis: Combine error explanation with domain-appropriate fix

Related Documents

• _meta/negotiation-protocol.md - Full protocol specification
• _meta/negotiation-templates.md - Response templates
• _meta/error-protocol.md - 3-Strike escalation
• agents/_negotiation/response-format.md - Agent response format