memex: update passepartout submodule → v0.7.2, add notes

passepartout v0.7.2 (Gate Trace + HITL + Search + 11 more features): - Gate trace visualization with Ctrl+G toggle - HITL inline panels with styled collapse on approve/deny - Agent identity file + /identity command - Safe-tool read-only allowlist - Message search mode with Up/Down nav and highlights - Context budget visibility with section breakdown - Session rewind /sessions /resume /rewind - Undo/redo per operation - Context debugging /context why /context dropped - Tool hardening (timeouts, write verify, read-only cache) - Tag stack severity tiers + trigger counts - Merkle provenance audit + audit-verify - Self-help /help <topic> reads USER_MANUAL.org - Live CONFIG section in system prompts - Pads: Page Up/Down scroll by 10 lines Core 92/92 TUI Main 104/104 TUI View 29/29 Neuro 13/13
2026-05-08 21:56:11 -04:00
parent 8c64b18335
commit 4e9431ec1d
254 changed files with 55970 additions and 3 deletions
--- a/COMPETITIVE_ANALYSIS.org
+++ b/COMPETITIVE_ANALYSIS.org
@@ -0,0 +1,829 @@
+#+TITLE: Competitive Analysis — AI Coding Agents & Personal AI Agent Systems
+#+DATE: 2026-05-08
+#+CONTEXT: Research for Passepartout — Common Lisp AI coding agent with TUI/CLI, REPL-driven, neurosymbolic TDD workflow
+
+* Overview
+
+This document surveys 30+ AI coding agents and personal AI agent systems across
+the dimensions most relevant to Passepartout: safety architecture, memory
+persistence, TUI/CLI interface, extensibility model, neurosymbolic or
+deterministic-rule components.
+
+* 1. Aider (Paul Gauthier)
+
+** What it does
+Git-aware AI pair programming in the terminal. Reads/writes files in your repo,
+auto-commits changes. Designed for interactive chat-based coding.
+
+** Architecture
+- Model: pluggable (OpenAI, Anthropic, Gemini, local via Ollama/LM Studio)
+- Tools: file read/write, git, lint/test execution, repo map (tree-sitter AST analysis)
+- Memory: git history + chat history file (.aider.chat.history.md). No persistent memory across sessions beyond git.
+- Safety: git-backed undo per edit; user must approve file additions; linting/tests auto-run
+
+** Differentiators
+- Repo map: compresses entire codebase into ~1024 tokens of structured context
+- Edit formats: whole-file, search/replace diff, universal diff — fallback chain
+- Open source (Apache 2.0), Python, highly scriptable
+- Benchmark leaderboard (SWE-bench, own editing/refactoring benchmarks)
+
+** Maturity
+Production. 30k+ GitHub stars. Active development.
+
+** Relevance to Passepartout: HIGH
+--- Directly comparable: CLI-native, git-integrated, extensible via Python scripting
+--- PP's .org-as-source-of-truth + tangle workflow is architecturally distinct
+--- Aider has no neurosymbolic components or deterministic rule engine
+--- Aider lacks memory persistence beyond git; PP's org-mode + contract-first TDD is richer
+
+* 2. Cursor Agent Mode
+
+** What it does
+IDE-integrated coding agent inside Cursor (VS Code fork). Agent mode can plan,
+read/write files, run terminal commands, and iterate autonomously.
+
+** Architecture
+- Model: Claude, GPT-4o, etc. (cursor-small model for tab completion)
+- Tools: file editing, terminal, @-symbols for context, MCP support, image input
+- Memory: session-only; no persistent memory across sessions
+- Safety: diff view for changes, user approval on terminal commands (configurable), lint monitoring
+
+** Differentiators
+- .cursorrules for project-specific instructions
+- Visual diff before applying changes
+- Tab completion + agent mode + chat in one IDE
+- MCP server integration for custom tools
+
+** Maturity
+Production. Widely used.
+
+** Relevance to Passepartout: MEDIUM
+--- IDE-dependent (not TUI-first). PP's Emacs/terminal-native approach is different
+--- Rule system (.cursorrules) is closest thing to deterministic rules — but plain-text prompts only
+--- No neurosymbolic, no persistent memory, no contract-first workflow
+
+* 3. GitHub Copilot Agent Mode
+
+** What it does
+Microsoft/GitHub's coding agent across VS Code, GitHub.com, CLI. Agent mode
+(2025) can autonomously plan, edit, run commands.
+
+** Architecture
+- Model: multi-model (OpenAI, Claude, Gemini, Haiku via Copilot)
+- Tools: IDE edit, terminal, MCP, code review, code search, GitHub issues
+- Memory: per-session; Enterprise can index org codebase for retrieval
+- Safety: IP indemnity, code referencing filter, admin-managed MCP allowlists,
+  audit logs for enterprise, opt-out for training data
+
+** Differentiators
+- Deep GitHub integration (PR review, issues, Actions)
+- Multi-model access from one subscription
+- Enterprise governance (SSO, audit, VPC)
+- Copilot CLI for terminal-only use
+
+** Maturity
+Production. Largest userbase (millions).
+
+** Relevance to Passepartout: LOW
+--- Massive platform lock-in. No extensibility for custom workflows
+--- No neurosymbolic. No persistent memory across sessions
+--- Enterprise features irrelevant to PP's use case
+--- The CLI component is closest competitor but lacks PP's TDD/contract cycle
+
+* 4. Amazon Q Developer
+
+** What it does
+AWS's coding assistant across IDE, CLI, and AWS console. Code completion, chat,
+security scanning, code transformation.
+
+** Architecture
+- Model: Amazon Bedrock (multiple FMs), augmented with AWS content
+- Tools: IDE extension, CLI, AWS console chat, automated code review,
+  vulnerability scanning, code transformation (e.g., Java upgrades)
+- Memory: session; no persistent cross-session memory
+- Safety: AWS IAM permissions, Bedrock abuse detection, zero data retention for
+  Business tier; no training on Enterprise data
+
+** Differentiators
+- Deep AWS knowledge (VPC, EC2, Lambda, etc.)
+- Automated code transformation (e.g., Java 8→17)
+- Security vulnerability scanning built in
+- Free tier generous
+
+** Maturity
+Production.
+
+** Relevance to Passepartout: LOW
+--- AWS-ecosystem focused. No CLI/TUI philosophy. No extensibility.
+--- Not a general-purpose agent; AWS-specific
+
+* 5. Devin (Cognition AI)
+
+** What it does
+Autonomous AI software engineer in a sandboxed environment. Plans, codes, tests,
+deploys end-to-end. Acquired Windsurf (Codeium).
+
+** Architecture
+- Model: Claude Sonnet 4.5 (publicly), proprietary model claimed
+- Tools: shell, code editor, browser, sandboxed compute environment
+- Memory: per-session long-term reasoning; can recall context across steps
+  within a task. Reports progress in real-time
+- Safety: sandboxed environment, user approval on deployment, SSH key support
+
+** Differentiators
+- Full autonomy (not pair programming) — can be assigned via Slack, Jira
+- SWE-bench leader: 13.86% (initial), now higher
+- Can learn unfamiliar technologies, train models, do Upwork tasks
+- Windsurf acquisition: now owns IDE + cloud agent stack
+
+** Maturity
+Production (GA Dec 2024). Backed by $21M+ from Founders Fund.
+
+** Relevance to Passepartout: MEDIUM
+--- Autonomous agent philosophy differs from PP's interactive TDD partner
+--- WindSurf integration creates IDE dependency; PP is terminal-native
+--- No neurosymbolic. No contract-first. No persistent memory (per-task only)
+
+* 6. Factory AI / Factory Droid
+
+** What it does
+Automated code review and bug-fixing. Runs as GitHub app on every PR.
+Droid bot auto-fixes issues found in review.
+
+** Architecture
+- Model: Claude/GPT (likely)
+- Tools: GitHub PR integration, code review, auto-fix generation
+- Memory: PR-level context; no cross-PR memory
+- Safety: review-before-apply; GitHub permissions
+
+** Differentiators
+- PR-review focused (not general coding agent)
+- Auto-fix generation as part of review workflow
+- Enterprise-focused (code review automation)
+
+** Maturity
+Beta/production.
+
+** Relevance to Passepartout: LOW
+--- Narrow scope (PR review). Not a general agent.
+--- No TUI, no memory, no extensibility.
+
+* 7. Cline (formerly Claude Dev)
+
+** What it does
+Autonomous coding agent VSCode extension. Can create/edit files, run terminal
+commands, use browser, execute MCP tools. Human-in-the-loop for all actions.
+
+** Architecture
+- Model: any (OpenRouter, Anthropic, OpenAI, Google, AWS Bedrock, local models)
+- Tools: file R/W, terminal, browser (computer use), MCP servers, linter/compiler
+  monitoring, checkpoint/restore
+- Memory: session context; checkpoints as workspace snapshots; no persistent
+  cross-session memory
+- Safety: human-in-the-loop for every file change and terminal command (GUI
+  approval); diff view; checkpoints for rollback; permission gates
+
+** Differentiators
+- "Add a tool" — can ask Cline to create new MCP servers on the fly
+- @url, @problems, @file, @folder context markers
+- Browser computer use for interactive debugging
+- Checkpoint system: compare/restore workspace snapshots
+- Open source (Apache 2.0), 61k+ stars
+- Enterprise: SSO, on-prem, audit trails
+
+** Maturity
+Production. 61.5k GitHub stars. Rapid development.
+
+** Relevance to Passepartout: HIGH
+--- Closest architecture: extensible via MCP, CLI+editor integration, human-in-loop
+--- MCP-based tool creation PP could adopt
+--- No neurosymbolic rules engine; contracts are plain .clinerules text
+--- Checkpoint workflow similar to PP's git-based snapshots but less structured
+--- PP's .org source-of-truth + tangle is unique
+
+* 8. RooCode
+
+** What it does
+VSCode extension for multi-agent coding. Variant/fork of Cline with multiple
+agent "modes" (architect, ask, code, custom).
+
+** Architecture
+- Model: any (same provider list as Cline)
+- Tools: file editing, terminal, browser, MCP, image support
+- Memory: per-session context
+- Safety: human approval gates, diff view
+
+** Differentiators
+- Multi-agent modes (architect plans, coder implements, ask answers)
+- Custom modes with custom prompts
+- Forked from Cline, similar architecture
+
+** Maturity
+Production.
+
+** Relevance to Passepartout: MEDIUM
+--- Multi-agent orchestration is interesting but VSCode-dependent
+--- No neurosymbolic. No persistent memory. No contract-first.
+
+* 9. AutoGPT
+
+** What it does
+Platform for building, deploying, and running continuous AI agents.
+Classic version was autonomous GPT-4 agent; now a platform with agent builder,
+marketplace, workflow management.
+
+** Architecture
+- Model: any LLM (pluggable)
+- Tools: web search, file operations, code execution, block-based workflow builder
+- Memory: long-term memory via vector DB (Redis/Pinecone), persistent agent state
+- Safety: Docker sandboxing, user approval gates
+
+** Differentiators
+- Agent builder with visual block-based workflow
+- Marketplace for pre-built agents
+- Continuous/long-running agents (not session-only)
+- Classic AutoGPT pioneered autonomous agent loop (think → act → observe)
+
+** Maturity
+Production. 184k stars. Classic in maintenance; platform in beta/active.
+
+** Relevance to Passepartout: MEDIUM
+--- Long-running, persistent agents concept is relevant
+--- Block-based workflow builder is anti-neurosymbolic (no rules engine)
+--- Python-centric; PP is Common Lisp
+--- No contract-first TDD workflow
+
+* 10. Microsoft AutoGen
+
+** What it does
+Multi-agent conversation framework from Microsoft. Agents can converse,
+collaborate, execute code, use tools. .NET and Python.
+
+** Architecture
+- Model: any (OpenAI, etc.)
+- Tools: MCP, Docker code execution, OpenAPI, web search, distributed runtimes
+- Memory: conversation history; no built-in long-term memory; use extensions
+- Safety: Docker sandbox for code execution; human-in-loop patterns
+
+** Differentiators
+- Event-driven, distributed multi-agent architecture (gRPC runtime)
+- AgentChat for conversational, Core for event-driven, Studio for GUI
+- MCP tool support built-in
+- .NET and Python support
+- Research-grade multi-agent patterns
+
+** Maturity
+Stable/Production. Backed by Microsoft.
+
+** Relevance to Passepartout: MEDIUM
+--- Multi-agent orchestration architecture is relevant
+--- No TUI/CLI focus; Python/.NET
+--- No neurosymbolic; no deterministic rules
+--- PP could learn from AutoGen's event-driven agent patterns
+
+* 11. CrewAI
+
+** What it does
+Open-source framework for orchestrating autonomous AI agents as "crews" with
+role-based collaboration. Flows for workflow control.
+
+** Architecture
+- Model: any LLM (pluggable)
+- Tools: API, database, custom tools; agent roles with specific goals
+- Memory: conversation-based; no built-in persistent memory across crews
+- Safety: enterprise security claims; human-in-loop patterns
+
+** Differentiators
+- Role-playing agents (researcher, writer, etc.)
+- Flows (stateful, event-driven) + Crews (autonomous teams)
+- 100k+ certified developers
+- Enterprise-ready
+
+** Maturity
+Production.
+
+** Relevance to Passepartout: LOW
+--- Python framework, not a standalone agent
+--- No TUI/CLI; not a coding agent
+--- Role-based agent pattern is interesting but not directly applicable
+
+* 12. Replit Agent (Ghostwriter)
+
+** What it does
+In-browser coding agent on Replit platform. Build, deploy apps from prompts.
+Full IDE in browser with AI agent.
+
+** Architecture
+- Model: proprietary (likely fine-tuned LLM)
+- Tools: in-browser IDE, file system, terminal, deployment, database
+- Memory: project context within session
+- Safety: sandboxed in-browser environment; Replit platform moderation
+
+** Differentiators
+- Zero setup: browser-based, no install
+- Full-stack: code + DB + deploy from one prompt
+- Educational focus (used in classrooms)
+- Collaborative editing
+
+** Maturity
+Production.
+
+** Relevance to Passepartout: LOW
+--- Cloud-only, browser-based. Anti-TUI.
+--- No extensibility. No memory persistence.
+--- Educational/consumer focus, not power-user agent
+
+* 13. Codex CLI (OpenAI)
+
+** What it does
+Lightweight CLI coding agent from OpenAI. Runs locally, writes files, runs
+commands. Desktop app variant available.
+
+** Architecture
+- Model: OpenAI models (GPT-5, o-series)
+- Tools: file read/write, shell execution, sandboxed environment
+- Memory: session context; conversation history per session
+- Safety: user approval on file writes and commands; runs locally; sandboxed
+  execution
+
+** Differentiators
+- CLI-native (npm install -g @openai/codex)
+- Desktop app (codex app) for richer UI
+- Multi-platform (macOS, Linux, Windows)
+- Open source (Apache 2.0), 81k stars, 6k+ commits
+- "Sign in with ChatGPT" or API key
+- Environment management for secrets
+
+** Maturity
+Production. 81k GitHub stars. Very active.
+
+** Relevance to Passepartout: HIGH
+--- Direct competitor: CLI-native coding agent
+--- Same philosophy: terminal-first, local execution
+--- PP differentiators: .org source-of-truth, tangle workflow, neurosymbolic
+    TDD, contract-first, deterministic rules engine
+--- Codex has NO neurosymbolic component, NO contracts, NO persistent memory
+    beyond git, NO rule engine
+
+* 14. Continue.dev
+
+** What it does
+Open-source AI code assistant for IDE. Chat, edit, tab-completion. Now pivoted
+to Continuous AI — AI checks on PRs (source-controlled checks).
+
+** Architecture
+- Model: any (OpenAI, Anthropic, Ollama, etc.)
+- Tools: IDE chat, file editing, @-references, PR checks
+- Memory: session-based
+- Safety: local models possible, diff-based editing
+
+** Differentiators
+- Fully open-source IDE assistant
+- "Checks" — source-controlled AI reviews as markdown files in repo
+- Multiple model providers
+- VS Code + JetBrains
+
+** Maturity
+Production. Renamed to Continuous AI for PR-check product.
+
+** Relevance to Passepartout: LOW
+--- IDE-dependent. PR-check focus is different from PP's build-time agent
+--- "Checks as markdown" concept is closest to PP's .org-based contracts —
+    but far less structured. PP's contracts are machine-verifiable, not just
+    prompts
+
+* 15. PearAI
+
+** What it does
+AI code editor (VS Code fork) with integrated coding agent + chat.
+Open-source, Bun-based performance.
+
+** Architecture
+- Model: any (OpenAI, Anthropic, Ollama)
+- Tools: IDE agent, chat, file editing, context management
+- Memory: session-based
+- Safety: open source, local model support
+
+** Differentiators
+- VS Code fork (not extension)
+- Bun for performance
+- Free, open source
+- "Context" management for prompt optimization
+
+** Maturity
+Beta/Production.
+
+** Relevance to Passepartout: LOW
+--- IDE-dependent fork. PP's Emacs + TUI is philosophically opposite.
+--- No unique architecture features.
+
+* 16. Melty (now Conductor)
+
+** What it does
+Originally Melty, now Conductor — orchestrator for running multiple coding
+agents (Claude Code, Codex) in parallel on your Mac. Each agent gets an
+isolated git worktree.
+
+** Architecture
+- Model: uses Codex + Claude Code under the hood
+- Tools: git worktree management, parallel agent execution, review UI
+- Memory: per-task git worktree; no cross-session memory
+- Safety: git isolation; user reviews changes before merging
+  Differentiators
+- Multi-agent parallelism (not multi-agent collaboration)
+- Git worktree-based isolation
+- Dashboard for monitoring agents
+
+** Maturity
+Production (Beta/2025). Used at Linear, Vercel, Notion, Ramp.
+
+** Relevance to Passepartout: MEDIUM
+--- Parallel agent orchestration model is interesting
+--- Doesn't replace PP's workflow; could complement
+--- No neurosymbolic, no rules engine, no memory persistence
+
+* 17. Windsurf / Codeium (now part of Cognition AI / Devin)
+
+** What it does
+AI-native IDE. Cascade agent for autonomous coding. Tab completion, agent mode,
+MCP support. Acquired by Cognition (Devin).
+
+** Architecture
+- Model: multi-model (GPT-5, Claude, custom)
+- Tools: Cascade (agent), Tab (completions), MCP, JetBrains plugin, Devin
+  integration, Spaces (bundled context)
+- Memory: Cascade sessions within workspace; Spaces for grouped context
+- Safety: admin-managed MCP servers; enterprise controls
+
+** Differentiators
+- Cascade: local agent for real-time assistance
+- Devin integration: cloud agent for long-running tasks
+- Spaces: bundle agent sessions, PRs, files around a task
+- Agent Command Center: Kanban dashboard for agents
+- JetBrains plugin (targets non-VS Code users)
+
+** Maturity
+Production. 1M+ users, 4k+ enterprise customers.
+
+** Relevance to Passepartout: MEDIUM
+--- IDE-dependent (VS Code fork + JetBrains plugin)
+--- Cascade + Devin hybrid local/cloud model is architecturally interesting
+--- No neurosymbolic. No deterministic rules. No contract-first.
+--- Spaces concept (grouping context around a task) is close to PP's session
+    management
+
+* 18. Cursor AI
+
+** What it does
+AI-first code editor (VS Code fork). Multi-model, agent mode, tab completion,
+MCP support. The most popular AI IDE.
+
+** Architecture
+- Model: proprietary (cursor-small) + OpenAI, Anthropic, Gemini
+- Tools: agent mode, tab completion, chat, @-symbols, MCP, terminal
+- Memory: session; no cross-session persistence
+- Safety: diff view, configurable permission levels, image input support
+
+** Differentiators
+- First-mover in AI IDEs (fork vs extension approach)
+- .cursorrules for project conventions
+- Fast tab completion (custom small model)
+- @-symbol context system (files, docs, web)
+
+** Maturity
+Production. Most popular AI IDE.
+
+** Relevance to Passepartout: LOW
+--- IDE-dependent. PP is philosophy of terminal + .org + Emacs
+--- No neurosymbolic, no persistent memory, no contract-first
+
+* 19. Augment Code
+
+** What it does
+AI coding platform with deep codebase understanding. Agent, chat, CLI (Auggie),
+context engine that indexes entire codebase.
+
+** Architecture
+- Model: proprietary + multi-model
+- Tools: agent, code completions (sunset soon), CLI (Auggie), IDE extensions
+- Memory: codebase index (persistent), session context
+- Safety: enterprise SSO, permissions
+
+** Differentiators
+- Auggie CLI — terminal-first agent (closest to PP)
+- Codebase-wide context engine (indexes entire repo, not just open files)
+- Agent can tackle large tasks autonomously
+
+** Maturity
+Production. Well-funded.
+
+** Relevance to Passepartout: HIGH
+--- Auggie CLI is directly comparable: terminal-native coding agent
+--- Full codebase indexing is better than PP's current approach
+--- No neurosymbolic. No contract-first. No org-mode source-of-truth.
+--- PP's TDD + contract + tangle workflow is unique differentiator
+
+* 20. Qoder
+
+** What it does
+Coding agent platform. Details limited.
+
+** Architecture
+Unknown — website unreachable.
+
+** Maturity
+Unknown.
+
+** Relevance to Passepartout: UNKNOWN
+--- Insufficient data.
+
+* 21. v0 by Vercel
+
+** What it does
+UI generation agent. Generates React/Next.js components and pages from text
+prompts. Visual design oriented.
+
+** Architecture
+- Model: proprietary (likely fine-tuned)
+- Tools: code generation, visual design mode, templates, deployment to Vercel
+- Memory: per-session; design context within chat
+- Safety: Vercel platform controls
+
+** Differentiators
+- Visual-first: generates UI, not general code
+- Design mode: fine-tune with visual controls
+- Template library
+- iOS app for mobile building
+- Deep Vercel/Next.js integration
+
+** Maturity
+Production.
+
+** Relevance to Passepartout: LOW
+--- Narrow domain (UI generation). Not a general coding agent.
+--- Cloud-only. No TUI.
+--- No relevance to PP's workflow.
+
+* 22. Lovable
+
+** What it does
+Full-stack application generation from natural language prompts. Build and
+deploy apps/websites via AI chat.
+
+** Architecture
+- Model: proprietary (likely fine-tuned)
+- Tools: app generation, deployment, domain registration, mobile app
+- Memory: per-project conversation
+- Safety: platform-level moderation
+
+** Differentiators
+- Full-stack: frontend + backend + DB + deploy
+- No-code-friendly (describe app → get working app)
+- Template library, mobile companion app
+- Enterprise security claims
+
+** Maturity
+Production.
+
+** Relevance to Passepartout: LOW
+--- Consumer/no-code focus. Not a developer coding agent.
+--- No TUI, no extensibility, no memory persistence beyond project.
+
+* 23. Void (formerly based on Codex)
+
+** What it does
+CLI coding agent for terminal-based AI code generation. Originally built on
+OpenAI Codex.
+
+** Architecture
+- Model: OpenAI API-compatible
+- Tools: terminal code generation, file writing
+- Memory: session context
+- Safety: user approval on file changes
+
+** Differentiators
+- CLI-native (similar to Codex CLI)
+- Lightweight
+
+** Maturity
+Beta/early.
+
+** Relevance to Passepartout: MEDIUM
+--- CLI-native coding agent, directly comparable to PP
+--- Less mature than Codex CLI or Aider
+--- No unique differentiators
+
+* 24. Cosine Genie
+
+** What it does
+Autonomous AI software engineer. Takes Jira tickets or PR descriptions, breaks
+them down, writes code, delivers PRs. Works asynchronously.
+
+** Architecture
+- Model: Genie 2 (proprietary model); 72% on SWE-Lancer
+- Tools: IDE/CLI, Slack, Jira, Linear, GitHub integration
+- Memory: task-level context; works asynchronously in background
+- Safety: sandboxed; desktop app runs locally; cloud service
+
+** Differentiators
+- Proprietary model (Genie 2) — not just wrapping an API
+- SWE-Lancer leader: 72% pass rate (highest)
+- Asynchronous: works without active session
+- Slack/Jira/Linear integration for task intake
+- CLI + Desktop app + Cloud
+
+** Maturity
+Production. Well-funded.
+
+** Relevance to Passepartout: HIGH
+--- Direct competitor: agent that takes tickets and delivers code
+--- CLI-native operation
+--- No contract-first, no neurosymbolic, no org-mode
+--- PP's structured TDD cycle + deterministic rules are key differentiators
+--- Cosine's Slack/Jira integration interesting for PP to consider
+
+* 25. Mentat
+
+** What it does
+CLI coding assistant that coordinates edits across multiple files. Project
+context understanding.
+
+** Architecture
+- Model: any LLM (OpenAI, Anthropic)
+- Tools: file editing across multiple files, project context gathering
+- Memory: session context, git awareness
+- Safety: user approval
+
+** Differentiators
+- Multi-file editing focus
+- Project-level understanding
+
+** Maturity
+Currently inactive/archived. GitHub 404.
+
+** Relevance to Passepartout: LOW
+--- Inactive project. No meaningful differentiation from Aider/Codex CLI.
+
+* 26. Ghostwriter by Replit (→ see Replit Agent #12)
+* 27. Poolside
+
+** What it does
+Foundation models for software engineering. Builds models + agents for
+enterprise. On-prem deployment, air-gapped. TUI, IDE extensions, agents.
+
+** Architecture
+- Model: Laguna XS.2 M.1 (proprietary foundation model)
+- Tools: agents, TUI, IDE extensions, multi-agent orchestration
+- Memory: enterprise context (connectors to repos, DBs, private data)
+- Safety: on-prem/VPC/air-gapped, RBAC for humans and agents, audit trails,
+  executive governance, no data leaves customer boundary
+
+** Differentiators
+- Full-stack: builds foundation models + agents + enterprise deployment
+- Forward Deployed Research Engineers embedded with customers
+- Outcome ownership (not just model handoff)
+- AGI thesis: software engineering as path to AGI
+- Military/defense-grade security (not just compliance)
+
+** Maturity
+Production. Frontier lab status. $500M+ funding.
+
+** Relevance to Passepartout: LOW
+--- Enterprise/military focus, completely different market
+--- Building own models (PP uses existing LLMs)
+--- TUI is just one surface among many
+--- PP's individual-developer, open-source, TDD-first philosophy is opposite
+
+* 28. Tabnine
+
+** What it does
+Enterprise AI code completion + agent platform. Code completions, chat, agents,
+CLI, context engine. Gartner Visionary 2025.
+
+** Architecture
+- Model: multiple (code-specific small models + large model access)
+- Tools: code completion, chat, CLI, agents (planning, coding, testing, docs),
+  context engine, provenance/attribution
+- Memory: Enterprise Context Engine (indexes org codebase, architecture,
+  standards)
+- Safety: on-prem/air-gapped/VPC, zero data retention, IP indemnity,
+  provenance tracking, admin controls, audit logs
+
+** Differentiators
+- Enterprise Context Engine: organizational intelligence layer for any agent
+- Fine-tuning on private repos
+- Provenance & attribution for IP compliance
+- Gartner Visionary; Leader in Omdia Universe
+- Zero Trust compliance (air-gapped)
+
+** Maturity
+Production. 15+ years in market (originally Codota). Millions of developers.
+
+** Relevance to Passepartout: LOW
+--- Enterprise-focused (compliance, IP, governance). PP is individual-agent.
+--- Context Engine concept is interesting but proprietary
+--- No neurosymbolic. No contract-first.
+--- CLI is secondary to IDE completions for Tabnine
+
+* 29. Factory Droid (→ see #6)
+* 30. Devin (→ see #5)
+
+* Emerging / Notable Others
+
+** Conductor (Melty) — see #16
+** Cline — see #7
+** RooCode — see #8
+** Augment Code CLI (Auggie) — see #19
+** Cosine Genie — see #24
+
+* Cross-Cutting Analysis
+
+** Safety / Security Architecture
+
+| System | Sandbox | Human-in-Loop | Diff Review | Gov/Enterprise | Notes |
+|--------|---------|---------------|-------------|----------------|-------|
+| Aider  | Git undo| File approval  | Git diff    | No             | Git as safety net |
+| Cline  | None    | Every op      | Diff view   | SSO, on-prem   | Best HIL in class |
+| Codex CLI | Sandboxed exec | On write/command | Console output | No | Basic |
+| Devin  | Sandboxed env | Deployment gate | PR review | Enterprise plan | Cloud sandbox |
+| Cursor | None    | Configurable   | Diff view   | No             | .cursorrules |
+| Copilot| None    | Configurable   | Diff view   | SSO, audit, MCP allowlist | Best enterprise |
+| Cosine | None    | PR review      | PR review   | Cloud + on-prem| Async operation |
+| Tabnine| None    | Configurable   | Diff view   | Air-gapped, on-prem, audit | Best air-gapped |
+| Poolside| Deploy boundary | Enterprise governance | Platform | Air-gapped, defense | Most secure by design |
+
+** Memory Persistence
+
+Nearly ALL systems have session-only memory. Exceptions:
+- Tabnine: Enterprise Context Engine (persistent codebase index)
+- Devin/Windsurf: Spaces (bundled context across sessions)
+- Poolside: enterprise connectors to repos+DBs
+- AutoGPT: vector DB persistent memory
+
+Passepartout's approach: git + .org files as source of truth is unique and
+powerful — no other system uses literate programming as memory.
+
+** TUI / CLI Interface
+
+CLI-native systems: Aider, Codex CLI, Cosine Genie, Void, Augment CLI
+IDE-first: Cursor, Windsurf, Copilot, Cline, Continue, PearAI
+Both: GitHub Copilot CLI, Poolside TUI
+
+PP is CLI + Emacs. Closest in philosophy: Aider, Codex CLI, Cosine Genie.
+
+** Extensibility Model
+
+- MCP (Model Context Protocol): Cline, Cursor, Windsurf, Copilot, AutoGen
+- Custom prompts/rules: .cursorrules, .clinerules, AGENTS.md, CLAUDE.md
+- Python scripting: Aider
+- Agent creation: AutoGPT (block builder), CrewAI (role-based)
+- MCP server creation: Cline ("add a tool" via LLM)
+
+PP's extensibility: Common Lisp macros + skill system. Unique: hot-reloadable
+skills, self-repair capability. No other system has this.
+
+** Neurosymbolic / Deterministic Rule Components
+
+NONE of the surveyed systems have a neurosymbolic architecture or deterministic
+rule engine. The closest approximations:
+- .cursorrules / .clinerules / AGENTS.md / CLAUDE.md: plain-text instructions
+  to the LLM (zero enforcement)
+- Cline's MCP tools: deterministic tool execution but no rule reasoning
+- Tabnine's Provenance: deterministic code matching but not rules
+- AutoGen's event-driven core: deterministic workflow but not rule-based
+  reasoning
+
+Passepartout's contract-first TDD (machine-verifiable contracts + Fiveam tests)
+is architecturally unique. No competitor has anything like it.
+
+* Key Takeaways for Passepartout
+
+1. NO competitor has neurosymbolic architecture or deterministic rule
+   enforcement. This is PP's strongest differentiator.
+
+2. NO competitor uses literate programming (.org as source of truth) or
+   org-babel tangle workflow. This is PP's second strongest differentiator.
+
+3. NO competitor has hot-reloadable, self-repairable skills. PP's skill system
+   (Lisp macros + fboundp guards) is unique.
+
+4. Memory persistence is universally weak. PP's git + .org approach is
+   arguably more robust than any competitor's session-only model.
+
+5. CLI-native agent space is growing: Codex CLI, Aider, Cosine Genie, Auggie.
+   PP must match or exceed their terminal UX quality.
+
+6. MCP is becoming the universal extensibility standard. PP should support MCP.
+
+7. Async/background operation (Cosine Genie, Devin) is a growing expectation.
+   PP's REPL-based daemon architecture is well-positioned for this.
+
+8. Enterprise features (SSO, on-prem, audit) are table stakes for enterprise
+   but irrelevant for PP's individual-agent use case.
+
+9. Multi-agent orchestration (AutoGen, CrewAI, Conductor) is a separate
+   concern. PP should focus on single-agent excellence first.
+
+10. The "contract-first TDD" workflow from .org → write test → watch fail →
+    implement → watch pass → tangle is UNIQUE in the entire competitive
+    landscape.