opencode-manifold 0.1.0

package/src/templates/skills/lead-dev-workflow/SKILL.md

@@ -0,0 +1,114 @@
+# Lead Dev Workflow Skill
+
+This skill guides the Lead Dev agent through reading plans and dispatching tasks.
+
+## Reading Any-Format Plans
+
+The plan document may be in ANY format. Your job is to interpret it.
+
+### Formats You Might Encounter
+
+**Markdown TODO list:**
+```markdown
+## Task 1: Implement auth middleware
+- [ ] pending
+
+## Task 2: Add user registration endpoint
+- [x] completed
+```
+
+**Meeting notes:**
+```
+John asked for:
+- Auth middleware
+- User registration
+- Password hashing utility
+```
+
+**Email thread:**
+```
+Hey, we need to add sharing to the cart feature.
+Mike suggested we use signed URLs.
+```
+
+**Structured JSON:**
+```json
+{
+  "tasks": [
+    { "id": 1, "description": "Implement auth", "status": "pending" }
+  ]
+}
+```
+
+**Whiteboard transcription:**
+```
+AUTH:
+- middleware
+- JWT handling
+- session management
+```
+
+### How to Extract Tasks
+
+1. **Identify the goal** — What is the plan trying to accomplish?
+2. **Find discrete units** — What can be done independently?
+3. **Check for dependencies** — Does order matter? Note it.
+4. **Assess completeness** — Can you act on this, or is more info needed?
+
+### When the Plan Is Too Vague
+
+If you can't identify concrete tasks:
+
+**Option A: Subtask to Plan Agent**
+- Call the plan agent to create a structured task list
+- User MUST approve the generated list before work begins
+- Don't start working until approval
+
+**Option B: Ask the User**
+- Reply asking for clarification
+- Be specific about what's unclear
+- Example: "I can see we need auth, but can you break down what 'auth middleware' means? Do we need login, registration, password reset?"
+
+## Dispatching Tasks
+
+Use the `dispatchTask` tool:
+
+```
+dispatchTask({ task_number, description, plan_file })
+```
+
+- `task_number`: Sequential number (1, 2, 3...)
+- `description`: One-line description of the task
+- `plan_file`: Path to the original plan document
+
+### Order of Dispatch
+
+- Dispatch tasks in dependency order
+- If tasks are independent, dispatch in any order
+- Wait for each task to complete before dispatching the next
+
+## Session Resumption
+
+If resuming from a previous session:
+
+1. Read the plan file
+2. Check `Manifold/index.md` for completed tasks
+3. Check task files in `Manifold/tasks/` for status
+4. Pick up from the first task NOT marked COMPLETED
+
+**Never re-execute completed tasks.**
+
+## Plan-Level Testing
+
+After ALL tasks are dispatched and completed:
+
+1. Check if the plan has a test section
+2. If yes, run the test command
+3. Report results to the user
+
+## Your Constraints
+
+- You read ONLY the plan document
+- You do NOT access the codebase
+- You do NOT read wiki files or task logs
+- You stay lean and fast

package/src/templates/skills/wiki-ingest/SKILL.md

@@ -0,0 +1,129 @@
+# Wiki Ingest Skill
+
+This skill guides the Clerk on how to log task results to the wiki.
+
+## Task File Format
+
+Create or update `Manifold/tasks/<task-id>.md`:
+
+```markdown
+# <task-id>: <Task Title>
+
+**Date:** <YYYY-MM-DD>
+**Status:** <IN_PROGRESS | COMPLETED | ESCALATED_USER>
+**Loops:** <number>
+**Git Commit:** <commit-hash>
+
+## Task
+<Task description>
+
+## Context Used
+- codebase-index: <files or search terms>
+- Wiki: <prior task logs referenced>
+- Graph: <graph files read>
+
+## Scoped Prompt
+> <The composed prompt for Senior Dev>
+
+## Design Decisions
+- <Decision 1 and why>
+- <Decision 2 and why>
+
+## Files Touched
+- [[<file-path-1>]]
+- [[<file-path-2>]]
+
+## Loop History
+### Loop 1
+- **Senior:** <what Senior produced>
+- **Junior:** <Junior's response>
+
+### Loop 2
+- **Senior:** <what Senior produced>
+- **Junior:** <Junior's response>
+```
+
+## Index.md Update
+
+After completing a task, add entry to `Manifold/index.md`:
+
+```markdown
+## <plan-slug> — <Plan Title>
+
+- [[<task-id-001>]] — <one-line summary> | <date> | COMPLETED
+- [[<task-id-002>]] — <one-line summary> | <date> | IN_PROGRESS
+```
+
+## Log.md Append
+
+Append a line to `Manifold/log.md`:
+
+```markdown
+## [<date>] <task-id> | <description> | <STATUS> | <loop-count> loops
+```
+
+Example:
+```markdown
+## [2026-04-06] share-cart-001 | Implement cart data model | COMPLETED | 2 loops
+```
+
+## Graph File Update
+
+For each file touched, update or create `Manifold/graph/<graph-name>.md`:
+
+```markdown
+# <original-file-path>
+
+## Calls
+- <files this file calls>
+
+## Depends On
+- <files this file depends on>
+
+## Tasks That Edited
+- [[<task-id>]]
+- [[<other-task-id>]]
+```
+
+### Graph Filename Convention
+
+Replace `/` and `.` with `_`, append `.md`:
+- `src/middleware/auth.ts` → `src_middleware_auth_ts.md`
+- `src/utils/helpers.ts` → `src_utils_helpers_ts.md`
+
+## Status Values
+
+| Status | When to Use |
+|--------|-------------|
+| `IN_PROGRESS` | Task log created, implementation ongoing |
+| `COMPLETED` | Task finished successfully, Junior approved |
+| `ESCALATED_USER` | Task blocked, requires human intervention |
+
+## Wikilink Conventions
+
+- Tasks: `[[task-id]]` — e.g., `[[share-cart-001]]`
+- Files: `[[file-path]]` — e.g., `[[src/middleware/auth.ts]]`
+- Always use absolute-style paths for files
+
+## Loop History Recording
+
+For each Senior→Junior exchange, record:
+1. What Senior produced (brief summary)
+2. Junior's response (COMPLETE or QUESTIONS + issues)
+
+If Debug was involved, add:
+3. Debug's analysis and suggestion
+4. Senior's response to the debug suggestion
+5. Debug's final review
+
+## Checklist Before Completing
+
+- [ ] Task file created with all sections
+- [ ] Status set correctly (COMPLETED or ESCALATED_USER)
+- [ ] Loop count accurate
+- [ ] All files touched listed with wikilinks
+- [ ] Design decisions recorded with reasoning
+- [ ] Loop history complete
+- [ ] index.md updated
+- [ ] log.md appended
+- [ ] All touched files' graph entries updated

package/src/templates/skills/wiki-query/SKILL.md

@@ -0,0 +1,95 @@
+# Wiki Query Skill
+
+This skill guides the Clerk on how to search the wiki for prior context.
+
+## Where to Look
+
+### 1. index.md — Task Catalog
+
+`Manifold/index.md` lists all tasks by plan.
+
+**Search strategies:**
+- By plan slug: look under the plan's section
+- By date: find tasks from a specific time period
+- By status: find IN_PROGRESS tasks to understand current work
+
+### 2. log.md — Chronological Log
+
+`Manifold/log.md` has a running history of all tasks.
+
+**Format:**
+```markdown
+## [2026-04-06] task-001 | Implement auth | COMPLETED | 2 loops
+```
+
+**Search strategies:**
+- By date range: find recent completions
+- By status: find ESCALATED_USER tasks (to avoid similar issues)
+- By loop count: find high-loop tasks (might indicate complexity)
+
+### 3. Task Files — Detailed History
+
+`Manifold/tasks/<task-id>.md` has full task details.
+
+**What to look for:**
+- `## Design Decisions` — why things were done a certain way
+- `## Loop History` — what issues Junior caught
+- `## Context Used` — what Clerk researched
+
+**Search strategies:**
+- By keyword: grep for terms like "cache", "auth", "performance"
+- By file: find tasks that touched `src/models/cart.ts`
+- By decision: find tasks that decided on "Map vs Array"
+
+### 4. Graph Files — Dependency Analysis
+
+`Manifold/graph/<graph-name>.md` tracks file relationships.
+
+**What they contain:**
+- `## Calls` — what this file uses
+- `## Depends On` — what this file is used by
+- `## Tasks That Edited` — which tasks modified this file
+
+**How to use:**
+1. Find graph files relevant to your task (from codebase search)
+2. Read them to understand dependencies
+3. Check "Tasks That Edited" for prior work on those files
+4. Read relevant task files for context
+
+## Combining Sources
+
+### Example: Adding share functionality to cart
+
+1. **Codebase search** → identified `src/models/cart.ts` and `src/utils/share.ts`
+2. **Graph for cart.ts** → depends on `src/models/order.ts`, called by `src/routes/cart.ts`
+3. **index.md** → found "share-cart" plan with 3 completed tasks
+4. **Read task logs** → share-cart-001 used Map for items, share-cart-002 used localStorage
+5. **Result** → scoped prompt includes: use Map for O(1) lookup, persist to localStorage, follow the share URL format from task-002
+
+## What to Look For
+
+### Design Decisions
+- Why was X chosen over Y?
+- What constraints influenced the approach?
+- What was explicitly rejected and why?
+
+### Rejected Approaches
+- What has Junior (or Debug) rejected before?
+- What patterns should Senior avoid?
+
+### Established Conventions
+- Project-specific file organization
+- Language idioms used in this codebase
+- Testing patterns
+
+### Prior Art
+- Similar features that might share code
+- Shared utilities already available
+- Dependencies between tasks
+
+## Search Tips
+
+- **Be specific**: "JWT validation" not just "auth"
+- **Use file paths**: "src/middleware/auth" to find related files
+- **Check dates**: recent decisions are more relevant than old ones
+- **Follow links**: wikilinks in task files lead to related context