opencode-onboard 0.1.13 → 0.2.3

package/content/.agents/agents/back-engineer.md

@@ -63,8 +63,18 @@ Rules:
 - Do not force push
 - Report blockers immediately rather than working around them
 
+## Workflow
+
+When spawned by the lead:
+1. For each assigned task: call `team_claim task_id:<id>` before starting
+2. Implement the task
+3. Call `team_tasks_complete task_id:<id>` after finishing
+4. When all tasks are done or blocked, send results to lead via `team_message`
+
 ## Output Format
 
+Send via `team_message` to lead when done:
+
 ```
 ## Back Engineer, Done
 

package/content/.agents/agents/front-engineer.md

@@ -62,8 +62,18 @@ Rules:
 - Do not force push
 - Report blockers immediately rather than working around them
 
+## Workflow
+
+When spawned by the lead:
+1. For each assigned task: call `team_claim task_id:<id>` before starting
+2. Implement the task
+3. Call `team_tasks_complete task_id:<id>` after finishing
+4. When all tasks are done or blocked, send results to lead via `team_message`
+
 ## Output Format
 
+Send via `team_message` to lead when done:
+
 ```
 ## Front Engineer, Done
 

package/content/.agents/agents/quality-engineer.md

@@ -60,8 +60,17 @@ Rules:
 - Do not force push
 - Report all failures, do not silently skip failing tests
 
+## Workflow
+
+When spawned by the lead:
+1. Read the task list and context files provided in the spawn prompt
+2. Run tests, build, lint, and verify acceptance criteria
+3. When done, send results to lead via `team_message`
+
 ## Output Format
 
+Send via `team_message` to lead when done:
+
 ```
 ## Quality Engineer, Done
 

package/content/.opencode/commands/opsx-apply.md

@@ -0,0 +1,170 @@
+---
+description: Implement tasks from an OpenSpec change via ensemble agent team
+---
+
+Implement tasks from an OpenSpec change using the ensemble agent team.
+
+**Input**: Optionally specify a change name (e.g., `/opsx-apply add-auth`). If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
+
+**Steps**
+
+1. **Select the change**
+
+   If a name is provided, use it. Otherwise:
+   - Infer from conversation context if the user mentioned a change
+   - Auto-select if only one active change exists
+   - If ambiguous, run `rtk openspec list --json` to get available changes and use the **AskUserQuestion tool** to let the user select
+
+   Always announce: "Using change: <name>" and how to override (e.g., `/opsx-apply <other>`).
+
+2. **Check status to understand the schema**
+
+   ```bash
+   rtk openspec status --change "<name>" --json
+   ```
+
+   Parse the JSON to understand:
+   - `schemaName`: The workflow being used (e.g., "spec-driven")
+   - Which artifact contains the tasks (typically "tasks" for spec-driven, check status for others)
+
+3. **Get apply instructions**
+
+   ```bash
+   rtk openspec instructions apply --change "<name>" --json
+   ```
+
+   This returns:
+   - `contextFiles`: artifact ID -> array of concrete file paths (varies by schema)
+   - Progress (total, complete, remaining)
+   - Task list with status
+   - Dynamic instruction based on current state
+
+   **Handle states:**
+   - If `state: "blocked"` (missing artifacts): show message, suggest using `/opsx-continue`
+   - If `state: "all_done"`: congratulate, suggest archive with `/opsx-archive`
+   - Otherwise: proceed to implementation
+
+4. **Read context files**
+
+   Read every file path listed under `contextFiles` from the apply instructions output.
+   Do NOT tell agents to read files themselves, summarize the content here and pass it in spawn prompts.
+
+5. **Show current progress**
+
+   Display:
+   - Schema being used
+   - Progress: "N/M tasks complete"
+   - Remaining tasks overview
+
+6. **Implement via ensemble team**
+
+   NEVER implement tasks directly. Always delegate to specialists via ensemble.
+   Do NOT touch any source files before the team is running, not even a single edit.
+
+   Steps MUST be followed in order. Do not skip any step.
+
+   **Step 6a.** Create feature branch if not already on one: `feature/{id}-{slug}`
+
+   **Step 6b.** Create the team:
+      ```
+      team_create "<change-name>-<random 4 digit number>"
+      ```
+      Announce: "Team running. Monitor at http://localhost:4747/"
+
+   **Step 6c.** Add ALL tasks to the shared board BEFORE spawning anyone.
+      Schema: { content: string, priority: "high"|"medium"|"low", depends_on?: string[] }
+      Use depends_on to block tasks that require other tasks first, pass the IDs returned by team_tasks_add.
+      ```
+      team_tasks_add tasks:[
+        { content: "1.1 <exact task text from tasks.md>", priority: "high" },
+        { content: "1.2 <exact task text>", priority: "high" },
+        { content: "3.1 <task that needs 1.x done first>", priority: "medium", depends_on: ["<id-of-1.1>"] },
+        ...every task, one entry each...
+      ]
+      ```
+      Save the task IDs returned. Pass them to agents in step 6d.
+      DO NOT call team_claim yourself, only agents claim tasks.
+      DO NOT proceed to 6d until team_tasks_add succeeds.
+
+   **Step 6d.** Spawn all needed specialists, then kick them off in parallel.
+
+      Each team_spawn MUST include the agent field (required, causes NOT NULL error if omitted).
+
+      The spawn prompt must contain exactly:
+      1. Their name and role on this team
+      2. Which tasks are theirs, list the task IDs and content from the board
+      3. Key context they need (summarized from context files, do NOT tell them to read files themselves)
+      4. The 6 OpenCode tools they have available (these are OpenCode tools, NOT shell commands, call them directly as tools, never via bash):
+         team_claim, team_tasks_complete, team_tasks_list, team_tasks_add, team_message, team_broadcast
+      5. How to proceed: call team_claim tool with the task_id to claim a task before starting it, call team_tasks_complete tool after finishing it, repeat until all their tasks are done, then call team_message tool to notify lead with results or blockers
+
+      Keep spawn prompts under 500 tokens. Do not describe team internals or how ensemble works.
+      Only spawn agents whose tasks are actually needed by this change. Skip agents with no tasks.
+
+      First spawn all agents (wait for each team_spawn to confirm before the next):
+      ```
+      team_spawn name:"back" agent:"back-engineer" prompt:"..."
+      (wait for result)
+      team_spawn name:"front" agent:"front-engineer" prompt:"..."
+      (wait for result)
+      team_spawn name:"infra" agent:"infra-engineer" prompt:"..."
+      (wait for result)
+      ```
+
+      Then immediately send each spawned agent a start message to kick them off:
+      ```
+      team_message to:"back" text:"Start now. Claim your first task with team_claim and begin implementing."
+      team_message to:"front" text:"Start now. Claim your first task with team_claim and begin implementing."
+      team_message to:"infra" text:"Start now. Claim your first task with team_claim and begin implementing."
+      ```
+
+   **Step 6e.** After sending start messages, tell the user what is running, then STOP and wait.
+      Do NOT call team_results, team_status, or team_broadcast in a loop.
+      Teammates will message you when done or blocked. Wait for those messages.
+
+   **Step 6f.** When a teammate messages back, you receive a ping only, the full content is NOT in the notification.
+      Call team_results to read the full message and mark it read. Then for each teammate: team_shutdown → team_merge.
+      If team_merge blocks ("overlapping local changes"), commit or stash your local changes first, then retry.
+      Fix any other blockers reported.
+
+7. **Quality check**
+
+   Spawn quality engineer with worktree:false (read-only, no file edits):
+   ```
+   team_spawn name:"quality" agent:"quality-engineer" worktree:false prompt:"<task list, context summary, run tests + build + lint + verify acceptance criteria, send results to lead when done>"
+   ```
+   Wait for message → team_results → fix blockers → team_shutdown (no team_merge needed, worktree:false)
+
+8. **Mark tasks complete in openspec**
+
+   Update tasks.md: `- [ ]` → `- [x]` for each completed task.
+   Run `rtk openspec status --change "<name>" --json` to confirm.
+
+9. **Show status, then cleanup**
+
+   Display:
+   - Tasks completed this session
+   - Overall progress: "N/M tasks complete"
+   - If all done: suggest archive with `/opsx-archive`
+   - If paused: explain why and wait for guidance
+
+   Then run `team_cleanup`.
+
+**Guardrails**
+- NEVER skip or reorder steps 6a-6f
+- NEVER implement tasks directly. Always use team_create + team_spawn, no exceptions
+- NEVER touch source files before team_create is called, not even one edit
+- NEVER call team_spawn without the agent field, it is required and will fail without it
+- NEVER call team_spawn before team_tasks_add, tasks must exist before agents are spawned
+- NEVER poll team_results or team_status in a loop, wait for teammates to message you
+- NEVER call team_claim or team_tasks_complete as lead, only agents call these tools
+- ALWAYS pass the task IDs returned by team_tasks_add to each agent's spawn prompt
+- NEVER edit files between team_spawn and team_merge, team_merge blocks on overlapping local changes
+- ALWAYS add every task to the board with team_tasks_add before spawning
+- ALWAYS spawn agents sequentially (wait for each team_spawn result before the next), then send start messages to all of them together
+- ALWAYS instruct agents to call team_claim before each task and team_tasks_complete after
+- If teammates are stuck, use team_message to resend tasks, then wait, never implement directly
+- Mark tasks complete in openspec AFTER specialists finish, not before
+- Pause on errors, blockers, or unclear requirements. Do not guess
+- Use contextFiles from CLI output, do not assume specific file paths
+- Use `rtk` wrapper for ALL CLI commands. Never run openspec, git, gh, or az directly

package/content/.opencode/plugins/session-log.js

@@ -3,7 +3,7 @@ import path from "node:path"
 
 const LOG_FILE = ".agents/session-log.json"
 
-// Per-session state: editCount and skills loaded
+// Per-session state: editCount and loaded skills
 const sessionState = new Map()
 
 function ts() {
@@ -32,6 +32,45 @@ function resolveAgentName(session) {
   return "lead"
 }
 
+function addSkillToState(state, skillName) {
+  if (!skillName || !state) return false
+  if (!state.skills) state.skills = new Set()
+  if (state.skills.has(skillName)) return false
+  state.skills.add(skillName)
+  return true
+}
+
+function buildTeamSkillsSummary() {
+  const byAgent = {}
+  for (const state of sessionState.values()) {
+    if (!state?.agentName) continue
+    if (!byAgent[state.agentName]) byAgent[state.agentName] = new Set()
+    for (const skill of state.skills ?? []) byAgent[state.agentName].add(skill)
+  }
+
+  const summary = {}
+  for (const [agent, skills] of Object.entries(byAgent)) {
+    summary[agent] = Array.from(skills).sort()
+  }
+  return summary
+}
+
+// Maps ensemble tool name → function that extracts the log entry fields from args
+const ENSEMBLE_TOOL_HANDLERS = {
+  team_create:         (args) => ({ action: "team-created",        team: args.name }),
+  team_spawn:          (args) => ({ action: "teammate-spawned",    name: args.name, agentType: args.agent }),
+  team_shutdown:       (args) => ({ action: "teammate-shutdown",   name: args.name }),
+  team_merge:          (args) => ({ action: "teammate-merged",     name: args.name }),
+  team_cleanup:        ()     => ({ action: "team-cleanup" }),
+  team_status:         ()     => ({ action: "team-status-checked" }),
+  team_results:        (args) => ({ action: "team-results-read",   from: args.from }),
+  team_message:        (args) => ({ action: "team-message",        to: args.to ?? "lead", preview: String(args.text ?? "").slice(0, 120) }),
+  team_broadcast:      (args) => ({ action: "team-broadcast",      preview: String(args.text ?? "").slice(0, 120) }),
+  team_tasks_add:      (args) => ({ action: "tasks-added",         count: Array.isArray(args.tasks) ? args.tasks.length : "?" }),
+  team_tasks_complete: (args) => ({ action: "task-completed",      taskId: args.task_id }),
+  team_claim:          (args) => ({ action: "task-claimed",        taskId: args.task_id }),
+}
+
 export const SessionLogPlugin = async ({ client, directory }) => {
   return {
     event: async ({ event }) => {
@@ -44,7 +83,7 @@ export const SessionLogPlugin = async ({ client, directory }) => {
           const session = res?.data
           const agentName = resolveAgentName(session)
 
-          sessionState.set(sessionId, { agentName, editCount: 0, skills: [] })
+          sessionState.set(sessionId, { agentName, editCount: 0, skills: new Set() })
           appendEntry(directory, { ts: ts(), agent: agentName, action: "started", sessionId })
         }
 
@@ -61,7 +100,8 @@ export const SessionLogPlugin = async ({ client, directory }) => {
           const state = sessionState.get(sessionId)
           if (!state) return
 
-          const { agentName, editCount, skills } = state
+          const { agentName, editCount } = state
+          const skills = Array.from(state.skills ?? []).sort()
           appendEntry(directory, { ts: ts(), agent: agentName, action: "completed", filesEdited: editCount, skills })
           sessionState.delete(sessionId)
         }
@@ -76,14 +116,43 @@ export const SessionLogPlugin = async ({ client, directory }) => {
         const state = sessionState.get(sessionId)
         if (!state) return
 
-        if (input?.tool === "read") {
+        const tool = input?.tool
+
+        // Track skill loads via skill tool (primary)
+        if (tool === "skill") {
+          const skillName = input?.args?.name
+          const added = addSkillToState(state, skillName)
+          if (added) {
+            appendEntry(directory, { ts: ts(), agent: state.agentName, action: "skill-loaded", skill: skillName, source: "skill-tool" })
+          }
+          return
+        }
+
+        // Track skill loads via reading SKILL.md (fallback)
+        if (tool === "read") {
           const filePath = input?.args?.filePath ?? ""
           const match = filePath.match(/[/\\]skills[/\\]([^/\\]+)[/\\]SKILL\.md$/i)
           if (match) {
             const skillName = match[1]
-            if (!state.skills.includes(skillName)) state.skills.push(skillName)
-            appendEntry(directory, { ts: ts(), agent: state.agentName, action: "skill-loaded", skill: skillName })
+            const added = addSkillToState(state, skillName)
+            if (added) {
+              appendEntry(directory, { ts: ts(), agent: state.agentName, action: "skill-loaded", skill: skillName, source: "read-skill-file" })
+            }
           }
+          return
+        }
+
+        const args = input?.args ?? {}
+
+        // Track ensemble tool calls
+        const ensembleHandler = ENSEMBLE_TOOL_HANDLERS[tool]
+        if (!ensembleHandler) return
+
+        const entry = { ts: ts(), agent: state.agentName, ...ensembleHandler(args) }
+        appendEntry(directory, entry)
+
+        if (tool === "team_cleanup") {
+          appendEntry(directory, { ts: ts(), agent: state.agentName, action: "team-skills-summary", byAgent: buildTeamSkillsSummary() })
         }
       } catch (_) {}
     },

package/content/.opencode/skills/openspec-apply-change/SKILL.md

@@ -0,0 +1,176 @@
+---
+name: openspec-apply-change
+description: Implement tasks from an OpenSpec change via ensemble agent team. Use when the user wants to start implementing, continue implementation, or work through tasks.
+license: MIT
+compatibility: Requires openspec CLI and opencode-ensemble plugin.
+metadata:
+  author: openspec-onboard
+  version: "2.0"
+---
+
+Implement tasks from an OpenSpec change using the ensemble agent team.
+
+**Input**: Optionally specify a change name. If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
+
+**Steps**
+
+1. **Select the change**
+
+   If a name is provided, use it. Otherwise:
+   - Infer from conversation context if the user mentioned a change
+   - Auto-select if only one active change exists
+   - If ambiguous, run `rtk openspec list --json` to get available changes and use the **AskUserQuestion tool** to let the user select
+
+   Always announce: "Using change: <name>" and how to override (e.g., `/opsx-apply <other>`).
+
+2. **Check status to understand the schema**
+
+   ```bash
+   rtk openspec status --change "<name>" --json
+   ```
+
+   Parse the JSON to understand:
+   - `schemaName`: The workflow being used (e.g., "spec-driven")
+   - Which artifact contains the tasks (typically "tasks" for spec-driven, check status for others)
+
+3. **Get apply instructions**
+
+   ```bash
+   rtk openspec instructions apply --change "<name>" --json
+   ```
+
+   This returns:
+   - `contextFiles`: artifact ID -> array of concrete file paths (varies by schema - could be proposal/specs/design/tasks or spec/tests/implementation/docs)
+   - Progress (total, complete, remaining)
+   - Task list with status
+   - Dynamic instruction based on current state
+
+   **Handle states:**
+   - If `state: "blocked"` (missing artifacts): show message, suggest using openspec-continue-change
+   - If `state: "all_done"`: congratulate, suggest archive with `/opsx-archive`
+   - Otherwise: proceed to implementation
+
+4. **Read context files**
+
+   Read every file path listed under `contextFiles` from the apply instructions output.
+   Do NOT tell agents to read files themselves, summarize the content here and pass it in spawn prompts.
+
+5. **Show current progress**
+
+   Display:
+   - Schema being used
+   - Progress: "N/M tasks complete"
+   - Remaining tasks overview
+
+6. **Implement via ensemble team**
+
+   NEVER implement tasks directly. Always delegate to specialists via ensemble.
+   Do NOT touch any source files before the team is running, not even a single edit.
+
+   Steps MUST be followed in order. Do not skip any step.
+
+   **Step 6a.** Create feature branch if not already on one: `feature/{id}-{slug}`
+
+   **Step 6b.** Create the team:
+      ```
+      team_create "<change-name>-<random 4 digit number>"
+      ```
+      Announce: "Team running. Monitor at http://localhost:4747/"
+
+   **Step 6c.** Add ALL tasks to the shared board BEFORE spawning anyone.
+      Schema: { content: string, priority: "high"|"medium"|"low", depends_on?: string[] }
+      Use depends_on to block tasks that require other tasks first, pass the IDs returned by team_tasks_add.
+      ```
+      team_tasks_add tasks:[
+        { content: "1.1 <exact task text from tasks.md>", priority: "high" },
+        { content: "1.2 <exact task text>", priority: "high" },
+        { content: "3.1 <task that needs 1.x done first>", priority: "medium", depends_on: ["<id-of-1.1>"] },
+        ...every task, one entry each...
+      ]
+      ```
+      Save the task IDs returned. Pass them to agents in step 6d.
+      DO NOT call team_claim yourself, only agents claim tasks.
+      DO NOT proceed to 6d until team_tasks_add succeeds.
+
+   **Step 6d.** Spawn all needed specialists, then kick them off in parallel.
+
+      Each team_spawn MUST include the agent field (required, causes NOT NULL error if omitted).
+
+      The spawn prompt must contain exactly:
+      1. Their name and role on this team
+      2. Which tasks are theirs, list the task IDs and content from the board
+      3. Key context they need (summarized from context files, do NOT tell them to read files themselves)
+      4. The 6 OpenCode tools they have available (these are OpenCode tools, NOT shell commands, call them directly as tools, never via bash):
+         team_claim, team_tasks_complete, team_tasks_list, team_tasks_add, team_message, team_broadcast
+      5. How to proceed: call team_claim tool with the task_id to claim a task before starting it, call team_tasks_complete tool after finishing it, repeat until all their tasks are done, then call team_message tool to notify lead with results or blockers
+
+      Keep spawn prompts under 500 tokens. Do not describe team internals or how ensemble works.
+      Only spawn agents whose tasks are actually needed by this change. Skip agents with no tasks.
+
+      First spawn all agents (wait for each team_spawn to confirm before the next):
+      ```
+      team_spawn name:"back" agent:"back-engineer" prompt:"..."
+      (wait for result)
+      team_spawn name:"front" agent:"front-engineer" prompt:"..."
+      (wait for result)
+      team_spawn name:"infra" agent:"infra-engineer" prompt:"..."
+      (wait for result)
+      ```
+
+      Then immediately send each spawned agent a start message to kick them off:
+      ```
+      team_message to:"back" text:"Start now. Claim your first task with team_claim and begin implementing."
+      team_message to:"front" text:"Start now. Claim your first task with team_claim and begin implementing."
+      team_message to:"infra" text:"Start now. Claim your first task with team_claim and begin implementing."
+      ```
+
+   **Step 6e.** After sending start messages, tell the user what is running, then STOP and wait.
+      Do NOT call team_results, team_status, or team_broadcast in a loop.
+      Teammates will message you when done or blocked. Wait for those messages.
+
+   **Step 6f.** When a teammate messages back, you receive a ping only, the full content is NOT in the notification.
+      Call team_results to read the full message and mark it read. Then for each teammate: team_shutdown → team_merge.
+      If team_merge blocks ("overlapping local changes"), commit or stash your local changes first, then retry.
+      Fix any other blockers reported.
+
+7. **Quality check**
+
+   Spawn quality engineer with worktree:false (read-only, no file edits):
+   ```
+   team_spawn name:"quality" agent:"quality-engineer" worktree:false prompt:"<task list, context summary, run tests + build + lint + verify acceptance criteria, send results to lead when done>"
+   ```
+   Wait for message → team_results → fix blockers → team_shutdown (no team_merge needed, worktree:false)
+
+8. **Mark tasks complete in openspec**
+
+   Update tasks.md: `- [ ]` → `- [x]` for each completed task.
+   Run `rtk openspec status --change "<name>" --json` to confirm.
+
+9. **Show status, then cleanup**
+
+   Display:
+   - Tasks completed this session
+   - Overall progress: "N/M tasks complete"
+   - If all done: suggest archive with `/opsx-archive`
+   - If paused: explain why and wait for guidance
+
+   Then run `team_cleanup`.
+
+**Guardrails**
+- NEVER skip or reorder steps 6a-6f
+- NEVER implement tasks directly. Always use team_create + team_spawn, no exceptions
+- NEVER touch source files before team_create is called, not even one edit
+- NEVER call team_spawn without the agent field, it is required and will fail without it
+- NEVER call team_spawn before team_tasks_add, tasks must exist before agents are spawned
+- NEVER poll team_results or team_status in a loop, wait for teammates to message you
+- NEVER call team_claim or team_tasks_complete as lead, only agents call these tools
+- ALWAYS pass the task IDs returned by team_tasks_add to each agent's spawn prompt
+- NEVER edit files between team_spawn and team_merge, team_merge blocks on overlapping local changes
+- ALWAYS add every task to the board with team_tasks_add before spawning
+- ALWAYS spawn agents sequentially (wait for each team_spawn result before the next), then send start messages to all of them together
+- ALWAYS instruct agents to call team_claim before each task and team_tasks_complete after
+- If teammates are stuck, use team_message to resend tasks, then wait, never implement directly
+- Mark tasks complete in openspec AFTER specialists finish, not before
+- Pause on errors, blockers, or unclear requirements. Do not guess
+- Use contextFiles from CLI output, do not assume specific file paths
+- Use `rtk` wrapper for ALL CLI commands. Never run openspec, git, gh, or az directly

package/content/AGENTS.md

@@ -40,7 +40,7 @@ openspec archive "project-history"
 1. **Read `DESIGN.md` now** using a file read tool. The file contains a prompt with instructions and an output format.
 2. **Store the full prompt text** in your context.
 3. **Overwrite `DESIGN.md` with an empty string** (zero bytes). Do this before generating any content.
-4. **Analyze the actual codebase**: read CSS files, Tailwind config, component files, token definitions. Do not rely on prior knowledge, read the files.
+4. **Analyze the actual codebase**: use `.agents/source-roots.json` as source roots when present, then read CSS files, Tailwind config, component files, token definitions. Do not rely on prior knowledge, read the files.
 5. **Write the result into `DESIGN.md`** following exactly the format and sections described in the stored prompt.
 
 The output must be a real, populated `DESIGN.md` based on what you found in the codebase, not from memory or assumptions.
@@ -54,7 +54,7 @@ The output must be a real, populated `DESIGN.md` based on what you found in the
 1. **Read `ARCHITECTURE.md` now** using a file read tool. The file contains a prompt with instructions and an output format.
 2. **Store the full prompt text** in your context.
 3. **Overwrite `ARCHITECTURE.md` with an empty string** (zero bytes). Do this before generating any content.
-4. **Analyze the actual codebase**: read folder structure, config files, route definitions, data models, integration points. Do not rely on prior knowledge, read the files.
+4. **Analyze the actual codebase**: use `.agents/source-roots.json` as source roots when present, then read folder structure, config files, route definitions, data models, integration points. Do not rely on prior knowledge, read the files.
 5. **Write the result into `ARCHITECTURE.md`** following exactly the format and sections described in the stored prompt.
 
 The output must be a real, populated `ARCHITECTURE.md` based on what you found in the codebase, covering all sections the prompt describes.
@@ -72,14 +72,20 @@ Replace the entire contents of this file (`AGENTS.md`) with everything below the
 Tell the user:
 
 ```
-Initialization complete.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Initialization complete.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 - ARCHITECTURE.md generated
 - DESIGN.md generated
 - Project history archived in openspec
 - AGENTS.md updated with real guidance
 
-You're ready to work.
+!! RESTART OPENCODE NOW !!
+
+Quit and reopen OpenCode before doing anything else.
+Nothing will work correctly until you do.
+After restarting you are ready to work.
 ```
 
 ---
@@ -108,13 +114,15 @@ This is the agent orchestration layer for your project. It provides:
 
 ## I Am the Lead, Full Workflow Ownership
 
-When the user provides a work item URL, says "implement the plan", or "I've added comments to the PR", **I own the full lifecycle**. I load the appropriate skill and use ensemble tools (`team_create`, `team_spawn`, etc.) to coordinate the agent team.
+When the user provides a work item URL or says "implement the plan" or "I've added comments to the PR", **I own the full lifecycle**. I load the appropriate skill and use ensemble tools to coordinate the agent team.
+
+Trigger patterns, I recognize ALL of these, exact wording does not matter:
+- User pastes or mentions a GitHub Issue URL → load `ob-userstory-gh` skill → parse issue → run `/opsx-propose` → confirm with user → run `/opsx-apply` → ship
+- User pastes or mentions an Azure DevOps URL → load `ob-userstory-az` skill → parse work item → run `/opsx-propose` → confirm with user → run `/opsx-apply` → ship
+- `implement the plan` / `implement` / `start` / `go` → run `/opsx-apply` → ship
+- `I've added comments to the PR` → read PR comments → fix → update PR
 
-Trigger patterns:
-- `work on this <azure-devops-url>` → spawn `devops-manager` in read mode → propose OpenSpec → **confirm with user** → implement → ship
-- `work on this <github-url>` → spawn `devops-manager` in read mode → propose OpenSpec → **confirm with user** → implement → ship
-- `implement the plan` → run `/opsx-apply` (ensemble orchestration is built into the command) → ship
-- `I've added comments to the PR` → spawn `devops-manager` in feedback mode → fix → update PR
+**A GitHub or Azure DevOps URL anywhere in the user's message is always a trigger, regardless of surrounding words.**
 
 **Never delegate without a plan. Never write implementation code directly, always spawn specialists, no exceptions. "Small feature", "faster to do it directly", or "environment issues" are not valid reasons to skip ensemble.**
 
@@ -130,11 +138,14 @@ Works on **all platforms** (Windows, macOS, Linux) via OpenCode's built-in workt
 | `team_shutdown` | Stop a teammate, preserve their branch |
 | `team_merge` | Merge a teammate's branch into working dir |
 | `team_cleanup` | Tear down the team |
-| `team_results` | Retrieve full message from a teammate |
-| `team_message` | Send a direct message to a teammate |
+| `team_results` | Retrieve full message content (delivery is a ping only) |
+| `team_message` | Send a direct message to a teammate or lead |
 | `team_broadcast` | Message all teammates |
+| `team_status` | View all members and task summary |
+| `team_tasks_list` | View the shared task board |
 | `team_tasks_add` | Add tasks to shared board |
-| `team_tasks_complete` | Mark task done |
+| `team_tasks_complete` | Mark task done, auto-unblocks dependents |
+| `team_claim` | Atomically claim a pending task (teammates use this) |
 
 **Dashboard**: Monitor running agents at **http://localhost:4747/**
 
@@ -151,12 +162,12 @@ devops-manager (read mode)
         ↓
   [confirm with user]
         ↓
-front-engineer + back-engineer + infra-engineer  ← parallel, only spawn what the task needs
+back-engineer → front-engineer → infra-engineer  ← sequential, one at a time, only spawn what the task needs
         ↓
-quality-engineer
+quality-engineer (worktree:false)
   → tests, build, lint, acceptance criteria
         ↓
-security-auditor
+security-auditor (worktree:false)
   → vulnerability audit, secrets, auth gaps
         ↓
 devops-manager (ship mode)
@@ -166,32 +177,35 @@ devops-manager (ship mode)
 ### Phase 1, Parse & Propose
 
 ```
-1. team_spawn devops-manager (read mode) → fetch work item via skill, output summary
-2. Load skill: openspec-propose → generate proposal.md, specs/, tasks.md
-   - team_create → spawn design + specs in parallel → merge → write tasks.md
-3. Show the plan: change name, schema, total tasks, task list summary
-4. STOP. Ask user: "Ready to implement? (yes/no)", DO NOT proceed until confirmed.
+1. Detect URL type → load matching skill (ob-userstory-gh or ob-userstory-az)
+2. Follow skill steps: fetch issue/work item via CLI, create OpenSpec change
+3. Run /opsx-propose → generates proposal.md, specs/, design.md, tasks.md
+4. Show the plan: change name, total tasks, task list summary
+5. STOP. Ask user: "Ready to implement? (yes/no)", DO NOT proceed until confirmed.
 ```
 
 ### Phase 2, Implement
 
 ```
 1. Run /opsx-apply, handles context reading, ensemble orchestration, and task marking.
+   - Lead adds all tasks to board, then spawns specialists ONE AT A TIME (not parallel)
+   - Each specialist claims tasks, implements, completes tasks, messages lead when done
+   - Lead merges each branch after shutdown, then marks tasks done in tasks.md
 2. After /opsx-apply completes, proceed to quality check.
 ```
 
 ### Phase 3, Quality
 
 ```
-7. team_spawn name:quality agent:quality-engineer → tests, build, lint
-8. Wait → team_results → fix any blockers → team_shutdown
+3. team_spawn name:quality agent:quality-engineer worktree:false → tests, build, lint
+4. Wait → team_results → fix any blockers → team_shutdown (no merge, worktree:false)
 ```
 
 ### Phase 4, Security
 
 ```
-9. team_spawn name:security agent:security-auditor → audit full change
-10. Wait → team_results → fix Critical findings → team_shutdown
+5. team_spawn name:security agent:security-auditor worktree:false → audit full change
+6. Wait → team_results → fix Critical findings → team_shutdown (no merge, worktree:false)
 ```
 
 ### Phase 5, Ship