ultimate-pi 0.1.2 → 0.1.4

package/vault/wiki/sources/openclaw-session-pruning.md

@@ -0,0 +1,13 @@
+---
+type: source
+status: stub
+created: 2026-05-02
+updated: 2026-05-02
+tags: [source, external-doc]
+---
+
+# OpenClaw Session Pruning
+
+Session pruning implementation from OpenClaw. Uses in-place context clearing to maintain agent performance across long sessions.
+
+Referenced in: [[resolved-context-pruning-inplace-vs-restart]]

package/vault/wiki/sources/opencode-dcp.md

@@ -0,0 +1,13 @@
+---
+type: source
+status: stub
+created: 2026-05-02
+updated: 2026-05-02
+tags: [source, external-doc]
+---
+
+# OpenCode DCP
+
+Dynamic Context Pruning system from OpenCode. Implements in-place context editing for agent sessions.
+
+Referenced in: [[resolved-context-pruning-inplace-vs-restart]]

package/vault/wiki/sources/opendev-arxiv-2603.05344v1.md

@@ -0,0 +1,79 @@
+---
+type: source
+source_type: academic-paper
+author: "Nghi D. Q. Bui (OpenDev)"
+date_published: 2026-03-05
+url: https://arxiv.org/html/2603.05344v1
+confidence: high
+tags:
+  - terminal-agents
+  - context-engineering
+  - agent-architecture
+  - safety
+  - multi-model
+key_claims:
+  - "OpenDev is the first comprehensive technical report for an open-source, terminal-native, interactive coding agent"
+  - "Compound AI system architecture with per-workflow LLM binding (action, thinking, critique, vision, compact models)"
+  - "Defense-in-depth safety with 5 independent layers: prompt guardrails, schema gating, runtime approval, tool validation, lifecycle hooks"
+  - "Adaptive Context Compaction (ACC) with 5 graduated stages reduces peak context consumption by ~54%"
+  - "Event-driven system reminders counteract instruction fade-out in long-running sessions"
+  - "Dual-agent architecture separating planning from execution via schema-level tool restrictions"
+---
+
+# Building AI Coding Agents for the Terminal: Scaffolding, Harness, Context Engineering, and Lessons Learned
+
+arXiv:2603.05344v1 — March 2026. OpenDev technical report by Nghi D. Q. Bui.
+
+## Core Architecture
+
+Four-layer system: Entry & UI → Agent → Tool & Context → Persistence.
+
+### Scaffolding vs Harness
+- **Scaffolding**: System prompt compilation, tool schema building, subagent registration — runs once before first prompt
+- **Harness**: Runtime orchestration — tool dispatch, context management, safety enforcement, session persistence
+
+### Compound AI System
+Five model roles with fallback chains:
+1. **Action model** — primary execution, tool-based reasoning
+2. **Thinking model** — extended reasoning without tool access (prevents premature action)
+3. **Critique model** — self-evaluation (Reflexion-inspired, selective)
+4. **Vision model** — screenshots/images
+5. **Compact model** — fast summarization during compaction
+
+### Extended ReAct Loop
+Four phases per iteration:
+- **Phase 0**: Staged context management (5 thresholds: 70%→80%→85%→90%→99%)
+- **Phase 1**: Thinking (4 depth levels, HIGH includes self-critique)
+- **Phase 2**: Action (LLM with full tool schemas)
+- **Phase 3**: Decision/dispatch with doom-loop detection (MD5 fingerprinting, 3-repeat threshold)
+
+## Context Engineering Highlights
+
+### Adaptive Context Compaction (ACC)
+Five graduated stages: Warning (70%) → Observation Masking (80%) → Fast Pruning (85%) → Aggressive Masking (90%) → Full Compaction (99%). Each stage applies progressively aggressive reduction.
+
+### System Reminders
+24 named reminders organized into 6 categories. Injected as `role: user` messages at maximum recency. Governed by guardrail counters (one-shot flags, attempt budgets). Addresses attention-decay where agents violate instructions after 30+ tool calls.
+
+### Dual-Memory Architecture
+- **Episodic memory**: LLM-generated summary of full history (regenerated every 5 messages from full history to prevent drift)
+- **Working memory**: Last 6 exchanges verbatim for operational detail
+
+## Safety Architecture (Defense-in-Depth)
+
+1. **Prompt-Level Guardrails** — security policy in system prompt
+2. **Schema-Level Tool Restrictions** — plan-mode whitelist, per-subagent allowed_tools
+3. **Runtime Approval System** — Manual/Semi-Auto/Auto levels, pattern/command/prefix/danger rules
+4. **Tool-Level Validation** — DANGEROUS_PATTERNS blocklist, stale-read detection, output truncation
+5. **Lifecycle Hooks** — pre-tool blocking (exit code 2), argument mutation, JSON stdin protocol
+
+Key insight: "Make unsafe tools invisible, not blocked" — removing tools from schema is more robust than runtime permission checks.
+
+## Lessons for Our Harness
+
+- Separate thinking from action (tool-free thinking phase produces better reasoning)
+- Inject reminders at decision points, not upfront (use `role: user`)
+- Treat context as a budget with graduated reduction (not binary emergency compaction)
+- Schema gating > runtime permission checks for safety
+- Design tools to absorb LLM imprecision (9-pass fuzzy edit matching chain)
+- Bound every resource that grows with session length (iteration caps, nudge budgets, undo history)

package/vault/wiki/sources/openhands-platform.md

@@ -0,0 +1,39 @@
+---
+type: source
+source_type: paper
+title: "OpenHands: An Open Platform for AI Software Developers as Generalist Agents"
+author: "Xingyao Wang et al."
+date_published: 2024-07-24
+url: "https://arxiv.org/abs/2407.16741"
+confidence: high
+key_claims:
+  - "Platform for AI agents that interact like human developers: write code, use CLI, browse web"
+  - "Supports sandboxed code execution, multi-agent coordination, and evaluation benchmarks"
+  - "Evaluated on 15+ tasks including SWE-bench and WebArena"
+  - "Community project with 2.1K+ contributions from 188+ contributors"
+  - "Accepted at ICLR 2025"
+status: ingested
+tags:
+  - agent-platform
+  - sandbox
+  - multi-agent
+created: 2024-07-24
+updated: 2026-04-30
+
+---# OpenHands: An Open Platform for AI Software Developers as Generalist Agents
+
+A platform that provides the infrastructure for AI agents to interact with codebases through the same interfaces humans use: writing code, executing commands, and browsing the web.
+
+## Agent-Codebase Interaction Model
+
+OpenHands treats the agent as a developer who:
+- Reads files via commands
+- Writes and edits code
+- Executes code in sandboxed environments
+- Browses documentation and search results
+
+This model mirrors the OSS guide's human workflow but automates it. The platform handles the infrastructure so researchers can focus on agent strategies.
+
+## Relevance
+
+OpenHands embodies the "ACI" concept from SWE-agent at platform scale. It shows that the human-centric OSS guide workflow (read, search, edit, test, iterate) maps directly to agent workflows — but agents need the infrastructure to execute these steps reliably.

package/vault/wiki/sources/oss-guide-codebase-exploration.md

@@ -0,0 +1,53 @@
+---
+type: source
+source_type: blog
+title: "General Guide For Exploring Large Open Source Codebases"
+author: "Parth Parikh, Kishore Ganesh, Chris Ewald, Cory Massaro, Makrand Rajagopal, Sarthak Kundra"
+date_published: 2021
+url: "https://pncnmnp.github.io/blogs/oss-guide.html"
+confidence: high
+key_claims:
+  - "Human contributors should use a project before contributing to understand its breadth"
+  - "Earliest commits reveal the core architecture and initial goals"
+  - "Test cases are the best form of documentation for understanding expected behavior"
+  - "Don't try to understand the whole codebase; narrow scope to relevant subsystem"
+  - "Paper Cut Principle: many small fixes across the codebase builds deep understanding over time"
+  - "Reproduce the bug before planning a fix; write a failing test"
+  - "Structured theorizing with creative hypothesis generation and verification"
+  - "Use debugging, logging, and profilers in addition to print statements"
+  - "Feedback from maintainers and rubber-duck debugging are effective"
+status: ingested
+tags:
+  - codebase-exploration
+  - open-source
+  - human-guide
+created: 2026-04-30
+updated: 2026-04-30
+
+---# General Guide For Exploring Large Open Source Codebases
+
+A guide created in Fall 2020 for MLH Fellows on how to explore and contribute to large open-source codebases. The guide covers the full lifecycle: choosing a project, getting started, discovering issues, planning, coding, and claiming issues.
+
+## Key Sections
+
+### Getting Started
+- **Use it**: Build something with the project to understand its breadth
+- **Earliest commits**: Initial commits contain the core architecture and goals
+- **Test cases**: Tests are the best documentation — shows how authors expect things to work
+- **Tools**: UML diagrams, pyreverse for class diagrams, call graphs for runtime visualization
+- **Git log trick**: `git log --pretty=format: --name-only | sort | uniq -c | sort -rg | head -10` to find most-edited files (80/20 rule)
+- **Searching**: grep, ctags integrated with vim, GitHub's `/` search
+
+### Planning
+- Use the issue description fully — maintainers often identify affected areas
+- Don't try to understand the whole codebase — scope down to the relevant subsystem
+- **Paper Cut Principle**: many small fixes across the codebase builds mastery
+- Figure out how your part fits in; treat everything else as a black box
+- Reproduce the issue before planning
+- Structured theorizing: brainstorm causes, verify each
+
+### Coding
+- Feedback from mentors/maintainers — rubber duck debugging works
+- Debugging: step through with gdb/pdb, use data breakpoints
+- Logging and profilers for non-linear, multithreaded, or destructive programs
+- "Hack it, then get it right" — proof of concept first, robust later

package/vault/wiki/sources/pi-compaction-extensions-ecosystem.md

@@ -0,0 +1,102 @@
+---
+type: source
+source_type: ecosystem-analysis
+title: "Pi Compaction Extensions Ecosystem (2026)"
+author: "Multiple authors"
+date_published: 2026-04-25
+date_accessed: 2026-05-05
+url: "https://www.npmjs.com/search?q=pi%20compaction"
+confidence: medium
+tags:
+  - pi-agent
+  - compaction
+  - extensions
+  - ecosystem
+key_claims:
+  - "At least 7 compaction-related extensions exist for Pi as of May 2026"
+  - "pi-vcc: deterministic algorithmic compaction + recall (only zero-LLM option)"
+  - "pi-model-aware-compaction: per-model context threshold triggers"
+  - "pi-custom-compaction: swap compaction model/template, fallback chains"
+  - "pi-agentic-compaction: virtual filesystem + sandboxed bash/jq approach"
+  - "pi-omni-compact: large-context model (1M+) subprocess for high-fidelity summaries"
+  - "pi-context-prune: tool-call batch summarization with original preservation"
+  - "pi-rtk-optimizer: upstream token reduction via command rewriting + output compaction"
+  - "Pi ecosystem has 2,808+ indexed resources and 1,183+ extensions (April 2026)"
+---
+
+# Pi Compaction Extensions Ecosystem
+
+## Summary
+
+As of May 2026, Pi's compaction layer has spawned at least 7 community extensions addressing different failure modes and layers of token management. The Pi ecosystem overall has 2,808+ indexed resources and 1,183+ extensions, with compaction as a critical pain point.
+
+## Extensions
+
+### 1. pi-vcc (sting8k) — Deterministic Algorithmic
+- **Approach**: No-LLM extraction into 5 semantic sections
+- **Differentiator**: Determinism + recall over JSONL lineage
+- **Stars**: 75 | **npm**: @sting8k/pi-vcc | **Version**: v0.3.12
+- **Install**: `pi install npm:@sting8k/pi-vcc`
+
+### 2. pi-model-aware-compaction — Per-Model Thresholds
+- **Approach**: Configurable per-model context-usage thresholds
+- **Differentiator**: Different models get different compaction triggers (wildcard support)
+- **Version**: v0.1.4 (April 2026)
+- **Use case**: Teams using multiple models with different context windows
+
+### 3. pi-custom-compaction (nicobailon) — Model/Template Swap
+- **Approach**: Swap the model and prompt template Pi uses for compaction
+- **Differentiator**: Fallback model chains, configurable raw context retention (tokens or %)
+- **Version**: v0.2.5 (April 2026)
+- **Use case**: Teams wanting to use cheaper/faster models for compaction while keeping LLM approach
+
+### 4. pi-agentic-compaction (laulauland/salemsayed) — Virtual Filesystem
+- **Approach**: Mounts conversation as `/conversation.json`, uses sandboxed bash/jq for extraction
+- **Differentiator**: More efficient for 50K+ token conversations (queries only relevant portions)
+- **Version**: Feb 2026
+- **Use case**: Long conversations where full-context summarization is too expensive
+
+### 5. pi-omni-compact (Whamp) — Large-Context Model
+- **Approach**: Spawns separate Pi subprocess with 1M+ token model to read entire conversation at once
+- **Differentiator**: Highest fidelity summaries — maximizes LLM compute for quality
+- **Version**: v0.1.2
+- **Use case**: When summary quality matters more than cost/speed
+- (Source: [[pi-omni-compact-github-repo]])
+
+### 6. pi-context-prune (championswimmer) — Tool-Call Batch Summarization
+- **Approach**: Summarizes tool-call batches, prunes verbose outputs, preserves originals in session index
+- **Differentiator**: 5 trigger modes + prefix caching integration + on-demand recovery
+- **Use case**: Mid-session tool-call bloat reduction
+- (Source: [[pi-context-prune-github-repo]])
+
+### 7. pi-rtk-optimizer (MasuRii) — Upstream Token Reduction
+- **Approach**: Rewrites bash commands to RTK equivalents + multi-stage output compaction pipeline
+- **Differentiator**: Operates UPSTREAM of conversation — prevents tokens from entering context
+- **Version**: v0.5.3 (April 2026)
+- **Use case**: Reducing tool output tokens before they accumulate
+- (Source: [[pi-rtk-optimizer-github-repo]])
+
+## Competitive Landscape
+
+| Extension | LLM Calls | Deterministic | Recall | Layer | Custom Model |
+|-----------|-----------|---------------|--------|-------|-------------|
+| pi-vcc | No | Yes | Yes | Conversation boundary | N/A |
+| model-aware | Yes (default) | No | No | Conversation boundary | No |
+| custom-compaction | Yes (custom) | No | No | Conversation boundary | Yes |
+| agentic-compaction | Yes (sandboxed) | No | No | Conversation boundary | Configurable |
+| omni-compact | Yes (large-ctx) | No | No | Conversation boundary | Yes (1M+ required) |
+| context-prune | Yes | No | Yes (originals) | Tool-call batches | Default model |
+| rtk-optimizer | No | Yes | N/A | Tool output | N/A |
+
+## Three Layers of Token Management
+
+The ecosystem reveals a layered architecture for token management:
+1. **Prevention** (rtk-optimizer): Reduce tokens at tool execution, before they enter conversation
+2. **Mid-session pruning** (context-prune): Summarize tool-call batches during conversation
+3. **Boundary compaction** (vcc, model-aware, custom, agentic, omni): Compress full conversation at threshold
+
+pi-vcc remains the only fully deterministic conversation compaction option. pi-rtk-optimizer is also deterministic but operates at a different layer (tool output).
+
+## Why This Matters
+
+The ecosystem has grown from 4 to 7 extensions in under a month. This validates compaction as the #1 pain point in the Pi ecosystem. The three-layer architecture that has emerged (prevention → pruning → compression) mirrors our harness's approach to context engineering.

package/vault/wiki/sources/pi-context-prune-github-repo.md

@@ -0,0 +1,38 @@
+---
+type: source
+source_type: github-repo
+title: "pi-context-prune — Tool-Call Batch Summarization"
+author: championswimmer
+date_published: 2026-03-01
+date_accessed: 2026-05-05
+url: "https://github.com/championswimmer/pi-context-prune"
+confidence: medium
+tags:
+  - pi-agent
+  - compaction
+  - extensions
+  - context-pruning
+key_claims:
+  - "Summarizes tool-call batches and prunes verbose outputs"
+  - "Preserves originals in session index for on-demand recovery"
+  - "Five trigger modes for flexible compaction timing"
+  - "Integrates with prefix caching for improved token efficiency"
+---
+
+# pi-context-prune
+
+## Summary
+
+pi-context-prune addresses context bloat by summarizing tool-call batches and pruning verbose outputs while preserving originals in the session index for on-demand recovery. Supports 5 trigger modes and integrates with prefix caching.
+
+## Approach
+
+Operates between pi-vcc (full conversation compaction) and pi-rtk-optimizer (tool output compaction). Targets specifically tool-call batches — groups of related tool calls that can be summarized together — rather than the entire conversation or individual tool outputs.
+
+## Key Differentiator
+
+Preserves originals for recovery, similar to pi-vcc's recall capability. However, uses LLM summarization for the compression step itself. Prefix caching integration is unique among Pi compaction extensions.
+
+## Relevance to pi-vcc
+
+Complementary. pi-context-prune operates on tool-call batches mid-session. pi-vcc operates on full conversation at compaction triggers. Different granularity, different timing.

package/vault/wiki/sources/pi-mono-compaction-docs.md

@@ -0,0 +1,38 @@
+---
+type: source
+source_type: official-docs
+title: "pi-mono compaction docs"
+author: "badlogic/pi-mono maintainers"
+date_published: 2026-05-05
+date_accessed: 2026-05-05
+url: "https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/docs/compaction.md"
+confidence: high
+tags:
+  - pi-agent
+  - compaction
+  - context-window
+  - docs
+key_claims:
+  - "Pi core has built-in /compact and auto-compaction with token thresholds"
+  - "Auto-compaction preserves recent tokens and summarizes older context"
+  - "Compaction settings include enabled, reserveTokens, keepRecentTokens"
+  - "pi-vcc can be evaluated as deterministic alternative/override to default flow"
+---
+
+# pi-mono Compaction Documentation
+
+## Summary
+
+Pi core already provides native conversation compaction. This matters for `pi-vcc` because it clarifies baseline behavior and where `pi-vcc` adds value: deterministic non-LLM compaction and recall across lineage.
+
+## Key Details
+
+- Core command: `/compact`
+- Auto mode: `/autocompact`
+- Trigger model: compaction activates near context limit based on configured token reserve
+- Config knobs: `enabled`, `reserveTokens`, `keepRecentTokens`
+- Scope: compaction and reload behavior in core Pi coding agent
+
+## Why This Matters for Topic
+
+`pi-vcc` is not mandatory to get compaction in Pi. It is a specialized replacement/augmentation path focused on determinism, speed, and recall ergonomics.

package/vault/wiki/sources/pi-omni-compact-github-repo.md

@@ -0,0 +1,50 @@
+---
+type: source
+source_type: github-repo
+title: "pi-omni-compact — Large-Context Model Compaction"
+author: Whamp
+date_published: 2026-02-01
+date_accessed: 2026-05-05
+url: "https://github.com/Whamp/pi-omni-compact"
+confidence: medium
+tags:
+  - pi-agent
+  - compaction
+  - extensions
+  - large-context
+key_claims:
+  - "Replaces default compaction with a large-context model subprocess"
+  - "Spawns separate Pi instance using 1M+ token model to read entire conversation"
+  - "Hooks session_before_compact and session_before_tree events"
+  - "Produces higher-fidelity summaries than default incremental summarization"
+  - "v0.1.2, MIT license, 0 dependencies"
+---
+
+# pi-omni-compact
+
+## Summary
+
+pi-omni-compact replaces Pi's default compaction by spawning a separate Pi subprocess using a large-context model (1M+ tokens). Instead of incremental summarization, the entire conversation is read at once, producing higher-fidelity summaries.
+
+## How It Works
+
+Hooks two Pi events:
+- `session_before_compact` — when context window fills
+- `session_before_tree` — when user abandons a conversation branch
+
+For both: analyzes session metadata, serializes conversation, resolves configured model with valid API key, spawns read-only Pi subprocess (with `read`, `grep`, `find`, `ls` tools only).
+
+## Configuration
+
+In `settings.json`:
+- `models`: Ordered list of models to try (first with valid API key wins)
+- `debugCompactions`: Save input/output JSON for diagnosis
+- `minSummaryChars`: Minimum summary length (default 100)
+
+## Key Differentiator
+
+Takes the opposite approach from pi-vcc: uses MORE compute (large-context model) for HIGHER fidelity, vs pi-vcc's zero-compute deterministic extraction. This is LLM-maximalist compaction vs pi-vcc's LLM-free approach.
+
+## Relevance
+
+Represents the strongest competing philosophy to deterministic compaction. If large-context models become cheap enough, this approach may produce better results. However, it has pi-vcc's three failure modes: non-reproducibility, hallucination risk, and API cost.

package/vault/wiki/sources/pi-rtk-optimizer-github-repo.md

@@ -0,0 +1,45 @@
+---
+type: source
+source_type: github-repo
+title: "pi-rtk-optimizer — Token Reduction via Command Rewriting"
+author: MasuRii
+date_published: 2026-03-01
+date_accessed: 2026-05-05
+url: "https://github.com/MasuRii/pi-rtk-optimizer"
+confidence: medium
+tags:
+  - pi-agent
+  - compaction
+  - token-optimization
+  - extensions
+key_claims:
+  - "Automatically rewrites bash commands to RTK equivalents for token reduction"
+  - "Multi-stage output compaction pipeline: ANSI strip, test aggregation, build filtering, git compaction, linter aggregation, smart truncation"
+  - "Operates on tool OUTPUT, not conversation history — different layer than pi-vcc"
+  - "v0.5.3 (April 2026), MIT license"
+  - "Supports command rewrite bypass rules for safety-critical operations"
+---
+
+# pi-rtk-optimizer
+
+## Summary
+
+pi-rtk-optimizer is a Pi extension that reduces token consumption by automatically rewriting bash commands to their RTK (Read-Tool-Kit) equivalents and compacting noisy tool output. Unlike pi-vcc (which compresses conversation history), pi-rtk-optimizer operates upstream — reducing tokens at the tool execution layer before they enter the conversation.
+
+## Architecture
+
+Two mechanisms:
+
+1. **Command Rewriting**: Intercepts bash tool calls and suggests/applies rewrites across git, filesystem, Rust, JavaScript, Python, Go, containers, and package managers. Includes bypass rules for safety-critical operations.
+
+2. **Output Compaction Pipeline**: Multi-stage processing of tool results — ANSI stripping, test aggregation, build filtering, git compaction, linter aggregation, search grouping, source code filtering, smart truncation, and hard character limits.
+
+## Key Stats
+
+- **Version**: v0.5.3 (April 2026)
+- **Install**: `pi install npm:pi-rtk-optimizer`
+- **TUI config**: `/rtk` command for interactive settings and session metrics
+
+## Relevance to pi-vcc
+
+pi-rtk-optimizer and pi-vcc are complementary, not competing. rtk-optimizer prevents token waste at the tool layer. pi-vcc compresses accumulated conversation history. Together they address both prevention and compression.

package/vault/wiki/sources/pi-vcc-github-repo.md

@@ -0,0 +1,69 @@
+---
+type: source
+source_type: github-repo
+title: "sting8k/pi-vcc"
+author: "Do Anh (sting8k)"
+date_published: 2026-04-24
+date_accessed: 2026-05-05
+url: "https://github.com/sting8k/pi-vcc"
+confidence: high
+tags:
+  - pi-agent
+  - vcc
+  - compaction
+  - memory
+  - extension
+key_claims:
+  - "pi-vcc is algorithmic conversation compactor for Pi, inspired by VCC"
+  - "No LLM calls for compaction; deterministic output"
+  - "35-99% token reduction on real sessions (99.8% peak on 2.2M char session)"
+  - "vcc_recall supports searchable lineage history after compaction"
+  - "Config option overrideDefaultCompaction routes /compact and auto-compaction through pi-vcc"
+  - "Latest release v0.3.12 (2026-04-25), 75 stars, 606 weekly / 3,299 monthly installs on pi.dev package index"
+  - "Tested on 794+ real HuggingFace sessions"
+  - "v0.3.8 added long-turn collapsing (keeps 8 most recent tool calls)"
+  - "At least 2 community forks exist (ceblan/pi-vcc, mvdirty/pi-vcc)"
+  - "Only fully deterministic compaction extension in Pi ecosystem"
+---
+
+# pi-vcc Repository
+
+## Summary
+
+pi-vcc is a Pi package/extension for deterministic conversation compaction and recall. It replaces or complements default compaction with algorithmic extraction into 5 semantic sections, then adds recall tooling over session JSONL history. It is the only fully deterministic compaction option in the Pi extension ecosystem.
+
+## Key Details
+
+- **Repo**: `sting8k/pi-vcc` (75 stars, 6 forks + 2 community forks)
+- **Latest release**: v0.3.12 (2026-04-25)
+- **npm**: @sting8k/pi-vcc (3,299 monthly / 606 weekly installs shown on pi.dev package index)
+- **Install**: `pi install npm:@sting8k/pi-vcc`
+- **Hook**: `session_before_compact`
+- **Config**: `~/.pi/agent/pi-vcc-config.json` (auto-created on first run)
+- **Override**: `overrideDefaultCompaction: true` to replace default `/compact` path
+
+## Performance Benchmarks
+
+- Session A: 997,162 → 7,959 chars (99.2% reduction, 64ms)
+- Session D: 2,258,477 → 4,439 chars (99.8% reduction, 30ms)
+- Tested on 794+ real HuggingFace sessions
+- Compaction latency: 30-470ms, zero API calls
+
+## v0.3.8 Key Changes (April 19, 2026)
+
+- `/compact` and auto-compact now run Pi core by default; `overrideDefaultCompaction: true` opts into pi-vcc
+- Long turns collapse older tool calls into `* (N earlier entries omitted)`, keeping 8 most recent — designed for explore/discover loops
+- `[Commits]` section no longer dropped after first compaction
+- Recall note no longer stacks on every compaction
+
+## 5 Semantic Sections
+
+1. Session goal
+2. Files and changes
+3. Commits
+4. Outstanding context
+5. User preferences
+
+## Competitive Position
+
+pi-vcc is the only fully deterministic (no-LLM) compaction extension in Pi's ecosystem. Three other extensions exist (pi-model-aware-compaction, pi-custom-compaction, pi-agentic-compaction) but all use LLM calls. See [[pi-compaction-extensions-ecosystem]].

package/vault/wiki/sources/pi-vscode-marketplace.md

@@ -0,0 +1,41 @@
+---
+type: source
+source_type: marketplace-listing
+title: "Pi Coding Agent - Visual Studio Marketplace"
+author: "pi0"
+date_published: 2026-02-26
+date_accessed: 2026-05-05
+url: "https://marketplace.visualstudio.com/items?itemName=pi0.pi-vscode"
+confidence: high
+tags:
+  - pi-agent
+  - vscode
+  - extension
+  - bridge
+  - chat
+key_claims:
+  - "pi0.pi-vscode is the official VS Code extension for Pi Coding Agent"
+  - "1,348 installs, version 0.0.9, last updated 2026-04-24"
+  - "Supports terminal-first workflow plus @pi chat participant in VS Code Chat"
+  - "Ships a VS Code bridge exposing inspection/action tools like vscode_get_editor_state"
+  - "Distributed on both VS Code Marketplace and Open VSX"
+---
+
+# Pi Coding Agent VS Code Extension (pi0.pi-vscode)
+
+## Summary
+
+This listing documents the official Pi extension for VS Code. It keeps Pi terminal-native while adding direct IDE bridge tools and a chat entry point (`@pi`) inside VS Code Chat. The bridge exposes diagnostics, symbols, references, code actions, file opens, edits, and formatting through VS Code APIs instead of shell-only workflows.
+
+## Key Details
+
+- Install count: 1,348
+- Version: 0.0.9
+- Released: 2026-02-26
+- Last updated: 2026-04-24
+- Publisher: pi0
+- Install targets: VS Code and Open VSX
+
+## Why This Matters for Topic
+
+For "vcc extension for pi coding agent", this source establishes the main official VS Code integration path. It is not called VCC, but it is likely what users mean when asking for a Pi coding agent extension in VS Code context.

package/vault/wiki/sources/pi-vscode-model-provider-marketplace.md

@@ -0,0 +1,39 @@
+---
+type: source
+source_type: marketplace-listing
+title: "Pi Coding Agent - Language Model Provider"
+author: "tintinweb"
+date_published: 2026-02-12
+date_accessed: 2026-05-05
+url: "https://marketplace.visualstudio.com/items?itemName=tintinweb.vscode-pi-model-chat-provider"
+confidence: high
+tags:
+  - pi-agent
+  - vscode
+  - copilot-chat
+  - language-model-provider
+  - extension
+key_claims:
+  - "Extension exposes Pi models to VS Code's Language Model API (vscode.lm.*)"
+  - "350 installs as of 2026-05-05 scrape"
+  - "Lets users pick Pi models directly in GitHub Copilot Chat model picker"
+  - "Pi runs as separate process with RPC communication and internal tool execution"
+---
+
+# Pi Language Model Provider Extension (tintinweb)
+
+## Summary
+
+This extension integrates Pi with VS Code's Language Model Provider API (`vscode.lm.*`). Instead of opening a dedicated Pi terminal UI, it makes Pi models appear in the model picker so Copilot Chat and other LM-enabled extensions can call Pi-backed models.
+
+## Key Details
+
+- Install count: 350
+- Marketplace status: Preview
+- Published: 2026-02-12
+- Publisher: tintinweb
+- Main integration target: GitHub Copilot Chat + any `vscode.lm.*` consumer
+
+## Why This Matters for Topic
+
+This is one concrete interpretation of "extension for pi coding agent" in VS Code: Pi as a model provider, not just a terminal companion. It expands where Pi can be used inside VS Code extension ecosystem.

package/vault/wiki/sources/py-tree-sitter.md

@@ -0,0 +1,13 @@
+---
+type: source
+status: stub
+created: 2026-05-02
+updated: 2026-05-02
+tags: [source, external-doc]
+---
+
+# Py Tree-Sitter
+
+Python bindings for Tree-sitter. Enables AST parsing for dynamic languages in Python-based tooling.
+
+Referenced in: [[resolved-treesitter-dynamic-languages]]