@oriro/orirocli 0.1.0

package/skills/craft/become-an-ai-engineer-26/phases/phase-0-mental-models/project/TEMPLATE.md

@@ -0,0 +1,33 @@
+# [Your Name] — AI Engineering Mental Models
+
+> 2-page concept doc. In your own words. No copy-paste.
+
+## 1. Workflow vs Agent
+
+- Workflow is...
+- Agent is...
+- I would choose an agent over a workflow when...
+
+## 2. The 5 Workflow Patterns
+
+1. Prompt chaining —
+2. Routing —
+3. Parallelisation —
+4. Orchestrator-worker —
+5. Evaluator-optimiser —
+
+## 3. The 4 Context Primitives
+
+- Write —
+- Select —
+- Compress —
+- Isolate —
+
+## 4. The Harness Stack
+
+- Why "the harness is the job":
+- One thing a harness gives the model that a raw API call does not:
+
+## 5. The one idea I understood only after writing this doc
+
+-

package/skills/craft/become-an-ai-engineer-26/phases/phase-1-first-agent/README.md

@@ -0,0 +1,25 @@
+# Phase 1 — Build Your First Agent From Scratch (Weeks 3-5)
+
+Write the agent twice. Raw API first, Agent SDK second. Feel the difference.
+
+## Build #1 — The raw loop
+
+[`code/raw_loop.py`](code/raw_loop.py) — ~100 lines, no framework. Give it three
+tools (`web_search`, `read_file`, `write_file`), run it on a research task, and
+read every step of the trace.
+
+```bash
+cd code
+pip install anthropic
+export ANTHROPIC_API_KEY=...      # PowerShell: $env:ANTHROPIC_API_KEY="..."
+python raw_loop.py "Research the top 3 AI agent frameworks in 2026"
+```
+
+## Build #2 — The same agent on Claude Agent SDK
+
+Add `CLAUDE.md`, a `skills/research/SKILL.md`, a `hooks/post_tool.py` PostToolUse
+hook, and spawn one sub-agent via the Task tool. See `SKILL.md` → _Phase 1_.
+
+**Deliverable:** a daily-briefing agent. Reads your notes + RSS, writes a
+summarised briefing to disk every morning. Run it for a week. Watch it fail.
+Fix it.

package/skills/craft/become-an-ai-engineer-26/phases/phase-1-first-agent/code/raw_loop.py

@@ -0,0 +1,126 @@
+"""
+Phase 1 — The Raw Agent Loop (~100 lines)
+
+The entire job of a harness, stripped to its skeleton. No framework.
+Just the loop: the model thinks, picks a tool, you run it, you feed the
+result back, repeat until the model says it's done.
+
+Build this first. Read every step of the trace. Once you can see what the
+loop does for you, you'll understand what every framework is hiding.
+
+Requires:  pip install anthropic
+Env:       ANTHROPIC_API_KEY
+Run:       python raw_loop.py "Research the top 3 AI agent frameworks in 2026"
+"""
+
+import json
+import sys
+from anthropic import Anthropic
+
+client = Anthropic()  # reads ANTHROPIC_API_KEY from the environment
+
+# --- 1. Define the tools the model is allowed to call -----------------------
+TOOLS = [
+    {
+        "name": "web_search",
+        "description": "Search the web and return short text snippets.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"query": {"type": "string"}},
+            "required": ["query"],
+        },
+    },
+    {
+        "name": "read_file",
+        "description": "Read a UTF-8 text file from disk and return its contents.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}},
+            "required": ["path"],
+        },
+    },
+    {
+        "name": "write_file",
+        "description": "Write text to a file on disk. Overwrites if it exists.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string"},
+                "content": {"type": "string"},
+            },
+            "required": ["path", "content"],
+        },
+    },
+]
+
+
+# --- 2. Implement the tools -------------------------------------------------
+def web_search(query: str) -> str:
+    # Stub. Wire to a real search API (Tavily, Brave, SerpAPI) in practice.
+    return f"[search results for: {query!r}] — replace this stub with a real API."
+
+
+def read_file(path: str) -> str:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    except Exception as e:  # surface the error to the model, don't crash the loop
+        return f"ERROR reading {path}: {e}"
+
+
+def write_file(path: str, content: str) -> str:
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return f"Wrote {len(content)} chars to {path}."
+    except Exception as e:
+        return f"ERROR writing {path}: {e}"
+
+
+def execute_tool(name: str, args: dict) -> str:
+    return {
+        "web_search": web_search,
+        "read_file": read_file,
+        "write_file": write_file,
+    }[name](**args)
+
+
+# --- 3. The loop ------------------------------------------------------------
+def run(user_input: str) -> None:
+    messages = [{"role": "user", "content": user_input}]
+    stop_reason = None
+
+    while stop_reason != "end_turn":
+        response = client.messages.create(
+            model="claude-sonnet-4-5",
+            max_tokens=2048,
+            messages=messages,
+            tools=TOOLS,
+        )
+        stop_reason = response.stop_reason
+
+        # Echo any text the model produced this turn
+        for block in response.content:
+            if block.type == "text":
+                print(block.text)
+
+        if stop_reason == "tool_use":
+            tool_results = []
+            for block in response.content:
+                if block.type == "tool_use":
+                    print(f"  -> {block.name}({json.dumps(block.input)})")
+                    result = execute_tool(block.name, block.input)
+                    tool_results.append(
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": block.id,
+                            "content": result,
+                        }
+                    )
+            messages.append({"role": "assistant", "content": response.content})
+            messages.append({"role": "user", "content": tool_results})
+
+
+if __name__ == "__main__":
+    task = sys.argv[1] if len(sys.argv) > 1 else "Say hello and stop."
+    run(task)

package/skills/craft/become-an-ai-engineer-26/phases/phase-2-architecture/README.md

@@ -0,0 +1,17 @@
+# Phase 2 — Real Architecture (Weeks 6-9)
+
+Build on **LangGraph + Deep Agents** — the production stack. See `SKILL.md` →
+_Phase 2_ for the full walkthrough (StateGraph, PostgresSaver checkpointing,
+middleware hooks, isolated-context sub-agents).
+
+**Deliverable:** a Research Analyst Agent.
+
+- Lead agent plans → spawns 3 search sub-agents in parallel (isolated context)
+- Sub-agents write results to files → a citation sub-agent verifies
+- Writer agent produces Markdown with inline citations
+- State persists via `PostgresSaver` (kill → resume)
+- Human-in-the-loop interrupt before exceeding $1 in tokens
+- Ship a LangSmith trace URL in your README
+
+> Reference implementation (`research_agent/graph.py`, `nodes.py`, `tools.py`)
+> is left for you to build — that's the point of the phase.

package/skills/craft/become-an-ai-engineer-26/phases/phase-3-harness/README.md

@@ -0,0 +1,17 @@
+# Phase 3 — Build the Harness Yourself (Weeks 10-13)
+
+**The highest-leverage phase in the roadmap.** You will not make the right
+production trade-offs until you've built a harness once. See `SKILL.md` →
+_Phase 3_ for the 10 components.
+
+**The 10 components:** loop control · tool dispatch · context management
+(auto-compaction at 85%) · persistence · sub-agent orchestration · skills /
+progressive disclosure · hooks · observability (OpenTelemetry) · sandboxing ·
+auth brokering.
+
+**Deliverable:** a ~1,500-line mini-harness in Python, plus a 1,000-word
+post-mortem comparing it to the Claude Agent SDK and Deep Agents — what you got
+right, what you cut, what you'd do differently.
+
+> `code/mini_harness/` is yours to write. Don't copy a framework — build it,
+> then read the frameworks and see what they hid from you.

package/skills/craft/become-an-ai-engineer-26/phases/phase-4-evals/README.md

@@ -0,0 +1,21 @@
+# Phase 4 — Evals & Regression Harness (Weeks 14-17)
+
+> Without this, every "improvement" is vibes.
+
+See `SKILL.md` → _Phase 4_. The four eval types: single-turn, trajectory,
+LLM-as-judge, end-state.
+
+The CI gate lives at
+[`code/.github/workflows/eval.yml`](code/.github/workflows/eval.yml) — a
+reference GitHub Actions workflow that blocks a merge if the golden-dataset
+pass rate drops 3+ points below baseline. Copy it into your own repo and wire
+`ANTHROPIC_API_KEY` as a repo secret.
+
+**Deliverable:**
+
+- Golden dataset: 30–50 hand-graded questions across 3 difficulty levels
+- Deterministic graders for factual queries
+- LLM-as-judge with a 5-criterion rubric
+- Trajectory eval: did it plan, spawn sub-agents, cite, stay under budget?
+- Wired into GitHub Actions, blocking merges on a 3-point regression
+- Production sampling: 1% of live traces auto-graded nightly

package/skills/craft/become-an-ai-engineer-26/phases/phase-4-evals/code/.github/workflows/eval.yml

@@ -0,0 +1,40 @@
+# Agent Regression Harness — GitHub Actions
+#
+# Reference workflow from Phase 4. Copy into your own repo's
+# .github/workflows/ and wire ANTHROPIC_API_KEY as a repo secret.
+# Blocks the merge if the golden-dataset pass rate drops 3+ points
+# below the committed baseline.
+name: Agent Regression
+
+on: [pull_request]
+
+jobs:
+  eval:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Run golden dataset
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        run: python evals/run_golden.py
+
+      - name: Check pass rate against baseline
+        run: |
+          PASS_RATE=$(cat results/pass_rate.json | jq .rate)
+          BASELINE=$(cat evals/baseline.json | jq .rate)
+          python -c "
+          pass_rate = $PASS_RATE
+          baseline = $BASELINE
+          if pass_rate < baseline - 0.03:
+              print(f'FAIL: {pass_rate:.1%} < baseline {baseline:.1%} - 3pp')
+              exit(1)
+          print(f'PASS: {pass_rate:.1%} (baseline {baseline:.1%})')
+          "

package/skills/craft/become-an-ai-engineer-26/phases/phase-5-production/README.md

@@ -0,0 +1,16 @@
+# Phase 5 — Production Hardening (Forever)
+
+This phase never ends. See `SKILL.md` → _Phase 5_ for the code patterns.
+
+The five fronts:
+
+1. **Cost discipline** — prompt caching (up to 90% savings), route by difficulty
+   (Haiku → Sonnet → Opus), Batch API for non-real-time work (50% off).
+2. **Latency** — parallel tool calls always; sub-agent fan-out turns a 60-step
+   sequential run into a 10-step lead + parallel sub-agents.
+3. **Safety & sandboxing** — never `exec()` model output; run it in an isolated
+   container. Never put credentials in the model's context — broker them.
+4. **Monitoring & drift** — alert on cost/request, tool-failure rate, judge
+   score, p95 latency. Re-baseline after every model upgrade.
+5. **Resilience** — durable execution (PostgresSaver) for anything running >60s,
+   so a process kill is a resume, not a restart.

package/skills/craft/become-an-ai-engineer-26/projects/1-mobile-app-slm/README.md

@@ -0,0 +1,11 @@
+# Project 1 — Mobile App + SLM (Beginner)
+
+**Proves:** Edge AI, resource constraints.
+
+Offline-first mobile app using a small language model. Zero API costs, complete
+privacy. See `SKILL.md` → _The 5 Portfolio Projects_.
+
+- Lazy-load models on demand; unload under memory pressure
+- Sliding context window with semantic chunking
+- 4-bit quantisation for older devices, 8-bit for newer
+- Batch inference to reduce battery wake cycles

package/skills/craft/become-an-ai-engineer-26/projects/2-self-improving-coder/README.md

@@ -0,0 +1,11 @@
+# Project 2 — Self-Improving Coding Agent (Intermediate)
+
+**Proves:** Agentic loops, debugging.
+
+Agent writes code → runs tests → learns from failures → loops until functional.
+See `SKILL.md` → _The 5 Portfolio Projects_.
+
+- Plan → Execute → Test → Reflect loop with a max-iteration limit
+- Isolated execution per task with resource limits
+- Memory: short-term (last 5) + long-term (successes) + failure memory (error signatures)
+- Static analysis before execution — detect dangerous operations

package/skills/craft/become-an-ai-engineer-26/projects/3-video-editor-agent/README.md

@@ -0,0 +1,11 @@
+# Project 3 — Video Editor Agent (Advanced)
+
+**Proves:** Multimodal AI, tool integration.
+
+Fork an open-source editor. User says "make this cinematic"; the agent handles
+cuts, transitions, colour. See `SKILL.md` → _The 5 Portfolio Projects_.
+
+- Vision model analyses frames + audio model analyses dialogue
+- Intent translation: "cinematic" → concrete parameters
+- Scene detection via frame-difference analysis
+- Incremental preview — only re-render affected sections

package/skills/craft/become-an-ai-engineer-26/projects/4-personal-life-os/README.md

@@ -0,0 +1,12 @@
+# Project 4 — Personal Life OS Agent (Expert)
+
+**Proves:** Deep context management, privacy-first design.
+
+Manages calendar, finances, and health. Plans months ahead. Detects burnout.
+See `SKILL.md` → _The 5 Portfolio Projects_.
+
+- Real-time ingestion: calendar, finance, health, communications
+- Personal knowledge graph of entities and relationships
+- Background thread every 6 hours checking for anomalies
+- Value alignment: user states priorities — recommendations validated against them
+- All data encrypted at rest with user-controlled keys

package/skills/craft/become-an-ai-engineer-26/projects/5-enterprise-workflow/README.md

@@ -0,0 +1,12 @@
+# Project 5 — Enterprise Workflow Agent (Master)
+
+**Proves:** Production orchestration.
+
+Monitors Slack/Jira → plans execution → delegates → reports with audit logs.
+See `SKILL.md` → _The 5 Portfolio Projects_.
+
+- Event-driven: Slack, Jira, email, monitoring systems
+- Multi-agent delegation: orchestrator → communication, data, analysis, documentation agents
+- Self-healing: exponential backoff, circuit breakers, retry decisions
+- Immutable audit log: every action, authorisation, outcome
+- Human-in-the-loop: agent proposes a plan before executing critical workflows

package/skills/craft/become-an-ai-engineer-26/references/benchmark-numbers.md

@@ -0,0 +1,41 @@
+# Benchmark Numbers (May 2026)
+
+The leaderboard changes weekly. What does **not** change: the same model on a
+different harness swings 10–36 points on any benchmark. The harness writes the
+score.
+
+## The one number
+
+```
+Same model. Two harnesses. CORE benchmark:
+
+  Claude Code harness:  78%
+  Smolagents harness:   42%
+                        ───
+                   36-point gap
+```
+
+## Current scores
+
+| Benchmark          | What it measures        | Leader (May 2026)                       |
+| ------------------ | ----------------------- | --------------------------------------- |
+| SWE-bench Verified | Real-world coding fixes | GPT-5.5 ~88.7% · Claude Opus 4.7 ~87.6% |
+| GAIA               | General agent tasks     | Claude Sonnet 4.5 — 74.6%               |
+| τ-bench            | Customer-service agents | Claude Mythos Preview — 89.2%           |
+
+## How to read a benchmark
+
+- **A single number is meaningless without the harness.** Always ask: which
+  scaffold produced this score? Tool set, context strategy, retry policy and
+  sub-agent structure move the number more than the base model does.
+- **Re-baseline after every model upgrade.** Harnesses encode assumptions about
+  model limitations; those assumptions go stale when the model changes.
+- **Your own golden dataset beats any public leaderboard** for deciding whether
+  _your_ system got better. Public benchmarks tell you the field is moving;
+  your evals tell you _you_ are.
+
+> Update this file as new scores publish — cite the primary source in the PR.
+
+---
+
+_Reference for "Become An AI Engineer 26"._

package/skills/craft/become-an-ai-engineer-26/references/mhc-stable-training.md

@@ -0,0 +1,73 @@
+# mHC — Stable Training at Scale
+
+> How to keep training stable at 27B+ parameters using manifold-constrained
+> residual streams. DeepSeek · arxiv:2512.24880 (Dec 2025)
+
+---
+
+## The problem
+
+Standard **residual connections** preserve signal by adding the input back to
+the output: `x_out = x_in + f(x_in)`. The identity term (`x_in`) is what keeps
+gradients flowing through very deep stacks.
+
+**Hyper-Connections (HC)** generalised this by adding several parallel residual
+streams and a learned matrix that mixes them. More capacity — but the learned
+mixing matrix can drift away from preserving identity, and when it does you get
+**loss spikes** (in the reported runs, around step 12,000). One spike can undo
+hours of training or diverge the run entirely.
+
+## The fix: constrain the mixing matrix to a manifold
+
+**mHC (manifold-constrained Hyper-Connections)** projects the stream-mixing
+matrix onto the **Sinkhorn manifold** — the set of doubly-stochastic matrices
+where every row and every column sums to 1. On that manifold, identity mapping
+is preserved automatically, so the residual stream can't blow up or collapse.
+
+```python
+import torch
+
+def sinkhorn(M: torch.Tensor, iters: int = 8, eps: float = 1e-6) -> torch.Tensor:
+    """Project a positive matrix toward doubly-stochastic (rows & cols sum to 1)."""
+    M = M.clamp_min(eps)
+    for _ in range(iters):
+        M = M / M.sum(dim=1, keepdim=True)   # normalise rows
+        M = M / M.sum(dim=0, keepdim=True)   # normalise columns
+    return M
+
+class ManifoldHyperConnection(torch.nn.Module):
+    def __init__(self, n_streams: int):
+        super().__init__()
+        self.logits = torch.nn.Parameter(torch.zeros(n_streams, n_streams))
+
+    def mixing_matrix(self) -> torch.Tensor:
+        # exp keeps entries positive; Sinkhorn makes it doubly-stochastic
+        return sinkhorn(self.logits.exp())
+
+    def forward(self, streams: torch.Tensor) -> torch.Tensor:
+        # streams: (n_streams, batch, dim) -> mixed streams, identity preserved
+        return torch.einsum("ij,jbd->ibd", self.mixing_matrix(), streams)
+```
+
+## Results
+
+- **6.7% compute overhead** vs standard residuals.
+- **Zero loss spikes** across the reported runs.
+- Evaluated at **3B / 9B / 27B** parameter scales.
+
+## The harness parallel
+
+The lesson generalises beyond model internals. **Constrain the system at the
+right point and the whole thing becomes stable under real load.** In harness
+design the equivalent constraints are:
+
+- **Context compaction at ~85%** of the window — never let context overflow.
+- **Credential brokering** — the model never sees raw secrets.
+- **Sandboxed execution** — model output runs in an isolated container.
+
+Same principle: pick the one invariant that must always hold, enforce it
+structurally, and stop firefighting the symptoms.
+
+---
+
+_Reference for "Become An AI Engineer 26". See SKILL.md → Advanced Science._

package/skills/craft/become-an-ai-engineer-26/references/stack-decisions.md

@@ -0,0 +1,37 @@
+# Stack Decisions
+
+The recommended 2026 production stack, with the reasoning for each call.
+
+## Use
+
+| Layer             | Choice                                                                                                                                 | Why                                                                                             |
+| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
+| Framework         | **LangGraph 1.0 + Deep Agents**                                                                                                        | State machine + durable checkpointing + observability. Survives process kills, resumes mid-run. |
+| Harness reference | **Claude Agent SDK**                                                                                                                   | Same harness as Claude Code: CLAUDE.md + Skills + sub-agents + hooks + filesystem-as-memory.    |
+| Observability     | **LangSmith** (LangGraph-native) / **Braintrust** (framework-agnostic, CI gating) / **Arize Phoenix** (open-source, OTEL-native, free) | Pick one. You cannot improve what you cannot trace.                                             |
+
+## Avoid in production
+
+| Avoid                            | Reason                                                 |
+| -------------------------------- | ------------------------------------------------------ |
+| CrewAI in production             | Fast demo, fragile at scale. Fine for hackathons only. |
+| OpenAI Swarm                     | Their own README says "not production-ready".          |
+| OpenAI Assistants API            | Sunsetting mid-2026.                                   |
+| No-code agent platforms          | Throwaway prototypes only.                             |
+| Custom vector store (by default) | Measure recall first — most apps don't need one.       |
+
+## The decision rule
+
+1. What is the **simplest** thing that solves this problem?
+2. What does it look like at **10×** current scale (not 100×)?
+3. What is the **cost of being wrong** — easy to change, or locked in?
+
+Start with a monolith. Start serverless. Buy everything that isn't your core
+product (auth, email, payments). Split into services only when parts genuinely
+need to scale independently.
+
+> Update with benchmark-backed comparisons only — see CONTRIBUTING.md.
+
+---
+
+_Reference for "Become An AI Engineer 26". See SKILL.md → The Stack._

package/skills/craft/become-an-ai-engineer-26/references/yarn-context-extension.md

@@ -0,0 +1,123 @@
+# YaRN — Context Window Extension
+
+> Give a model a 128K-token context window using ~10× fewer training steps
+> than prior methods. ICLR 2024 · [arxiv.org/abs/2309.00071](https://arxiv.org/abs/2309.00071)
+
+---
+
+## Why context extension is hard
+
+Models trained on, say, 4K tokens struggle past 32K at inference. The root
+cause is **RoPE** (Rotary Position Embeddings): the position frequencies used
+at long positions were _never seen during training_ — they are out of
+distribution. The model has no learned behaviour for them.
+
+There is also the **"lost in the middle"** problem: models attend strongly to
+the beginning and end of a long context and miss information buried at 10–50%
+depth. Extending the window does not fix this by itself — you have to test for
+it (see NIAH below).
+
+## The RoPE scaling landscape
+
+| Method      | Max scale  | Quality  | Training cost | When                         |
+| ----------- | ---------- | -------- | ------------- | ---------------------------- |
+| Linear PI   | 2–4×       | Poor     | none          | avoid                        |
+| NTK-Aware   | 4–8×       | Moderate | none          | quick inference-only fix     |
+| Dynamic NTK | 8–16×      | Good     | none          | adaptive, inconsistent       |
+| **YaRN**    | **16–32×** | **Best** | **<0.1%**     | **standard for fine-tuning** |
+| LongRoPE    | up to 2M   | Best     | medium        | extreme contexts             |
+
+## The YaRN insight
+
+Different RoPE frequency dimensions need different treatment. **Low-frequency**
+dimensions (long-range dependencies) get interpolated; **high-frequency**
+dimensions (local resolution) are left untouched. A softmax temperature factor
+(`attention_factor`) corrects the attention distribution at the new scale.
+
+```python
+# rope_scaling block in config.json — 4K base extended to 128K (32x):
+rope_scaling = {
+    "type": "yarn",
+    "factor": 32.0,
+    "original_max_position_embeddings": 4096,
+    "attention_factor": 0.1,   # softmax temperature — do not omit
+}
+```
+
+Performance: 200–600 fine-tuning steps are usually enough, using ~0.1% of the
+original pre-training token budget. Compatible with KV cache and FlashAttention.
+
+## Always verify the config survived checkpoint load
+
+```python
+rope_cfg = getattr(model.config, "rope_scaling", None)
+assert rope_cfg is not None, "YaRN rope_scaling missing — STOP"
+assert rope_cfg.get("type") in ("yarn", "longrope"), \
+    f"Unexpected rope type: {rope_cfg.get('type')}"
+print(f"YaRN preserved: {rope_cfg}")
+```
+
+---
+
+## Test it: Needle-in-a-Haystack (NIAH)
+
+Insert a specific fact (the _needle_) into a long block of irrelevant text
+(the _haystack_) and ask the model to retrieve it. Test at multiple lengths
+**and** multiple depths — failures cluster at 50% depth.
+
+```python
+import random
+
+NEEDLE = "The magic access code is YARN-NIAH-4731."
+QUESTION = "What is the magic access code?"
+
+def build_prompt(filler_paragraph: str, target_tokens: int, depth: float) -> str:
+    # crude token proxy: ~0.75 words/token. Repeat filler to reach length.
+    haystack = (filler_paragraph + "\n\n") * (target_tokens // 200)
+    cut = int(len(haystack) * depth)
+    return haystack[:cut] + "\n" + NEEDLE + "\n" + haystack[cut:] + "\n\n" + QUESTION
+
+def passes(model_answer: str) -> bool:
+    return "YARN-NIAH-4731" in model_answer
+
+# Sweep a 5x5 grid and print a hit/miss heatmap.
+lengths = [8_000, 32_000, 64_000, 128_000]
+depths = [0.1, 0.3, 0.5, 0.7, 0.9]
+for L in lengths:
+    row = []
+    for d in depths:
+        prompt = build_prompt("Lorem ipsum dolor sit amet. " * 30, L, d)
+        answer = run_model(prompt)          # your inference call
+        row.append("HIT " if passes(answer) else "MISS")
+    print(f"{L:>7}:  " + "  ".join(row))
+```
+
+A clean YaRN extension returns HIT across the whole grid. Cold spots at the
+50% column mean "lost in the middle" survived — re-check `attention_factor`
+and the fine-tune coverage at long positions.
+
+### Go harder: NoLiMa (no literal matching)
+
+NIAH is gameable — the model can keyword-match "magic code" in the question to
+"magic code" in the needle. **NoLiMa** removes the lexical overlap:
+
+```
+Needle:   "The combination for the safe is 7734."
+Question: "What numbers open the vault?"
+```
+
+The model must infer _safe ≈ vault_ with no shared keyword. Passing NoLiMa is
+real long-context comprehension, not string lookup.
+
+---
+
+## Surviving quantization
+
+Standard Q4_K_M can degrade YaRN because the position-embedding weights get
+quantized too — long-context recall breaks even when short-context scores look
+fine. Keep the embedding layer at F16 when exporting to GGUF, then **re-run the
+NIAH grid on the quantized model**, not just short-context benchmarks.
+
+---
+
+_Reference for "Become An AI Engineer 26". See SKILL.md → Advanced Science._

package/skills/craft/codex-result-handling/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ORIRO.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.