opcrew 0.1.4 → 0.1.5

package/dist/cli.js

@@ -5,8 +5,8 @@
 import process from "process";
 
 // src/cli/install.ts
-import { mkdir, writeFile } from "fs/promises";
-import path from "path";
+import { mkdir, writeFile, cp, rm } from "fs/promises";
+import path2 from "path";
 // src/core/tools/translations.ts
 var CLAUDE_TOOLS = {
   read: "Read",
@@ -20,7 +20,7 @@ var CLAUDE_TOOLS = {
   delegate: "Agent",
   todo: "TodoWrite",
   test: "Bash",
-  logbook: "Edit",
+  logbook: "",
   skill: "Skill"
 };
 var OPENCODE_TOOLS = {
@@ -61,7 +61,7 @@ function translateTools(canonicalTools, platform) {
   };
   const translationMap = maps[platform];
   const translated = canonicalTools.map((tool) => translationMap[tool]);
-  return [...new Set(translated)];
+  return [...new Set(translated)].filter((tool) => tool !== "");
 }
 // src/core/Agent.ts
 class OpCrewAgent {
@@ -69,8 +69,24 @@ class OpCrewAgent {
   constructor(config) {
     this.config = config;
   }
+  getAllowedTools() {
+    return this.config.allowedTools ?? this.config.tools ?? [];
+  }
+  hasTool(tool) {
+    return this.getAllowedTools().includes(tool);
+  }
+  validateToolUsage(tool) {
+    if (!this.hasTool(tool)) {
+      const allowedList = this.getAllowedTools().join(", ") || "(none)";
+      throw new Error(`Tool '${tool}' is not allowed for agent '${this.config.name}'. ` + `Allowed tools: [${allowedList}]`);
+    }
+  }
+  getForbiddenTools(allAvailableTools) {
+    const allowedSet = new Set(this.getAllowedTools());
+    return allAvailableTools.filter((tool) => !allowedSet.has(tool));
+  }
   compileToMarkdown() {
-    const translatedTools = translateTools(this.config.tools, "claude");
+    const translatedTools = translateTools(this.getAllowedTools(), "claude");
     const lowerName = this.config.name.toLowerCase();
     const frontmatter = `---
 name: ${lowerName}
@@ -85,7 +101,7 @@ ${this.buildMarkdownBody()}`;
       Orchestrator: { edit: "deny", bash: "ask", webfetch: "deny" },
       Planner: { edit: "deny", bash: "ask", webfetch: "allow" },
       Executor: { edit: "allow", bash: "allow", webfetch: "ask" },
-      Reviewer: { edit: "deny", bash: "ask", webfetch: "deny" },
+      Reviewer: { edit: "deny", bash: "allow", webfetch: "deny" },
       Researcher: { edit: "deny", bash: "deny", webfetch: "allow" }
     };
     const permission = permissionByRole[this.config.role];
@@ -101,7 +117,7 @@ permission:
 ${this.buildMarkdownBody()}`;
   }
   compileToCodexMarkdown() {
-    const translatedTools = translateTools(this.config.tools, "codex");
+    const translatedTools = translateTools(this.getAllowedTools(), "codex");
     const frontmatter = `---
 name: ${this.config.name}
 role: ${this.config.role}
@@ -130,21 +146,22 @@ var Captain = new OpCrewAgent({
   role: "Orchestrator",
   mode: "primary",
   instructions: [
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: read, logbook, delegate, skill. Using any other tool is a violation.",
     "You are the orchestrator - you NEVER execute work directly. Your role is to coordinate, delegate, and verify.",
-    "Define mission intent with explicit scope, constraints, and success criteria before any execution.",
+    "Workstream Fan-out: divide missions into independent Workstreams (e.g., Logic, Testing, Documentation) to enable parallel specialists.",
     "Assign roles in order: Navigator plans, Boatswain executes, Quartermaster reviews; resolve conflicts quickly.",
-    "Require a logbook entry that captures decisions, risks, and acceptance checks for every mission.",
+    "Collision Prevention: ensure no two Boatswains are assigned the same file or symbol in parallel. Launch workstreams only if they are logically decoupled.",
     "Escalate blockers immediately and re-sequence work to unblock the critical path.",
     "Enforce conventions: small, reviewable diffs; no scope creep; verification required before declaring done.",
     "Intent gate: restate user intent, classify task type (trivial/explicit/exploratory/open-ended/ambiguous), and choose the workflow before action.",
     "Delegation mandate: ALWAYS delegate work to specialists using the task tool. Never perform file edits, code changes, or direct execution yourself.",
     "Delegation protocol: require task/outcome/tools/must-do/must-not/context in every order; reject vague asks.",
-    "Parallel exploration: launch explore/librarian tasks concurrently for non-trivial discovery, and avoid duplicate searches.",
     "Verification gate: delegate verification to Quartermaster; ensure diagnostics/tests run and evidence is logged before marking complete.",
+    "Conflict Resolution: if specialists disagree on implementation, make the final call based on project documentation.",
     "Knowledge discipline: require crew to read/update docs/knowledge (project map, glossary, relevant ADRs) for any decision or scope change.",
     "Ensure every material decision is captured as an ADR in docs/knowledge/decisions."
   ],
-  tools: ["read", "logbook", "delegate"]
+  tools: ["read", "logbook", "delegate", "skill"]
 });
 
 // src/crew/Navigator.ts
@@ -154,19 +171,26 @@ var Navigator = new OpCrewAgent({
   role: "Planner",
   mode: "subagent",
   instructions: [
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: read, websearch, logbook, todo, skill. Using any other tool is a violation.",
     "Chart the implementation path based on the Captain's intent and constraints.",
     "Decompose work into atomic, ordered tasks with clear inputs, outputs, and ownership.",
+    "Workstream Decomposition: break the plan into atomic, parallel tracks. Define File Ownership (e.g., Boatswain-A owns src/, Boatswain-B owns tests/).",
+    "Survey the Stack: identify the project's native build system (BUILD_CMD), test runner (TEST_CMD), and style guide immediately.",
+    "Documentation Maintenance: plan for updates to docs/project-map.md and docs/glossary.md; assign these to a specific workstream.",
+    "Dependency Graphing: flag Blocking Tasks where one workstream depends on the output of another; sequence these to avoid idle agents.",
+    "Execution Manifest: for every task, specify Target File, Affected Symbols, Invariants, and the exact Verification Command.",
     "Record the plan in the logbook with file targets, dependencies, and acceptance checks.",
     "Maintain a current project map (key files, modules, and ownership boundaries).",
     "Flag ambiguity early, propose alternatives, and surface risks before execution starts.",
     "Apply the intent gate: classify the request and select the correct workflow (explore vs. implement vs. clarify).",
     "Create and manage todo/task lists for any multi-step plan; enforce one in-progress item at a time.",
     "Mandate parallel discovery for unknowns: launch multiple explore/librarian threads and consolidate findings.",
+    "Discovery Primitives: use language-agnostic tools (grep, find, tree) to map dependencies before proposing edits.",
     "Delegate external research to Scout when you need information from outside the project: libraries, APIs, best practices, or documentation.",
     "Define verification steps explicitly (diagnostics/tests/build) and include success evidence in the plan.",
     "Consult docs/knowledge before planning; update project-map/glossary/ADRs when scope or definitions change."
   ],
-  tools: ["read", "websearch", "logbook", "todo"]
+  tools: ["read", "websearch", "logbook", "todo", "skill"]
 });
 
 // src/crew/Boatswain.ts
@@ -176,17 +200,20 @@ var Boatswain = new OpCrewAgent({
   role: "Executor",
   mode: "subagent",
   instructions: [
-    "Turn approved Navigator steps into precise edits without scope creep.",
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: read, edit, write, test, todo, glob, grep, skill. Using any other tool is a violation.",
+    "Scope Guarding: ONLY touch files assigned to your Workstream ID. If you must edit a file owned by another agent, escalate to Captain for a plan revision.",
     "Follow existing patterns, naming, and formatting; avoid speculative changes.",
+    "Context Anchoring: before editing, read the surrounding code to match indentation, casing, and comment styles. Maintain the project's local laws.",
+    "Parallel Execution: implement the Navigator's Manifest exactly. Update code, tests, and documentation (docs/project-map.md or docs/glossary.md) as assigned.",
     "Keep diffs lean and standards-compliant; update only what the plan calls for.",
-    "Run required sanity tests and record results in the logbook.",
-    "Log completion status, assumptions, and blockers immediately for the Captain.",
+    "Atomic Verification: run the assigned TEST_CMD for your scope. Record stdout/stderr logs in the logbook immediately.",
     "Do not re-run delegated exploration; wait for Navigator findings before implementing dependent changes.",
-    "Use verification gates: lsp diagnostics on touched files plus relevant tests/builds before completion.",
+    "LSP/Compiler Check: use native diagnostics to ensure no syntax errors were introduced in touched files.",
     "Update docs/knowledge when execution changes assumptions, definitions, or operational steps.",
-    "Update todo task status immediately upon completion of each task."
+    "Update todo task status immediately upon completion of each task.",
+    "Status Discipline: update your specific task status in logbook.json as you work; do not wait for other workstreams to finish."
   ],
-  tools: ["read", "edit", "test", "todo"]
+  tools: ["read", "edit", "write", "test", "todo", "glob", "grep", "skill"]
 });
 
 // src/crew/Quartermaster.ts
@@ -196,16 +223,20 @@ var Quartermaster = new OpCrewAgent({
   role: "Reviewer",
   mode: "subagent",
   instructions: [
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: read, grep, execute, write, skill. Using any other tool is a violation.",
     "Inspect each diff for regression risks, scope drift, and missing context.",
-    "Confirm tests, docs, and logbook entries prove the change is complete.",
-    "Verify acceptance checks and ensure the plan-to-implementation trace is intact.",
+    "Integration Audit: once all parallel Boatswains report Complete, verify the combined diff for logic conflicts or signature mismatches.",
+    "Documentation Gate: REJECT approval if code changed but docs/project-map.md or docs/glossary.md were not updated to reflect the new state.",
+    "Evidence Verification: ensure every workstream provided terminal logs proving their respective tests or build commands passed.",
+    "Traceability: confirm the final implementation matches the Navigator's original Invariants.",
     "Escalate unresolved quality gaps to the Captain before approval.",
     "Require rework when verification is missing or conventions are violated.",
     "Reject approvals lacking evidence (diagnostics/tests/build logs) or missing todo/task tracking.",
+    "Regression Check: require a full project TEST_CMD run (if available) to ensure integrated workstreams didn't break the system.",
     "Verify delegation protocol compliance when specialists were involved (task/outcome/tools/must-do/must-not/context).",
     "Reject approval if docs/knowledge changes are missing for material decisions or scope shifts."
   ],
-  tools: ["read", "grep", "execute", "write"]
+  tools: ["read", "grep", "execute", "write", "skill"]
 });
 
 // src/crew/Scout.ts
@@ -215,18 +246,22 @@ var Scout = new OpCrewAgent({
   role: "Researcher",
   mode: "subagent",
   instructions: [
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: websearch, webfetch, read, skill. Using any other tool is a violation.",
     "You are the crew's eyes to the outside world - research and gather information when summoned by Captain or Navigator.",
     "Focus exclusively on external research: web searches, documentation lookup, API references, and best practices.",
     "Never modify project files - your job is to gather intelligence, not execute changes.",
     "Provide concise, actionable findings with clear sources and citations.",
+    "Rosetta Stone Summaries: when researching a new language, explain concepts via analogy - 'This is the [Go] equivalent of [Python's] Decorators.'",
     "When researching libraries or frameworks, include: version info, installation methods, key APIs, and gotchas.",
     "Compare alternatives when relevant: pros/cons, trade-offs, and recommendations with rationale.",
     "Flag deprecated or outdated information; always verify against official sources when possible.",
     "Summarize findings in a structured format: problem, findings, recommendations, sources.",
+    "Glossary Contribution: propose new terms or external definitions for the Boatswain to add to docs/glossary.md.",
     "If research reveals the task is more complex than expected, escalate to Navigator for replanning.",
-    "Cache useful references in docs/knowledge for future crew reference."
+    "Environment Discovery: research specific error messages or build tool quirks if the Boatswain hits a blocker.",
+    "Knowledge Caching: store research summaries in docs/research/ for future crew reference."
   ],
-  tools: ["websearch", "webfetch", "read"]
+  tools: ["websearch", "webfetch", "read", "skill"]
 });
 
 // src/crew/index.ts
@@ -238,10 +273,66 @@ var crew = [
   Scout
 ];
 
+// src/skills.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
+async function loadSkills() {
+  const skillsDir = path.join(__dirname2, "skills");
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const skillPath = path.join(skillsDir, entry.name);
+      const skillMdPath = path.join(skillPath, "SKILL.md");
+      try {
+        const content = await readFile(skillMdPath, "utf-8");
+        const { name, description } = parseSkillFrontmatter(content);
+        skills.push({
+          name: name || entry.name,
+          description: description || "",
+          sourcePath: skillPath
+        });
+      } catch {
+        console.warn(`Warning: No SKILL.md found in ${skillPath}`);
+      }
+    }
+    return skills;
+  } catch {
+    return [];
+  }
+}
+function parseSkillFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return {};
+  }
+  const frontmatter = frontmatterMatch[1];
+  const result = {};
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+  if (nameMatch) {
+    result.name = nameMatch[1].trim();
+  }
+  const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+  if (descMatch) {
+    result.description = descMatch[1].trim();
+  }
+  return result;
+}
+async function getSkillContent(skillName) {
+  const skillMdPath = path.join(__dirname2, "skills", skillName, "SKILL.md");
+  return readFile(skillMdPath, "utf-8");
+}
+
 // src/cli/install.ts
-var CLAUDE_DIR = path.join(".claude", "agents");
-var OPENCODE_DIR = path.join(".opencode", "agents");
-var CODEX_FILE = path.join(".codex", "instructions.md");
+var CLAUDE_AGENTS_DIR = path2.join(".claude", "agents");
+var CLAUDE_SKILLS_DIR = path2.join(".claude", "skills");
+var OPENCODE_AGENTS_DIR = path2.join(".opencode", "agents");
+var OPENCODE_SKILLS_DIR = path2.join(".opencode", "skills");
+var CODEX_FILE = path2.join(".codex", "instructions.md");
 async function ensureDir(targetDir) {
   await mkdir(targetDir, { recursive: true });
 }
@@ -250,26 +341,67 @@ async function installToTool(tool) {
     await installForCodex();
     return;
   }
-  const targetDir = tool === "claude" ? CLAUDE_DIR : OPENCODE_DIR;
-  await ensureDir(targetDir);
+  const agentsDir = tool === "claude" ? CLAUDE_AGENTS_DIR : OPENCODE_AGENTS_DIR;
+  const skillsDir = tool === "claude" ? CLAUDE_SKILLS_DIR : OPENCODE_SKILLS_DIR;
+  await ensureDir(agentsDir);
   for (const agent of crew) {
     const filename = `${agent.config.name.toLowerCase()}.md`;
-    const filePath = path.join(targetDir, filename);
+    const filePath = path2.join(agentsDir, filename);
     const content = tool === "opencode" ? agent.compileToOpenCodeMarkdown() : agent.compileToMarkdown();
     await writeFile(filePath, content);
-    console.log(`Synced ${agent.config.name} to ${targetDir}`);
+    console.log(`Synced ${agent.config.name} to ${agentsDir}`);
+  }
+  await installSkills(skillsDir, tool);
+}
+async function installSkills(targetDir, tool) {
+  const skills = await loadSkills();
+  if (skills.length === 0) {
+    console.log("No skills found to install.");
+    return;
+  }
+  await ensureDir(targetDir);
+  for (const skill of skills) {
+    const skillDestDir = path2.join(targetDir, skill.name);
+    await rm(skillDestDir, { recursive: true, force: true });
+    await cp(skill.sourcePath, skillDestDir, { recursive: true });
+    console.log(`Synced skill ${skill.name} to ${targetDir}`);
   }
 }
 async function installForCodex() {
-  const codexDir = path.dirname(CODEX_FILE);
+  const codexDir = path2.dirname(CODEX_FILE);
   await ensureDir(codexDir);
-  const compiled = crew.map((agent) => agent.compileToCodexMarkdown()).join(`
+  const agentsContent = crew.map((agent) => agent.compileToCodexMarkdown()).join(`
+
+---
+
+`);
+  const skills = await loadSkills();
+  let skillsContent = "";
+  if (skills.length > 0) {
+    const skillContents = await Promise.all(skills.map(async (skill) => {
+      const content = await getSkillContent(skill.name);
+      return `## Skill: ${skill.name}
+
+${content}`;
+    }));
+    skillsContent = `
+
+---
+
+# Skills
+
+` + skillContents.join(`
 
 ---
 
 `);
-  await writeFile(CODEX_FILE, compiled);
+  }
+  const fullContent = agentsContent + skillsContent;
+  await writeFile(CODEX_FILE, fullContent);
   console.log(`Synced Codex instructions to ${CODEX_FILE}`);
+  if (skills.length > 0) {
+    console.log(`Synced ${skills.length} skill(s) to Codex instructions`);
+  }
 }
 
 // src/cli/index.ts

package/dist/opencode-plugin.js

@@ -26,7 +26,7 @@ var CLAUDE_TOOLS = {
   delegate: "Agent",
   todo: "TodoWrite",
   test: "Bash",
-  logbook: "Edit",
+  logbook: "",
   skill: "Skill"
 };
 var OPENCODE_TOOLS = {
@@ -67,7 +67,7 @@ function translateTools(canonicalTools, platform) {
   };
   const translationMap = maps[platform];
   const translated = canonicalTools.map((tool) => translationMap[tool]);
-  return [...new Set(translated)];
+  return [...new Set(translated)].filter((tool) => tool !== "");
 }
 // src/core/Agent.ts
 class OpCrewAgent {
@@ -75,8 +75,24 @@ class OpCrewAgent {
   constructor(config) {
     this.config = config;
   }
+  getAllowedTools() {
+    return this.config.allowedTools ?? this.config.tools ?? [];
+  }
+  hasTool(tool) {
+    return this.getAllowedTools().includes(tool);
+  }
+  validateToolUsage(tool) {
+    if (!this.hasTool(tool)) {
+      const allowedList = this.getAllowedTools().join(", ") || "(none)";
+      throw new Error(`Tool '${tool}' is not allowed for agent '${this.config.name}'. ` + `Allowed tools: [${allowedList}]`);
+    }
+  }
+  getForbiddenTools(allAvailableTools) {
+    const allowedSet = new Set(this.getAllowedTools());
+    return allAvailableTools.filter((tool) => !allowedSet.has(tool));
+  }
   compileToMarkdown() {
-    const translatedTools = translateTools(this.config.tools, "claude");
+    const translatedTools = translateTools(this.getAllowedTools(), "claude");
     const lowerName = this.config.name.toLowerCase();
     const frontmatter = `---
 name: ${lowerName}
@@ -91,7 +107,7 @@ ${this.buildMarkdownBody()}`;
       Orchestrator: { edit: "deny", bash: "ask", webfetch: "deny" },
       Planner: { edit: "deny", bash: "ask", webfetch: "allow" },
       Executor: { edit: "allow", bash: "allow", webfetch: "ask" },
-      Reviewer: { edit: "deny", bash: "ask", webfetch: "deny" },
+      Reviewer: { edit: "deny", bash: "allow", webfetch: "deny" },
       Researcher: { edit: "deny", bash: "deny", webfetch: "allow" }
     };
     const permission = permissionByRole[this.config.role];
@@ -107,7 +123,7 @@ permission:
 ${this.buildMarkdownBody()}`;
   }
   compileToCodexMarkdown() {
-    const translatedTools = translateTools(this.config.tools, "codex");
+    const translatedTools = translateTools(this.getAllowedTools(), "codex");
     const frontmatter = `---
 name: ${this.config.name}
 role: ${this.config.role}
@@ -136,21 +152,22 @@ var Captain = new OpCrewAgent({
   role: "Orchestrator",
   mode: "primary",
   instructions: [
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: read, logbook, delegate, skill. Using any other tool is a violation.",
     "You are the orchestrator - you NEVER execute work directly. Your role is to coordinate, delegate, and verify.",
-    "Define mission intent with explicit scope, constraints, and success criteria before any execution.",
+    "Workstream Fan-out: divide missions into independent Workstreams (e.g., Logic, Testing, Documentation) to enable parallel specialists.",
     "Assign roles in order: Navigator plans, Boatswain executes, Quartermaster reviews; resolve conflicts quickly.",
-    "Require a logbook entry that captures decisions, risks, and acceptance checks for every mission.",
+    "Collision Prevention: ensure no two Boatswains are assigned the same file or symbol in parallel. Launch workstreams only if they are logically decoupled.",
     "Escalate blockers immediately and re-sequence work to unblock the critical path.",
     "Enforce conventions: small, reviewable diffs; no scope creep; verification required before declaring done.",
     "Intent gate: restate user intent, classify task type (trivial/explicit/exploratory/open-ended/ambiguous), and choose the workflow before action.",
     "Delegation mandate: ALWAYS delegate work to specialists using the task tool. Never perform file edits, code changes, or direct execution yourself.",
     "Delegation protocol: require task/outcome/tools/must-do/must-not/context in every order; reject vague asks.",
-    "Parallel exploration: launch explore/librarian tasks concurrently for non-trivial discovery, and avoid duplicate searches.",
     "Verification gate: delegate verification to Quartermaster; ensure diagnostics/tests run and evidence is logged before marking complete.",
+    "Conflict Resolution: if specialists disagree on implementation, make the final call based on project documentation.",
     "Knowledge discipline: require crew to read/update docs/knowledge (project map, glossary, relevant ADRs) for any decision or scope change.",
     "Ensure every material decision is captured as an ADR in docs/knowledge/decisions."
   ],
-  tools: ["read", "logbook", "delegate"]
+  tools: ["read", "logbook", "delegate", "skill"]
 });
 
 // src/crew/Navigator.ts
@@ -160,19 +177,26 @@ var Navigator = new OpCrewAgent({
   role: "Planner",
   mode: "subagent",
   instructions: [
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: read, websearch, logbook, todo, skill. Using any other tool is a violation.",
     "Chart the implementation path based on the Captain's intent and constraints.",
     "Decompose work into atomic, ordered tasks with clear inputs, outputs, and ownership.",
+    "Workstream Decomposition: break the plan into atomic, parallel tracks. Define File Ownership (e.g., Boatswain-A owns src/, Boatswain-B owns tests/).",
+    "Survey the Stack: identify the project's native build system (BUILD_CMD), test runner (TEST_CMD), and style guide immediately.",
+    "Documentation Maintenance: plan for updates to docs/project-map.md and docs/glossary.md; assign these to a specific workstream.",
+    "Dependency Graphing: flag Blocking Tasks where one workstream depends on the output of another; sequence these to avoid idle agents.",
+    "Execution Manifest: for every task, specify Target File, Affected Symbols, Invariants, and the exact Verification Command.",
     "Record the plan in the logbook with file targets, dependencies, and acceptance checks.",
     "Maintain a current project map (key files, modules, and ownership boundaries).",
     "Flag ambiguity early, propose alternatives, and surface risks before execution starts.",
     "Apply the intent gate: classify the request and select the correct workflow (explore vs. implement vs. clarify).",
     "Create and manage todo/task lists for any multi-step plan; enforce one in-progress item at a time.",
     "Mandate parallel discovery for unknowns: launch multiple explore/librarian threads and consolidate findings.",
+    "Discovery Primitives: use language-agnostic tools (grep, find, tree) to map dependencies before proposing edits.",
     "Delegate external research to Scout when you need information from outside the project: libraries, APIs, best practices, or documentation.",
     "Define verification steps explicitly (diagnostics/tests/build) and include success evidence in the plan.",
     "Consult docs/knowledge before planning; update project-map/glossary/ADRs when scope or definitions change."
   ],
-  tools: ["read", "websearch", "logbook", "todo"]
+  tools: ["read", "websearch", "logbook", "todo", "skill"]
 });
 
 // src/crew/Boatswain.ts
@@ -182,17 +206,20 @@ var Boatswain = new OpCrewAgent({
   role: "Executor",
   mode: "subagent",
   instructions: [
-    "Turn approved Navigator steps into precise edits without scope creep.",
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: read, edit, write, test, todo, glob, grep, skill. Using any other tool is a violation.",
+    "Scope Guarding: ONLY touch files assigned to your Workstream ID. If you must edit a file owned by another agent, escalate to Captain for a plan revision.",
     "Follow existing patterns, naming, and formatting; avoid speculative changes.",
+    "Context Anchoring: before editing, read the surrounding code to match indentation, casing, and comment styles. Maintain the project's local laws.",
+    "Parallel Execution: implement the Navigator's Manifest exactly. Update code, tests, and documentation (docs/project-map.md or docs/glossary.md) as assigned.",
     "Keep diffs lean and standards-compliant; update only what the plan calls for.",
-    "Run required sanity tests and record results in the logbook.",
-    "Log completion status, assumptions, and blockers immediately for the Captain.",
+    "Atomic Verification: run the assigned TEST_CMD for your scope. Record stdout/stderr logs in the logbook immediately.",
     "Do not re-run delegated exploration; wait for Navigator findings before implementing dependent changes.",
-    "Use verification gates: lsp diagnostics on touched files plus relevant tests/builds before completion.",
+    "LSP/Compiler Check: use native diagnostics to ensure no syntax errors were introduced in touched files.",
     "Update docs/knowledge when execution changes assumptions, definitions, or operational steps.",
-    "Update todo task status immediately upon completion of each task."
+    "Update todo task status immediately upon completion of each task.",
+    "Status Discipline: update your specific task status in logbook.json as you work; do not wait for other workstreams to finish."
   ],
-  tools: ["read", "edit", "test", "todo"]
+  tools: ["read", "edit", "write", "test", "todo", "glob", "grep", "skill"]
 });
 
 // src/crew/Quartermaster.ts
@@ -202,16 +229,20 @@ var Quartermaster = new OpCrewAgent({
   role: "Reviewer",
   mode: "subagent",
   instructions: [
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: read, grep, execute, write, skill. Using any other tool is a violation.",
     "Inspect each diff for regression risks, scope drift, and missing context.",
-    "Confirm tests, docs, and logbook entries prove the change is complete.",
-    "Verify acceptance checks and ensure the plan-to-implementation trace is intact.",
+    "Integration Audit: once all parallel Boatswains report Complete, verify the combined diff for logic conflicts or signature mismatches.",
+    "Documentation Gate: REJECT approval if code changed but docs/project-map.md or docs/glossary.md were not updated to reflect the new state.",
+    "Evidence Verification: ensure every workstream provided terminal logs proving their respective tests or build commands passed.",
+    "Traceability: confirm the final implementation matches the Navigator's original Invariants.",
     "Escalate unresolved quality gaps to the Captain before approval.",
     "Require rework when verification is missing or conventions are violated.",
     "Reject approvals lacking evidence (diagnostics/tests/build logs) or missing todo/task tracking.",
+    "Regression Check: require a full project TEST_CMD run (if available) to ensure integrated workstreams didn't break the system.",
     "Verify delegation protocol compliance when specialists were involved (task/outcome/tools/must-do/must-not/context).",
     "Reject approval if docs/knowledge changes are missing for material decisions or scope shifts."
   ],
-  tools: ["read", "grep", "execute", "write"]
+  tools: ["read", "grep", "execute", "write", "skill"]
 });
 
 // src/crew/Scout.ts
@@ -221,18 +252,22 @@ var Scout = new OpCrewAgent({
   role: "Researcher",
   mode: "subagent",
   instructions: [
+    "TOOL BOUNDARY: You are ONLY permitted to use these tools: websearch, webfetch, read, skill. Using any other tool is a violation.",
     "You are the crew's eyes to the outside world - research and gather information when summoned by Captain or Navigator.",
     "Focus exclusively on external research: web searches, documentation lookup, API references, and best practices.",
     "Never modify project files - your job is to gather intelligence, not execute changes.",
     "Provide concise, actionable findings with clear sources and citations.",
+    "Rosetta Stone Summaries: when researching a new language, explain concepts via analogy - 'This is the [Go] equivalent of [Python's] Decorators.'",
     "When researching libraries or frameworks, include: version info, installation methods, key APIs, and gotchas.",
     "Compare alternatives when relevant: pros/cons, trade-offs, and recommendations with rationale.",
     "Flag deprecated or outdated information; always verify against official sources when possible.",
     "Summarize findings in a structured format: problem, findings, recommendations, sources.",
+    "Glossary Contribution: propose new terms or external definitions for the Boatswain to add to docs/glossary.md.",
     "If research reveals the task is more complex than expected, escalate to Navigator for replanning.",
-    "Cache useful references in docs/knowledge for future crew reference."
+    "Environment Discovery: research specific error messages or build tool quirks if the Boatswain hits a blocker.",
+    "Knowledge Caching: store research summaries in docs/research/ for future crew reference."
   ],
-  tools: ["websearch", "webfetch", "read"]
+  tools: ["websearch", "webfetch", "read", "skill"]
 });
 
 // src/crew/index.ts
@@ -12686,65 +12721,128 @@ The logbook tracks:
 });
 
 // src/opencode-plugin.ts
+var DEFAULT_CANONICAL_TOOLS = [
+  "read",
+  "write",
+  "edit",
+  "glob",
+  "grep",
+  "execute",
+  "websearch",
+  "webfetch",
+  "delegate",
+  "todo",
+  "test",
+  "logbook",
+  "skill"
+];
+var ALL_AVAILABLE_TOOLS = DEFAULT_CANONICAL_TOOLS;
 var permissionByRole = {
   Orchestrator: { edit: "deny", bash: "ask", webfetch: "deny" },
   Planner: { edit: "deny", bash: "ask", webfetch: "allow" },
   Executor: { edit: "allow", bash: "allow", webfetch: "ask" },
-  Reviewer: { edit: "deny", bash: "ask", webfetch: "deny" },
+  Reviewer: { edit: "deny", bash: "allow", webfetch: "deny" },
   Researcher: { edit: "deny", bash: "deny", webfetch: "allow" }
 };
 function toAgentId(agent) {
   return agent.config.name.toLowerCase().replace(/\s+/g, "-");
 }
-function buildPrompt(agent) {
+function buildPrompt(agent, availableTools) {
   const instructionsList = agent.config.instructions.map((instruction) => `- ${instruction}`).join(`
 `);
+  const allowedTools = agent.getAllowedTools();
+  const forbiddenTools = agent.getForbiddenTools(availableTools);
+  const toolBoundariesSection = `## TOOL BOUNDARIES
+- **Allowed:** ${allowedTools.length > 0 ? allowedTools.join(", ") : "(none)"}
+- **Forbidden:** ${forbiddenTools.length > 0 ? forbiddenTools.join(", ") : "(none)"}`;
   return `# ${agent.config.name}
+
+${toolBoundariesSection}
+
 ${instructionsList}
 
 ## Shared Context
 Refer to \`.opcrew/logbook.json\` for the current voyage status.
 `;
 }
-function toOpenCodeAgentConfig(agent) {
+function toOpenCodeAgentConfig(agent, availableTools) {
+  const allowedTools = agent.getAllowedTools();
+  const validTools = allowedTools.every((tool3) => availableTools.includes(tool3));
+  if (!validTools) {
+    const invalidTools = allowedTools.filter((tool3) => !availableTools.includes(tool3));
+    throw new Error(`Agent '${agent.config.name}' has invalid tools in allowlist: [${invalidTools.join(", ")}]. ` + `Valid tools: [${availableTools.join(", ")}]`);
+  }
   return {
     description: agent.config.name,
     mode: agent.config.mode,
-    prompt: buildPrompt(agent),
+    prompt: buildPrompt(agent, availableTools),
     permission: permissionByRole[agent.config.role]
   };
 }
-var OpCrewPlugin = async ({ client }) => {
-  await client.app.log({
-    body: {
-      service: "opcrew",
-      level: "info",
-      message: "OpenCode plugin initialized"
-    }
-  });
-  return {
-    config: async (config2) => {
-      const agents = config2.agent ?? {};
-      for (const agent of crew) {
-        agents[toAgentId(agent)] = toOpenCodeAgentConfig(agent);
-      }
-      config2.agent = agents;
-      await client.app.log({
-        body: {
-          service: "opcrew",
-          level: "info",
-          message: "Crew agents registered",
-          extra: { agents: Object.keys(agents) }
-        }
-      });
-    },
-    tool: {
-      edit_logbook: editLogbookTool
-    }
+function createOpCrewPlugin(options = {}) {
+  const {
+    tools: customTools = {},
+    skills,
+    availableTools = DEFAULT_CANONICAL_TOOLS,
+    includeDefaultTools = true,
+    crew: customCrew = crew
+  } = options;
+  const defaultTools = includeDefaultTools ? { edit_logbook: editLogbookTool } : {};
+  const mergedTools = {
+    ...defaultTools,
+    ...customTools
+  };
+  const _skills = skills;
+  return async ({ client }) => {
+    await client.app.log({
+      body: {
+        service: "opcrew",
+        level: "info",
+        message: "OpenCode plugin initialized"
+      }
+    });
+    return {
+      config: async (config2) => {
+        const agents = config2.agent ?? {};
+        agents["build"] = { ...agents["build"], disable: true };
+        for (const agent of customCrew) {
+          const agentId = toAgentId(agent);
+          const allowedTools = agent.getAllowedTools();
+          const forbiddenTools = agent.getForbiddenTools(availableTools);
+          await client.app.log({
+            body: {
+              service: "opcrew",
+              level: "info",
+              message: `Registering agent '${agent.config.name}' with tool boundaries`,
+              extra: {
+                agentId,
+                allowedTools,
+                forbiddenTools
+              }
+            }
+          });
+          agents[agentId] = toOpenCodeAgentConfig(agent, availableTools);
+        }
+        config2.agent = agents;
+        await client.app.log({
+          body: {
+            service: "opcrew",
+            level: "info",
+            message: "Crew agents registered",
+            extra: { agents: Object.keys(agents) }
+          }
+        });
+      },
+      tool: mergedTools
+    };
   };
-};
+}
+var OpCrewPlugin = createOpCrewPlugin();
 var opencode_plugin_default = OpCrewPlugin;
 export {
   opencode_plugin_default as default,
-  OpCrewPlugin
+  createOpCrewPlugin,
+  OpCrewPlugin,
+  DEFAULT_CANONICAL_TOOLS,
+  ALL_AVAILABLE_TOOLS
 };

package/dist/skills/skills/write-adr/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: write-adr
+description: Guides the crew to write Architecture Decision Records (ADRs). Use when making material decisions that should be documented, when asked to create an ADR, or when a decision with long-term impact is made.
+---
+
+# Write ADR Skill
+
+This skill guides the OpCrew to write well-structured Architecture Decision Records (ADRs) following the project's conventions.
+
+## When to Use This Skill
+
+Use this skill when:
+- Making a material decision that affects the project's architecture, conventions, or workflows
+- A decision has long-term impact and should be preserved for future reference
+- Explicitly asked to create or write an ADR
+- Changing a previous architectural decision
+- Introducing new patterns, tools, or approaches that others should follow
+
+## What is an ADR?
+
+An Architecture Decision Record (ADR) captures a significant architectural decision along with its context and consequences. ADRs:
+
+- Create a decision log that's reviewable in Git
+- Help future team members understand *why* decisions were made
+- Prevent "why did we do this?" questions months later
+- Make decisions explicit and traceable
+
+## ADR Structure
+
+OpCrew ADRs use four sections:
+
+### 1. Status
+The current state of the decision:
+- **Proposed** - Under discussion, not yet finalized
+- **Accepted** - Approved and in effect
+- **Deprecated** - Still in effect but should be avoided for new work
+- **Superseded** - Replaced by a newer ADR (link to it)
+
+### 2. Context
+What is the issue or situation motivating this decision?
+- Describe the problem or opportunity
+- Include relevant constraints and requirements
+- Explain why a decision is needed now
+
+### 3. Decision
+What is the change being made or proposed?
+- State the decision clearly and concisely
+- Be specific about what is being done
+- Include any alternatives considered (briefly)
+
+### 4. Consequences
+What becomes easier or more difficult because of this change?
+- List positive outcomes
+- Acknowledge trade-offs and limitations
+- Note any follow-up actions required
+
+## Filename Convention
+
+ADRs are stored in `docs/knowledge/decisions/` with this format:
+
+```
+YYYYMMDD-NNN-slug.md
+```
+
+- `YYYYMMDD` - Date the ADR is created
+- `NNN` - Sequential number (001, 002, 003...)
+- `slug` - Short kebab-case description
+
+**Examples:**
+- `20260328-001-knowledge-base-source-of-truth.md`
+- `20260329-002-agent-configuration-standard.md`
+
+## Step-by-Step Workflow
+
+1. **Identify the decision** - Is this a material decision worth documenting?
+2. **Check existing ADRs** - Look in `docs/knowledge/decisions/` for related decisions
+3. **Determine the next sequence number** - Look at existing files and increment
+4. **Create the file** - Use the template and filename convention
+5. **Write the ADR** - Fill in all four sections with clear, concise content
+6. **Review** - Ensure the ADR captures the full context and rationale
+7. **Commit** - Include the ADR in your commit with related changes
+
+## Example ADR
+
+```markdown
+# Knowledge Base Source of Truth
+
+## Status
+Accepted
+
+## Context
+We need a maintainable way to preserve project decisions, conventions, and operational guidance for agents and humans.
+
+## Decision
+Use the filesystem as the canonical knowledge base in `docs/knowledge/`. Keep decisions as ADRs, project map and glossary as living docs, and runbooks for operational procedures.
+
+## Consequences
+- Decisions become reviewable and diffable in Git.
+- Agents must read/update these docs as part of workflow conventions.
+- A database can be added later only as a derived index, not as the source of truth.
+```
+
+## Tips for Good ADRs
+
+- **Be concise** - ADRs should be readable in 2-3 minutes
+- **Focus on why** - The context and rationale matter more than the details
+- **Write for the future** - Assume the reader doesn't have your current context
+- **Include trade-offs** - Every decision has downsides; acknowledge them
+- **Link related ADRs** - If this supersedes or relates to another ADR, mention it
+- **Keep it current** - Update status if the decision changes
+
+## Template Location
+
+Use the template at `templates/adr-template.md` as a starting point.

package/dist/skills/skills/write-adr/templates/adr-template.md

@@ -0,0 +1,13 @@
+# [Title]
+
+## Status
+[Proposed | Accepted | Deprecated | Superseded]
+
+## Context
+[What is the issue that we're seeing that is motivating this decision or change?]
+
+## Decision
+[What is the change that we're proposing and/or doing?]
+
+## Consequences
+[What becomes easier or more difficult to do because of this change?]

package/dist/skills/write-adr/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: write-adr
+description: Guides the crew to write Architecture Decision Records (ADRs). Use when making material decisions that should be documented, when asked to create an ADR, or when a decision with long-term impact is made.
+---
+
+# Write ADR Skill
+
+This skill guides the OpCrew to write well-structured Architecture Decision Records (ADRs) following the project's conventions.
+
+## When to Use This Skill
+
+Use this skill when:
+- Making a material decision that affects the project's architecture, conventions, or workflows
+- A decision has long-term impact and should be preserved for future reference
+- Explicitly asked to create or write an ADR
+- Changing a previous architectural decision
+- Introducing new patterns, tools, or approaches that others should follow
+
+## What is an ADR?
+
+An Architecture Decision Record (ADR) captures a significant architectural decision along with its context and consequences. ADRs:
+
+- Create a decision log that's reviewable in Git
+- Help future team members understand *why* decisions were made
+- Prevent "why did we do this?" questions months later
+- Make decisions explicit and traceable
+
+## ADR Structure
+
+OpCrew ADRs use four sections:
+
+### 1. Status
+The current state of the decision:
+- **Proposed** - Under discussion, not yet finalized
+- **Accepted** - Approved and in effect
+- **Deprecated** - Still in effect but should be avoided for new work
+- **Superseded** - Replaced by a newer ADR (link to it)
+
+### 2. Context
+What is the issue or situation motivating this decision?
+- Describe the problem or opportunity
+- Include relevant constraints and requirements
+- Explain why a decision is needed now
+
+### 3. Decision
+What is the change being made or proposed?
+- State the decision clearly and concisely
+- Be specific about what is being done
+- Include any alternatives considered (briefly)
+
+### 4. Consequences
+What becomes easier or more difficult because of this change?
+- List positive outcomes
+- Acknowledge trade-offs and limitations
+- Note any follow-up actions required
+
+## Filename Convention
+
+ADRs are stored in `docs/knowledge/decisions/` with this format:
+
+```
+YYYYMMDD-NNN-slug.md
+```
+
+- `YYYYMMDD` - Date the ADR is created
+- `NNN` - Sequential number (001, 002, 003...)
+- `slug` - Short kebab-case description
+
+**Examples:**
+- `20260328-001-knowledge-base-source-of-truth.md`
+- `20260329-002-agent-configuration-standard.md`
+
+## Step-by-Step Workflow
+
+1. **Identify the decision** - Is this a material decision worth documenting?
+2. **Check existing ADRs** - Look in `docs/knowledge/decisions/` for related decisions
+3. **Determine the next sequence number** - Look at existing files and increment
+4. **Create the file** - Use the template and filename convention
+5. **Write the ADR** - Fill in all four sections with clear, concise content
+6. **Review** - Ensure the ADR captures the full context and rationale
+7. **Commit** - Include the ADR in your commit with related changes
+
+## Example ADR
+
+```markdown
+# Knowledge Base Source of Truth
+
+## Status
+Accepted
+
+## Context
+We need a maintainable way to preserve project decisions, conventions, and operational guidance for agents and humans.
+
+## Decision
+Use the filesystem as the canonical knowledge base in `docs/knowledge/`. Keep decisions as ADRs, project map and glossary as living docs, and runbooks for operational procedures.
+
+## Consequences
+- Decisions become reviewable and diffable in Git.
+- Agents must read/update these docs as part of workflow conventions.
+- A database can be added later only as a derived index, not as the source of truth.
+```
+
+## Tips for Good ADRs
+
+- **Be concise** - ADRs should be readable in 2-3 minutes
+- **Focus on why** - The context and rationale matter more than the details
+- **Write for the future** - Assume the reader doesn't have your current context
+- **Include trade-offs** - Every decision has downsides; acknowledge them
+- **Link related ADRs** - If this supersedes or relates to another ADR, mention it
+- **Keep it current** - Update status if the decision changes
+
+## Template Location
+
+Use the template at `templates/adr-template.md` as a starting point.

package/dist/skills/write-adr/templates/adr-template.md

@@ -0,0 +1,13 @@
+# [Title]
+
+## Status
+[Proposed | Accepted | Deprecated | Superseded]
+
+## Context
+[What is the issue that we're seeing that is motivating this decision or change?]
+
+## Decision
+[What is the change that we're proposing and/or doing?]
+
+## Consequences
+[What becomes easier or more difficult to do because of this change?]

package/docs/knowledge/decisions/20260329-002-strict-agent-boundaries.md

@@ -0,0 +1,51 @@
+# Strict Agent Tool Boundaries
+
+## Status
+Accepted
+
+## Context
+OpenCrew agents currently have tool assignments defined declaratively in their configuration, but these assignments are NOT technically enforced. The existing permission system only covers three operations (edit, bash, webfetch) at the platform level, while tool assignments like `read`, `write`, `delegate`, `logbook`, etc. are purely instructional.
+
+This creates several problems:
+1. **Role confusion**: Captain could theoretically use tools meant for Boatswain (like `edit`)
+2. **Accountability gaps**: No verification that agents stay within their designated scope
+3. **Debugging difficulty**: When something goes wrong, it's unclear which agent overstepped
+4. **Security risk**: An agent could access tools it shouldn't have access to
+
+The principle "Captain never writes code - that's Boatswain's job" is currently enforced only through instructions, not technical barriers.
+
+## Decision
+Implement strict technical enforcement of agent tool boundaries through:
+
+1. **Tool Allowlist per Agent**: Each agent definition will include an explicit `allowedTools` array that is validated at runtime
+2. **Plugin-Level Enforcement**: The OpenCode plugin will filter available tools based on the agent's allowlist before registration
+3. **Instruction Injection**: Agent instructions will be auto-generated with explicit "ALLOWED TOOLS" and "FORBIDDEN TOOLS" sections
+4. **Runtime Validation**: A guard function will validate tool usage before each invocation
+
+Agent tool boundaries:
+- **Captain (Orchestrator)**: read, logbook, delegate, skill
+- **Navigator (Planner)**: read, websearch, logbook, todo, skill
+- **Boatswain (Executor)**: read, edit, write, test, todo, glob, grep, skill
+- **Quartermaster (Reviewer)**: read, grep, execute, write, skill
+- **Scout (Researcher)**: websearch, webfetch, read, skill
+
+## Consequences
+
+**Benefits:**
+- Clear separation of concerns - each agent has a defined operational scope
+- Easier debugging - tool usage violations are caught immediately
+- Better security - no accidental or intentional tool misuse
+- Self-documenting - agent capabilities are explicit in code
+- Improved trust - users can rely on agents staying in their lane
+
+**Trade-offs:**
+- More rigid system - changing tool access requires code changes
+- Potential friction - if an agent legitimately needs a new tool, must update config
+- Implementation overhead - validation logic adds complexity
+
+**Follow-up Actions:**
+- Update Agent.ts with tool enforcement methods
+- Add allowedTools array to each agent definition
+- Create guard functions in src/core/guards.ts
+- Update opencode-plugin.ts to filter tools at registration
+- Write tests for boundary enforcement

package/docs/knowledge/decisions/20260329-003-plugin-factory-pattern.md

@@ -0,0 +1,83 @@
+# Plugin Factory Pattern for Configuration
+
+## Status
+Accepted
+
+## Context
+The OpenCrew plugin (`src/opencode-plugin.ts`) previously hardcoded all configuration:
+- Tools (`edit_logbook`) were imported and registered directly
+- `ALL_AVAILABLE_TOOLS` was defined inline
+- The crew of agents was imported from a fixed location
+- Skills were not configurable through the plugin
+
+This made it difficult to:
+1. Add custom tools without modifying the plugin source
+2. Extend the available tools list for custom tool types
+3. Use a custom crew configuration
+4. Configure the plugin for different deployment scenarios
+
+The `Plugin` type from `@opencode-ai/plugin` is a function signature `(input: PluginInput) => Promise<Hooks>`, which doesn't accept custom configuration parameters directly.
+
+## Decision
+Implement a **Factory Pattern** for the OpCrew plugin:
+
+1. **`OpCrewPluginOptions` interface** - Configuration object with:
+   - `tools?: Record<string, ToolDefinition>` - Custom tools to register
+   - `skills?: SkillConfig[]` - Skills to make available
+   - `availableTools?: CanonicalTool[]` - Canonical tools for boundary enforcement
+   - `includeDefaultTools?: boolean` - Whether to include default tools (default: true)
+   - `crew?: OpCrewAgent[]` - Custom crew of agents
+
+2. **`createOpCrewPlugin(options)` factory function** - Creates a configured Plugin instance
+
+3. **`DEFAULT_CANONICAL_TOOLS` export** - The default list for extension
+
+4. **Backwards compatibility** - Default export `OpCrewPlugin` uses default options
+
+### Usage Examples
+
+**Default (backwards compatible):**
+```typescript
+import { OpCrewPlugin } from 'opcrew';
+export default OpCrewPlugin;
+```
+
+**With custom tools:**
+```typescript
+import { createOpCrewPlugin } from 'opcrew';
+import { myTool } from './my-tool';
+
+export default createOpCrewPlugin({
+  tools: { my_tool: myTool },
+});
+```
+
+**Full customization:**
+```typescript
+import { createOpCrewPlugin, DEFAULT_CANONICAL_TOOLS } from 'opcrew';
+
+export default createOpCrewPlugin({
+  tools: { custom_tool: myTool },
+  availableTools: [...DEFAULT_CANONICAL_TOOLS, 'custom_tool'],
+  includeDefaultTools: false,
+  crew: [customAgent],
+});
+```
+
+## Consequences
+
+**Benefits:**
+- Extensibility: Users can add custom tools without forking
+- Flexibility: Different configurations for different environments
+- Testability: Easier to test with mock configurations
+- Backwards compatible: Existing usage continues to work
+
+**Trade-offs:**
+- Slightly more complex API surface
+- Need to document configuration options
+- Type definitions must be exported for consumers
+
+**Follow-up:**
+- Document the configuration API in README
+- Consider adding validation for configuration options
+- Update package.json exports if needed

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opcrew",
   "description": "OpenCrew agents and OpenCode plugin",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "main": "./dist/opencode-plugin.js",
   "module": "./dist/opencode-plugin.js",
   "type": "module",
@@ -29,9 +29,10 @@
     "opcrew": "./dist/cli.js"
   },
   "scripts": {
-    "build": "bun run build:plugin && bun run build:cli",
+    "build": "bun run build:plugin && bun run build:cli && bun run build:skills",
     "build:plugin": "bun build src/opencode-plugin.ts --outdir dist --target bun",
     "build:cli": "bun build src/cli/index.ts --outfile dist/cli.js --target bun",
+    "build:skills": "cp -r src/skills dist/skills",
     "prepack": "bun run build",
     "test": "bun test",
     "build:types": "bunx tsc -p tsconfig.build.json"