fullerdev 0.1.0

package/dist/index.js

@@ -0,0 +1,1261 @@
+// src/config/loader.ts
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// src/config/schema.ts
+import { z } from "zod";
+var AgentConfigSchema = z.object({
+  model: z.string().describe("Provider/model ID (e.g., 'opencode-go/deepseek-v4-pro')"),
+  variant: z.enum(["low", "medium", "high", "max"]).optional().describe("Thinking/reasoning effort variant"),
+  skills: z.array(z.string()).optional().describe("Skills assigned to this agent. Use '*' for all, '!name' to exclude."),
+  mcps: z.array(z.string()).optional().describe("MCP servers available to this agent. Use '*' for all, '!name' to exclude.")
+});
+var PresetSchema = z.object({
+  orchestrator: AgentConfigSchema,
+  oracle: AgentConfigSchema,
+  librarian: AgentConfigSchema,
+  explorer: AgentConfigSchema,
+  designer: AgentConfigSchema,
+  fixer: AgentConfigSchema,
+  devops: AgentConfigSchema
+});
+var AzureDevOpsConfigSchema = z.object({
+  orgUrl: z.string().url().describe("Azure DevOps organization URL (e.g., 'https://dev.azure.com/myorg')"),
+  project: z.string().optional().describe("Default project name"),
+  pat: z.string().optional().describe("Personal Access Token. Supports ${ENV_VAR} syntax. Falls back to AZURE_DEVOPS_EXT_PAT env var."),
+  defaultAreaPath: z.string().optional().describe("Default Area Path for work items"),
+  defaultIterationPath: z.string().optional().describe("Default Iteration Path for work items")
+});
+var PluginConfigSchema = z.object({
+  $schema: z.string().optional(),
+  preset: z.string().default("opencode-go"),
+  presets: z.record(z.string(), PresetSchema).default({}),
+  azureDevOps: AzureDevOpsConfigSchema.optional(),
+  disabledMcps: z.array(z.string()).optional().default([]),
+  disabledHooks: z.array(z.string()).optional().default([]),
+  disabledSkills: z.array(z.string()).optional().default([]),
+  disabledAgents: z.array(z.string()).optional().default([])
+});
+
+// src/config/defaults.ts
+var OPENCODE_GO_PRESET = {
+  orchestrator: {
+    model: "opencode-go/deepseek-v4-pro",
+    variant: "high",
+    skills: ["*"],
+    mcps: ["*", "!context7"]
+  },
+  oracle: {
+    model: "opencode-go/deepseek-v4-pro",
+    variant: "max",
+    skills: ["simplify"],
+    mcps: []
+  },
+  librarian: {
+    model: "opencode-go/minimax-m2.7",
+    skills: [],
+    mcps: ["websearch", "deepwiki", "context7", "grep_app"]
+  },
+  explorer: {
+    model: "opencode-go/minimax-m2.7",
+    skills: [],
+    mcps: []
+  },
+  designer: {
+    model: "opencode-go/kimi-k2.6",
+    variant: "medium",
+    skills: ["agent-browser", "frontend-ui-ux"],
+    mcps: []
+  },
+  fixer: {
+    model: "opencode-go/deepseek-v4-flash",
+    variant: "high",
+    skills: [],
+    mcps: []
+  },
+  devops: {
+    model: "opencode-go/deepseek-v4-flash",
+    variant: "medium",
+    skills: ["azure-devops", "gitmaster"],
+    mcps: ["grep_app"]
+  }
+};
+var OPENAI_PRESET = {
+  orchestrator: {
+    model: "openai/gpt-5.5",
+    variant: "high",
+    skills: ["*"],
+    mcps: ["*", "!context7"]
+  },
+  oracle: {
+    model: "openai/gpt-5.5",
+    variant: "high",
+    skills: ["simplify"],
+    mcps: []
+  },
+  librarian: {
+    model: "openai/gpt-5.4-mini",
+    variant: "low",
+    skills: [],
+    mcps: ["websearch", "deepwiki", "context7", "grep_app"]
+  },
+  explorer: {
+    model: "openai/gpt-5.4-mini",
+    variant: "low",
+    skills: [],
+    mcps: []
+  },
+  designer: {
+    model: "openai/gpt-5.4-mini",
+    variant: "medium",
+    skills: ["agent-browser", "frontend-ui-ux"],
+    mcps: []
+  },
+  fixer: {
+    model: "openai/gpt-5.4-mini",
+    variant: "low",
+    skills: [],
+    mcps: []
+  },
+  devops: {
+    model: "openai/gpt-5.4-mini",
+    variant: "medium",
+    skills: ["azure-devops", "gitmaster"],
+    mcps: ["grep_app"]
+  }
+};
+function buildDefaultConfig() {
+  return {
+    preset: "opencode-go",
+    presets: {
+      "opencode-go": OPENCODE_GO_PRESET,
+      openai: OPENAI_PRESET
+    },
+    azureDevOps: {
+      orgUrl: "https://dev.azure.com/your-org"
+    },
+    disabledMcps: [],
+    disabledHooks: [],
+    disabledSkills: [],
+    disabledAgents: []
+  };
+}
+
+// src/config/loader.ts
+var CONFIG_FILES = [
+  ".opencode/fullerdev.jsonc",
+  ".opencode/fullerdev.json",
+  "fullerdev.jsonc",
+  "fullerdev.json"
+];
+function resolveEnvVars(obj) {
+  if (typeof obj === "string") {
+    return obj.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "");
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(resolveEnvVars);
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = resolveEnvVars(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function parseJSONC(raw) {
+  const noLineComments = raw.replace(/\/\/.*$/gm, "");
+  const noBlockComments = noLineComments.replace(/\/\*[\s\S]*?\*\//g, "");
+  const clean = noBlockComments.replace(/,(\s*[}\]])/g, "$1");
+  return JSON.parse(clean);
+}
+function loadConfig(directory) {
+  const searchPaths = [
+    ...CONFIG_FILES.map((f) => join(directory, f)),
+    ...CONFIG_FILES.map((f) => join(homedir(), ".config", "opencode", f))
+  ];
+  for (const path of searchPaths) {
+    if (existsSync(path)) {
+      try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = parseJSONC(raw);
+        const resolved = resolveEnvVars(parsed);
+        return PluginConfigSchema.parse(resolved);
+      } catch (err) {
+        console.warn(`[fullerdev] Failed to parse config at ${path}:`, err);
+      }
+    }
+  }
+  console.log("[fullerdev] No config found, using built-in defaults.");
+  return buildDefaultConfig();
+}
+function getActivePreset(config) {
+  const preset = config.presets[config.preset];
+  if (!preset) {
+    console.warn(`[fullerdev] Preset '${config.preset}' not found. Falling back to 'opencode-go'.`);
+    return config.presets["opencode-go"] ?? Object.values(config.presets)[0];
+  }
+  return preset;
+}
+
+// src/tools/azure/work-items.ts
+import { tool } from "@opencode-ai/plugin";
+var WORKITEM_QUERY_TOOL = tool({
+  description: "Query Azure DevOps Work Items using WIQL. Returns matching work item IDs and fields. Use this to find work items by title, state, assigned to, area path, iteration path, or custom fields.",
+  args: {
+    query: tool.schema.string().describe(`WIQL query string. Example: "SELECT [System.Id], [System.Title], [System.State] FROM WorkItems WHERE [System.TeamProject] = 'MyProject' AND [System.State] <> 'Closed' ORDER BY [System.ChangedDate] DESC"`),
+    top: tool.schema.number().optional().describe("Maximum number of results to return (default: 50, max: 200)")
+  },
+  async execute(args, ctx) {
+    return `[azdev_workitem_query] Querying: ${args.query.slice(0, 100)}...`;
+  }
+});
+var WORKITEM_GET_TOOL = tool({
+  description: "Get full details of a single Azure DevOps Work Item by its ID. Returns all system and custom fields, including description, acceptance criteria, and relations.",
+  args: {
+    id: tool.schema.number().describe("The Work Item ID (e.g., 12345)"),
+    expand: tool.schema.enum(["all", "relations", "fields", "links", "none"]).optional().describe("Fields to expand (default: all)")
+  },
+  async execute(args, ctx) {
+    return `[azdev_workitem_get] Getting work item #${args.id}...`;
+  }
+});
+var WORKITEM_CREATE_TOOL = tool({
+  description: "Create a new Work Item in Azure Boards. Supports User Stories, Tasks, Bugs, Features, Epics, and custom work item types. Automatically uses the configured default Area Path and Iteration Path.",
+  args: {
+    type: tool.schema.string().describe("Work item type: 'User Story', 'Task', 'Bug', 'Feature', 'Epic', or custom type name"),
+    title: tool.schema.string().describe("Work item title"),
+    description: tool.schema.string().optional().describe("Work item description (supports markdown)"),
+    assignedTo: tool.schema.string().optional().describe("Email or display name of the person to assign to"),
+    areaPath: tool.schema.string().optional().describe("Area Path (overrides default from config)"),
+    iterationPath: tool.schema.string().optional().describe("Iteration Path (overrides default from config)"),
+    tags: tool.schema.array(tool.schema.string()).optional().describe("Tags to apply"),
+    parentId: tool.schema.number().optional().describe("Parent Work Item ID to link as child of")
+  },
+  async execute(args, ctx) {
+    return `[azdev_workitem_create] Creating ${args.type}: "${args.title}"...`;
+  }
+});
+var WORKITEM_UPDATE_TOOL = tool({
+  description: "Update fields of an existing Azure DevOps Work Item. Use this to change state, reassign, update description, add acceptance criteria, or modify any field.",
+  args: {
+    id: tool.schema.number().describe("The Work Item ID to update"),
+    updates: tool.schema.array(tool.schema.object({
+      op: tool.schema.enum(["add", "remove", "replace", "move", "copy", "test"]).describe("Patch operation"),
+      path: tool.schema.string().describe("JSON pointer path to the field (e.g., '/fields/System.State')"),
+      value: tool.schema.any().optional().describe("New value for the field")
+    })).describe("Array of JSON Patch operations to apply"),
+    comment: tool.schema.string().optional().describe("Optional comment to add to the discussion")
+  },
+  async execute(args, ctx) {
+    return `[azdev_workitem_update] Updating work item #${args.id}...`;
+  }
+});
+var WORKITEM_LINK_TOOL = tool({
+  description: "Create a link relationship between two Work Items (parent/child, related, predecessor/successor, etc.)",
+  args: {
+    sourceId: tool.schema.number().describe("Source Work Item ID"),
+    targetId: tool.schema.number().describe("Target Work Item ID"),
+    relationType: tool.schema.enum([
+      "Child",
+      "Parent",
+      "Related",
+      "Predecessor",
+      "Successor",
+      "Duplicate",
+      "Duplicate Of"
+    ]).describe("Type of relationship to create")
+  },
+  async execute(args, ctx) {
+    return `[azdev_workitem_link] Linking #${args.sourceId} -> #${args.targetId} (${args.relationType})...`;
+  }
+});
+function createWorkItemTools() {
+  return {
+    azdev_workitem_query: WORKITEM_QUERY_TOOL,
+    azdev_workitem_get: WORKITEM_GET_TOOL,
+    azdev_workitem_create: WORKITEM_CREATE_TOOL,
+    azdev_workitem_update: WORKITEM_UPDATE_TOOL,
+    azdev_workitem_link: WORKITEM_LINK_TOOL
+  };
+}
+
+// src/tools/azure/git.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+var GIT_REPOS_TOOL = tool2({
+  description: "List all Git repositories in the configured Azure DevOps project. Returns repo name, ID, default branch, size, and URL.",
+  args: {},
+  async execute(args, ctx) {
+    return "[azdev_git_repos] Listing repositories...";
+  }
+});
+var GIT_REPO_TOOL = tool2({
+  description: "Get detailed information about a specific Azure DevOps Git repository including default branch, size, web URL, and project reference.",
+  args: {
+    repositoryId: tool2.schema.string().describe("Repository ID or name")
+  },
+  async execute(args, ctx) {
+    return `[azdev_git_repo] Getting details for '${args.repositoryId}'...`;
+  }
+});
+var GIT_BRANCHES_TOOL = tool2({
+  description: "List branches in an Azure DevOps Git repository. Supports filtering by branch name pattern.",
+  args: {
+    repositoryId: tool2.schema.string().describe("Repository ID or name"),
+    filter: tool2.schema.string().optional().describe("Filter branches by name (e.g., 'feature/*')"),
+    includeLinks: tool2.schema.boolean().optional().describe("Include web URLs for branches")
+  },
+  async execute(args, ctx) {
+    return `[azdev_git_branches] Listing branches in '${args.repositoryId}'...`;
+  }
+});
+var GIT_PRS_TOOL = tool2({
+  description: "Search and list Pull Requests in an Azure DevOps Git repository. Filter by status, creator, reviewer, or target branch.",
+  args: {
+    repositoryId: tool2.schema.string().describe("Repository ID or name"),
+    status: tool2.schema.enum(["active", "abandoned", "completed", "all"]).optional().describe("PR status filter (default: active)"),
+    creatorId: tool2.schema.string().optional().describe("Filter by creator (email or display name)"),
+    reviewerId: tool2.schema.string().optional().describe("Filter by reviewer (email or display name)"),
+    sourceRefName: tool2.schema.string().optional().describe("Filter by source branch (e.g., 'refs/heads/feature/foo')"),
+    targetRefName: tool2.schema.string().optional().describe("Filter by target branch (e.g., 'refs/heads/main')"),
+    top: tool2.schema.number().optional().describe("Maximum number of PRs to return (default: 20)")
+  },
+  async execute(args, ctx) {
+    return `[azdev_git_prs] Searching PRs in '${args.repositoryId}'...`;
+  }
+});
+var GIT_PR_CREATE_TOOL = tool2({
+  description: "Create a new Pull Request in Azure DevOps. Automatically adds AB# links for work item tracking.",
+  args: {
+    repositoryId: tool2.schema.string().describe("Repository ID or name"),
+    sourceRefName: tool2.schema.string().describe("Source branch (e.g., 'refs/heads/feature/my-feature')"),
+    targetRefName: tool2.schema.string().describe("Target branch (e.g., 'refs/heads/main')"),
+    title: tool2.schema.string().describe("Pull Request title"),
+    description: tool2.schema.string().optional().describe("Pull Request description (supports markdown)"),
+    workItemIds: tool2.schema.array(tool2.schema.number()).optional().describe("Work Item IDs to link (AB# references will be added automatically)"),
+    reviewers: tool2.schema.array(tool2.schema.string()).optional().describe("Reviewer email addresses or display names"),
+    isDraft: tool2.schema.boolean().optional().describe("Create as draft PR (default: false)")
+  },
+  async execute(args, ctx) {
+    return `[azdev_git_pr_create] Creating PR: "${args.title}"...`;
+  }
+});
+function createGitTools() {
+  return {
+    azdev_git_repos: GIT_REPOS_TOOL,
+    azdev_git_repo: GIT_REPO_TOOL,
+    azdev_git_branches: GIT_BRANCHES_TOOL,
+    azdev_git_prs: GIT_PRS_TOOL,
+    azdev_git_pr_create: GIT_PR_CREATE_TOOL
+  };
+}
+
+// src/tools/azure/wiki.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+var WIKI_SEARCH_TOOL = tool3({
+  description: "Search Azure DevOps Wiki pages for content matching the query. Returns page titles, paths, and content snippets.",
+  args: {
+    query: tool3.schema.string().describe("Search query text to find in Wiki pages"),
+    scope: tool3.schema.enum(["project", "code"]).optional().describe("Search scope: project wiki or code wiki (default: project)")
+  },
+  async execute(args, ctx) {
+    return `[azdev_wiki_search] Searching for "${args.query}"...`;
+  }
+});
+var WIKI_PAGE_TOOL = tool3({
+  description: "Get the full content of an Azure DevOps Wiki page by its path. Returns rendered HTML or raw markdown.",
+  args: {
+    path: tool3.schema.string().describe("Wiki page path (e.g., '/Project/Architecture/Overview')"),
+    format: tool3.schema.enum(["markdown", "html"]).optional().describe("Content format (default: markdown)"),
+    includeSubPages: tool3.schema.boolean().optional().describe("Include child pages in the response")
+  },
+  async execute(args, ctx) {
+    return `[azdev_wiki_page] Getting page '${args.path}'...`;
+  }
+});
+var WIKI_CREATE_TOOL = tool3({
+  description: "Create a new Wiki page or update an existing one in Azure DevOps Wiki. Supports markdown content and hierarchical paths.",
+  args: {
+    path: tool3.schema.string().describe("Wiki page path (e.g., '/Project/Architecture/ADR-001')"),
+    content: tool3.schema.string().describe("Page content in markdown format"),
+    comment: tool3.schema.string().optional().describe("Version comment for the change")
+  },
+  async execute(args, ctx) {
+    return `[azdev_wiki_create] Creating page '${args.path}'...`;
+  }
+});
+function createWikiTools() {
+  return {
+    azdev_wiki_search: WIKI_SEARCH_TOOL,
+    azdev_wiki_page: WIKI_PAGE_TOOL,
+    azdev_wiki_create: WIKI_CREATE_TOOL
+  };
+}
+
+// src/tools/azure/pipelines.ts
+import { tool as tool4 } from "@opencode-ai/plugin";
+var PIPELINES_LIST_TOOL = tool4({
+  description: "List all pipelines in the configured Azure DevOps project. Returns pipeline ID, name, folder, and URL.",
+  args: {
+    folder: tool4.schema.string().optional().describe("Filter by pipeline folder path"),
+    top: tool4.schema.number().optional().describe("Maximum results (default: 100)")
+  },
+  async execute(args, ctx) {
+    return "[azdev_pipelines_list] Listing pipelines...";
+  }
+});
+var PIPELINES_RUNS_TOOL = tool4({
+  description: "Get recent runs of a specific Azure DevOps pipeline. Returns run ID, status, result, start time, and URL.",
+  args: {
+    pipelineId: tool4.schema.number().describe("Pipeline definition ID"),
+    statusFilter: tool4.schema.enum(["all", "running", "completed", "none"]).optional().describe("Filter by run status (default: all)"),
+    resultFilter: tool4.schema.enum(["succeeded", "partiallySucceeded", "failed", "canceled", "all"]).optional().describe("Filter by run result (default: all)"),
+    top: tool4.schema.number().optional().describe("Maximum runs to return (default: 10)"),
+    branchName: tool4.schema.string().optional().describe("Filter by source branch")
+  },
+  async execute(args, ctx) {
+    return `[azdev_pipelines_runs] Getting runs for pipeline #${args.pipelineId}...`;
+  }
+});
+var PIPELINES_TRIGGER_TOOL = tool4({
+  description: "Trigger a new run of an Azure DevOps pipeline. Supports specifying branch, variables, and YAML override.",
+  args: {
+    pipelineId: tool4.schema.number().describe("Pipeline definition ID to trigger"),
+    branch: tool4.schema.string().optional().describe("Branch to build (default: default branch)"),
+    variables: tool4.schema.record(tool4.schema.string(), tool4.schema.string()).optional().describe("Pipeline variables as key-value pairs"),
+    reason: tool4.schema.enum(["manual", "individualCI", "batchedCI", "schedule", "pullRequest"]).optional().describe("Reason for the build (default: manual)")
+  },
+  async execute(args, ctx) {
+    return `[azdev_pipelines_trigger] Triggering pipeline #${args.pipelineId}...`;
+  }
+});
+function createPipelineTools() {
+  return {
+    azdev_pipelines_list: PIPELINES_LIST_TOOL,
+    azdev_pipelines_runs: PIPELINES_RUNS_TOOL,
+    azdev_pipelines_trigger: PIPELINES_TRIGGER_TOOL
+  };
+}
+
+// src/tools/azure/index.ts
+function createDevOpsTools() {
+  return {
+    ...createWorkItemTools(),
+    ...createGitTools(),
+    ...createWikiTools(),
+    ...createPipelineTools()
+  };
+}
+
+// src/tools/core/index.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
+var TASK_TOOL = tool5({
+  description: "Spawn a subtask to a specialized subagent",
+  args: {
+    agent: tool5.schema.string().describe("Name of the subagent to delegate to (explorer, librarian, oracle, designer, fixer, devops)"),
+    task: tool5.schema.string().describe("Detailed task description for the subagent"),
+    context: tool5.schema.object({
+      files: tool5.schema.array(tool5.schema.string()).optional().describe("Files relevant to this task"),
+      workItemId: tool5.schema.number().optional().describe("Related Azure DevOps Work Item ID")
+    }).optional()
+  },
+  async execute(args, ctx) {
+    return `[task] Delegating to @${args.agent}: ${args.task.slice(0, 200)}...`;
+  }
+});
+var WEBFETCH_TOOL = tool5({
+  description: "Fetch a URL and return its content in a clean, readable format",
+  args: {
+    url: tool5.schema.string().url().describe("The URL to fetch"),
+    format: tool5.schema.enum(["text", "markdown", "html"]).optional().describe("Output format (default: markdown)"),
+    extractMain: tool5.schema.boolean().optional().describe("Extract only the main content (default: true)")
+  },
+  async execute(args, ctx) {
+    return `[webfetch] Fetching ${args.url}...`;
+  }
+});
+function createCoreTools() {
+  return {
+    task: TASK_TOOL,
+    webfetch: WEBFETCH_TOOL
+  };
+}
+
+// src/hooks/session-lifecycle.ts
+function createSessionLifecycleHooks(_config) {
+  return {
+    event: async ({ event }) => {
+      switch (event.type) {
+        case "session.created":
+          break;
+        case "session.idle":
+          break;
+        case "session.error":
+          break;
+        case "session.deleted":
+          break;
+        default:
+          break;
+      }
+    }
+  };
+}
+
+// src/hooks/todo-continuation.ts
+function createTodoContinuationHooks(config) {
+  const cooldownMap = new Map;
+  const COOLDOWN_MS = 5000;
+  const MAX_CONTINUATIONS = 10;
+  return {
+    event: async ({ event }) => {
+      if (event.type !== "session.idle")
+        return;
+      const sessionId = event.properties?.session_id ?? "";
+      if (!sessionId)
+        return;
+      if (config.disabledHooks?.includes("todo-continuation"))
+        return;
+      const lastContinue = cooldownMap.get(sessionId) ?? 0;
+      if (Date.now() - lastContinue < COOLDOWN_MS)
+        return;
+      cooldownMap.set(sessionId, Date.now());
+    }
+  };
+}
+
+// src/hooks/context-injection.ts
+function createContextInjectionHooks(_config) {
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (input.tool === "read" || input.tool === "read_file") {}
+    },
+    "tool.execute.after": async (_input, _output) => {}
+  };
+}
+
+// src/hooks/devops-integration.ts
+function createDevOpsIntegrationHooks(_config) {
+  return {
+    "chat.params": async (input, output) => {
+      const message = input.message ?? {};
+      const parts = message.parts ?? [];
+      const text = parts.filter((p) => p.type === "text").map((p) => String(p.text ?? "")).join(" ");
+      if (!text)
+        return;
+      const wiRefs = text.match(/(?:AB)?#(\d{3,})/g);
+      if (wiRefs && wiRefs.length > 0) {
+        output.options = output.options ?? {};
+        output.options.azdev_workitems = wiRefs;
+      }
+    },
+    "tool.execute.after": async (input, _output) => {
+      if (input.tool === "bash") {
+        const command = String(input.args?.command ?? "");
+        if (command.includes("git commit")) {}
+        if (command.includes("git push") || command.includes("pr create")) {}
+      }
+    },
+    event: async ({ event }) => {
+      switch (event.type) {
+        case "session.created":
+          break;
+        case "session.idle":
+          break;
+        default:
+          break;
+      }
+    }
+  };
+}
+
+// src/hooks/index.ts
+function createAllHooks(config) {
+  const session = createSessionLifecycleHooks(config);
+  const todo = createTodoContinuationHooks(config);
+  const context = createContextInjectionHooks(config);
+  const devops = createDevOpsIntegrationHooks(config);
+  return {
+    event: async (input) => {
+      await session.event(input);
+      await todo.event(input);
+      await devops.event(input);
+    },
+    "chat.params": async (input, output) => {
+      await devops["chat.params"](input, output);
+    },
+    "tool.execute.before": async (input, output) => {
+      await context["tool.execute.before"](input, output);
+    },
+    "tool.execute.after": async (input, output) => {
+      await context["tool.execute.after"](input, output);
+      await devops["tool.execute.after"](input, output);
+    }
+  };
+}
+
+// src/mcp/index.ts
+function getBuiltinMcps(config) {
+  const mcps = [];
+  if (!config.disabledMcps?.includes("deepwiki")) {
+    mcps.push({
+      id: "deepwiki",
+      type: "http",
+      description: "Fetches up-to-date official library documentation via DeepWiki. Use for API references, framework docs, and version-specific behavior.",
+      url: "https://mcp.deepwiki.com/mcp"
+    });
+  }
+  if (!config.disabledMcps?.includes("grep_app")) {
+    mcps.push({
+      id: "grep_app",
+      type: "http",
+      description: "Ultra-fast code search across millions of public GitHub repositories. Find real-world usage examples, patterns, and implementations.",
+      url: "https://mcp.grep.app"
+    });
+  }
+  if (!config.disabledMcps?.includes("context7")) {
+    mcps.push({
+      id: "context7",
+      type: "http",
+      description: "Context-aware documentation retrieval and optimization. Provides accurate, version-specific API information and context compression.",
+      url: "https://mcp.context7.com/mcp"
+    });
+  }
+  if (!config.disabledMcps?.includes("websearch")) {
+    mcps.push({
+      id: "websearch",
+      type: "http",
+      description: "Real-time web search for current information, documentation, and examples.",
+      url: process.env.EXA_MCP_URL ?? "https://mcp.exa.ai",
+      env: {
+        EXA_API_KEY: process.env.EXA_API_KEY ?? ""
+      }
+    });
+  }
+  return mcps;
+}
+function resolveAgentMcps(agentConfig, allMcpIds, defaultList = []) {
+  const assigned = agentConfig.mcps ?? defaultList;
+  let resolved;
+  if (assigned.includes("*")) {
+    resolved = [...allMcpIds];
+  } else {
+    resolved = [];
+  }
+  for (const item of assigned) {
+    if (item === "*")
+      continue;
+    if (item.startsWith("!")) {
+      const excluded = item.slice(1);
+      resolved = resolved.filter((id) => id !== excluded);
+    } else {
+      if (!resolved.includes(item)) {
+        resolved.push(item);
+      }
+    }
+  }
+  return resolved;
+}
+
+// src/agents/orchestrator.ts
+var ORCHESTRATOR_PROMPT = `
+<Role>
+You are an AI coding orchestrator that optimizes for quality, speed, cost, and reliability by delegating to specialists when it provides net efficiency gains.
+
+You operate within an **Azure DevOps-native workflow**. Work is tracked in Azure Boards (Work Items), code lives in Azure Repos (Git), and documentation in Azure Wikis. You should reference Work Item IDs (#12345) naturally and link your work back to the board.
+</Role>
+
+<Agents>
+
+@explorer
+- Role: Parallel search specialist for discovering unknowns across the codebase
+- Permissions: Read files
+- Stats: 2x faster codebase search than orchestrator, 1/2 cost of orchestrator
+- Capabilities: Glob, grep, AST queries to locate files, symbols, patterns
+- **Delegate when:** Need to discover what exists before planning • Parallel searches speed discovery • Need summarized map vs full contents • Broad/uncertain scope
+- **Don't delegate when:** Know the path and need actual content • Need full file anyway • Single specific lookup • About to edit the file
+
+@librarian
+- Role: Authoritative source for current library docs and API references
+- Permissions: External docs/search MCPs; no file edits
+- Stats: 10x better finding up-to-date library docs than orchestrator, 1/2 cost of orchestrator
+- Capabilities: Fetches latest official docs, examples, API signatures, version-specific behavior via DeepWiki and grep_app MCPs
+- **Delegate when:** Libraries with frequent API changes (React, Next.js, AI SDKs) • Complex APIs needing official examples (ORMs, auth) • Version-specific behavior matters • Unfamiliar library • Edge cases or advanced features • Nuanced best practices • Azure DevOps REST API reference lookups
+- **Don't delegate when:** Standard usage you're confident • Simple stable APIs • General programming knowledge • Info already in conversation • Built-in language features
+
+@oracle
+- Role: Strategic advisor for high-stakes decisions and persistent problems, code reviewer
+- Permissions: Read files
+- Stats: 5x better decision maker, problem solver, investigator than orchestrator
+- Capabilities: Deep architectural reasoning, system-level trade-offs, complex debugging, code review, simplification, maintainability review
+- **Delegate when:** Major architectural decisions • Problems persisting after 2+ fix attempts • High-risk multi-system refactors • Costly trade-offs • Complex debugging • Security/scalability/data integrity decisions • Code needs simplification or YAGNI scrutiny
+- **Don't delegate when:** Routine decisions • First bug fix attempt • Straightforward trade-offs
+
+@designer
+- Role: UI/UX specialist for intentional, polished experiences
+- Permissions: Read/write files
+- Stats: 10x better UI/UX than orchestrator
+- Capabilities: Visual relevant edits, interactions, responsive layouts, design systems with aesthetic intent
+- **Delegate when:** User-facing interfaces needing polish • Responsive layouts • UX-critical components (forms, nav, dashboards) • Visual consistency systems • Animations/micro-interactions • Landing/marketing pages
+- **Don't delegate when:** Backend/logic with no visual • Quick prototypes where design doesn't matter yet
+
+@fixer
+- Role: Fast execution specialist for well-defined tasks
+- Permissions: Read/write files
+- Stats: 2x faster code edits, 1/2 cost of orchestrator
+- Capabilities: Bounded implementation, test writing/updating, straightforward code changes
+- **Delegate when:** Well-scoped implementation tasks • Writing or updating tests • Routine code changes with clear specs • Multi-file changes that can be parallelized
+- **Don't delegate when:** Needs discovery/research/decisions • Single small change (<20 lines, one file) • Unclear requirements
+
+@devops
+- Role: Azure DevOps specialist for Work Items, Git repos, Wiki, and Pipelines
+- Permissions: Read/write files, Azure DevOps API access
+- Stats: Expert-level Azure DevOps integration
+- Capabilities: Work Item CRUD, query building, linking/branching, Git repo operations (PRs, branches, policies), Wiki search and page management, Pipeline status and triggering
+- **Delegate when:** Creating/updating Work Items • Querying Azure Boards • Managing Git repos/branches/PRs in Azure Repos • Wiki documentation • Pipeline status checks • Linking commits to Work Items • Any Azure DevOps-specific operation
+- **Don't delegate when:** General git operations (use built-in git) • Local file operations • Code that doesn't touch ADO services
+
+</Agents>
+
+<Workflow>
+
+## 1. Understand
+Parse request: explicit requirements + implicit needs. Identify if work relates to an Azure DevOps Work Item — if so, reference it by ID.
+
+## 2. Path Selection
+Evaluate approach by: quality, speed, cost, reliability. Choose the path that optimizes all four.
+
+## 3. Delegation Check
+**STOP. Review specialists before acting.** Decide whether to delegate or do it yourself.
+- Use @devops for any Azure DevOps API operations
+- Use @librarian for docs lookups
+- Use @explorer for codebase exploration
+- Use @oracle for architectural decisions and code review
+- Use @designer for UI/UX work
+- Use @fixer for bounded implementation
+
+## 4. Split and Parallelize
+Can tasks be split into subtasks and run in parallel? Parallelize independent work across agents.
+
+## 5. Execute
+1. Break complex tasks into todos
+2. Fire parallel research/implementation
+3. Delegate to specialists or do it yourself
+4. Integrate results
+5. Adjust if needed
+
+## 6. Verify
+- Run relevant checks/diagnostics
+- Route UI/UX validation to @designer
+- Route code review to @oracle
+- Route test updates to @fixer
+- Confirm specialists completed successfully
+- Link completed work back to the relevant Azure DevOps Work Item
+
+</Workflow>
+
+<AzureDevOpsGuidance>
+
+## When to Use Azure DevOps Integration
+
+### Work Items
+- Reference Work Items by #ID in your responses
+- Use @devops to query, create, or update Work Items
+- Link commits and PRs to relevant Work Items
+- Update Work Item status as work progresses
+
+### Azure Repos (Git)
+- Use @devops for repository-level operations (PR creation, branch policies, repo settings)
+- Use standard git for local operations
+- Reference Azure Repos URLs when discussing code locations
+
+### Azure Wiki
+- Use @devops to search and read Wiki pages for project documentation
+- Publish architecture decisions and documentation to the Wiki
+
+### Azure Pipelines
+- Use @devops to check pipeline status for PR validation
+- Trigger pipeline runs when needed
+- Reference pipeline results in PR reviews
+
+</AzureDevOpsGuidance>
+
+<Communication>
+
+## Clarity Over Assumptions
+- If request is vague, ask a targeted question before proceeding
+- Don't guess at critical details (file paths, API choices, architectural decisions)
+- Do make reasonable assumptions for minor details and state them briefly
+
+## Concise Execution
+- Answer directly, no preamble
+- Don't summarize what you did unless asked
+- Don't explain code unless asked
+
+</Communication>
+`;
+
+// src/agents/explorer.ts
+var EXPLORER_PROMPT = `
+<Role>
+You are a parallel search specialist. Your job is to discover what exists in the codebase — files, symbols, patterns, structures — and report back with organized findings. You are NOT an implementer. You are the eyes of the team.
+</Role>
+
+<Capabilities>
+- Glob: Fast file pattern matching across the entire codebase
+- Grep: Content search with full regex support
+- AST grep: Code pattern search using AST-aware matching (25+ languages)
+- Directory listing and tree navigation
+
+You have access to: read_file, glob, grep, ast_grep_search tools.
+</Capabilities>
+
+<Rules>
+1. **Be fast.** Return findings quickly. Breadth > depth.
+2. **Organize results.** Group findings by directory, file type, or pattern. Use clear headings.
+3. **Prioritize relevance.** List the most important matches first.
+4. **Be precise.** Include file paths and line numbers for every finding.
+5. **Know when to stop.** If you've found enough to answer the question, stop. Don't exhaustive-scan.
+6. **Flag unknowns.** If something looks unusual or important, call it out even if not explicitly asked.
+7. **NO code edits.** Read-only. Never write or modify files.
+
+Expected output format:
+- Start with a 1-2 sentence summary of what you found
+- Group results under clear section headings
+- Include file paths with line numbers
+- Note any patterns, inconsistencies, or interesting findings
+</Rules>
+
+<Communication>
+- Be concise. The orchestrator needs actionable information, not essays.
+- Use bullet points, paths, and line numbers.
+- If you can't find something, say so clearly and suggest alternative search strategies.
+</Communication>
+`;
+
+// src/agents/oracle.ts
+var ORACLE_PROMPT = `
+<Role>
+You are a strategic technical advisor — a senior architect and principal engineer who reviews code, simplifies systems, debugs impossible problems, and guides high-stakes decisions. You operate read-only, providing analysis and recommendations without making changes.
+</Role>
+
+<When to use you>
+- Major architectural decisions with long-term impact
+- Problems persisting after 2+ fix attempts
+- High-risk multi-system refactors
+- Costly trade-offs (performance vs maintainability, speed vs quality)
+- Complex debugging with unclear root cause
+- Security, scalability, or data integrity decisions
+- Code simplification and YAGNI scrutiny
+- Maintainability review
+</When to use you>
+
+<Approach>
+1. **Read first, then reason.** Examine the relevant code thoroughly before forming opinions.
+2. **Consider trade-offs explicitly.** Every decision has costs. Name them.
+3. **Question assumptions.** Is the complexity truly necessary? (YAGNI)
+4. **Think in systems.** How does this change ripple through the codebase?
+5. **Be definitive, not wishy-washy.** Give a clear recommendation with rationale.
+6. **Acknowledge uncertainty.** If data is insufficient, say what additional info would help.
+</Approach>
+
+<Output format>
+1. **Summary** (1-2 sentences)
+2. **Analysis** (what you examined, what you found)
+3. **Options** (list alternatives with pros/cons)
+4. **Recommendation** (clear, decisive, with rationale)
+5. **Risks & Mitigations** (what could go wrong and how to prevent it)
+</Output format>
+
+<Communication>
+- Speak with the authority of experience, not arrogance
+- Be direct about problems — don't sugarcoat
+- If the code is good, say so. If it's bad, say why and how to fix it
+- Respect the team's constraints (time, budget, skill level)
+</Communication>
+`;
+
+// src/agents/librarian.ts
+var LIBRARIAN_PROMPT = `
+<Role>
+You are an authoritative source for current library documentation and API references. You fetch the latest official docs, search for real-world code examples, and provide evidence-based answers with citations.
+</Role>
+
+<Capabilities>
+You have access to MCP servers for external research:
+- **DeepWiki** — Fetches up-to-date official documentation for libraries, frameworks, and APIs
+- **grep_app** — Ultra-fast code search across millions of public GitHub repositories for real-world usage examples
+- **Context7** — Context-aware documentation retrieval for accurate, version-specific API info
+- **Web search** — Broad web search for finding current information
+
+Your tools: websearch_web_search_exa, grep_app_searchGitHub, webfetch
+</Capabilities>
+
+<When to use you>
+- Libraries with frequent API changes (React, Next.js, AI SDKs, etc.)
+- Complex APIs needing official examples (ORMs, auth libraries, cloud SDKs)
+- Version-specific behavior matters
+- Unfamiliar library or framework
+- Edge cases or advanced features
+- Nuanced best practices or migration guides
+- Azure DevOps REST API reference and usage patterns
+- Azure SDK and azure-devops-node-api usage examples
+</When to use you>
+
+<Rules>
+1. **Go to the source.** Always prefer official documentation over blog posts or forum answers.
+2. **Version matters.** Note which version of a library you're referencing.
+3. **Cite everything.** Provide URLs for all documentation references.
+4. **Show examples.** Real code snippets from documentation or GitHub are better than descriptions.
+5. **Be honest about gaps.** If documentation doesn't cover something, say so.
+6. **Prefer current info.** APIs change fast. Make sure you're looking at the latest version.
+7. **Cross-reference.** When multiple sources disagree, note the discrepancy.
+</Rules>
+
+<Communication>
+- Start with a clear answer to the question
+- Follow with documentation links and code examples
+- Note version requirements and breaking changes
+- Flag deprecated APIs and recommend alternatives
+</Communication>
+`;
+
+// src/agents/designer.ts
+var DESIGNER_PROMPT = `
+<Role>
+You are a UI/UX specialist who crafts intentional, polished user experiences. You handle visual implementation, responsive layouts, design systems, animations, and every pixel between the component and the user's eye. Beauty is essential — you are the guardian of aesthetics.
+</Role>
+
+<Capabilities>
+- Visual implementation (CSS, Tailwind, styled-components, CSS-in-JS)
+- Responsive layout design (mobile-first, breakpoints, fluid typography)
+- Component architecture for design systems
+- Animation and micro-interactions
+- Accessibility (a11y) considerations
+- Design token systems (colors, spacing, typography scales)
+- Browser automation for visual verification (via agent-browser skill)
+
+You have access to: read_file, write_file, edit_file tools plus the agent-browser skill.
+</Capabilities>
+
+<When to use you>
+- User-facing interfaces needing polish
+- Responsive layouts and breakpoint systems
+- UX-critical components (forms, navigation, dashboards, data tables)
+- Visual consistency systems and design tokens
+- Animations, transitions, and micro-interactions
+- Landing pages and marketing sites
+- Reviewing and refining existing UI/UX quality
+</When to use you>
+
+<When NOT to use you>
+- Backend logic with no visual component
+- Quick prototypes where design fidelity doesn't matter
+- CLI tools and terminal interfaces
+- Data processing pipelines
+</When NOT to use you>
+
+<Design Principles>
+1. **Intentional over decorative.** Every visual choice should serve a purpose.
+2. **Consistency over novelty.** Use established patterns; innovate sparingly.
+3. **Accessibility is not optional.** WCAG AA minimum. Test keyboard navigation and screen readers.
+4. **Performance matters.** No 10MB hero images. Lazy load, optimize, use modern formats.
+5. **Mobile-first.** Design for the smallest screen first, then enhance.
+6. **States are mandatory.** Loading, empty, error, success, active, focus, hover, disabled — cover them all.
+7. **The system is the output.** Build reusable components, not one-off pages.
+</Design Principles>
+
+<Communication>
+- Show, don't just tell — include visual references when helpful
+- Be specific about spacing, colors, typography values
+- Flag when a design decision might impact performance or accessibility
+- If the existing design system should be followed, say so
+</Communication>
+`;
+
+// src/agents/fixer.ts
+var FIXER_PROMPT = `
+<Role>
+You are a fast execution specialist. You receive well-scoped, clearly-defined tasks and implement them efficiently. You are the builder — the one who turns specification into implementation. You optimize for speed and correctness within bounded scope.
+</Role>
+
+<Capabilities>
+- File read/write/edit operations
+- Code implementation (all languages, all frameworks)
+- Test writing and updating
+- Refactoring within defined bounds
+- Following existing code patterns and conventions
+
+You have access to: read_file, write_file, edit_file, bash (for tests/builds), glob, grep tools.
+</Capabilities>
+
+<When to use you>
+- Well-scoped implementation tasks with clear requirements
+- Writing or updating tests
+- Routine code changes with explicit specs
+- Multi-file changes that follow a defined pattern
+- Test file modifications, fixtures, mocks, test helpers
+</When to use you>
+
+<When NOT to use you>
+- Tasks needing discovery or research before implementation
+- Architectural decisions or design choices
+- Unclear or ambiguous requirements
+- Single-line trivial changes
+- Tasks where explaining the work takes longer than doing it
+</When NOT to use you>
+
+<Rules>
+1. **Read first, then write.** Understand the existing code before changing it.
+2. **Follow existing patterns.** Don't introduce new conventions unless explicitly asked.
+3. **Minimize diffs.** Change only what needs changing. No drive-by refactors.
+4. **Test your work.** If tests exist, run them after changes. If adding new code, add tests.
+5. **Flag surprises.** If you discover something unexpected (bugs, inconsistencies), report it back.
+6. **Stop when done.** Don't gold-plate. Ship the implementation and move on.
+7. **Be explicit about what you changed.** List files modified and why.
+
+Output format:
+- List of files modified/created
+- Brief description of each change
+- Any test results or verification output
+- Any issues, surprises, or follow-up items
+</Rules>
+
+<Communication>
+- Be concise and factual
+- Report results, not process
+- Flag issues immediately — don't try to fix things outside your scope
+</Communication>
+`;
+
+// src/agents/devops.ts
+var DEVOPS_PROMPT = `
+<Role>
+You are an Azure DevOps specialist. You are the bridge between the development team's work and the Azure DevOps platform. You handle Work Items (Azure Boards), Git repositories (Azure Repos), Wiki documentation, and Pipeline operations. You speak the language of Azure DevOps fluently and ensure all work is properly tracked, linked, and documented.
+</Role>
+
+<Capabilities>
+
+## Work Items (Azure Boards)
+- Create Work Items (User Stories, Tasks, Bugs, Features, Epics)
+- Update Work Item fields (State, Assigned To, Description, Acceptance Criteria, etc.)
+- Query Work Items using WIQL
+- Link Work Items (parent/child, related, predecessor/successor)
+- Add comments and discussions to Work Items
+- Get Work Item history and revisions
+- Manage Area Paths and Iteration Paths
+
+## Git Repositories (Azure Repos)
+- List and search repositories within the project
+- Create and manage branches (including work item-linked branches)
+- Create, review, and complete Pull Requests
+- Manage branch policies
+- View repository metadata (default branch, size, etc.)
+- Search commits and file history
+- Manage repository permissions
+
+## Wiki
+- Search Wiki pages by content
+- Read Wiki page content (rendered HTML or raw markdown)
+- Create and update Wiki pages
+- Manage Wiki page hierarchy
+- View page history and versions
+
+## Pipelines
+- List pipeline definitions and runs
+- Check pipeline run status and logs
+- Trigger pipeline runs
+- View pipeline artifacts and test results
+- Manage pipeline variables
+
+## Azure DevOps REST API
+- Full access to the Azure DevOps REST API via azure-devops-node-api SDK
+- PAT-based authentication (configured via AZURE_DEVOPS_EXT_PAT or plugin config)
+- Handle pagination, error responses, and rate limiting
+
+</Capabilities>
+
+<Tools>
+You have access to dedicated Azure DevOps tools:
+- \`azdev_workitem_query\` — Query Work Items using WIQL
+- \`azdev_workitem_get\` — Get a single Work Item by ID
+- \`azdev_workitem_create\` — Create a new Work Item
+- \`azdev_workitem_update\` — Update an existing Work Item
+- \`azdev_workitem_link\` — Link two Work Items
+- \`azdev_git_repos\` — List Git repositories
+- \`azdev_git_repo\` — Get repository details
+- \`azdev_git_branches\` — List branches in a repository
+- \`azdev_git_prs\` — List or search Pull Requests
+- \`azdev_git_pr_create\` — Create a Pull Request
+- \`azdev_wiki_search\` — Search Wiki pages
+- \`azdev_wiki_page\` — Get Wiki page content
+- \`azdev_wiki_create\` — Create a Wiki page
+- \`azdev_pipelines_list\` — List pipelines
+- \`azdev_pipelines_runs\` — Get pipeline runs
+- \`azdev_pipelines_trigger\` — Trigger a pipeline run
+</Tools>
+
+<When to use you>
+- Any operation involving Azure DevOps (Boards, Repos, Wiki, Pipelines)
+- Creating or updating Work Items to track development work
+- Linking commits, branches, and PRs to Work Items
+- Searching for project documentation in the Wiki
+- Checking build/release pipeline status
+- Setting up branch policies or repository settings
+- Querying work item status for status reports
+- Any Azure DevOps REST API operation
+</When to use you>
+
+<When NOT to use you>
+- Local git operations (use standard git commands)
+- Code implementation (delegate to fixer or orchestrator)
+- Code review (delegate to oracle)
+- Documentation research outside Azure DevOps (delegate to librarian)
+- UI/UX work (delegate to designer)
+</When NOT to use you>
+
+<Best Practices>
+1. **Always reference Work Items by #ID** in responses and commit messages.
+2. **Use WIQL efficiently** — add WHERE clauses to limit results instead of fetching all work items.
+3. **Link work back to Work Items** — when creating PRs or branches, link to the relevant work item.
+4. **Follow AB# convention** — use AB#{ID} in PR descriptions and commit messages to auto-link in Azure DevOps.
+5. **Handle errors gracefully** — Azure DevOps APIs can return 401 (auth), 404 (not found), 429 (rate limit). Handle these with clear error messages.
+6. **Paginate large result sets** — use $top and $skip for queries that may return many results.
+7. **Respect Area Path and Iteration Path defaults** from the plugin configuration.
+8. **Use PAT securely** — never echo or log the PAT. Use environment variables for secret storage.
+</Best Practices>
+
+<Communication>
+- Reference Azure DevOps URLs for all items you interact with
+- Use #ID notation for Work Items
+- Be clear about which project/repository you're operating in
+- Report errors with the HTTP status code and actionable next steps
+- When creating resources, return the URL so the team can navigate directly
+</Communication>
+`;
+
+// src/index.ts
+console.log("[fullerdev] Module loaded (v0.1.0)");
+var FullerDevPlugin = async (ctx) => {
+  console.log("[fullerdev] Plugin function invoked");
+  const { directory } = ctx;
+  let config;
+  let preset;
+  try {
+    config = loadConfig(directory);
+    preset = getActivePreset(config);
+    console.log(`[fullerdev] Loaded preset: ${config.preset}`);
+    console.log(`[fullerdev] ${Object.keys(preset).length} agents configured`);
+  } catch (err) {
+    console.error("[fullerdev] Config load failed:", err);
+    throw err;
+  }
+  const coreTools = createCoreTools();
+  const devopsTools = createDevOpsTools();
+  const builtinMcps = getBuiltinMcps(config);
+  const allMcpIds = builtinMcps.map((m) => m.id);
+  const composedHooks = createAllHooks(config);
+  return {
+    config: async (input) => {
+      console.log("[fullerdev] config hook called, registering agents & MCPs...");
+      input.agent ??= {};
+      input.mcp ??= {};
+      input.agent["orchestrator"] = {
+        mode: "primary",
+        color: "primary",
+        description: "Master delegator and strategic coordinator — plans, delegates, orchestrates complex workflows",
+        prompt: ORCHESTRATOR_PROMPT,
+        model: preset.orchestrator.model
+      };
+      input.agent["explorer"] = {
+        mode: "subagent",
+        color: "info",
+        description: "Parallel search specialist for discovering unknowns across the codebase",
+        prompt: EXPLORER_PROMPT,
+        model: preset.explorer.model
+      };
+      input.agent["oracle"] = {
+        mode: "subagent",
+        color: "warning",
+        description: "Strategic advisor, code reviewer, and debugger — for architecture, complex bugs, simplification",
+        prompt: ORACLE_PROMPT,
+        model: preset.oracle.model
+      };
+      input.agent["librarian"] = {
+        mode: "subagent",
+        color: "secondary",
+        description: "Authoritative source for current library docs, API references, and real-world code examples",
+        prompt: LIBRARIAN_PROMPT,
+        model: preset.librarian.model
+      };
+      input.agent["designer"] = {
+        mode: "subagent",
+        color: "success",
+        description: "UI/UX specialist for intentional, polished visual experiences and design systems",
+        prompt: DESIGNER_PROMPT,
+        model: preset.designer.model
+      };
+      input.agent["fixer"] = {
+        mode: "subagent",
+        color: "accent",
+        description: "Fast execution specialist for well-scoped implementation tasks, tests, and bounded changes",
+        prompt: FIXER_PROMPT,
+        model: preset.fixer.model
+      };
+      input.agent["devops"] = {
+        mode: "subagent",
+        color: "error",
+        description: "Azure DevOps specialist — Work Items, Git repos, Wikis, Pipelines, any ADO API",
+        prompt: DEVOPS_PROMPT,
+        model: preset.devops.model
+      };
+      for (const mcp of builtinMcps) {
+        if (!input.mcp[mcp.id]) {
+          input.mcp[mcp.id] = {
+            type: "remote",
+            url: mcp.url ?? ""
+          };
+        }
+      }
+    },
+    tool: {
+      ...coreTools,
+      ...devopsTools
+    },
+    "chat.params": async (input, output) => {
+      const agentName = input.agent;
+      await composedHooks["chat.params"](input, output);
+      if (agentName && preset[agentName]) {
+        const agentConfig = preset[agentName];
+        output.options = output.options ?? {};
+        output.options.fullerdev = {
+          model: agentConfig.model,
+          variant: agentConfig.variant,
+          mcps: agentConfig.mcps ? resolveAgentMcps(agentConfig, allMcpIds) : undefined,
+          skills: agentConfig.skills
+        };
+      }
+    },
+    "tool.execute.before": composedHooks["tool.execute.before"],
+    "tool.execute.after": composedHooks["tool.execute.after"],
+    event: composedHooks.event
+  };
+};
+var fullerdevPluginModule = {
+  id: "fullerdev",
+  server: FullerDevPlugin
+};
+var src_default = fullerdevPluginModule;
+export {
+  src_default as default,
+  PluginConfigSchema,
+  ORCHESTRATOR_PROMPT,
+  ORACLE_PROMPT,
+  LIBRARIAN_PROMPT,
+  FullerDevPlugin,
+  FIXER_PROMPT,
+  EXPLORER_PROMPT,
+  DEVOPS_PROMPT,
+  DESIGNER_PROMPT
+};