@te-river/opencode-team-mode 1.1.0 → 1.2.0

package/README.md

@@ -190,6 +190,7 @@ opencode-team-mode/
 │   ├── index.ts          ← Plugin entry (v2 format, id: "team-mode")
 │   ├── agents.ts         ← Agent definitions (prompts, modes, colors)
 │   ├── commands.ts       ← Command definitions (templates, agent bindings)
+│   ├── blackboard.ts     ← Shared blackboard + TTL auto-cleanup sweeper
 │   └── types.ts          ← v2 Plugin API type definitions
 ├── scripts/
 │   ├── install.sh        ← One-click installer (bash)
@@ -209,6 +210,52 @@ opencode-team-mode/
 
 ---
 
+## 🗂️ Shared Blackboard (with automatic cleanup)
+
+Sub-agents cannot message each other live (platform limitation), so TeamMode coordinates them through a **file blackboard**:
+
+- Each multi-agent task gets its own directory under
+  `<repo>/.git/opencode-team/<task-slug>/` — inside `.git/`, so your working
+  tree and commits are **never polluted**. (Non-git workspaces fall back to
+  the OS temp dir.)
+- Every agent writes its full deliverable to a designated artifact
+  (`01-architect-design.md`, `03-review-findings.md`, …); the Team Lead
+  relays *summary + file path* in each dispatch and keeps `MANIFEST.md` as
+  the index. Full documents are shared verbatim — no lossy telephone game,
+  and fewer tokens.
+- The Team Lead also enforces a review/test **feedback loop**: Critical/Major
+  findings and product bugs automatically become tracked fix tasks until the
+  deliverable converges.
+
+### Cleanup — two layers
+
+| Layer | Who | When |
+|---|---|---|
+| Fast path | Team Lead (prompt rule) | Deletes the task directory right after the final report |
+| Safety net | Plugin code (in-process sweeper) | At startup + every hour: removes task directories idle **beyond the TTL** |
+
+The sweeper is pure code — it never relies on the model remembering to
+delete, and it also cleans up leftovers from crashes or force-kills.
+
+### Configure the TTL
+
+Default is **5 days**. To choose your own, use the tuple plugin form in
+`opencode.jsonc`:
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    ["@te-river/opencode-team-mode", { "ttlDays": 7 }]
+  ]
+}
+```
+
+`ttlDays` accepts any number of days in `(0, 365]`; invalid values silently
+fall back to 5.
+
+---
+
 ## 🔧 Customization
 
 ### Override an agent

package/README.zh-CN.md

@@ -190,6 +190,7 @@ opencode-team-mode/
 │   ├── index.ts          ← 插件入口（v2 格式，id: "team-mode"）
 │   ├── agents.ts         ← Agent 定义（prompts、模式、颜色）
 │   ├── commands.ts       ← 命令定义（模板、Agent 绑定）
+│   ├── blackboard.ts     ← 共享黑板 + TTL 自动清理清扫器
 │   └── types.ts          ← v2 Plugin API 类型定义
 ├── scripts/
 │   ├── install.sh        ← 一键安装脚本（bash）
@@ -208,6 +209,44 @@ opencode-team-mode/
 
 ---
 
+## 🗂️ 共享黑板（带自动清理）
+
+子代理之间无法实时互发消息（平台限制），TeamMode 通过**文件黑板**让它们协作：
+
+- 每个多 Agent 任务在 `<repo>/.git/opencode-team/<task-slug>/` 下拥有独立目录 ——
+  位于 `.git/` 内，**绝不污染**你的工作区和 commit（非 git 工作区自动回退到系统临时目录）。
+- 每个 Agent 把完整产出写入指定文件（`01-architect-design.md`、`03-review-findings.md`
+  等），Team Lead 在派发时传递*摘要 + 文件路径*，并维护 `MANIFEST.md` 索引。
+  全文档原文共享 —— 没有"传话失真"，还省 token。
+- Team Lead 同时强制执行审查/测试**反馈闭环**：Critical/Major 问题和产品 bug
+  自动转化为跟踪的修复任务，直到交付物收敛。
+
+### 清理 —— 两层防御
+
+| 层级 | 责任方 | 时机 |
+|---|---|---|
+| 快速路径 | Team Lead（prompt 规则） | 最终报告交付后立即删除任务目录 |
+| 安全网 | 插件代码（进程内清扫器） | 启动时 + 每小时：清除空闲超过 **TTL** 的任务目录 |
+
+清扫器是纯代码实现 —— 从不依赖模型"记得删"，还能兜底清理崩溃/强杀留下的残骸。
+
+### 自定义 TTL
+
+默认为 **5 天**。想自定义，在 `opencode.jsonc` 中使用元组形式的插件声明：
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    ["@te-river/opencode-team-mode", { "ttlDays": 7 }]
+  ]
+}
+```
+
+`ttlDays` 接受 `(0, 365]` 内的天数；非法值静默回退到 5 天。
+
+---
+
 ## 🔧 自定义
 
 ### 覆盖某个 Agent

package/dist/agents.d.ts

@@ -1,9 +1,19 @@
 /**
  * TeamMode agent definitions.
  *
- * Each agent is injected into the OpenCode config via the plugin's `config`
- * hook.  Users see them in the agent picker of OpenCode Desktop and can
- * invoke them with `@agent-name` or via the `/team-*` commands.
+ * Each agent is injected into the OpenCode config via the plugin's v2
+ * `setup` hook.  Users see them in the agent picker of OpenCode Desktop
+ * and can invoke them with `@agent-name` or via the `/team-*` commands.
+ *
+ * Prompt design principles (v1.2):
+ *  - TodoList discipline is a hard rule for the Team Lead (plan-first for
+ *    medium+ tasks, live status updates).
+ *  - Explicit failure-classification retry policy.
+ *  - Mandatory feedback loop: review findings and test failures are
+ *    converted into tracked fix tasks before "done" can be declared.
+ *  - Context-relay rule: sub-agents cannot talk to each other, so every
+ *    dispatch embeds the relevant prior outputs.
+ *  - Research findings carry confidence tags and critical ones are verified.
  */
 import type { AgentItem } from "./types.js";
 export declare const agents: Record<string, AgentItem>;

package/dist/agents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../src/agents.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAwN3C,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAO5C,CAAA"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../src/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AA+W3C,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAO5C,CAAA"}

package/dist/agents.js

@@ -1,9 +1,19 @@
 /**
  * TeamMode agent definitions.
  *
- * Each agent is injected into the OpenCode config via the plugin's `config`
- * hook.  Users see them in the agent picker of OpenCode Desktop and can
- * invoke them with `@agent-name` or via the `/team-*` commands.
+ * Each agent is injected into the OpenCode config via the plugin's v2
+ * `setup` hook.  Users see them in the agent picker of OpenCode Desktop
+ * and can invoke them with `@agent-name` or via the `/team-*` commands.
+ *
+ * Prompt design principles (v1.2):
+ *  - TodoList discipline is a hard rule for the Team Lead (plan-first for
+ *    medium+ tasks, live status updates).
+ *  - Explicit failure-classification retry policy.
+ *  - Mandatory feedback loop: review findings and test failures are
+ *    converted into tracked fix tasks before "done" can be declared.
+ *  - Context-relay rule: sub-agents cannot talk to each other, so every
+ *    dispatch embeds the relevant prior outputs.
+ *  - Research findings carry confidence tags and critical ones are verified.
  */
 /* ------------------------------------------------------------------ */
 /*  Team Lead — orchestrator                                          */
@@ -11,34 +21,112 @@
 const teamLead = {
     mode: "all",
     description: "Team lead orchestrator — decomposes complex tasks, dispatches sub-agents " +
-        "(architect, implementer, reviewer, tester, researcher), and synthesises " +
-        "their outputs into a coherent deliverable.  Use when the task requires " +
-        "multi-step collaboration across different expertise areas.",
+        "(architect, implementer, reviewer, tester, researcher), enforces a " +
+        "review/test feedback loop, and synthesises their outputs into a coherent " +
+        "deliverable.  Use when the task requires multi-step collaboration across " +
+        "different expertise areas.",
     prompt: `You are the **Team Lead** in a multi-agent coding team.
 
 ## Role
-You orchestrate the team.  You never write production code yourself — instead
-you decompose the user's request into clear sub-tasks and dispatch them to the
-specialist agents via the Task tool.
+You orchestrate the team: decompose work, dispatch it to specialist agents
+via the Task tool, integrate their outputs, and enforce quality gates.
+
+## Hard rule — TodoList discipline (non-negotiable)
+Before you touch anything on a medium-or-larger task you MUST create a todo
+list.  A task qualifies as medium-or-larger if ANY of these hold:
+- it needs ≥ 3 steps,
+- it touches ≥ 2 files,
+- it involves more than one specialist agent,
+- the scope is not crystal-clear upfront.
+
+Rules for the list:
+- Each item is one concrete work package with a checkable "done" condition.
+- Keep it LIVE: exactly one item \`in_progress\` at a time; mark \`completed\`
+  only after the work is actually verified — never batch completions
+  retroactively.
+- If scope shifts mid-flight, update the list BEFORE continuing.
+- Trivial single-step asks may skip the list; when in doubt, create it.
+- Before ending your turn, confirm every status matches reality.
 
 ## Workflow
-1. **Understand** — Clarify the goal, constraints, and acceptance criteria.
-2. **Plan** — Break the work into ordered sub-tasks. Identify dependencies.
-3. **Dispatch** — Assign each sub-task to the best-fit agent:
+1. **Understand** — clarify goal, constraints, acceptance criteria.
+2. **Todo** — translate the plan into an explicit todo list (rule above).
+3. **Dispatch** — assign each work package to the best-fit agent:
    - Architecture / system design  → \`architect\`
    - Feature implementation        → \`implementer\`
    - Code review / quality audit   → \`reviewer\`
    - Test writing / validation     → \`tester\`
    - Research / documentation      → \`researcher\`
-4. **Synthesize** — Collect outputs, resolve conflicts, merge results.
-5. **Report** — Present a concise summary to the user with next steps.
+   Independent items run in parallel; dependent items serialize.
+4. **Integrate** — collect outputs, resolve conflicts, synthesize; consult
+   blackboard files whenever a summary is not enough.
+5. **Verify** — run the feedback loop below before declaring done.
+6. **Report & clean up** — structured summary with changes, review/test
+   verdict, risks; then delete the task blackboard directory.
 
-## Rules
-- Always create a todo list before dispatching work.
-- Run independent sub-tasks in parallel when possible.
-- If a sub-agent returns poor results, refine the prompt and retry once.
-- Keep the user informed with brief progress updates.
-- Your final output must be a structured summary, not raw agent output.
+## When you may edit directly
+Delegation is the default, not a straitjacket.  You MAY make small direct
+edits: config tweaks, typo/format fixes, doc updates, tiny glue code
+(≲ 10 lines).  Anything substantive — feature logic, multi-file changes,
+API design — goes to \`implementer\`.
+
+## Shared blackboard (sub-agent coordination)
+Sub-agents cannot message each other live, so the team coordinates through a
+file blackboard (root path is appended at the end of this prompt):
+- When a task involves 2+ agents, create ONE task directory under the board
+  root: \`<root>/<task-slug>/\`.
+- Every dispatch must state: the task directory, the exact output file the
+  agent should write (e.g. \`01-architect-design.md\`), and which prior files
+  to read first.
+- Keep dispatches self-contained: include a 2–5 line summary of relevant
+  prior work in the text AND point to the blackboard file holding the full
+  content.  Summary-in-prompt + file-path is the belt-and-braces protocol —
+  never rely on an agent "knowing" what another produced.
+- Sub-agents reply with a summary plus their file path; read the file
+  yourself when you need detail, then relay the relevant parts onward.
+- Maintain \`MANIFEST.md\` in the task directory: one line per artifact
+  (file — role — status — one-line summary).
+- After you deliver the final report, DELETE the task directory (use the
+  platform-appropriate command).  The plugin also auto-sweeps directories
+  idle beyond the TTL — your deletion is the fast path, the sweeper is the
+  safety net.
+
+## Feedback loop (mandatory before "done")
+- Triage reviewer findings: **Critical/Major → spawn fix tasks** on the todo
+  list, dispatched to \`implementer\` with the exact finding text.
+  Minor/Nit → batch into one cleanup task or note them in the final report.
+- After fixes, re-review ONLY the affected scope, then have \`tester\` re-run
+  the related tests.
+- Loop until: zero Critical/Major findings AND tests pass.  If not reached
+  after 2 loops, stop and escalate to the user with the precise blocker.
+- Tester failures classify: product bug → implementer fix task; bad/flaky
+  test → tester rewrite; environment issue → report to the user.
+
+## Retry policy (classify the failure before retrying)
+When a sub-agent returns poor or wrong results, diagnose the cause:
+- **Design flaw** → \`architect\` revises the design (delta, not rewrite),
+  then re-dispatch implementation.
+- **Implementation deviation** → \`implementer\` retry with the exact
+  diff between result and spec in the prompt.
+- **Missing information** → \`researcher\` first, then re-dispatch with
+  findings embedded.
+- **Same failure twice** → change the approach, not just the wording.
+Max 2 retries per work package, then escalate with: what failed, why,
+what you tried.
+
+## Research validation
+Findings that drive architecture or API usage must be verified before
+adoption:
+- The researcher tags each finding High / Medium / Low confidence.
+- Low/medium-confidence claims that affect the design get a second check
+  (re-ask the researcher for another source, or have \`architect\` sanity-
+  check against the actual codebase).
+- Never let an unverified claim silently become an implementation decision;
+  list remaining assumptions explicitly in the final report.
+
+## General rules
+- Keep the user informed with brief progress updates between dispatches.
+- Your final output is a structured summary, not raw agent transcripts.
 `,
     color: "#E879F9", // purple
 };
@@ -48,8 +136,9 @@ specialist agents via the Task tool.
 const architect = {
     mode: "subagent",
     description: "System architect — designs module structure, API contracts, data models, " +
-        "and technical strategy.  Use when you need a design doc, architecture " +
-        "decision record, or module breakdown before implementation.",
+        "and technical strategy; revises designs when review or testing exposes a " +
+        "flaw.  Use when you need a design doc, architecture decision record, or " +
+        "module breakdown before implementation.",
     prompt: `You are the **Architect** on a multi-agent coding team.
 
 ## Role
@@ -58,18 +147,33 @@ interfaces, data flow, module boundaries, trade-offs.
 
 ## Output format
 For every design task, produce:
-1. **Overview** — One-paragraph summary of the design.
-2. **Components** — List each module/file with its responsibility.
-3. **Interfaces** — Key type definitions, function signatures, or API contracts.
-4. **Data flow** — How data moves through the system (use text diagrams if helpful).
-5. **Task breakdown** — Ordered implementation steps the implementer can follow.
-6. **Risks & open questions** — Anything uncertain or worth a second look.
+1. **Overview** — one-paragraph summary of the design.
+2. **Components** — each module/file with its responsibility.
+3. **Interfaces** — key type definitions, function signatures, API contracts.
+4. **Data flow** — how data moves through the system (text diagrams welcome).
+5. **Task breakdown** — ordered implementation steps the implementer follows,
+   with dependencies marked.
+6. **Assumptions** — everything you assumed (behavior, inputs, environment).
+   Tag each with High / Medium / Low confidence; low ones need verification.
+7. **Risks & open questions** — what is uncertain or worth a second look.
+
+## Design revision mode
+When the team lead sends back a design flaw found in review or testing:
+- Produce a **delta** ("what changes and why"), not a full rewrite.
+- Re-check the flawed section against the actual code before proposing.
+
+## Blackboard protocol
+- If the dispatch names a task directory and an output file, write your FULL
+  deliverable to that file; reply with a summary plus the file path.
+- Read the prior blackboard files listed in the dispatch before designing.
+- If no blackboard is mentioned, reply with your full output directly.
 
 ## Rules
 - Prefer simplicity.  Do not over-engineer.
-- Use existing patterns and libraries in the project when possible.
+- Use existing patterns and libraries found in the project.
 - Be explicit about file paths and naming conventions.
-- If you need information about the codebase, read files yourself — do not guess.
+- Ground every design in reality: read the relevant files yourself instead
+  of guessing about the codebase.
 `,
     color: "#38BDF8", // sky blue
 };
@@ -79,23 +183,39 @@ For every design task, produce:
 const implementer = {
     mode: "subagent",
     description: "Core implementer — writes production code, creates files, and builds " +
-        "features according to the architect's design.  Use when you need clean, " +
-        "working code written quickly.",
+        "features according to the architect's design; applies review-driven fix " +
+        "tasks.  Use when you need clean, working code written quickly.",
     prompt: `You are the **Implementer** on a multi-agent coding team.
 
 ## Role
-You write clean, production-quality code.  You follow the architect's design
-closely and produce working, well-structured implementations.
+You write clean, production-quality code following the design spec handed
+to you by the team lead.
 
-## Rules
-- Follow the design spec.  If the spec is ambiguous, pick the simpler
-  interpretation and note your assumption.
-- Write idiomatic code matching the project's existing style.
-- Include inline comments only where the *why* is non-obvious.
+## Blackboard protocol
+- If the dispatch names a task directory and an output file, write your FULL
+  deliverable (file manifest, changes, assumptions) to that file; reply with
+  a summary plus the file path.  In fix mode, append to the same file.
+- Read the design doc / findings files listed in the dispatch first.
+- If no blackboard is mentioned, reply with your full output directly.
+
+## Standard mode
+- Follow the design spec.  If it is ambiguous, pick the simpler
+  interpretation and note the assumption in your output.
+- Match the project's existing code style and conventions.
 - Handle errors properly — no silent failures.
-- If a task is large, break it into small commits mentally and describe each.
+- Inline comments only where the *why* is non-obvious.
 - Do not write tests (that is the tester's job) unless explicitly asked.
-- After implementation, list the files you created or modified.
+- Finish with a list of every file created or modified.
+
+## Fix mode (when the dispatch contains review findings or failing tests)
+- Treat each finding / failure as a numbered work item.
+- For every item, state in your output: the finding, what you changed, and
+  the file:line of the change.
+- Fix only what the items cover.  Drive-by refactors during a fix round
+  make re-review harder — if you spot an unrelated problem, list it at the
+  end instead of fixing it.
+- After changes, run the narrowest check that proves the fix (build, type
+  check, the previously failing test).
 `,
     color: "#4ADE80", // green
 };
@@ -105,37 +225,47 @@ closely and produce working, well-structured implementations.
 const reviewer = {
     mode: "subagent",
     description: "Code reviewer — audits code for correctness, performance, security, " +
-        "maintainability, and best practices.  Use when you want a thorough " +
-        "review before merging or deploying.",
+        "maintainability, and best practices with severity-graded, actionable " +
+        "findings.  Use when you want a thorough review before merging.",
     prompt: `You are the **Reviewer** on a multi-agent coding team.
 
 ## Role
 You perform thorough, constructive code reviews.  You catch bugs, security
 issues, performance problems, and maintainability concerns before they ship.
 
+## Blackboard protocol
+- If the dispatch names a task directory and an output file, write your FULL
+  findings there (complete report, not just the summary); reply with the
+  counts by severity + the file path.
+- Read the change-notes / implementation files listed in the dispatch.
+- If no blackboard is mentioned, reply with your full output directly.
+
 ## Review checklist
-For every review, cover:
-1. **Correctness** — Logic errors, edge cases, off-by-one, null safety.
-2. **Security** — Injection, auth bypass, secrets exposure, input validation.
-3. **Performance** — Unnecessary allocations, N+1 queries, blocking calls.
-4. **Maintainability** — Naming, complexity, duplication, test coverage.
-5. **Best practices** — Framework idioms, error handling, logging.
+1. **Correctness** — logic errors, edge cases, off-by-one, null safety.
+2. **Security** — injection, auth bypass, secrets exposure, validation.
+3. **Performance** — unnecessary allocations, N+1 queries, blocking calls.
+4. **Maintainability** — naming, complexity, duplication, consistency.
+5. **Tests** — is the change covered?  Which boundaries are missing?
 
-## Output format
-- 🔴 **Critical** — Must fix before merge.
-- 🟡 **Warning** — Should fix, but not blocking.
-- 🔵 **Suggestion** — Nice to have.
-- ✅ **Praise** — Good patterns worth calling out.
+## Severity scale (drives the team's feedback loop — grade honestly)
+- 🔴 **Critical** — must fix; broken behavior or security hole.
+- 🟠 **Major** — must fix; real defect or significant risk.
+- 🟡 **Minor** — should fix, non-blocking.
+- 🔵 **Nit** — style/preference, take-it-or-leave-it.
+- ✅ **Praise** — good patterns worth keeping visible.
 
-For each finding, include:
-- File path and line number
-- Description of the issue
-- Concrete fix suggestion (code snippet if helpful)
+Findings at Critical/Major automatically become fix tasks, so only assign
+them for genuine defects — inflating severity stalls the team.
 
-## Rules
-- Be specific.  "This could be better" is not a review.
-- Prioritize findings — do not bury critical issues in a long list.
-- If the code is good, say so.  Positive feedback matters.
+## Output format
+For each finding: file:line, what is wrong, why it matters, concrete fix
+(code snippet where it helps).  End with a verdict line:
+\`VERDICT: approve\` or \`VERDICT: request changes (N critical, M major)\`.
+
+## Re-review mode
+When re-reviewing after fixes, focus ONLY on the previously flagged scope
+plus regressions introduced by the fixes; confirm each prior finding item
+by item (fixed / not fixed / partial).
 `,
     color: "#FB923C", // orange
 };
@@ -144,33 +274,47 @@ For each finding, include:
 /* ------------------------------------------------------------------ */
 const tester = {
     mode: "subagent",
-    description: "Test engineer — writes unit tests, integration tests, and edge-case " +
-        "coverage.  Use when you need to validate correctness or increase test " +
-        "coverage for existing or new code.",
+    description: "Test engineer — writes and runs unit/integration tests, classifies " +
+        "failures (product bug vs bad test vs environment), and reports a clear " +
+        "verdict.  Use to validate correctness or raise coverage.",
     prompt: `You are the **Tester** on a multi-agent coding team.
 
 ## Role
-You write comprehensive, maintainable tests that give the team confidence
-to ship.
+You write comprehensive, maintainable tests and give the team a trustworthy
+pass/fail signal.
+
+## Blackboard protocol
+- If the dispatch names a task directory and an output file, write your FULL
+  report there; reply with the verdict line + the file path.
+- Read the implementation notes / spec files listed in the dispatch.
+- If no blackboard is mentioned, reply with your full output directly.
 
 ## Strategy
-1. **Read the implementation** thoroughly before writing any test.
-2. Identify the **happy path**, **edge cases**, and **error paths**.
-3. Use the project's existing test framework and patterns.
-4. Write **table-driven tests** (or equivalent) for parameterized cases.
+1. Read the implementation thoroughly before writing any test.
+2. Cover happy path, edge cases, and error paths.
+3. Use the project's existing test framework, runner, and conventions.
+4. Table-driven tests (or equivalent) for parameterized cases.
 5. Mock external dependencies; test units in isolation.
 
+## Failure classification (required for every failing case)
+- **PRODUCT_BUG** — the code is wrong.  Include minimal repro + expected
+  vs actual.  The lead will route this to the implementer.
+- **TEST_DEFECT** — the test itself is wrong/flaky.  Fix it yourself.
+- **ENVIRONMENT** — tooling/deps/config issue.  Report precisely; do not
+  work around silently.
+
 ## Output format
-- Test file path(s)
-- List of test cases with descriptions
-- Any assumptions about behavior that should be verified with the team
+- Test files created/modified.
+- Run command used and result: passed / failed / error counts.
+- Per-failure classification line as above.
+- Verdict line: \`VERDICT: pass\` or \`VERDICT: fail (N product bugs)\`.
 
 ## Rules
 - Tests must be deterministic — no flaky tests.
-- Each test should test exactly one behavior.
-- Use descriptive test names: \`should return 404 when user does not exist\`.
-- Include boundary conditions: empty input, max values, null/undefined.
-- If the code is untestable as-is, flag it and suggest refactoring.
+- One behavior per test; descriptive names state the expectation.
+- Boundaries always: empty input, max values, null/undefined.
+- If the code is untestable as-is, say so and propose the minimal
+  refactor instead of contorting the test.
 `,
     color: "#F472B6", // pink
 };
@@ -180,26 +324,43 @@ to ship.
 const researcher = {
     mode: "subagent",
     description: "Researcher — investigates libraries, APIs, best practices, and " +
-        "documentation.  Use when you need accurate, up-to-date information " +
-        "to inform a technical decision.",
+        "documentation; every finding carries a source and confidence tag so " +
+        "the team can decide what needs verification.  Use for information that " +
+        "must inform a technical decision.",
     prompt: `You are the **Researcher** on a multi-agent coding team.
 
 ## Role
 You find accurate, actionable information so the team can make informed
-decisions.  You consult documentation, source code, and reliable references.
+decisions.  Your output feeds a verification loop — tag honestly.
+
+## Blackboard protocol
+- If the dispatch names a task directory and an output file, write your FULL
+  findings report there; reply with the summary + the file path.
+- Anything tagged Low/Medium confidence that could change the design will be
+  re-checked by the team — flag it prominently in the file too.
+- If no blackboard is mentioned, reply with your full output directly.
 
 ## Output format
-1. **Summary** — Key findings in 2-3 sentences.
-2. **Details** — Structured findings with sources.
-3. **Recommendation** — What the team should do, with trade-offs.
-4. **Sources** — Links or file paths consulted.
+1. **Summary** — key findings in 2-3 sentences.
+2. **Findings** — one entry per fact/answer:
+   - statement
+   - \`[confidence: High|Medium|Low]\`
+   - source (official docs / source code / issue tracker / blog / inference)
+3. **Recommendation** — what the team should do, with trade-offs.
+4. **Gaps** — what you could not confirm and what would confirm it.
+
+## Confidence calibration
+- **High** — official documentation, source code you quoted, vendor examples.
+- **Medium** — reputable secondary sources, single community issue thread.
+- **Low** — blog posts, your own inference, version-uncertain info.
+Anything tagged Low/Medium that could change the design will be re-checked
+by the team — flag prominently if that is the case.
 
 ## Rules
-- Cite your sources.  Do not fabricate URLs or API details.
-- Distinguish between facts and your own interpretation.
-- If information is uncertain, say so explicitly.
-- Prefer official documentation over blog posts.
-- When reading source code, quote the relevant lines.
+- Cite sources with paths or links.  Never fabricate URLs or API details.
+- Separate fact from interpretation explicitly.
+- Prefer official documentation; quote the relevant lines when reading code.
+- State which product/version each finding applies to.
 `,
     color: "#A78BFA", // violet
 };

package/dist/agents.js.map

@@ -1 +1 @@
-{"version":3,"file":"agents.js","sourceRoot":"","sources":["../src/agents.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,QAAQ,GAAc;IAC1B,IAAI,EAAE,KAAK;IACX,WAAW,EACT,2EAA2E;QAC3E,0EAA0E;QAC1E,yEAAyE;QACzE,4DAA4D;IAC9D,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;CAyBT;IACC,KAAK,EAAE,SAAS,EAAE,SAAS;CAC5B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,SAAS,GAAc;IAC3B,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,2EAA2E;QAC3E,wEAAwE;QACxE,6DAA6D;IAC/D,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;CAoBT;IACC,KAAK,EAAE,SAAS,EAAE,WAAW;CAC9B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,WAAW,GAAc;IAC7B,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,uEAAuE;QACvE,0EAA0E;QAC1E,+BAA+B;IACjC,MAAM,EAAE;;;;;;;;;;;;;;;CAeT;IACC,KAAK,EAAE,SAAS,EAAE,QAAQ;CAC3B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,QAAQ,GAAc;IAC1B,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,sEAAsE;QACtE,qEAAqE;QACrE,qCAAqC;IACvC,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BT;IACC,KAAK,EAAE,SAAS,EAAE,SAAS;CAC5B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,MAAM,GAAc;IACxB,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,sEAAsE;QACtE,wEAAwE;QACxE,oCAAoC;IACtC,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;CAwBT;IACC,KAAK,EAAE,SAAS,EAAE,OAAO;CAC1B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,UAAU,GAAc;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,iEAAiE;QACjE,qEAAqE;QACrE,iCAAiC;IACnC,MAAM,EAAE;;;;;;;;;;;;;;;;;;CAkBT;IACC,KAAK,EAAE,SAAS,EAAE,SAAS;CAC5B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AAExE,MAAM,CAAC,MAAM,MAAM,GAA8B;IAC/C,WAAW,EAAE,QAAQ;IACrB,SAAS;IACT,WAAW;IACX,QAAQ;IACR,MAAM;IACN,UAAU;CACX,CAAA"}
+{"version":3,"file":"agents.js","sourceRoot":"","sources":["../src/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,QAAQ,GAAc;IAC1B,IAAI,EAAE,KAAK;IACX,WAAW,EACT,2EAA2E;QAC3E,qEAAqE;QACrE,2EAA2E;QAC3E,2EAA2E;QAC3E,4BAA4B;IAC9B,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsGT;IACC,KAAK,EAAE,SAAS,EAAE,SAAS;CAC5B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,SAAS,GAAc;IAC3B,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,2EAA2E;QAC3E,2EAA2E;QAC3E,0EAA0E;QAC1E,yCAAyC;IAC3C,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCT;IACC,KAAK,EAAE,SAAS,EAAE,WAAW;CAC9B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,WAAW,GAAc;IAC7B,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,uEAAuE;QACvE,0EAA0E;QAC1E,gEAAgE;IAClE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BT;IACC,KAAK,EAAE,SAAS,EAAE,QAAQ;CAC3B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,QAAQ,GAAc;IAC1B,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,sEAAsE;QACtE,uEAAuE;QACvE,gEAAgE;IAClE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCT;IACC,KAAK,EAAE,SAAS,EAAE,SAAS;CAC5B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,MAAM,GAAc;IACxB,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,qEAAqE;QACrE,yEAAyE;QACzE,0DAA0D;IAC5D,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCT;IACC,KAAK,EAAE,SAAS,EAAE,OAAO;CAC1B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,UAAU,GAAc;IAC5B,IAAI,EAAE,UAAU;IAChB,WAAW,EACT,iEAAiE;QACjE,sEAAsE;QACtE,yEAAyE;QACzE,mCAAmC;IACrC,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCT;IACC,KAAK,EAAE,SAAS,EAAE,SAAS;CAC5B,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AAExE,MAAM,CAAC,MAAM,MAAM,GAA8B;IAC/C,WAAW,EAAE,QAAQ;IACrB,SAAS;IACT,WAAW;IACX,QAAQ;IACR,MAAM;IACN,UAAU;CACX,CAAA"}

package/dist/blackboard.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared blackboard for sub-agent coordination + automatic maintenance.
+ *
+ * Sub-agents cannot message each other live (platform limitation), so
+ * TeamMode uses a file blackboard under `<repo>/.git/opencode-team/<task>/`:
+ *  - each agent writes its full deliverable to a designated file;
+ *  - the team lead relays summaries + file paths in every dispatch;
+ *  - the team lead deletes the task directory when the workflow ends.
+ *
+ * This module is the code-level safety net independent of the model:
+ * a sweeper removes task directories whose last activity is older than
+ * the TTL, at plugin startup and hourly in-process.  Placing the board
+ * inside `.git/` guarantees the user's working tree and commits are never
+ * polluted; for non-git workspaces we fall back to the OS temp dir.
+ *
+ * TTL is user-configurable via plugin options:
+ *   "plugin": [["@te-river/opencode-team-mode", { "ttlDays": 7 }]]
+ * Default: 5 days.
+ */
+/** Default idle time before a task directory is swept: 5 days. */
+export declare const DEFAULT_TTL_DAYS = 5;
+export declare const DEFAULT_TTL_MS: number;
+/** Walk upward from `start` to find the git repository root, if any. */
+export declare function findRepoRoot(start: string): string | null;
+/** Absolute blackboard root for a workspace. */
+export declare function teamRootFor(directory: string): string;
+/**
+ * Resolve the TTL from plugin options.  Accepts `ttlDays` (or the more
+ * explicit `blackboardTtlDays`) as a finite number in (0, 365]; anything
+ * else silently falls back to the 5-day default.
+ */
+export declare function resolveTtlMs(options?: Record<string, unknown>): number;
+/**
+ * Remove idle task directories under `root`.
+ * Returns the number of directories deleted; never throws.
+ */
+export declare function sweepStale(root: string, ttlMs?: number): number;
+/**
+ * Start blackboard maintenance (idempotent within the process) and return
+ * the resolved board root.  Runs a startup sweep (catches leftovers from
+ * crashes / force-kills) plus an unref'd hourly interval so the timer never
+ * keeps the process alive on its own.
+ */
+export declare function startBlackboardMaintenance(directory: string, ttlMs?: number): string;
+//# sourceMappingURL=blackboard.d.ts.map

package/dist/blackboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blackboard.d.ts","sourceRoot":"","sources":["../src/blackboard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,kEAAkE;AAClE,eAAO,MAAM,gBAAgB,IAAI,CAAA;AACjC,eAAO,MAAM,cAAc,QAAyC,CAAA;AAQpE,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQzD;AAED,gDAAgD;AAChD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAIrD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,MAAM,CAM1E;AAoBD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAiB,GAAG,MAAM,CAwBvE;AAID;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,EACjB,KAAK,SAAiB,GACrB,MAAM,CASR"}

package/dist/blackboard.js

@@ -0,0 +1,131 @@
+/**
+ * Shared blackboard for sub-agent coordination + automatic maintenance.
+ *
+ * Sub-agents cannot message each other live (platform limitation), so
+ * TeamMode uses a file blackboard under `<repo>/.git/opencode-team/<task>/`:
+ *  - each agent writes its full deliverable to a designated file;
+ *  - the team lead relays summaries + file paths in every dispatch;
+ *  - the team lead deletes the task directory when the workflow ends.
+ *
+ * This module is the code-level safety net independent of the model:
+ * a sweeper removes task directories whose last activity is older than
+ * the TTL, at plugin startup and hourly in-process.  Placing the board
+ * inside `.git/` guarantees the user's working tree and commits are never
+ * polluted; for non-git workspaces we fall back to the OS temp dir.
+ *
+ * TTL is user-configurable via plugin options:
+ *   "plugin": [["@te-river/opencode-team-mode", { "ttlDays": 7 }]]
+ * Default: 5 days.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+/** Default idle time before a task directory is swept: 5 days. */
+export const DEFAULT_TTL_DAYS = 5;
+export const DEFAULT_TTL_MS = DEFAULT_TTL_DAYS * 24 * 60 * 60 * 1000;
+/** In-process sweep cadence. */
+const SWEEP_INTERVAL_MS = 60 * 60 * 1000;
+/** Board root directory name (under .git/, or under tmpdir as fallback). */
+const ROOT_NAME = "opencode-team";
+/** Walk upward from `start` to find the git repository root, if any. */
+export function findRepoRoot(start) {
+    let dir = path.resolve(start);
+    for (;;) {
+        if (fs.existsSync(path.join(dir, ".git")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/** Absolute blackboard root for a workspace. */
+export function teamRootFor(directory) {
+    const repo = findRepoRoot(directory);
+    const base = repo ? path.join(repo, ".git") : os.tmpdir();
+    return path.join(base, ROOT_NAME);
+}
+/**
+ * Resolve the TTL from plugin options.  Accepts `ttlDays` (or the more
+ * explicit `blackboardTtlDays`) as a finite number in (0, 365]; anything
+ * else silently falls back to the 5-day default.
+ */
+export function resolveTtlMs(options = {}) {
+    const raw = options.ttlDays ?? options.blackboardTtlDays;
+    if (typeof raw === "number" && Number.isFinite(raw) && raw > 0 && raw <= 365) {
+        return raw * 24 * 60 * 60 * 1000;
+    }
+    return DEFAULT_TTL_MS;
+}
+/** Latest mtime among a directory and its immediate entries. */
+function lastActivity(dir) {
+    try {
+        let latest = fs.statSync(dir).mtimeMs;
+        for (const entry of fs.readdirSync(dir)) {
+            try {
+                const st = fs.statSync(path.join(dir, entry));
+                if (st.mtimeMs > latest)
+                    latest = st.mtimeMs;
+            }
+            catch {
+                /* raced deletion — ignore */
+            }
+        }
+        return latest;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Remove idle task directories under `root`.
+ * Returns the number of directories deleted; never throws.
+ */
+export function sweepStale(root, ttlMs = DEFAULT_TTL_MS) {
+    let entries;
+    try {
+        entries = fs.readdirSync(root);
+    }
+    catch {
+        return 0; // root does not exist yet — nothing to sweep
+    }
+    const now = Date.now();
+    let removed = 0;
+    for (const entry of entries) {
+        const dir = path.join(root, entry);
+        try {
+            if (!fs.statSync(dir).isDirectory())
+                continue;
+            const seen = lastActivity(dir);
+            if (seen === 0)
+                continue;
+            if (now - seen > ttlMs) {
+                fs.rmSync(dir, { recursive: true, force: true });
+                removed++;
+            }
+        }
+        catch {
+            /* stat/race failure on a single entry — skip it */
+        }
+    }
+    return removed;
+}
+let maintenanceStarted = false;
+/**
+ * Start blackboard maintenance (idempotent within the process) and return
+ * the resolved board root.  Runs a startup sweep (catches leftovers from
+ * crashes / force-kills) plus an unref'd hourly interval so the timer never
+ * keeps the process alive on its own.
+ */
+export function startBlackboardMaintenance(directory, ttlMs = DEFAULT_TTL_MS) {
+    const root = teamRootFor(directory);
+    if (!maintenanceStarted) {
+        maintenanceStarted = true;
+        sweepStale(root, ttlMs);
+        const timer = setInterval(() => sweepStale(root, ttlMs), SWEEP_INTERVAL_MS);
+        if (typeof timer.unref === "function")
+            timer.unref();
+    }
+    return root;
+}
+//# sourceMappingURL=blackboard.js.map

package/dist/blackboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blackboard.js","sourceRoot":"","sources":["../src/blackboard.ts"],"names":[],"mappings":"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"}

package/dist/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AA8H7C,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAOhD,CAAA"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAwI7C,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAOhD,CAAA"}

package/dist/commands.js

@@ -102,16 +102,26 @@ $ARGUMENTS
 
 ## Workflow
 1. Understand the goal and acceptance criteria.
-2. Create a todo list of all sub-tasks.
+2. **Create a todo list FIRST** — one item per work package, with checkable
+   done-conditions.  Update statuses live (exactly one in_progress).
 3. Dispatch sub-tasks to the appropriate agents:
    - Design / architecture → architect
    - Implementation → implementer
    - Code review → reviewer
    - Testing → tester
    - Research → researcher
-4. Run independent sub-tasks in parallel.
-5. Collect all outputs, resolve conflicts, and synthesize a final result.
-6. Present a structured summary to the user.`,
+   Each dispatch must be self-contained (embed relevant prior outputs).
+4. For multi-agent work, coordinate through the shared blackboard: create
+   one task directory, have each agent write its full deliverable there,
+   and relay summary + file path in every dispatch.  Run independent
+   sub-tasks in parallel.
+5. Enforce the feedback loop: reviewer Critical/Major findings and tester
+   product-bugs become fix tasks on the list → implementer fixes → re-review
+   affected scope → re-run tests.  Repeat until clean (max 2 loops, then
+   escalate).
+6. Collect all outputs, resolve conflicts, synthesize a final result.
+7. Present a structured summary: changes, review/test verdict, remaining
+   assumptions and risks.  Then delete the task blackboard directory.`,
 };
 /* ------------------------------------------------------------------ */
 /*  Export all commands keyed by name                                 */

package/dist/commands.js.map

@@ -1 +1 @@
-{"version":3,"file":"commands.js","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,wEAAwE;AACxE,MAAM,QAAQ,GAAgB;IAC5B,WAAW,EACT,+FAA+F;IACjG,KAAK,EAAE,WAAW;IAClB,QAAQ,EAAE;;;;;;;;;;;;;kDAasC;CACjD,CAAA;AAED,wEAAwE;AACxE,MAAM,aAAa,GAAgB;IACjC,WAAW,EACT,0FAA0F;IAC5F,KAAK,EAAE,aAAa;IACpB,QAAQ,EAAE;;;;;;;;4DAQgD;CAC3D,CAAA;AAED,wEAAwE;AACxE,MAAM,UAAU,GAAgB;IAC9B,WAAW,EACT,0EAA0E;IAC5E,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE;;;;;;;;;;;;;gEAaoD;CAC/D,CAAA;AAED,wEAAwE;AACxE,MAAM,QAAQ,GAAgB;IAC5B,WAAW,EACT,2EAA2E;IAC7E,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE;;;;;;;;;;;8BAWkB;CAC7B,CAAA;AAED,wEAAwE;AACxE,MAAM,YAAY,GAAgB;IAChC,WAAW,EACT,uEAAuE;IACzE,KAAK,EAAE,YAAY;IACnB,QAAQ,EAAE;;;;;;;;;;;0DAW8C;CACzD,CAAA;AAED,wEAAwE;AACxE,MAAM,OAAO,GAAgB;IAC3B,WAAW,EACT,mGAAmG;IACrG,KAAK,EAAE,WAAW;IAClB,QAAQ,EAAE;;;;;;;;;;;;;;;;6CAgBiC;CAC5C,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AAExE,MAAM,CAAC,MAAM,QAAQ,GAAgC;IACnD,WAAW,EAAE,QAAQ;IACrB,gBAAgB,EAAE,aAAa;IAC/B,aAAa,EAAE,UAAU;IACzB,WAAW,EAAE,QAAQ;IACrB,eAAe,EAAE,YAAY;IAC7B,UAAU,EAAE,OAAO;CACpB,CAAA"}
+{"version":3,"file":"commands.js","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,wEAAwE;AACxE,MAAM,QAAQ,GAAgB;IAC5B,WAAW,EACT,+FAA+F;IACjG,KAAK,EAAE,WAAW;IAClB,QAAQ,EAAE;;;;;;;;;;;;;kDAasC;CACjD,CAAA;AAED,wEAAwE;AACxE,MAAM,aAAa,GAAgB;IACjC,WAAW,EACT,0FAA0F;IAC5F,KAAK,EAAE,aAAa;IACpB,QAAQ,EAAE;;;;;;;;4DAQgD;CAC3D,CAAA;AAED,wEAAwE;AACxE,MAAM,UAAU,GAAgB;IAC9B,WAAW,EACT,0EAA0E;IAC5E,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE;;;;;;;;;;;;;gEAaoD;CAC/D,CAAA;AAED,wEAAwE;AACxE,MAAM,QAAQ,GAAgB;IAC5B,WAAW,EACT,2EAA2E;IAC7E,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE;;;;;;;;;;;8BAWkB;CAC7B,CAAA;AAED,wEAAwE;AACxE,MAAM,YAAY,GAAgB;IAChC,WAAW,EACT,uEAAuE;IACzE,KAAK,EAAE,YAAY;IACnB,QAAQ,EAAE;;;;;;;;;;;0DAW8C;CACzD,CAAA;AAED,wEAAwE;AACxE,MAAM,OAAO,GAAgB;IAC3B,WAAW,EACT,mGAAmG;IACrG,KAAK,EAAE,WAAW;IAClB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;sEA0B0D;CACrE,CAAA;AAED,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AAExE,MAAM,CAAC,MAAM,QAAQ,GAAgC;IACnD,WAAW,EAAE,QAAQ;IACrB,gBAAgB,EAAE,aAAa;IAC/B,aAAa,EAAE,UAAU;IACzB,WAAW,EAAE,QAAQ;IACrB,eAAe,EAAE,YAAY;IAC7B,UAAU,EAAE,OAAO;CACpB,CAAA"}

package/dist/index.d.ts

@@ -4,6 +4,10 @@
  * Uses the v2 Promise API with an explicit `id` field.  The `id` is the
  * display name shown in OpenCode Desktop's plugin list (instead of the
  * raw file path).
+ *
+ * Options (via the tuple plugin form):
+ *   "plugin": [["@te-river/opencode-team-mode", { "ttlDays": 7 }]]
+ * `ttlDays` controls blackboard auto-cleanup; default 5.
  */
 export declare const Plugin: import("./types.js").PluginDefinition;
 export default Plugin;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,eAAO,MAAM,MAAM,uCA2BjB,CAAA;AAEF,eAAe,MAAM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAiCH,eAAO,MAAM,MAAM,uCAoCjB,CAAA;AAEF,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -4,20 +4,53 @@
  * Uses the v2 Promise API with an explicit `id` field.  The `id` is the
  * display name shown in OpenCode Desktop's plugin list (instead of the
  * raw file path).
+ *
+ * Options (via the tuple plugin form):
+ *   "plugin": [["@te-river/opencode-team-mode", { "ttlDays": 7 }]]
+ * `ttlDays` controls blackboard auto-cleanup; default 5.
  */
 import { define } from "./types.js";
 import { agents } from "./agents.js";
 import { commands } from "./commands.js";
+import { startBlackboardMaintenance, resolveTtlMs, DEFAULT_TTL_DAYS, } from "./blackboard.js";
+/** Best-effort workspace directory from plugin context, else cwd. */
+function resolveDirectory(ctx) {
+    for (const candidate of [ctx.directory, ctx.project]) {
+        if (typeof candidate === "string" && candidate.length > 0)
+            return candidate;
+    }
+    return process.cwd();
+}
+/** Runtime addendum to the team-lead prompt: concrete board + TTL. */
+function blackboardNote(root, ttlDays) {
+    return [
+        "",
+        "",
+        "## Team Blackboard — resolved for this workspace",
+        `Root directory: \`${root}\``,
+        `- Create exactly ONE task sub-directory per multi-agent task: \`<root>/<task-slug>/\`.`,
+        `- Auto-cleanup: the plugin sweeps task directories idle for more than ${ttlDays} days.`,
+        `  Your own delete-after-report is the fast path; the sweep is the safety net.`,
+    ].join("\n");
+}
 export const Plugin = define({
     id: "team-mode",
     setup: async (ctx) => {
+        // ---------- blackboard maintenance (code-level TTL sweeper) ----------
+        const directory = resolveDirectory(ctx);
+        const ttlMs = resolveTtlMs(ctx.options);
+        const ttlDays = Math.round(ttlMs / (24 * 60 * 60 * 1000)) || DEFAULT_TTL_DAYS;
+        const boardRoot = startBlackboardMaintenance(directory, ttlMs);
         // ---------- inject team agents ----------
         await ctx.agent.transform((agent) => {
             for (const [name, def] of Object.entries(agents)) {
                 agent.update(name, (item) => {
                     item.description = def.description;
                     item.mode = def.mode;
-                    item.prompt = def.prompt;
+                    item.prompt =
+                        name === "team-lead"
+                            ? def.prompt + blackboardNote(boardRoot, ttlDays)
+                            : def.prompt;
                     item.color = def.color;
                 });
             }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC;IAC3B,EAAE,EAAE,WAAW;IAEf,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QACnB,2CAA2C;QAC3C,MAAM,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YAClC,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;gBACjD,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;oBAC1B,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC,WAAW,CAAA;oBAClC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAA;oBACpB,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAA;oBACxB,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAA;gBACxB,CAAC,CAAC,CAAA;YACJ,CAAC;QACH,CAAC,CAAC,CAAA;QAEF,6CAA6C;QAC7C,MAAM,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;YACtC,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACnD,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;oBAC5B,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC,WAAW,CAAA;oBAClC,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAA;oBAC5B,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAA;gBACxB,CAAC,CAAC,CAAA;YACJ,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;CACF,CAAC,CAAA;AAEF,eAAe,MAAM,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@te-river/opencode-team-mode",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Team collaboration mode plugin for OpenCode Desktop — injects specialized agents (architect, reviewer, implementer, tester, researcher) and team workflow commands into your OpenCode workspace.",
   "type": "module",
   "main": "dist/index.js",
@@ -18,6 +18,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "test": "tsc && node test-blackboard.mjs",
     "prepublishOnly": "tsc",
     "dev": "tsc --watch"
   },
@@ -33,10 +34,14 @@
   ],
   "author": "",
   "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
   "peerDependencies": {
     "@opencode-ai/plugin": ">=0.1.0"
   },
   "devDependencies": {
+    "@types/node": "^26.4.0",
     "typescript": "^5.5.0"
   },
   "repository": {