Skill: cnf6682/lattice (version 1.2.1)

--- name: lattice description: > Initialize and manage Lattice organizations — a file-based operating system for AI agent teams that enables stable, long-running iterative development through an 8-phase pipeline. Core strengths: (1) File-driven state keeps agents on track across sessions — no context loss, no drift, tasks complete reliably over hours or days. (2) Three-tier failure handling (model escalation → peer consult → auto-triage) automatically unblocks stuck agents without human intervention. (3) Per-phase model configuration — use strong models for thinking-heavy phases (planning, review), cost-efficient models for token-heavy phases (implementation, testing), optimizing token cost. (4) Multi-project parallel execution with cron scheduling — run several projects simultaneously, each on its own cadence. Triggers: lattice, org framework, pipeline setup, agent team, multi-agent project, 8-phase pipeline, new org, new project, department setup, pipeline orchestrator, long-running tasks, model escalation, peer consult, auto-triage, token optimization. --- # Lattice Lattice is a file-based operating system for AI agent teams. It replaces volatile chat windows with persistent files, enabling agents to work stably through long, iterative development cycles via an 8-phase execution pipeline. **Why Lattice?** - **Stable long-running execution** — File-driven state machine ensures agents stay on track across sessions. No context window overflow, no drift. Tasks complete reliably over hours or days through structured iteration. - **Three-tier failure handling** — When an agent gets stuck: (1) Model Escalation retries with stronger models, (2) Peer Consult gathers parallel opinions from multiple models, (3) Auto-Triage makes a judgment call (relax constraints / defer / block for human). Most blockers resolve automatically. - **Per-phase model configuration** — Thinking-heavy phases (planning, review, architecture) need strong reasoning models; token-heavy phases (implementation, testing) can use cost-efficient coding models. This dramatically reduces overall token cost without sacrificing quality where it matters. **Example model assignment (from a production setup):** | Phase | Model tier | Example | |-------|-----------|---------| | Constitute (architecture) | Strong reasoning | Claude Opus | | Research | Strong reasoning | Gemini Pro | | Specify (design) | Strong reasoning | Claude Opus | | Plan + Tasks | Strong reasoning | Claude Opus | | Implement | Cost-efficient coding | GPT Codex | | Test | Cost-efficient coding | GPT Codex | | Review | Strong reasoning | Claude Opus | | Gap Analysis | Strong reasoning | Gemini Pro | The key insight: implementation and testing consume the most tokens (writing/running code), but don't require the most expensive models. Planning and review consume fewer tokens but need deeper reasoning. Match model strength to cognitive demand, not token volume. - **Multi-project parallel execution** — Run multiple projects simultaneously, each with its own cron-scheduled orchestrator. Combined with OpenClaw's cron system, projects advance autonomously on independent cadences. Templates are bundled at `templates/ORG/` relative to this skill directory. ## Quick Reference - Full design doc: `templates/ORG/PROJECTS/pipeline-framework/DESIGN.md` - Pipeline guide (all agents): `templates/ORG/PIPELINE_GUIDE.md` - Sub-agent guide: `templates/ORG/PROJECTS/pipeline-framework/templates/PIPELINE_GUIDE_FOR_SUBAGENTS.md` - Orchestrator prompt template: `templates/ORG/PROJECTS/pipeline-framework/templates/ORCHESTRATOR_PROMPT.template.md` - Phase prompt templates: [REDACTED_SECRET] - State machine template: `templates/ORG/PROJECTS/pipeline-framework/templates/PIPELINE_STATE.template.json` --- ## Task: Initialize a New Organization (`lattice init`) ### 1. Gather Information Ask the user for: - **Organization name** (e.g. "Acme Labs") - **Target directory** — where to create the `ORG/` folder (default: current workspace root) - **Departments** — list of department names (e.g. Research, Engineering, Reliability) - **First project** (optional) — name + one-line description Keep it conversational. Don't dump all questions at once. ### 2. Scaffold the ORG Directory Copy the entire `templates/ORG/` directory to `<target>/ORG/`. Then customize: 1. **ORG_README.md** — Replace the example org structure in §5 with the user's actual departments 2. **TASKBOARD.md** — Leave the template structure intact (user fills in priorities later) 3. **Departments** — For each department the user listed: - Copy `DEPARTMENTS/example-dept/` → `DEPARTMENTS/<dept-name>/` - In each copied department, replace `<Department Name>` placeholders in CHARTER.md, RUNBOOK.md, HANDOFF.md with the actual department name - Reset STATE.json to `{"lastRun": null, "cursor": null, "notes": "Initial state"}` 4. **Remove** `DEPARTMENTS/example-dept/` after creating real departments (unless user wants to keep it as reference) ### 3. Create the First Project (if requested) - Copy `PROJECTS/example-project/` → `PROJECTS/<project-name>/` - Update STATUS.md with the project name - Update DECISIONS.md header - Configure PIPELINE_STATE.json (see "Configure Pipeline State" below) - Remove `PROJECTS/example-project/` after creating the real project ### 4. Configure Pipeline State Read `templates/ORG/PROJECTS/pipeline-framework/templates/PIPELINE_STATE.template.json` as the reference. Ask the user: - **Which agents** will run each phase? (agentId per role — or a single agent for all) - **Which models** for each phase? (or a default model) - **Escalation chain** — list of models from cheapest to strongest (e.g. `["gflash", "gpro", "sonnet"]`) - **Peer consult models** — which models to consult in parallel when stuck - **Synthesizer/triage model** — typically the strongest available model - **Notification channel** (optional) — where to send pipeline status updates Fill in the project's `PIPELINE_STATE.json` with these values, replacing all `<placeholder>` tokens. ### 5. Set Up the Orchestrator Cron Job Read `templates/ORG/PROJECTS/pipeline-framework/templates/ORCHESTRATOR_PROMPT.template.md`. Create a cron job using the `cron` tool: - **Schedule**: `every 30 minutes` (adjustable) - **Session target**: `isolated` - **Payload kind**: `agentTurn` - **Model**: the user's chosen orchestrator model - **Message**: the orchestrator prompt template, with all `<placeholder>` tokens filled in: - `<project>` → project name - `<org-root>` → absolute path to the ORG directory - `<project-root>` → absolute path to the project directory - `<repo-root>` → absolute path to the code repository (ask user) - Phase prompt paths → absolute paths to the skill's bundled phase prompt templates Tell the user the cron job ID so they can manage it later. ### 6. Summary Print a brief summary: - ORG directory location - Departments created - Project(s) created - Cron job ID and schedule - Remind them to fill in TASKBOARD.md with initial priorities --- ## Task: Add a New Project (`lattice new-project`) 1. Ask for: project name, one-line description, code repo path 2. Copy [REDACTED_SECRET] → `ORG/PROJECTS/<name>/` 3. Customize STATUS.md, DECISIONS.md, PIPELINE_STATE.json (same as step 3-4 above) 4. Optionally create a new orchestrator cron job for this project --- ## Task: Add a New Department (`lattice new-dept`) 1. Ask for: department name, mission (one sentence) 2. Copy [REDACTED_SECRET] → `ORG/DEPARTMENTS/<name>/` 3. Fill in CHARTER.md with the department name and mission 4. Update ORG_README.md §5 to include the new department --- ## Task: Check Organization Status (`lattice status`) 1. Read `ORG/TASKBOARD.md` — summarize active priorities 2. For each project in `ORG/PROJECTS/`: - Read `STATUS.md` — current phase and progress - Read `PIPELINE_STATE.json` — phase statuses, blockers, run number 3. For each department in `ORG/DEPARTMENTS/`: - Read `HANDOFF.md` — current state and blockers 4. Present a concise status report --- ## Pipeline Architecture (for reference) ### 8 Phases ``` Constitute → Research → Specify → Plan+Tasks → Implement → Test → Review → Gap Analysis ``` ### 3-Layer Assistance (when a phase gets stuck) 1. **Model Escalation** — retry with progressively stronger models 2. **Peer Consult** — parallel multi-model consultation + synthesis 3. **Auto-Triage** — automated judge decides: RELAX (loosen constraints) / DEFER (next iteration) / BLOCK (wait for human) ### Key Files per Project ``` ORG/PROJECTS/<project>/ ├── STATUS.md # Human-readable status ├── DECISIONS.md # Key decisions + rationale ├── PIPELINE_STATE.json # Phase state machine ├── PIPELINE_LOG.jsonl # Append-only history ├── pipeline/ # Current run artifacts └── pipeline_archive/ # Historical runs ```


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: suspicious | SkillSpector: suspicious (HIGH)