Add F1 multi-agent missions, ponytail/caveman skills, and graph design doc.

MissionWorkflow decomposes goals into parallel child AgentRunWorkflows with Postgres coordination, path-scoped edits, and mission-tagged memory. Document target DAG orchestration (scope doc, real edges, fan-in) for F2+.

Author: CascadiaTech

.cursor/rules/caveman.mdc

@@ -0,0 +1,23 @@
+---
+description: Caveman mode — terse replies, full technical accuracy. Complements ponytail (code) with shorter prose.
+globs:
+alwaysApply: false
+---
+
+# Caveman (token-efficient prose)
+
+Use when the user wants brevity or when editing agent plan/observation text.
+
+## Rules
+
+- Drop filler, hedging, pleasantries. Fragments OK.
+- Keep code, commands, paths, API names, and error strings **exact**.
+- Never drop negations (`not`, `never`, `only`) — they change meaning.
+- Code blocks and JSON unchanged.
+- For docs and commits: write normal prose (caveman is for chat/plan summaries, not user-facing docs).
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Upstream: [JuliusBrussee/caveman](https://github.com/JuliusBrussee/caveman) (MIT skill). Full skill in `third_party/caveman-skill/SKILL.md`.
+
+Works with ponytail: caveman shrinks what you **say**; ponytail shrinks what you **build**.

.cursor/rules/ponytail.mdc

@@ -0,0 +1,36 @@
+---
+description: Ponytail, lazy senior dev mode. Always pick the simplest solution that works.
+globs:
+alwaysApply: true
+---
+
+# Ponytail, lazy senior dev mode
+
+You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
+
+Before writing any code, stop at the first rung that holds:
+
+1. Does this need to be built at all? (YAGNI)
+2. Does it already exist in this codebase? Reuse the helper, util, or pattern that's already here, don't re-write it.
+3. Does the standard library already do this? Use it.
+4. Does a native platform feature cover it? Use it.
+5. Does an already-installed dependency solve it? Use it.
+6. Can this be one line? Make it one line.
+7. Only then: write the minimum code that works.
+
+The ladder runs after you understand the problem, not instead of it: read the task and the code it touches, trace the real flow end to end, then climb.
+
+Bug fix = root cause, not symptom: a report names a symptom. Grep every caller of the function you touch and fix the shared function once — one guard there is a smaller diff than one per caller, and patching only the path the ticket names leaves a sibling caller still broken.
+
+Rules:
+
+- No abstractions that weren't explicitly requested.
+- No new dependency if it can be avoided.
+- No boilerplate nobody asked for.
+- Deletion over addition. Boring over clever. Fewest files possible.
+- Shortest working diff wins, but only once you understand the problem. The smallest change in the wrong place isn't lazy, it's a second bug.
+- Question complex requests: "Do you actually need X, or does Y cover it?"
+- Pick the edge-case-correct option when two stdlib approaches are the same size, lazy means less code, not the flimsier algorithm.
+- Mark deliberate simplifications that cut a real corner with a known ceiling (global lock, O(n²) scan, naive heuristic) with a `ponytail:` comment naming the ceiling and upgrade path.
+
+Not lazy about: understanding the problem (read it fully and trace the real flow before picking a rung, a small diff you don't understand is just laziness dressed up as efficiency), input validation at trust boundaries, error handling that prevents data loss, security, accessibility, the calibration real hardware needs (the platform is never the spec ideal, a clock drifts, a sensor reads off), anything explicitly requested. Lazy code without its check is unfinished: non-trivial logic leaves ONE runnable check behind, the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "third_party/ponytail"]
+	path = third_party/ponytail
+	url = https://github.com/DietrichGebert/ponytail.git

README.md

@@ -15,7 +15,7 @@ Training platform for **Kubernetes + guardrails + Temporal + LangGraph** — tow
 
 **Rule:** Temporal orchestrates. LangGraph reasons. Guardrails gate what gets written and deployed.
 
-**Docs:** [docs/README.md](docs/README.md) · [Local dev](docs/local-dev.md) · [Agent roadmap](docs/agent-roadmap.md) · [Planned improvements](docs/planned-improvements.md)
+**Docs:** [docs/README.md](docs/README.md) · [Local dev](docs/local-dev.md) · [Agent roadmap](docs/agent-roadmap.md) · [Agent skills](docs/agent-skills.md)
 
 ---
 

deploy/postgres/mission-schema-init.yaml

@@ -0,0 +1,68 @@
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: mission-schema-init
+  namespace: lunar
+spec:
+  ttlSecondsAfterFinished: 300
+  template:
+    spec:
+      restartPolicy: OnFailure
+      containers:
+        - name: init
+          image: postgres:16
+          env:
+            - name: PGHOST
+              value: postgres
+            - name: PGPORT
+              value: "5432"
+            - name: PGUSER
+              valueFrom:
+                secretKeyRef:
+                  name: lunar-db
+                  key: username
+            - name: PGPASSWORD
+              valueFrom:
+                secretKeyRef:
+                  name: lunar-db
+                  key: password
+            - name: PGDATABASE
+              value: lunar
+          command:
+            - /bin/sh
+            - -c
+            - |
+              psql -v ON_ERROR_STOP=1 <<'SQL'
+              CREATE TABLE IF NOT EXISTS agent_missions (
+                  mission_id     TEXT PRIMARY KEY,
+                  goal           TEXT NOT NULL,
+                  status         TEXT NOT NULL DEFAULT 'pending',
+                  plan           JSONB NOT NULL DEFAULT '[]',
+                  synthesis      TEXT,
+                  error          TEXT,
+                  created_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+                  updated_at     TIMESTAMPTZ NOT NULL DEFAULT now()
+              );
+
+              CREATE TABLE IF NOT EXISTS agent_mission_tasks (
+                  task_id        TEXT NOT NULL,
+                  mission_id     TEXT NOT NULL REFERENCES agent_missions(mission_id) ON DELETE CASCADE,
+                  role           TEXT NOT NULL DEFAULT 'builder',
+                  goal           TEXT NOT NULL,
+                  status         TEXT NOT NULL DEFAULT 'pending',
+                  workflow_id    TEXT,
+                  paths          JSONB NOT NULL DEFAULT '[]',
+                  blocked_by     JSONB NOT NULL DEFAULT '[]',
+                  artifacts      JSONB NOT NULL DEFAULT '[]',
+                  error          TEXT,
+                  sort_order     INT NOT NULL DEFAULT 0,
+                  started_at     TIMESTAMPTZ,
+                  completed_at   TIMESTAMPTZ,
+                  updated_at     TIMESTAMPTZ NOT NULL DEFAULT now(),
+                  PRIMARY KEY (mission_id, task_id)
+              );
+
+              CREATE INDEX IF NOT EXISTS idx_mission_tasks_status
+                  ON agent_mission_tasks (mission_id, status);
+              SQL
+              echo "mission schema ready"

docs/README.md

@@ -12,6 +12,8 @@ Public docs for [agentic-workflows](https://github.com/CascadiaTech/agentic-work
 | [agent-roadmap.md](./agent-roadmap.md) | Phased plan — K8s → Temporal → LangGraph → GitHub agent |
 | [platform-architecture.md](./platform-architecture.md) | Four-layer north star and design decisions |
 | [guardrails-alternatives.md](./guardrails-alternatives.md) | Conftest + Python guardrails without Lunar Hub |
+| [agent-skills.md](./agent-skills.md) | Ponytail + caveman integration (Cursor + Temporal) |
+| [multi-agent.md](./multi-agent.md) | Multi-agent missions — Postgres board, parallel child workflows |
 
 ---
 

docs/agent-roadmap.md

@@ -165,6 +165,24 @@ Placeholder: [services/github-webhook/README.md](../services/github-webhook/READ
 
 See [memory/README.md](../memory/README.md).
 
+### Phase S — Agent skills (ponytail + caveman)
+
+- [x] **S1:** Vendored MIT skill content — [agent-skills.md](./agent-skills.md), `third_party/`, Cursor rules
+- [x] **S1:** Temporal prompt injection — `AGENT_PONYTAIL`, `AGENT_CAVEMAN` in `temporal/config/agent_skills.py`
+- [ ] **S2:** Role-specific graphs (planner=caveman, builder=ponytail) in multi-agent mission workflow
+- [ ] **S3:** Optional Caveman Proxy for worker input compression (upstream BSL CLI, not vendored)
+
+Upstream: [ponytail](https://github.com/DietrichGebert/ponytail) · [caveman](https://github.com/JuliusBrussee/caveman)
+
+### Phase F — Multi-agent missions
+
+See [multi-agent.md](./multi-agent.md) for graph engineering target (delegator DAG, fan-in, shared memory).
+
+- [x] **F1:** `MissionWorkflow` + Postgres board + parallel child workflows
+- [ ] **F2:** Scope document, `depends_on` execution, `task_outputs`, LLM fan-in
+- [ ] **F3:** Role graphs — doc-agent, review-agent
+- [ ] **F4:** K8s worker always-on (deferred during local iteration)
+
 ### Phase D2 — Real code agent (git tools)
 
 **Done (local lite):** LangGraph nodes `propose_edits` → `apply_edits` write files in **this repo** via path allowlist (`temporal/config/agent_config.py`). No git clone/PR yet.

docs/agent-skills.md

@@ -0,0 +1,93 @@
+# Agent skills — ponytail + caveman
+
+How [ponytail](https://github.com/DietrichGebert/ponytail) and [caveman](https://github.com/JuliusBrussee/caveman) integrate with this platform.
+
+---
+
+## Why both
+
+| Skill | Shrinks | Where it applies |
+|-------|---------|------------------|
+| **Ponytail** | What agents **build** | Edit prompts, code diffs, guardrailed file writes |
+| **Caveman** | What agents **say** | Plan step strings, observations, chat-style output |
+
+They compose: ponytail picks `<input type="date">` over a date-picker library; caveman writes "Use native date input" instead of a paragraph.
+
+---
+
+## Cursor (local development)
+
+| File | Purpose |
+|------|---------|
+| `.cursor/rules/ponytail.mdc` | Always-on YAGNI ladder |
+| `.cursor/rules/caveman.mdc` | Optional terse prose mode |
+
+Install / refresh:
+
+```bash
+chmod +x scripts/install-agent-skills.sh
+./scripts/install-agent-skills.sh
+```
+
+Optional full caveman skill via skills CLI (installs to gitignored `.cursor/skills/`):
+
+```bash
+npx skills add JuliusBrussee/caveman -a cursor --yes
+```
+
+---
+
+## Temporal workers (autonomous agents)
+
+Prompt injection lives in `temporal/config/agent_skills.py` and is appended to:
+
+- **Plan nodes** — `DRAFT_PLAN_SYSTEM_PROMPT`, `REFINE_PLAN_SYSTEM_PROMPT` (caveman)
+- **Edit node** — `EDIT_SYSTEM_PROMPT` (ponytail)
+- **Observations** — compact memory writes (caveman hint)
+
+Environment toggles on the worker:
+
+```bash
+export AGENT_PONYTAIL=full   # default
+export AGENT_CAVEMAN=lite    # default
+export AGENT_PONYTAIL=off    # disable ponytail ladder
+export AGENT_CAVEMAN=off     # disable terse plans
+```
+
+---
+
+## Multi-agent orchestration (planned)
+
+When `MissionWorkflow` lands, assign skills by role:
+
+```text
+MissionWorkflow
+  ├── planner task   → caveman (board + task titles)
+  ├── builder tasks  → ponytail (minimal edits per task)
+  └── reviewer task  → ponytail-review pattern (delete-list)
+```
+
+Shared **Postgres mission board** holds progress; shared RAG holds observations tagged by mission/task. Target graph design: [multi-agent.md](./multi-agent.md).
+
+---
+
+## Third-party layout
+
+See [third_party/README.md](../third_party/README.md).
+
+- `third_party/ponytail/` — optional git submodule (full upstream)
+- `third_party/caveman-skill/SKILL.md` — MIT skill text only
+
+**Not included:** Caveman Proxy / Engine (BSL-1.1). Install separately if you want input-token compression:
+
+```bash
+npm install -g @caveman-ai/cli && caveman setup --install
+```
+
+---
+
+## License
+
+- Ponytail: MIT
+- Caveman skill: MIT
+- Caveman engine/proxy: BSL-1.1 — not vendored in this repo

docs/local-dev.md

@@ -1,29 +1,33 @@
 # Local Development Setup for Temporal
 
-This document outlines the steps to set up and run Temporal locally using Python and uv.
+## Prerequisites
+Ensure you have the necessary environment set up for running Temporal locally.
 
 ## Quick Start Guide
+To quickly set up Temporal in a local development environment, follow these steps:
 
-Follow these steps to get your local Temporal setup ready using three terminals:
+1. **Start the Temporal server**:
+   Open a terminal and run the following command to start the Temporal server:
+   
+   ```bash
+   temporal server start-dev --db-filename /tmp/temporal-training.db
+   ```
+   
+   This will start the Temporal server and ensure that the UI is accessible at [http://localhost:8233](http://localhost:8233).
 
-### Terminal 1: Start Temporal Server
-Run the following command to start the Temporal server:
-```bash
-temporal server start-dev --db-filename /tmp/temporal-training.db
-```
-The Temporal UI is available at [http://localhost:8233](http://localhost:8233) and the server listens on localhost:7233.
+2. **Run the Temporal worker**:
+   Open another terminal and navigate to the Temporal workspace:
+   
+   ```bash
+   cd temporal && uv run worker.py
+   ```
+   Make sure to export your `OPENAI_API_KEY` before running this command.
 
-### Terminal 2: Start Your Worker
-In a new terminal, navigate to the temporal directory and run your worker:
-```bash
-cd temporal && uv run worker.py
-```
-Make sure to export your `OPENAI_API_KEY` before running the worker.
+3. **Start the Temporal agent**:
+   Finally, open a third terminal and run the following script to start the Temporal agent:
+   
+   ```bash
+   ./scripts/temporal/start-agent.sh
+   ```
 
-### Terminal 3: Start the Temporal Agent
-In another terminal, start the Temporal agent:
-```bash
-./scripts/temporal/start-agent.sh
-```
-
-Once all three terminals are running, you are set up to develop and test your Temporal applications locally.
+You should now have a fully operational local Temporal setup!