lacp

LACP

Local policy, evidence, and recovery controls for coding agents.

LACP wraps Claude, Codex, Hermes, and other CLI agents with deterministic routing, approval gates, execution records, memory controls, and rollback paths. It runs on your machine and keeps remote execution opt-in.

---

Development status: main and the GitHub release are v0.10.1. Homebrew's last bottled release may lag until the tap is updated; brew install --HEAD tracks main. Git worktrees isolate files, not ports — see Runtime isolation.

Contents

• Quick Start
• Why teams adopt LACP
• Use-case recipes
• Documentation
• Architecture
• Features
• Prerequisites
• Install Options
• Who It's For
• Testing
• Security
• Contributing

What LACP controls

LACP is a local execution wrapper and control plane. The coding-agent host still owns its model, tools, session, and interface. LACP owns the contract around a run: where it may execute, which risk tier applies, when approval is required, what evidence must be kept, and how a failed change is recovered.

---

Quick start

Install

# Homebrew (recommended)
brew tap 0xNyk/lacp && brew install lacp

# or inspect and run the bootstrap at a published tag
curl -fsSLo /tmp/lacp-install.sh \
  https://raw.githubusercontent.com/0xNyk/lacp/v0.10.1/install.sh
LACP_REF=v0.10.1 bash /tmp/lacp-install.sh

Bootstrap and verify

lacp bootstrap-system --profile starter --with-verify
lacp doctor --json | jq '.ok,.summary'

After bootstrap: .env is created, dependencies installed, directories scaffolded, Obsidian vault wired, and verification artifacts produced.

For the full setup and daily operator flow, start with the Runbook and Local Dev Loop.

First gated command

# Route a task through LACP policy gates
lacp run --task "hello world" --repo-trust trusted -- echo "LACP is working"

# Make claude/codex/hermes default to LACP routing (reversible)
lacp adopt-local --json | jq

Why teams adopt LACP

• Route commands through explicit policy and budget gates.
• Keep evidence, provenance, and verification results with each run.
• Leave remote execution disabled until an operator enables it.
• Isolate parallel agents with sessions and Git worktrees.

Use-case recipes

1) Harden local agent usage in under 5 minutes

lacp bootstrap-system --profile starter --with-verify
lacp adopt-local --json | jq   # wraps claude + codex only; Hermes stays native
lacp posture --strict

2) Run one risky command with explicit policy controls

lacp run \
  --task "dependency update with tests" \
  --repo-trust trusted \
  --context-profile default \
  -- pnpm up && pnpm test

3) Generate PR-ready evidence before opening a PR

lacp e2e smoke --workdir . --init-template --command "npx playwright test --grep @smoke"
lacp api-e2e smoke --workdir . --init-template --command "npx schemathesis run --checks all"
lacp pr-preflight --changed-files ./changed-files.txt --checks-json ./checks.json

4) Run parallel agents safely on isolated worktrees

lacp worktree create --repo-root . --name feature-a --base HEAD
lacp up --session feature-a --instances 3 --command "claude"
lacp swarm launch --manifest ./swarm.json

---

Documentation

Guide	What You'll Learn
Runbook	Daily operator workflow, command map, troubleshooting entry points
Local Dev Loop	Fast build/test/verify loop for contributors
Framework Scope	What LACP is, what it is not, and design boundaries
Implementation Path	Step-by-step rollout plan for full control-plane adoption
Memory Quality Workflow	How memory ingestion, expansion, and validation are run safely
Incident Response	Triage and recovery flow when policy gates fail
Release Checklist	Pre-release, release, and post-release controls
Troubleshooting	Common errors, doctor diagnostics, fix hints
Runtime isolation	Worktrees vs ports vs Claude host isolation

Project health files

• CONTRIBUTING.md - contribution and PR expectations
• SECURITY.md - vulnerability disclosure process
• CHANGELOG.md - release history
• LICENSE - MIT

---

Architecture

lacp/
├── bin/                    # CLI commands (lacp <command>)
│   ├── lacp                # Top-level dispatcher
│   ├── lacp-bootstrap-system
│   ├── lacp-doctor         # Diagnostics (--json, --fix-hints)
│   ├── lacp-route          # Policy-driven tier/provider routing
│   ├── lacp-sandbox-run    # Gated execution with artifact logging
│   ├── lacp-brain-*        # Memory stack (ingest, expand, doctor, stack)
│   ├── lacp-obsidian       # Vault config management
│   ├── lacp-up             # Multi-instance agent sessions
│   ├── lacp-swarm          # Batch orchestration
│   └── lacp-claude-hooks   # Hook profile management
├── config/
│   ├── sandbox-policy.json     # Routing + cost ceilings
│   ├── risk-policy-contract.json
│   ├── obsidian/               # Vault manifest + optimization profiles
│   └── harness/                # Task schemas, sandbox profiles, verification policies
├── hooks/                  # Python hook pipeline for Claude Code
├── scripts/
│   ├── ci/                 # Test suites
│   └── runners/            # Daytona/E2B execution adapters
└── docs/                   # Guides and reference docs

Control Flow

Agent invocation
  → lacp route (risk tier + provider selection)
    → context contract validation
      → budget gate check
        → session fingerprint verification
          → sandbox-run (dispatch + artifact logging)

Features

Policy-Gated Execution

Every command routes through risk tiers (safe → review → critical), budget ceilings per tier, and context contracts that validate host, working directory, git branch, and remote targets before execution.

5-Layer Memory Stack

Layer	Purpose
Session memory	Per-project scaffolding under ~/.claude/projects/
Knowledge graph	Obsidian vault with MCP wiring (smart-connections, QMD, ori-mnemos)
Ingestion pipeline	brain-ingest converts text/audio/video/URLs into structured notes
Code intelligence	GitNexus AST-level knowledge graph via MCP (optional)
Agent identity	Persistent IDs per (hostname, project) + SHA-256 hash-chained provenance

lacp brain-stack init --json | jq          # Bootstrap all layers
lacp brain-ingest --url "https://..." --apply --json | jq
lacp brain-expand --apply --json | jq      # Full expansion loop

Hook Pipeline for Claude Code

Modular Python hooks enforcing quality at every session stage:

Hook	Event	Purpose
session_start.py	SessionStart	Git context injection, test command caching
pretool_guard.py	PreToolUse	Block dangerous operations (publish, chmod 777, fork bombs, secrets)
write_validate.py	PostToolUse	YAML frontmatter schema validation
stop_quality_gate.py	Stop	3-tier eval: heuristics, test verification, local LLM rationalization detection

Profiles: minimal-stop, balanced, hardened-exec, quality-gate-v2. Apply with lacp claude-hooks apply-profile <profile>. hardened-exec also logs SubagentStart / SubagentStop. It does not install a WorktreeCreate hook (that event replaces Claude's git worktree creation).

Mycelium Network Memory

Biologically-inspired memory consolidation modeled on fungal networks:

Mechanism	Description
Adaptive path reinforcement	Frequently-traversed edges strengthen (like mycelium hyphae)
Self-healing	Pruned nodes trigger reconnection of orphaned neighbors
Exploratory tendrils	Frontier nodes in active categories shielded from pruning
Flow scoring	Betweenness centrality identifies critical knowledge hubs
Temporal decay	FSRS dual-strength model with forgetting curve

Multi-Agent Orchestration

# dmux-style multi-instance launch
lacp up --session dev --instances 3 --command "claude"

# Git worktree isolation
lacp worktree create --repo-root . --name "feature-a" --base HEAD

# Batch swarm execution
lacp swarm launch --manifest ./swarm.json

Evidence Pipelines

Generate machine-verifiable evidence for PR gates:

lacp e2e smoke --workdir . --init-template --command "npx playwright test --grep @smoke"
lacp api-e2e smoke --workdir . --init-template --command "npx schemathesis run --checks all"
lacp contract-e2e smoke --workdir . --init-template --command "forge test -vv"
lacp pr-preflight --changed-files ./changed-files.txt --checks-json ./checks.json

---

Prerequisites

Required	Recommended
bash, python3, jq, rg (ripgrep)	shellcheck, tmux, gh

The installer auto-detects and installs missing dependencies on macOS via Homebrew.

Install options

All installation methods

Homebrew

brew tap 0xNyk/lacp
brew install lacp            # published v0.10.1 release (tap may lag)
brew install --HEAD lacp     # current main

cURL Bootstrap

curl -fsSLo /tmp/lacp-install.sh \
  https://raw.githubusercontent.com/0xNyk/lacp/v0.10.1/install.sh
LACP_REF=v0.10.1 bash /tmp/lacp-install.sh

Change both references to main only when you intend to install unreleased development code. The script also accepts --dir, --profile, and --with-verify; run it with