opencode-swarm-plugin 0.12.10 → 0.12.12

package/dist/plugin.js

@@ -21683,6 +21683,16 @@ var ValidationResultSchema = exports_external.object({
   errors: exports_external.array(exports_external.string()).optional(),
   extractionMethod: exports_external.string().optional()
 });
+var FailureModeSchema = exports_external.enum([
+  "timeout",
+  "conflict",
+  "validation",
+  "tool_failure",
+  "context_overflow",
+  "dependency_blocked",
+  "user_cancelled",
+  "unknown"
+]);
 // src/schemas/task.ts
 var EffortLevelSchema = exports_external.enum([
   "trivial",
@@ -23751,6 +23761,16 @@ var DecompositionStrategySchema = exports_external.enum([
   "risk-based",
   "research-based"
 ]);
+var FailureModeSchema2 = exports_external.enum([
+  "timeout",
+  "conflict",
+  "validation",
+  "tool_failure",
+  "context_overflow",
+  "dependency_blocked",
+  "user_cancelled",
+  "unknown"
+]);
 var OutcomeSignalsSchema = exports_external.object({
   bead_id: exports_external.string(),
   duration_ms: exports_external.number().int().min(0),
@@ -23759,7 +23779,9 @@ var OutcomeSignalsSchema = exports_external.object({
   success: exports_external.boolean(),
   files_touched: exports_external.array(exports_external.string()).default([]),
   timestamp: exports_external.string(),
-  strategy: DecompositionStrategySchema.optional()
+  strategy: DecompositionStrategySchema.optional(),
+  failure_mode: FailureModeSchema2.optional(),
+  failure_details: exports_external.string().optional()
 });
 var ScoredOutcomeSchema = exports_external.object({
   signals: OutcomeSignalsSchema,
@@ -24386,51 +24408,46 @@ Before writing code:
 Begin work on your subtask now.`;
 var SUBTASK_PROMPT_V2 = `You are a swarm agent working on: **{subtask_title}**
 
-## Identity
-- **Bead ID**: {bead_id}
-- **Epic ID**: {epic_id}
+## [IDENTITY]
+Agent: (assigned at spawn)
+Bead: {bead_id}
+Epic: {epic_id}
 
-## Task
+## [TASK]
 {subtask_description}
 
-## Files (exclusive reservation)
+## [FILES]
+Reserved (exclusive):
 {file_list}
 
 Only modify these files. Need others? Message the coordinator.
 
-## Context
+## [CONTEXT]
 {shared_context}
 
 {compressed_context}
 
 {error_context}
 
-## MANDATORY: Use These Tools
+## [TOOLS]
+### Beads
+- beads_update (status: blocked)
+- beads_create (new bugs)
+- beads_close (via swarm_complete)
 
-### Agent Mail - communicate with the swarm
-\`\`\`typescript
-// Report progress, ask questions, announce blockers
-agentmail_send({
-  to: ["coordinator"],
-  subject: "Progress update",
-  body: "What you did or need",
-  thread_id: "{epic_id}"
-})
-\`\`\`
+### Agent Mail
+- agentmail_send (thread_id: {epic_id})
 
-### Beads - track your work
-- **Blocked?** \`beads_update({ id: "{bead_id}", status: "blocked" })\`
-- **Found bug?** \`beads_create({ title: "Bug description", type: "bug" })\`
-- **Done?** \`swarm_complete({ bead_id: "{bead_id}", summary: "What you did", files_touched: [...] })\`
+### Completion
+- swarm_complete (REQUIRED when done)
 
-## Workflow
+## [OUTPUT]
+1. Read files first
+2. Implement changes
+3. Verify (typecheck)
+4. Complete with swarm_complete
 
-1. **Read** the files first
-2. **Plan** your approach (message coordinator if complex)
-3. **Implement** the changes
-4. **Verify** (typecheck, tests)
-5. **Report** progress via Agent Mail
-6. **Complete** with swarm_complete when done
+Return: Summary of changes made
 
 **Never work silently.** Communicate progress and blockers immediately.
 
@@ -25021,6 +25038,52 @@ async function runUbsScan(files) {
     return null;
   }
 }
+var swarm_broadcast = tool({
+  description: "Broadcast context update to all agents working on the same epic",
+  args: {
+    epic_id: tool.schema.string().describe("Epic ID (e.g., bd-abc123)"),
+    message: tool.schema.string().describe("Context update to share (what changed, what was learned)"),
+    importance: tool.schema.enum(["info", "warning", "blocker"]).default("info").describe("Priority level (default: info)"),
+    files_affected: tool.schema.array(tool.schema.string()).optional().describe("Files this context relates to")
+  },
+  async execute(args, ctx) {
+    const state = requireState(ctx.sessionID);
+    const beadId = ctx.beadId || "unknown";
+    const body = [
+      `## Context Update`,
+      "",
+      `**From**: ${state.agentName} (${beadId})`,
+      `**Priority**: ${args.importance.toUpperCase()}`,
+      "",
+      args.message,
+      "",
+      args.files_affected && args.files_affected.length > 0 ? `**Files affected**:
+${args.files_affected.map((f) => `- \`${f}\``).join(`
+`)}` : ""
+    ].filter(Boolean).join(`
+`);
+    const mailImportance = args.importance === "blocker" ? "urgent" : args.importance === "warning" ? "high" : "normal";
+    await mcpCall("send_message", {
+      project_key: state.projectKey,
+      sender_name: state.agentName,
+      to: [],
+      subject: `[${args.importance.toUpperCase()}] Context update from ${state.agentName}`,
+      body_md: body,
+      thread_id: args.epic_id,
+      importance: mailImportance,
+      ack_required: args.importance === "blocker"
+    });
+    return JSON.stringify({
+      broadcast: true,
+      epic_id: args.epic_id,
+      from: state.agentName,
+      bead_id: beadId,
+      importance: args.importance,
+      recipients: "all agents in epic",
+      ack_required: args.importance === "blocker"
+    }, null, 2);
+  }
+});
 var swarm_complete = tool({
   description: "Mark subtask complete, release reservations, notify coordinator. Runs UBS bug scan if files_touched provided.",
   args: {
@@ -25113,6 +25176,25 @@ var swarm_complete = tool({
     }, null, 2);
   }
 });
+function classifyFailure(error45) {
+  const msg = (typeof error45 === "string" ? error45 : error45.message).toLowerCase();
+  if (msg.includes("timeout"))
+    return "timeout";
+  if (msg.includes("conflict") || msg.includes("reservation"))
+    return "conflict";
+  if (msg.includes("validation") || msg.includes("schema"))
+    return "validation";
+  if (msg.includes("context") || msg.includes("token"))
+    return "context_overflow";
+  if (msg.includes("blocked") || msg.includes("dependency"))
+    return "dependency_blocked";
+  if (msg.includes("cancel"))
+    return "user_cancelled";
+  if (msg.includes("tool") || msg.includes("command") || msg.includes("failed to execute")) {
+    return "tool_failure";
+  }
+  return "unknown";
+}
 var swarm_record_outcome = tool({
   description: "Record subtask outcome for implicit feedback scoring. Tracks duration, errors, retries to learn decomposition quality.",
   args: {
@@ -25123,7 +25205,18 @@ var swarm_record_outcome = tool({
     success: tool.schema.boolean().describe("Whether the subtask succeeded"),
     files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files that were modified"),
     criteria: tool.schema.array(tool.schema.string()).optional().describe("Criteria to generate feedback for (default: all default criteria)"),
-    strategy: tool.schema.enum(["file-based", "feature-based", "risk-based", "research-based"]).optional().describe("Decomposition strategy used for this task")
+    strategy: tool.schema.enum(["file-based", "feature-based", "risk-based", "research-based"]).optional().describe("Decomposition strategy used for this task"),
+    failure_mode: tool.schema.enum([
+      "timeout",
+      "conflict",
+      "validation",
+      "tool_failure",
+      "context_overflow",
+      "dependency_blocked",
+      "user_cancelled",
+      "unknown"
+    ]).optional().describe("Failure classification (only when success=false). Auto-classified if not provided."),
+    failure_details: tool.schema.string().optional().describe("Detailed failure context (error message, stack trace, etc.)")
   },
   async execute(args) {
     const signals = {
@@ -25134,8 +25227,13 @@ var swarm_record_outcome = tool({
       success: args.success,
       files_touched: args.files_touched ?? [],
       timestamp: new Date().toISOString(),
-      strategy: args.strategy
+      strategy: args.strategy,
+      failure_mode: args.failure_mode,
+      failure_details: args.failure_details
     };
+    if (!args.success && !args.failure_mode && args.failure_details) {
+      signals.failure_mode = classifyFailure(args.failure_details);
+    }
     const validated = OutcomeSignalsSchema.parse(signals);
     const scored = scoreImplicitFeedback(validated, DEFAULT_LEARNING_CONFIG);
     const errorStats = await globalErrorAccumulator.getErrorStats(args.bead_id);
@@ -25175,6 +25273,8 @@ var swarm_record_outcome = tool({
         retry_count: args.retry_count ?? 0,
         success: args.success,
         strategy: args.strategy,
+        failure_mode: validated.failure_mode,
+        failure_details: validated.failure_details,
         accumulated_errors: errorStats.total,
         unresolved_errors: errorStats.unresolved
       },
@@ -25466,6 +25566,7 @@ var swarmTools = {
   swarm_validate_decomposition,
   swarm_status,
   swarm_progress,
+  swarm_broadcast,
   swarm_complete,
   swarm_record_outcome,
   swarm_subtask_prompt,
@@ -25476,6 +25577,327 @@ var swarmTools = {
   swarm_get_error_context,
   swarm_resolve_error
 };
+
+// src/repo-crawl.ts
+var GITHUB_API_URL = "https://api.github.com";
+var GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+var DEFAULT_MAX_RESULTS = 10;
+var DEFAULT_MAX_LENGTH = 1e4;
+var DEFAULT_DEPTH = 2;
+
+class RepoCrawlError extends Error {
+  statusCode;
+  endpoint;
+  constructor(message, statusCode, endpoint) {
+    super(message);
+    this.statusCode = statusCode;
+    this.endpoint = endpoint;
+    this.name = "RepoCrawlError";
+  }
+}
+function parseRepo(input) {
+  let normalized = input.replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/^github\.com\//, "");
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length < 2) {
+    throw new RepoCrawlError(`Invalid repo format: "${input}". Expected "owner/repo" or GitHub URL.`);
+  }
+  const [owner, repo] = parts;
+  return { owner, repo };
+}
+async function githubFetch(endpoint, options = {}) {
+  const headers = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "opencode-swarm-plugin",
+    ...options.headers || {}
+  };
+  if (GITHUB_TOKEN) {
+    headers.Authorization = `Bearer ${GITHUB_TOKEN}`;
+  }
+  const url2 = `${GITHUB_API_URL}${endpoint}`;
+  const response = await fetch(url2, { ...options, headers });
+  if (response.status === 403) {
+    const rateLimitRemaining = response.headers.get("x-ratelimit-remaining");
+    const rateLimitReset = response.headers.get("x-ratelimit-reset");
+    if (rateLimitRemaining === "0" && rateLimitReset) {
+      const resetDate = new Date(parseInt(rateLimitReset) * 1000);
+      throw new RepoCrawlError(`GitHub API rate limit exceeded. Resets at ${resetDate.toISOString()}. ` + `${GITHUB_TOKEN ? "Using authenticated token." : "Set GITHUB_TOKEN env var for higher limits."}`, 403, endpoint);
+    }
+  }
+  if (response.status === 404) {
+    throw new RepoCrawlError(`Resource not found: ${endpoint}`, 404, endpoint);
+  }
+  if (!response.ok) {
+    const body = await response.text();
+    throw new RepoCrawlError(`GitHub API error (${response.status}): ${body}`, response.status, endpoint);
+  }
+  return response.json();
+}
+function decodeContent(content, encoding) {
+  if (encoding === "base64") {
+    return Buffer.from(content, "base64").toString("utf-8");
+  }
+  return content;
+}
+function detectTechStack(tree) {
+  const stack = new Set;
+  const filePatterns = {
+    "package.json": "Node.js/npm",
+    "yarn.lock": "Yarn",
+    "pnpm-lock.yaml": "pnpm",
+    "bun.lockb": "Bun",
+    "Cargo.toml": "Rust",
+    "go.mod": "Go",
+    "requirements.txt": "Python/pip",
+    Pipfile: "Python/pipenv",
+    "pyproject.toml": "Python/poetry",
+    Gemfile: "Ruby/Bundler",
+    "composer.json": "PHP/Composer",
+    "pom.xml": "Java/Maven",
+    "build.gradle": "Java/Gradle",
+    "tsconfig.json": "TypeScript",
+    "next.config.js": "Next.js",
+    "nuxt.config.js": "Nuxt.js",
+    "vue.config.js": "Vue.js",
+    "angular.json": "Angular",
+    "svelte.config.js": "Svelte",
+    Dockerfile: "Docker",
+    "docker-compose.yml": "Docker Compose",
+    ".terraform": "Terraform",
+    Makefile: "Make"
+  };
+  for (const item of tree) {
+    const basename = item.path.split("/").pop() || "";
+    if (filePatterns[basename]) {
+      stack.add(filePatterns[basename]);
+    }
+    if (basename.endsWith(".rs"))
+      stack.add("Rust");
+    if (basename.endsWith(".go"))
+      stack.add("Go");
+    if (basename.endsWith(".py"))
+      stack.add("Python");
+    if (basename.endsWith(".rb"))
+      stack.add("Ruby");
+    if (basename.endsWith(".php"))
+      stack.add("PHP");
+    if (basename.endsWith(".java"))
+      stack.add("Java");
+    if (basename.endsWith(".kt"))
+      stack.add("Kotlin");
+    if (basename.endsWith(".swift"))
+      stack.add("Swift");
+    if (basename.endsWith(".ts") || basename.endsWith(".tsx"))
+      stack.add("TypeScript");
+    if (basename.endsWith(".jsx"))
+      stack.add("React");
+  }
+  return Array.from(stack).sort();
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength) + `
+
+[... truncated ...]`;
+}
+var repo_readme = tool({
+  description: "Get README.md content from a GitHub repository",
+  args: {
+    repo: tool.schema.string().describe('Repository (e.g., "owner/repo" or GitHub URL)'),
+    maxLength: tool.schema.number().optional().describe(`Max content length (default: ${DEFAULT_MAX_LENGTH})`)
+  },
+  async execute(args, ctx) {
+    try {
+      const { owner, repo } = parseRepo(args.repo);
+      const maxLength = args.maxLength || DEFAULT_MAX_LENGTH;
+      const readme = await githubFetch(`/repos/${owner}/${repo}/readme`);
+      if (!readme.content || !readme.encoding) {
+        return "README exists but content is not available";
+      }
+      const content = decodeContent(readme.content, readme.encoding);
+      const truncated = truncate(content, maxLength);
+      return JSON.stringify({
+        repo: `${owner}/${repo}`,
+        path: readme.path,
+        size: readme.size,
+        content: truncated,
+        truncated: content.length > maxLength
+      }, null, 2);
+    } catch (error45) {
+      if (error45 instanceof RepoCrawlError) {
+        return JSON.stringify({ error: error45.message }, null, 2);
+      }
+      throw error45;
+    }
+  }
+});
+var repo_structure = tool({
+  description: "Get repository structure with tech stack detection (root level only by default)",
+  args: {
+    repo: tool.schema.string().describe('Repository (e.g., "owner/repo" or GitHub URL)'),
+    depth: tool.schema.number().optional().describe(`Tree depth (1=root only, 2=one level deep, etc. Default: ${DEFAULT_DEPTH})`)
+  },
+  async execute(args, ctx) {
+    try {
+      const { owner, repo } = parseRepo(args.repo);
+      const depth = args.depth || DEFAULT_DEPTH;
+      const repoInfo = await githubFetch(`/repos/${owner}/${repo}`);
+      const tree = await githubFetch(`/repos/${owner}/${repo}/git/trees/${repoInfo.default_branch}`, {
+        method: "GET"
+      });
+      const filtered = tree.tree.filter((item) => {
+        const pathDepth = item.path.split("/").length;
+        return pathDepth <= depth;
+      });
+      const techStack = detectTechStack(filtered);
+      const dirs = filtered.filter((item) => item.type === "tree").map((item) => item.path);
+      const files = filtered.filter((item) => item.type === "blob").map((item) => item.path);
+      return JSON.stringify({
+        repo: repoInfo.full_name,
+        description: repoInfo.description,
+        language: repoInfo.language,
+        stars: repoInfo.stargazers_count,
+        topics: repoInfo.topics,
+        techStack,
+        directories: dirs.slice(0, 50),
+        files: files.slice(0, 50),
+        truncated: tree.truncated || dirs.length > 50 || files.length > 50
+      }, null, 2);
+    } catch (error45) {
+      if (error45 instanceof RepoCrawlError) {
+        return JSON.stringify({ error: error45.message }, null, 2);
+      }
+      throw error45;
+    }
+  }
+});
+var repo_tree = tool({
+  description: "Get directory tree for a path in a repository",
+  args: {
+    repo: tool.schema.string().describe('Repository (e.g., "owner/repo" or GitHub URL)'),
+    path: tool.schema.string().optional().describe("Path in repo (default: root)"),
+    maxDepth: tool.schema.number().optional().describe(`Max depth to traverse (default: ${DEFAULT_DEPTH})`)
+  },
+  async execute(args, ctx) {
+    try {
+      const { owner, repo } = parseRepo(args.repo);
+      const targetPath = args.path || "";
+      const maxDepth = args.maxDepth || DEFAULT_DEPTH;
+      const repoInfo = await githubFetch(`/repos/${owner}/${repo}`);
+      const contents = await githubFetch(`/repos/${owner}/${repo}/contents/${targetPath}`);
+      if (!Array.isArray(contents)) {
+        return JSON.stringify({ error: "Path is a file, not a directory" });
+      }
+      const tree = [];
+      for (const item of contents) {
+        tree.push({
+          path: item.path,
+          type: item.type,
+          size: item.size
+        });
+        if (item.type === "dir" && maxDepth > 1) {
+          try {
+            const subContents = await githubFetch(`/repos/${owner}/${repo}/contents/${item.path}`);
+            if (Array.isArray(subContents)) {
+              for (const subItem of subContents.slice(0, 20)) {
+                tree.push({
+                  path: subItem.path,
+                  type: subItem.type,
+                  size: subItem.size
+                });
+              }
+            }
+          } catch {}
+        }
+      }
+      return JSON.stringify({
+        repo: `${owner}/${repo}`,
+        path: targetPath || "(root)",
+        items: tree
+      }, null, 2);
+    } catch (error45) {
+      if (error45 instanceof RepoCrawlError) {
+        return JSON.stringify({ error: error45.message }, null, 2);
+      }
+      throw error45;
+    }
+  }
+});
+var repo_file = tool({
+  description: "Get file content from a GitHub repository",
+  args: {
+    repo: tool.schema.string().describe('Repository (e.g., "owner/repo" or GitHub URL)'),
+    path: tool.schema.string().describe("File path in repository"),
+    maxLength: tool.schema.number().optional().describe(`Max content length (default: ${DEFAULT_MAX_LENGTH})`)
+  },
+  async execute(args, ctx) {
+    try {
+      const { owner, repo } = parseRepo(args.repo);
+      const maxLength = args.maxLength || DEFAULT_MAX_LENGTH;
+      const file2 = await githubFetch(`/repos/${owner}/${repo}/contents/${args.path}`);
+      if (file2.type !== "file") {
+        return JSON.stringify({ error: "Path is not a file" });
+      }
+      if (!file2.content || !file2.encoding) {
+        return JSON.stringify({ error: "File content not available" });
+      }
+      const content = decodeContent(file2.content, file2.encoding);
+      const truncated = truncate(content, maxLength);
+      return JSON.stringify({
+        repo: `${owner}/${repo}`,
+        path: file2.path,
+        size: file2.size,
+        content: truncated,
+        truncated: content.length > maxLength
+      }, null, 2);
+    } catch (error45) {
+      if (error45 instanceof RepoCrawlError) {
+        return JSON.stringify({ error: error45.message }, null, 2);
+      }
+      throw error45;
+    }
+  }
+});
+var repo_search = tool({
+  description: "Search code in a GitHub repository",
+  args: {
+    repo: tool.schema.string().describe('Repository (e.g., "owner/repo" or GitHub URL)'),
+    query: tool.schema.string().describe("Search query (GitHub code search)"),
+    maxResults: tool.schema.number().optional().describe(`Max results (default: ${DEFAULT_MAX_RESULTS})`)
+  },
+  async execute(args, ctx) {
+    try {
+      const { owner, repo } = parseRepo(args.repo);
+      const maxResults = args.maxResults || DEFAULT_MAX_RESULTS;
+      const searchQuery = `${args.query} repo:${owner}/${repo}`;
+      const results = await githubFetch(`/search/code?q=${encodeURIComponent(searchQuery)}&per_page=${maxResults}`);
+      const items = results.items.map((item) => ({
+        path: item.path,
+        url: item.html_url,
+        matches: item.text_matches?.map((m) => m.fragment) || []
+      }));
+      return JSON.stringify({
+        repo: `${owner}/${repo}`,
+        query: args.query,
+        totalCount: results.total_count,
+        results: items
+      }, null, 2);
+    } catch (error45) {
+      if (error45 instanceof RepoCrawlError) {
+        return JSON.stringify({ error: error45.message }, null, 2);
+      }
+      throw error45;
+    }
+  }
+});
+var repoCrawlTools = {
+  repo_readme,
+  repo_structure,
+  repo_tree,
+  repo_file,
+  repo_search
+};
 // src/anti-patterns.ts
 var PatternKindSchema = exports_external.enum(["pattern", "anti_pattern"]);
 var DecompositionPatternSchema = exports_external.object({
@@ -25602,7 +26024,8 @@ var SwarmPlugin = async (input) => {
       ...beadsTools,
       ...agentMailTools,
       ...structuredTools,
-      ...swarmTools
+      ...swarmTools,
+      ...repoCrawlTools
     },
     event: async ({ event }) => {
       if (event.type === "session.idle") {
@@ -25646,7 +26069,8 @@ var allTools = {
   ...beadsTools,
   ...agentMailTools,
   ...structuredTools,
-  ...swarmTools
+  ...swarmTools,
+  ...repoCrawlTools
 };
 export {
   SwarmPlugin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.12.10",
+  "version": "0.12.12",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "dist/index.js",

package/src/index.ts

@@ -30,6 +30,7 @@ import {
 } from "./agent-mail";
 import { structuredTools } from "./structured";
 import { swarmTools } from "./swarm";
+import { repoCrawlTools } from "./repo-crawl";
 
 /**
  * OpenCode Swarm Plugin
@@ -39,6 +40,7 @@ import { swarmTools } from "./swarm";
  * - agent-mail:* - Multi-agent coordination via Agent Mail MCP
  * - structured:* - Structured output parsing and validation
  * - swarm:* - Swarm orchestration and task decomposition
+ * - repo-crawl:* - GitHub API tools for repository research
  *
  * @param input - Plugin context from OpenCode
  * @returns Plugin hooks including tools, events, and tool execution hooks
@@ -102,12 +104,14 @@ export const SwarmPlugin: Plugin = async (
      * Tools are namespaced by module:
      * - beads:create, beads:query, beads:update, etc.
      * - agent-mail:init, agent-mail:send, agent-mail:reserve, etc.
+     * - repo-crawl:readme, repo-crawl:structure, etc.
      */
     tool: {
       ...beadsTools,
       ...agentMailTools,
       ...structuredTools,
       ...swarmTools,
+      ...repoCrawlTools,
     },
 
     /**
@@ -295,6 +299,7 @@ export const allTools = {
   ...agentMailTools,
   ...structuredTools,
   ...swarmTools,
+  ...repoCrawlTools,
 } as const;
 
 /**
@@ -361,3 +366,19 @@ export {
   type ToolStatus,
   type ToolAvailability,
 } from "./tool-availability";
+
+/**
+ * Re-export repo-crawl module
+ *
+ * Includes:
+ * - repoCrawlTools - All GitHub API repository research tools
+ * - repo_readme, repo_structure, repo_tree, repo_file, repo_search - Individual tools
+ * - RepoCrawlError - Error class
+ *
+ * Features:
+ * - Parse repos from various formats (owner/repo, URLs)
+ * - Optional GITHUB_TOKEN auth for higher rate limits (5000 vs 60 req/hour)
+ * - Tech stack detection from file patterns
+ * - Graceful rate limit handling
+ */
+export { repoCrawlTools, RepoCrawlError } from "./repo-crawl";

package/src/learning.ts

@@ -115,6 +115,21 @@ export const DecompositionStrategySchema = z.enum([
 ]);
 export type DecompositionStrategy = z.infer<typeof DecompositionStrategySchema>;
 
+/**
+ * Failure mode taxonomy (imported from evaluation.ts)
+ */
+export const FailureModeSchema = z.enum([
+  "timeout",
+  "conflict",
+  "validation",
+  "tool_failure",
+  "context_overflow",
+  "dependency_blocked",
+  "user_cancelled",
+  "unknown",
+]);
+export type FailureMode = z.infer<typeof FailureModeSchema>;
+
 /**
  * Outcome signals from a completed subtask
  *
@@ -138,6 +153,10 @@ export const OutcomeSignalsSchema = z.object({
   timestamp: z.string(), // ISO-8601
   /** Decomposition strategy used for this task */
   strategy: DecompositionStrategySchema.optional(),
+  /** Failure classification (only when success=false) */
+  failure_mode: FailureModeSchema.optional(),
+  /** Detailed failure context */
+  failure_details: z.string().optional(),
 });
 export type OutcomeSignals = z.infer<typeof OutcomeSignalsSchema>;