@glrs-dev/cli 0.0.1 → 0.1.1

package/dist/vendor/harness-opencode/dist/index.js

@@ -0,0 +1,2092 @@
+import {
+  AGENT_TIERS,
+  createAgents,
+  formatModelOverrideWarning,
+  validateModelOverride
+} from "./chunk-XCZ3NOXR.js";
+import {
+  PACKAGE_NAME,
+  readOurPackageVersion,
+  refreshPluginCache
+} from "./chunk-VJUETC6A.js";
+
+// src/config-hook.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+// src/commands/index.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var HERE = dirname(fileURLToPath(import.meta.url));
+function readPrompt(name) {
+  const candidates = [
+    join(HERE, "prompts", name),
+    // dev: src/commands/prompts/
+    join(HERE, "commands", "prompts", name),
+    // dist: dist/ → dist/commands/prompts/
+    join(HERE, "..", "..", "src", "commands", "prompts", name)
+    // fallback dev
+  ];
+  for (const p of candidates) {
+    try {
+      return readFileSync(p, "utf8");
+    } catch {
+    }
+  }
+  throw new Error(`Could not find command prompt: ${name}`);
+}
+var autopilotPrompt = readPrompt("autopilot.md");
+var shipPrompt = readPrompt("ship.md");
+var reviewPrompt = readPrompt("review.md");
+var initDeepPrompt = readPrompt("init-deep.md");
+var researchPrompt = readPrompt("research.md");
+var freshPrompt = readPrompt("fresh.md");
+var costsPrompt = readPrompt("costs.md");
+function createCommands() {
+  return {
+    autopilot: {
+      template: autopilotPrompt,
+      description: "Self-driving run. Pass a ticket ref (any tracker), a task description, or a question."
+    },
+    ship: {
+      template: shipPrompt,
+      description: "Finalize, commit, push, and open a PR/MR. Human-gated at each step."
+    },
+    review: {
+      template: reviewPrompt,
+      description: "Adversarial read-only review of a PR, current branch, commit range, or file."
+    },
+    "init-deep": {
+      template: initDeepPrompt,
+      description: "Generate hierarchical AGENTS.md files for the current repo."
+    },
+    research: {
+      template: researchPrompt,
+      description: "Deep codebase exploration via parallel subagents."
+    },
+    fresh: {
+      template: freshPrompt,
+      description: "Re-key the current worktree to a new task. Runs the repo's .glorious/hooks/fresh-reset if present; otherwise discards local changes and creates a new branch from latest origin/<default>. Then continues inline into the PRIME on the new task."
+    },
+    costs: {
+      template: costsPrompt,
+      description: "Show running LLM cost totals accrued by the cost-tracker plugin. Pass --json or --log for raw data."
+    }
+  };
+}
+
+// src/mcp/index.ts
+function createMcpConfig() {
+  const memoryLauncherCmd = [
+    "bash",
+    "-c",
+    // Use node's require.resolve to find the bundled launcher inside the
+    // installed package, then exec it. Works because the MCP command runs
+    // in a CJS-compatible shell context.
+    `exec bash "$(node -e 'process.stdout.write(require.resolve("@glrs-dev/harness-plugin-opencode/dist/bin/memory-mcp-launcher.sh"))')"`
+  ];
+  return {
+    serena: {
+      type: "local",
+      command: [
+        "uvx",
+        "--from",
+        "git+https://github.com/oraios/serena",
+        "serena",
+        "start-mcp-server",
+        "--context=ide-assistant",
+        "--open-web-dashboard",
+        "false"
+      ],
+      enabled: true
+    },
+    memory: {
+      type: "local",
+      command: memoryLauncherCmd,
+      enabled: true
+    },
+    git: {
+      type: "local",
+      command: ["uvx", "mcp-server-git"],
+      enabled: true
+    },
+    playwright: {
+      type: "local",
+      command: ["npx", "-y", "@playwright/mcp"],
+      enabled: false
+    },
+    linear: {
+      type: "remote",
+      url: "https://mcp.linear.app/mcp",
+      enabled: false
+    }
+  };
+}
+
+// src/skills/paths.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+function getSkillsRoot() {
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  return join2(here, "skills");
+}
+
+// src/config-hook.ts
+function writePermDebugSnapshot(config) {
+  if (process.env["HARNESS_OPENCODE_PERM_DEBUG"] !== "1") return;
+  try {
+    const stateDir = process.env["XDG_STATE_HOME"] || path.join(os.homedir(), ".local", "state");
+    const targetDir = path.join(stateDir, "harness-opencode");
+    const targetFile = path.join(targetDir, "perm-debug.json");
+    const version = readOurPackageVersion(import.meta.url);
+    const agentBlock = config.agent ?? {};
+    const agentPerms = {};
+    for (const [name, cfg] of Object.entries(agentBlock)) {
+      agentPerms[name] = cfg?.permission ?? null;
+    }
+    const payload = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      pluginVersion: version,
+      agents: Object.keys(agentBlock),
+      agentPermissions: agentPerms,
+      // Include the global permission block too — useful context when
+      // diagnosing interplay between global and per-agent rules.
+      globalPermission: config.permission ?? null
+    };
+    fs.mkdirSync(targetDir, { recursive: true });
+    fs.writeFileSync(targetFile, JSON.stringify(payload, null, 2));
+  } catch {
+  }
+}
+function resolveHarnessModels(agents, config, pluginOptions) {
+  const modelsConfig = pluginOptions?.models ?? config.harness?.models;
+  if (!modelsConfig) return agents;
+  const warnedIds = /* @__PURE__ */ new Set();
+  const warnIfInvalid = (value, source) => {
+    const result = validateModelOverride(value);
+    if (result.valid) return;
+    if (warnedIds.has(value)) return;
+    warnedIds.add(value);
+    console.warn(formatModelOverrideWarning(value, source, result.suggestion));
+  };
+  for (const [agentName, agentCfg] of Object.entries(agents)) {
+    const perAgent = modelsConfig[agentName];
+    if (perAgent !== void 0) {
+      const picked = Array.isArray(perAgent) ? perAgent[0] : perAgent;
+      agentCfg.model = picked;
+      warnIfInvalid(picked, `models.${agentName}`);
+      continue;
+    }
+    const tier = AGENT_TIERS[agentName];
+    if (tier) {
+      const perTier = modelsConfig[tier];
+      if (perTier !== void 0) {
+        const picked = Array.isArray(perTier) ? perTier[0] : perTier;
+        agentCfg.model = picked;
+        warnIfInvalid(picked, `models.${tier}`);
+      }
+    }
+  }
+  return agents;
+}
+function applyConfig(config, pluginOptions) {
+  const ourAgents = createAgents();
+  resolveHarnessModels(ourAgents, config, pluginOptions);
+  config.agent = { ...ourAgents, ...config.agent ?? {} };
+  const ourCommands = createCommands();
+  config.command = {
+    ...ourCommands,
+    ...config.command ?? {}
+  };
+  const ourMcp = createMcpConfig();
+  config.mcp = { ...ourMcp, ...config.mcp ?? {} };
+  const skillsRoot = getSkillsRoot();
+  const existingSkills = config.skills ?? {};
+  const existingPaths = Array.isArray(existingSkills.paths) ? existingSkills.paths : [];
+  const existingUrls = Array.isArray(existingSkills.urls) ? existingSkills.urls : [];
+  config.skills = {
+    ...existingSkills,
+    paths: [skillsRoot, ...existingPaths],
+    urls: existingUrls
+  };
+  if (!config.default_agent) {
+    config.default_agent = "prime";
+  }
+  const existingPermission = config.permission ?? {};
+  const existingExtDir = existingPermission.external_directory ?? {};
+  config.permission = {
+    ...existingPermission,
+    external_directory: {
+      "~/.glorious/worktrees/**": "allow",
+      "~/.glorious/opencode/**": "allow",
+      // repo-shared plan storage (see src/plan-paths.ts) + cost-tracker data
+      "/tmp/**": "allow",
+      "/private/tmp/**": "allow",
+      // macOS: /tmp symlinks to /private/tmp
+      "/var/folders/**/T/**": "allow",
+      // macOS $TMPDIR expansion
+      "~/.config/opencode/**": "allow",
+      // OpenCode's own config dir — agents read it routinely
+      "~/.config/crush/**": "allow",
+      // sibling AI tool config — agents read it routinely
+      "~/.cache/**": "allow",
+      // XDG cache dir — tooling (npm, pip, etc.) writes here
+      "~/.local/share/**": "allow",
+      // XDG data dir — Linear MCP cache, etc.
+      "~/.local/state/**": "allow",
+      // XDG state dir — includes plugin spill at harness-opencode/tool-output/ and perm-debug.json
+      ...existingExtDir
+    }
+  };
+  writePermDebugSnapshot(config);
+}
+
+// src/tools/ast_grep.ts
+import { tool } from "@opencode-ai/plugin";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+var ast_grep_default = tool({
+  description: "Search or rewrite TypeScript/JavaScript/Python/etc. by AST pattern using ast-grep. Use this instead of grep when you need structural matching: function signatures, JSX patterns, import shapes, decorator usage, etc. Patterns use $VAR for captures.",
+  args: {
+    pattern: tool.schema.string().describe(
+      "ast-grep pattern, e.g. 'console.log($MSG)' or 'function $NAME($$$ARGS) { $$$BODY }'"
+    ),
+    rewrite: tool.schema.string().optional().describe(
+      "If set, rewrites matches to this template. Use $VAR to reference captures."
+    ),
+    paths: tool.schema.array(tool.schema.string()).default(["."]).describe("Files or directories to search"),
+    language: tool.schema.enum(["ts", "tsx", "js", "jsx", "py", "go", "rs"]).optional().describe("Language hint; auto-detected by extension if omitted"),
+    dryRun: tool.schema.boolean().default(true).describe("If false and rewrite is set, applies changes to disk")
+  },
+  async execute(args, context) {
+    const cmdArgs = ["run", "--pattern", args.pattern];
+    if (args.rewrite) cmdArgs.push("--rewrite", args.rewrite);
+    if (args.language) cmdArgs.push("--lang", args.language);
+    if (args.rewrite && !args.dryRun) cmdArgs.push("--update-all");
+    cmdArgs.push(...args.paths);
+    try {
+      const { stdout, stderr } = await exec("ast-grep", cmdArgs, {
+        maxBuffer: 10 * 1024 * 1024,
+        cwd: context.directory,
+        encoding: "utf8"
+      });
+      const out = String(stdout || "(no matches)");
+      const warn = stderr ? `
+[warnings]
+${String(stderr)}` : "";
+      return out + warn;
+    } catch (err) {
+      const e = err;
+      return `ast-grep error: ${e.message}${e.stderr ? "\n" + e.stderr : ""}`;
+    }
+  }
+});
+
+// src/tools/tsc_check.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var exec2 = promisify2(execFile2);
+var MAX_ROWS = 15;
+var MAX_BUFFER = 2 * 1024 * 1024;
+var REMEDIATION_HINTS = {
+  TS2322: "Assigned type isn't assignable \u2014 narrow with a guard or widen the target type",
+  TS2345: "Argument type doesn't match param \u2014 check param type & coerce or narrow",
+  TS2531: "Value is possibly null \u2014 guard with `if (x)` or use optional chaining",
+  TS18048: "Value is possibly undefined \u2014 guard before use or assert non-null",
+  TS2307: "Module not found \u2014 install the dep or fix the import path",
+  TS7006: "Implicit `any` on parameter \u2014 annotate the type explicitly",
+  TS2339: "Property doesn't exist on type \u2014 check the type, widen it, or use indexing",
+  TS2304: "Name not found \u2014 missing import or typo",
+  TS2532: "Object possibly undefined \u2014 guard with `?.` or narrow before access",
+  TS18047: "Value is possibly null \u2014 add a null guard",
+  TS2769: "No overload matches \u2014 check argument types/arity against signatures",
+  TS2741: "Missing required property \u2014 add it to the object literal",
+  TS2739: "Missing required properties \u2014 add all listed fields",
+  TS2554: "Wrong number of arguments \u2014 check the function signature",
+  TS2551: "Property not found; did you mean <suggestion>? \u2014 fix the name",
+  TS7016: "No type declarations \u2014 add `@types/<pkg>` or `declare module`",
+  TS2367: "Comparison always false \u2014 types don't overlap; rework the check",
+  TS1005: "Syntax error \u2014 check brackets/commas/semicolons near the report",
+  TS1109: "Expression expected \u2014 syntax malformation; re-check the line",
+  TS2420: "Class incorrectly implements interface \u2014 add/align missing members"
+};
+function parseTscOutput(raw) {
+  const re = /^(.+?)\((\d+),(\d+)\):\s+error\s+TS(\d+):\s+(.+)$/;
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const m = re.exec(line);
+    if (!m) continue;
+    out.push({
+      file: m[1],
+      line: Number(m[2]),
+      col: Number(m[3]),
+      code: `TS${m[4]}`,
+      message: m[5]
+    });
+  }
+  return out;
+}
+function dedupeAndCap(errors, cap) {
+  const map = /* @__PURE__ */ new Map();
+  for (const e of errors) {
+    const key = `${e.code}::${e.file}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.count += 1;
+    } else {
+      map.set(key, { ...e, count: 1 });
+    }
+  }
+  const all = [...map.values()].sort((a, b) => {
+    if (b.count !== a.count) return b.count - a.count;
+    return a.code.localeCompare(b.code);
+  });
+  if (all.length <= cap) return { rows: all, truncated: 0 };
+  return { rows: all.slice(0, cap), truncated: all.length - cap };
+}
+function formatRow(row) {
+  const hint = REMEDIATION_HINTS[row.code];
+  const hintSuffix = hint ? `
+    \u2192 ${hint}` : "";
+  const countSuffix = row.count > 1 ? ` (\xD7${row.count})` : "";
+  return `${row.file}:${row.line}:${row.col} ${row.code}${countSuffix}: ${row.message}${hintSuffix}`;
+}
+var tsc_check_default = tool2({
+  description: "Run TypeScript compiler in noEmit mode on the project. Returns errors only. Faster than running the full test suite for type-correctness checks.",
+  args: {
+    project: tool2.schema.string().default("tsconfig.json").describe("Path to tsconfig.json (relative to the project directory)"),
+    full: tool2.schema.boolean().default(false).describe(
+      "If true, bypass the 15-row (code,file) dedupe/cap and return every error"
+    )
+  },
+  async execute(args, context) {
+    let raw;
+    try {
+      const { stdout, stderr } = await exec2(
+        "npx",
+        ["tsc", "--noEmit", "--project", args.project, "--pretty", "false"],
+        { maxBuffer: MAX_BUFFER, cwd: context.directory, encoding: "utf8" }
+      );
+      raw = String(stdout || "");
+      if (stderr) raw += `
+[warnings]
+${String(stderr)}`;
+    } catch (err) {
+      const e = err;
+      if (e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || /\bENOBUFS\b/.test(e.message ?? "")) {
+        return `[tsc output overflowed ${MAX_BUFFER} byte buffer \u2014 too many errors to stream. Pass full:true is NOT recommended here; fix the top-level errors first and re-run.]`;
+      }
+      raw = String(e.stdout || e.message || "");
+    }
+    if (!raw.trim()) return "(no errors)";
+    const errors = parseTscOutput(raw);
+    if (errors.length === 0) {
+      return raw;
+    }
+    if (args.full) {
+      const lines2 = errors.map((e) => formatRow({ ...e, count: 1 }));
+      return `Total errors: ${errors.length}
+
+${lines2.join("\n")}`;
+    }
+    const { rows, truncated } = dedupeAndCap(errors, MAX_ROWS);
+    const lines = rows.map(formatRow);
+    const footer = truncated > 0 ? `
+
+\u2026 ${truncated} more (code,file) categories (pass full:true to see all). Total raw errors: ${errors.length}.` : `
+
+Total raw errors: ${errors.length}.`;
+    return `${lines.join("\n")}${footer}`;
+  }
+});
+
+// src/tools/eslint_check.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var exec3 = promisify3(execFile3);
+var MAX_ROWS2 = 50;
+var MAX_BUFFER2 = 2 * 1024 * 1024;
+var ESLINT_REMEDIATION_HINTS = {
+  "no-unused-vars": "Remove the binding or prefix with `_` to mark intentional",
+  "no-explicit-any": "Replace `any` with a real type or `unknown` + narrowing",
+  "prefer-const": "Binding is never reassigned \u2014 use `const` instead of `let`",
+  "no-console": "Remove the console call or route through a real logger",
+  eqeqeq: "Use `===` / `!==` instead of `==` / `!=`",
+  "no-empty": "Empty block \u2014 add a comment or handle the case explicitly",
+  "no-shadow": "Rename to avoid shadowing the outer binding",
+  "no-undef": "Missing import or typo; add to imports or declare globally",
+  "no-var": "Replace `var` with `let` or `const`",
+  semi: "Add or remove the trailing semicolon per the config",
+  quotes: "Use the configured quote style (single vs double)",
+  indent: "Re-indent to match the config; run the formatter",
+  "no-restricted-syntax": "Usage blocked by config \u2014 pick an allowed alternative",
+  "@typescript-eslint/no-floating-promises": "Await, `.catch()`, or `void`-prefix the promise",
+  "@typescript-eslint/no-misused-promises": "Handler can't return a promise; wrap or refactor"
+};
+function parseEslintJson(raw) {
+  if (!raw.trim()) return [];
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file of data) {
+    for (const msg of file.messages) {
+      out.push({
+        rule: msg.ruleId ?? "<parse-error>",
+        file: file.filePath,
+        line: msg.line,
+        message: msg.message,
+        severity: msg.severity,
+        count: 1
+      });
+    }
+  }
+  return out;
+}
+function dedupeAndCap2(rows, cap) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const key = `${r.rule}::${r.file}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.count += 1;
+    } else {
+      map.set(key, { ...r });
+    }
+  }
+  const all = [...map.values()].sort((a, b) => {
+    if (b.severity !== a.severity) return b.severity - a.severity;
+    if (b.count !== a.count) return b.count - a.count;
+    return a.rule.localeCompare(b.rule);
+  });
+  if (all.length <= cap) return { rows: all, truncated: 0 };
+  return { rows: all.slice(0, cap), truncated: all.length - cap };
+}
+function formatRow2(r) {
+  const sev = r.severity === 2 ? "error" : "warn";
+  const hint = ESLINT_REMEDIATION_HINTS[r.rule];
+  const hintSuffix = hint ? `
+    \u2192 ${hint}` : "";
+  const countSuffix = r.count > 1 ? ` (\xD7${r.count})` : "";
+  return `${r.file}:${r.line} [${sev}] ${r.rule}${countSuffix}: ${r.message}${hintSuffix}`;
+}
+var eslint_check_default = tool3({
+  description: "Run eslint on specific files. Returns lint errors as JSON.",
+  args: {
+    files: tool3.schema.array(tool3.schema.string()).describe("Files or globs to lint"),
+    fix: tool3.schema.boolean().default(false).describe("If true, auto-fix safe issues"),
+    full: tool3.schema.boolean().default(false).describe(
+      "If true, bypass the 50-row (rule,file) dedupe/cap and return every violation"
+    )
+  },
+  async execute(args, context) {
+    const cmdArgs = ["eslint", "--format", "json"];
+    if (args.fix) cmdArgs.push("--fix");
+    cmdArgs.push(...args.files);
+    let raw;
+    try {
+      const { stdout } = await exec3("npx", cmdArgs, {
+        maxBuffer: MAX_BUFFER2,
+        cwd: context.directory,
+        encoding: "utf8"
+      });
+      raw = String(stdout || "[]");
+    } catch (err) {
+      const e = err;
+      if (e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || /\bENOBUFS\b/.test(e.message ?? "")) {
+        return `[eslint output overflowed ${MAX_BUFFER2} byte buffer. Fix the top-level rules first and re-run on narrower globs.]`;
+      }
+      raw = String(e.stdout || `eslint error: ${e.message}`);
+    }
+    const rows = parseEslintJson(raw);
+    if (rows.length === 0) {
+      return raw;
+    }
+    if (args.full) {
+      const lines2 = rows.map((r) => formatRow2(r));
+      return `Total violations: ${rows.length}
+
+${lines2.join("\n")}`;
+    }
+    const { rows: capped, truncated } = dedupeAndCap2(rows, MAX_ROWS2);
+    const lines = capped.map(formatRow2);
+    const footer = truncated > 0 ? `
+
+\u2026 ${truncated} more (rule,file) categories (pass full:true to see all). Total raw violations: ${rows.length}.` : `
+
+Total raw violations: ${rows.length}.`;
+    return `${lines.join("\n")}${footer}`;
+  }
+});
+
+// src/tools/todo_scan.ts
+import { tool as tool4 } from "@opencode-ai/plugin";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var exec4 = promisify4(execFile4);
+var todo_scan_default = tool4({
+  description: "Scan files for TODO / FIXME / HACK / XXX comments. Returns a structured list of matches (file:line:type:text). Use `onlyChanged: true` to restrict to files changed vs HEAD \u2014 useful for QA review to catch tech debt introduced in the current change. Returns plain-text output, one match per line.",
+  args: {
+    paths: tool4.schema.array(tool4.schema.string()).default(["."]).describe("Files or directories to scan (ignored if onlyChanged is true)"),
+    onlyChanged: tool4.schema.boolean().default(false).describe("If true, scan only files modified vs HEAD (git diff --name-only)"),
+    types: tool4.schema.array(tool4.schema.enum(["TODO", "FIXME", "HACK", "XXX"])).default(["TODO", "FIXME", "HACK", "XXX"]).describe("Annotation types to look for"),
+    maxResults: tool4.schema.number().default(200).describe("Cap on number of matches returned")
+  },
+  async execute(args, context) {
+    let scanPaths = args.paths;
+    if (args.onlyChanged) {
+      try {
+        const { stdout } = await exec4(
+          "git",
+          ["diff", "--name-only", "HEAD"],
+          { cwd: context.directory, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 }
+        );
+        scanPaths = String(stdout).split("\n").filter(Boolean);
+        if (scanPaths.length === 0) return "(no changed files)";
+      } catch (err) {
+        const e = err;
+        return `git diff failed: ${e.message}`;
+      }
+    }
+    const pattern = `(${args.types.join("|")})\\b`;
+    const rgArgs = [
+      "--line-number",
+      "--no-heading",
+      "--color=never",
+      "-e",
+      pattern,
+      ...scanPaths
+    ];
+    try {
+      const { stdout } = await exec4("rg", rgArgs, {
+        cwd: context.directory,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const lines = String(stdout).split("\n").filter(Boolean);
+      const capped = lines.slice(0, args.maxResults);
+      const suffix = lines.length > args.maxResults ? `
+
+[truncated: ${lines.length - args.maxResults} additional matches \u2014 narrow paths or raise maxResults]` : "";
+      return capped.length > 0 ? capped.join("\n") + suffix : `(no ${args.types.join("/")} matches in scanned paths)`;
+    } catch (err) {
+      const e = err;
+      if (e.code === 1) return `(no ${args.types.join("/")} matches in scanned paths)`;
+      return `rg error: ${e.message}`;
+    }
+  }
+});
+
+// src/tools/comment_check.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+var exec5 = promisify5(execFile5);
+var DEFAULT_TYPES = ["TODO", "FIXME", "HACK", "XXX", "DEPRECATED"];
+var comment_check_default = tool5({
+  description: "Find attributed code annotations like @TODO(alice), @FIXME, @HACK, @XXX, @DEPRECATED. Returns structured matches with author if captured, plus optional age-in-days via git blame. Use this before planning or editing an area to inventory known tech debt.",
+  args: {
+    paths: tool5.schema.array(tool5.schema.string()).default(["."]).describe("Files or directories to scan"),
+    types: tool5.schema.array(tool5.schema.string()).default([...DEFAULT_TYPES]).describe("Annotation types to surface (e.g. TODO, FIXME, HACK, DEPRECATED)"),
+    includeAge: tool5.schema.boolean().default(false).describe(
+      "If true, run git blame per match to determine age in days (slow on large result sets)"
+    ),
+    maxResults: tool5.schema.number().default(30).describe("Cap on matches returned (default reduced from 100 to 30 to limit context flooding)")
+  },
+  async execute(args, context) {
+    const typesAlt = args.types.join("|");
+    const pattern = `@(${typesAlt})(\\(([^)]+)\\))?`;
+    const rgArgs = [
+      "--line-number",
+      "--no-heading",
+      "--color=never",
+      "-e",
+      pattern,
+      ...args.paths
+    ];
+    let raw;
+    try {
+      const { stdout } = await exec5("rg", rgArgs, {
+        cwd: context.directory,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      raw = String(stdout);
+    } catch (err) {
+      const e = err;
+      if (e.code === 1) return "(no annotations found)";
+      return `rg error: ${e.message}`;
+    }
+    const annotRe = new RegExp(`@(${typesAlt})(?:\\(([^)]+)\\))?`);
+    const lineRe = /^(.+?):(\d+):(.*)$/;
+    const rows = [];
+    const lines = raw.split("\n").filter(Boolean);
+    for (const line of lines) {
+      const parts = line.match(lineRe);
+      if (!parts) continue;
+      const [, file, lineStr, text] = parts;
+      const am = text.match(annotRe);
+      if (!am) continue;
+      const type = am[1];
+      const author = am[2] ?? "";
+      let age = "";
+      let ageDays = -1;
+      if (args.includeAge) {
+        try {
+          const { stdout: blame } = await exec5(
+            "git",
+            ["log", "-1", "--format=%ct", "-L", `${lineStr},${lineStr}:${file}`],
+            { cwd: context.directory, encoding: "utf8", maxBuffer: 1024 * 1024 }
+          );
+          const ts = parseInt(String(blame).trim().split("\n")[0] ?? "", 10);
+          if (!Number.isNaN(ts)) {
+            ageDays = Math.floor((Date.now() / 1e3 - ts) / 86400);
+            age = ` (${ageDays}d old)`;
+          }
+        } catch {
+        }
+      }
+      const authorPart = author ? ` [${author}]` : "";
+      rows.push({
+        text: `${file}:${lineStr} @${type}${authorPart}${age} \u2014 ${text.trim().slice(0, 200)}`,
+        ageDays
+      });
+    }
+    if (rows.length === 0) return "(no annotations found)";
+    if (args.includeAge) {
+      rows.sort((a, b) => {
+        if (a.ageDays === -1 && b.ageDays === -1) return 0;
+        if (a.ageDays === -1) return 1;
+        if (b.ageDays === -1) return -1;
+        return b.ageDays - a.ageDays;
+      });
+    }
+    const capped = rows.slice(0, args.maxResults);
+    const truncated = rows.length > args.maxResults ? `
+
+[truncated: ${rows.length - args.maxResults} more]` : "";
+    return capped.map((r) => r.text).join("\n") + truncated;
+  }
+});
+
+// src/tools/index.ts
+function createTools() {
+  return {
+    ast_grep: ast_grep_default,
+    tsc_check: tsc_check_default,
+    eslint_check: eslint_check_default,
+    todo_scan: todo_scan_default,
+    comment_check: comment_check_default
+  };
+}
+
+// src/plugins/dotenv.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var DOTENV_FILES = [".env", ".env.local"];
+function parseDotenv(content) {
+  const out = {};
+  for (const raw of content.split(/\r?\n/)) {
+    let line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("export ")) {
+      line = line.slice(7).trimStart();
+    }
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    if (!key) continue;
+    let val = line.slice(eq + 1);
+    const trimmedVal = val.trimStart();
+    if (trimmedVal.startsWith('"') && trimmedVal.endsWith('"') || trimmedVal.startsWith("'") && trimmedVal.endsWith("'")) {
+      val = trimmedVal.slice(1, -1);
+    } else {
+      const hashIdx = val.indexOf(" #");
+      if (hashIdx !== -1) {
+        val = val.slice(0, hashIdx);
+      }
+      val = val.trim();
+    }
+    out[key] = val;
+  }
+  return out;
+}
+function loadDotenv(directory) {
+  const merged = {};
+  const filesLoaded = [];
+  for (const name of DOTENV_FILES) {
+    const filePath = path2.join(directory, name);
+    let content;
+    try {
+      content = fs2.readFileSync(filePath, "utf8");
+    } catch {
+      continue;
+    }
+    const parsed = parseDotenv(content);
+    Object.assign(merged, parsed);
+    filesLoaded.push(name);
+  }
+  let varsSet = 0;
+  for (const [key, value] of Object.entries(merged)) {
+    if (!(key in process.env)) {
+      process.env[key] = value;
+      varsSet++;
+    }
+  }
+  return { filesLoaded, varsSet };
+}
+
+// src/plugins/autopilot.ts
+import { execFile as execFileCb } from "child_process";
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import { promisify as promisify6 } from "util";
+var STATE_PATH = ".agent/autopilot-state.json";
+var KILL_SWITCH_PATH = ".agent/autopilot-disable";
+var MAX_ITERATIONS = 20;
+var TARGET_AGENTS = /* @__PURE__ */ new Set(["build", "prime"]);
+var MESSAGE_LIMIT = 40;
+var NUDGE_DEBOUNCE_MS = 3e4;
+var PR_CACHE_MS = 5 * 60 * 1e3;
+var MAX_CONSECUTIVE_STOPS = 2;
+var UMBRELLA_MIN_BYTES = 5e4;
+var UMBRELLA_MIN_LINEAR_IDS = 3;
+var AUTOPILOT_MARKER_RE = /(^|\s)\/autopilot(\s|$)|AUTOPILOT mode/;
+var OPT_OUT_RE = /<!--\s*autopilot:\s*(skip|false)\s*-->/i;
+var UMBRELLA_SECTION_RE = /^##\s+(Chunks|Milestones|Workstreams)\b/m;
+var LINEAR_ID_RE = /\b[A-Z]{2,10}-\d+\b/g;
+var MEASUREMENT_GATE_RE = /\b(7-day|production window|post-deploy|post-launch|SLO|success rate reaches|after deploy|bake time)\b/i;
+var STOP_REPORT_RE = /^STOP[:.\s—]/m;
+var NUDGE_TEXT = "[autopilot] Session idled with unchecked acceptance criteria. Re-read the plan, do the most important unchecked item, check its box when done, then move to the next. When all boxes are `[x]`, print the Phase 5 handoff and stop \u2014 the user runs `/ship` manually.";
+var MAX_ITERATIONS_TEXT = `[autopilot] Stopped: hit max iterations (${MAX_ITERATIONS}). Either the work is complete or the loop is stuck. Review and resume manually; a new \`/autopilot\` session will re-enable nudges.`;
+async function readState(dir) {
+  try {
+    const raw = await fs3.readFile(path3.join(dir, STATE_PATH), "utf8");
+    const parsed = JSON.parse(raw);
+    return { sessions: parsed.sessions ?? {} };
+  } catch {
+    return { sessions: {} };
+  }
+}
+async function writeState(dir, state) {
+  const p = path3.join(dir, STATE_PATH);
+  await fs3.mkdir(path3.dirname(p), { recursive: true });
+  await fs3.writeFile(p, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+function userText(msg) {
+  if (msg.info?.role !== "user") return "";
+  const parts = msg.parts ?? [];
+  return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("\n");
+}
+function latestUserAgent(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const info = messages[i].info;
+    if (info?.role === "user" && typeof info.agent === "string") {
+      return info.agent;
+    }
+  }
+  return void 0;
+}
+function latestAssistantText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.info?.role !== "assistant") continue;
+    const parts = msg.parts ?? [];
+    return parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("\n");
+  }
+  return "";
+}
+function detectActivation(messages) {
+  for (const msg of messages) {
+    if (msg.info?.role !== "user") continue;
+    return AUTOPILOT_MARKER_RE.test(userText(msg));
+  }
+  return false;
+}
+var PLAN_PATH_RE = /(?:\.agent\/plans\/[\w-]+\.md|(?:\/[^\s`"']*)?\/[\w.-]+\/plans\/[\w-]+\.md)/;
+function findPlanPath(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const parts = messages[i].parts ?? [];
+    for (const part of parts) {
+      if (part.type === "text" && typeof part.text === "string") {
+        const m = part.text.match(PLAN_PATH_RE);
+        if (m) return m[0];
+      }
+    }
+  }
+  return null;
+}
+function countUnchecked(planContent) {
+  const section = /## Acceptance criteria([\s\S]*?)(?=\n##|$)/.exec(planContent);
+  if (!section) return 0;
+  const matches = section[1].match(/^- \[ \]/gm);
+  return matches?.length ?? 0;
+}
+function classifyPlan(content) {
+  if (OPT_OUT_RE.test(content)) return "opted-out";
+  if (UMBRELLA_SECTION_RE.test(content)) return "umbrella";
+  if (content.length > UMBRELLA_MIN_BYTES) return "umbrella";
+  const linearIds = content.match(LINEAR_ID_RE) ?? [];
+  const unique = new Set(linearIds);
+  if (unique.size >= UMBRELLA_MIN_LINEAR_IDS) return "umbrella";
+  const acSection = /## Acceptance criteria([\s\S]*?)(?=\n##|$)/.exec(content);
+  if (acSection && MEASUREMENT_GATE_RE.test(acSection[1])) {
+    return "measurement-gated";
+  }
+  return "unit";
+}
+function planGoalLinearId(content) {
+  const goal = /## Goal([\s\S]*?)(?=\n##|$)/.exec(content);
+  if (!goal) return null;
+  const m = goal[1].match(LINEAR_ID_RE);
+  return m ? m[0] : null;
+}
+function detectStopReport(assistantText) {
+  if (!assistantText) return false;
+  return STOP_REPORT_RE.test(assistantText);
+}
+var execFile6 = promisify6(execFileCb);
+async function currentBranch(dir) {
+  try {
+    const { stdout } = await execFile6(
+      "git",
+      ["-C", dir, "branch", "--show-current"],
+      { timeout: 2e3 }
+    );
+    const branch = stdout.trim();
+    return branch.length > 0 ? branch : null;
+  } catch {
+    return null;
+  }
+}
+async function pullRequestState(dir) {
+  try {
+    const { stdout } = await execFile6(
+      "gh",
+      ["pr", "view", "--json", "state", "--jq", ".state"],
+      { cwd: dir, timeout: 5e3 }
+    );
+    const state = stdout.trim();
+    return state.length > 0 ? state : null;
+  } catch {
+    return null;
+  }
+}
+async function killSwitchEngaged(dir) {
+  try {
+    await fs3.access(path3.join(dir, KILL_SWITCH_PATH));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function sendNudge(client, sessionID, sessState, text, now = Date.now()) {
+  if (sessState.lastNudgeAt !== void 0 && now - sessState.lastNudgeAt < NUDGE_DEBOUNCE_MS) {
+    return false;
+  }
+  await client.session.promptAsync({
+    path: { id: sessionID },
+    body: { parts: [{ type: "text", text }] }
+  });
+  sessState.lastNudgeAt = now;
+  return true;
+}
+var plugin = async ({ client, directory }) => {
+  return {
+    event: async ({ event }) => {
+      if (event.type !== "session.idle") return;
+      const sessionID = event.properties.sessionID;
+      const msgsResp = await client.session.messages({
+        path: { id: sessionID },
+        query: { limit: MESSAGE_LIMIT }
+      });
+      const messages = msgsResp.data ?? [];
+      const agent = latestUserAgent(messages);
+      if (!agent || !TARGET_AGENTS.has(agent)) return;
+      const state = await readState(directory);
+      const sessState = state.sessions[sessionID] ?? {
+        iterations: 0
+      };
+      if (sessState.stopped) return;
+      if (!sessState.enabled) {
+        if (!detectActivation(messages)) return;
+        sessState.enabled = true;
+      }
+      if (await killSwitchEngaged(directory)) {
+        state.sessions[sessionID] = {
+          ...sessState,
+          stopped: true,
+          stopReason: "kill-switch"
+        };
+        await writeState(directory, state);
+        return;
+      }
+      if (sessState.iterations >= MAX_ITERATIONS) {
+        await sendNudge(client, sessionID, sessState, MAX_ITERATIONS_TEXT);
+        state.sessions[sessionID] = {
+          ...sessState,
+          stopped: true,
+          stopReason: "max-iterations"
+        };
+        await writeState(directory, state);
+        return;
+      }
+      const planPath = findPlanPath(messages);
+      if (!planPath) return;
+      const resolvedPlanPath = path3.isAbsolute(planPath) ? planPath : path3.join(directory, planPath);
+      let planContent;
+      try {
+        planContent = await fs3.readFile(resolvedPlanPath, "utf8");
+      } catch {
+        return;
+      }
+      const shape = classifyPlan(planContent);
+      if (shape !== "unit") {
+        state.sessions[sessionID] = {
+          ...sessState,
+          stopped: true,
+          stopReason: `plan-shape:${shape}`
+        };
+        await writeState(directory, state);
+        return;
+      }
+      const planLinearId = planGoalLinearId(planContent);
+      if (planLinearId) {
+        const branch = await currentBranch(directory);
+        if (branch && !branch.toLowerCase().includes(planLinearId.toLowerCase())) {
+          state.sessions[sessionID] = {
+            ...sessState,
+            stopped: true,
+            stopReason: "branch-mismatch"
+          };
+          await writeState(directory, state);
+          return;
+        }
+      }
+      const now = Date.now();
+      let prState = sessState.prState;
+      const prExpired = sessState.prCheckedAt === void 0 || now - sessState.prCheckedAt > PR_CACHE_MS;
+      if (prExpired) {
+        const fetched = await pullRequestState(directory);
+        prState = fetched ?? "none";
+        sessState.prState = prState;
+        sessState.prCheckedAt = now;
+      }
+      if (prState === "MERGED") {
+        state.sessions[sessionID] = {
+          ...sessState,
+          stopped: true,
+          stopReason: "pr-merged"
+        };
+        await writeState(directory, state);
+        return;
+      }
+      const unchecked = countUnchecked(planContent);
+      if (unchecked === 0) {
+        state.sessions[sessionID] = {
+          ...sessState,
+          consecutiveStops: 0,
+          lastUncheckedCount: 0
+        };
+        await writeState(directory, state);
+        return;
+      }
+      const lastUnchecked = sessState.lastUncheckedCount;
+      const madeProgress = lastUnchecked !== void 0 && unchecked < lastUnchecked;
+      const stopReported = detectStopReport(latestAssistantText(messages));
+      let consecutiveStops = sessState.consecutiveStops ?? 0;
+      if (madeProgress) {
+        consecutiveStops = 0;
+      } else if (stopReported) {
+        consecutiveStops += 1;
+      } else {
+      }
+      sessState.consecutiveStops = consecutiveStops;
+      sessState.lastUncheckedCount = unchecked;
+      if (consecutiveStops >= MAX_CONSECUTIVE_STOPS) {
+        state.sessions[sessionID] = {
+          ...sessState,
+          stopped: true,
+          stopReason: "agent-stop-report"
+        };
+        await writeState(directory, state);
+        return;
+      }
+      const sent = await sendNudge(client, sessionID, sessState, NUDGE_TEXT);
+      if (sent) {
+        state.sessions[sessionID] = {
+          ...sessState,
+          iterations: sessState.iterations + 1
+        };
+        await writeState(directory, state);
+      } else {
+        state.sessions[sessionID] = { ...sessState };
+        await writeState(directory, state);
+      }
+    },
+    "chat.message": async ({ sessionID, agent }) => {
+      if (!agent || !TARGET_AGENTS.has(agent)) return;
+      const state = await readState(directory);
+      const existing = state.sessions[sessionID];
+      if (!existing?.enabled) return;
+      state.sessions[sessionID] = {
+        ...existing,
+        iterations: 0
+      };
+      await writeState(directory, state);
+    }
+  };
+};
+var autopilot_default = plugin;
+
+// src/plugins/notify.ts
+var plugin2 = async ({ $, client }) => {
+  async function notify(title, message) {
+    if (process.platform === "darwin") {
+      const esc = (s) => s.replace(/"/g, '\\"');
+      await $`osascript -e ${`display notification "${esc(message)}" with title "${esc(title)}" sound name "Glass"`}`.nothrow();
+    } else if (process.platform === "linux") {
+      await $`notify-send ${title} ${message}`.nothrow();
+    }
+    try {
+      await client.tui.showToast({
+        body: { title, message, variant: "info", duration: 8e3 }
+      });
+    } catch {
+    }
+  }
+  return {
+    // Notify when a permission prompt fires (replaces the old permission.asked event)
+    "permission.ask": async (input, output) => {
+      const tool6 = input?.tool ?? input?.title ?? "a tool";
+      await notify("opencode permission required", `Approval needed for ${tool6}.`);
+    }
+  };
+};
+var notify_default = plugin2;
+
+// src/plugins/cost-tracker.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+import * as os2 from "os";
+var MAX_LINE_BYTES = 2048;
+var ROLLUP_DEBOUNCE_MS = 5e3;
+function resolveDataDir() {
+  const override = process.env.GLORIOUS_COST_TRACKER_DIR;
+  if (override) {
+    if (override.startsWith("~")) {
+      return path4.join(os2.homedir(), override.slice(1));
+    }
+    return override;
+  }
+  return path4.join(os2.homedir(), ".glorious", "opencode");
+}
+function zeroTokens() {
+  return {
+    input: 0,
+    output: 0,
+    reasoning: 0,
+    cache: { read: 0, write: 0 }
+  };
+}
+function readTokens(src) {
+  const s = src ?? {};
+  const cache = s.cache ?? {};
+  return {
+    input: Number(s.input) || 0,
+    output: Number(s.output) || 0,
+    reasoning: Number(s.reasoning) || 0,
+    cache: {
+      read: Number(cache.read) || 0,
+      write: Number(cache.write) || 0
+    }
+  };
+}
+function subTokens(a, b) {
+  return {
+    input: a.input - b.input,
+    output: a.output - b.output,
+    reasoning: a.reasoning - b.reasoning,
+    cache: {
+      read: a.cache.read - b.cache.read,
+      write: a.cache.write - b.cache.write
+    }
+  };
+}
+function addTokens(a, b) {
+  return {
+    input: a.input + b.input,
+    output: a.output + b.output,
+    reasoning: a.reasoning + b.reasoning,
+    cache: {
+      read: a.cache.read + b.cache.read,
+      write: a.cache.write + b.cache.write
+    }
+  };
+}
+function clampTokens(t) {
+  return {
+    input: Math.max(0, t.input),
+    output: Math.max(0, t.output),
+    reasoning: Math.max(0, t.reasoning),
+    cache: {
+      read: Math.max(0, t.cache.read),
+      write: Math.max(0, t.cache.write)
+    }
+  };
+}
+function anyNonZero(cost, tokens) {
+  return cost !== 0 || tokens.input !== 0 || tokens.output !== 0 || tokens.reasoning !== 0 || tokens.cache.read !== 0 || tokens.cache.write !== 0;
+}
+function emptyRollup() {
+  return {
+    version: 1,
+    updatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    grandTotal: { cost: 0, tokens: zeroTokens(), messages: 0 },
+    byProvider: {}
+  };
+}
+var plugin3 = async () => {
+  if (process.env.GLORIOUS_COST_TRACKER === "0") {
+    return {};
+  }
+  const dataDir = resolveDataDir();
+  const jsonlPath = path4.join(dataDir, "costs.jsonl");
+  const rollupPath = path4.join(dataDir, "costs.json");
+  const lastSeen = /* @__PURE__ */ new Map();
+  const messageMeta = /* @__PURE__ */ new Map();
+  const rollup = emptyRollup();
+  const warned = /* @__PURE__ */ new Set();
+  function warnOnce(category, err) {
+    if (warned.has(category)) return;
+    warned.add(category);
+    const msg = err instanceof Error ? err.message : typeof err === "string" ? err : String(err);
+    process.stderr.write(`[cost-tracker] ${category}: ${msg}
+`);
+  }
+  let disabled = false;
+  async function ensureDir() {
+    if (disabled) return false;
+    try {
+      await fs4.mkdir(dataDir, { recursive: true });
+      return true;
+    } catch (err) {
+      warnOnce("mkdir", err);
+      disabled = true;
+      return false;
+    }
+  }
+  function applyToRollup(providerID, modelID, costDelta, tokensDelta, isFinalization, messageID) {
+    const prov = rollup.byProvider[providerID] ??= {
+      cost: 0,
+      tokens: zeroTokens(),
+      messages: 0,
+      byModel: {}
+    };
+    const model = prov.byModel[modelID] ??= {
+      cost: 0,
+      tokens: zeroTokens(),
+      messages: 0
+    };
+    prov.cost += costDelta;
+    model.cost += costDelta;
+    rollup.grandTotal.cost += costDelta;
+    prov.tokens = addTokens(prov.tokens, tokensDelta);
+    model.tokens = addTokens(model.tokens, tokensDelta);
+    rollup.grandTotal.tokens = addTokens(rollup.grandTotal.tokens, tokensDelta);
+    if (isFinalization) {
+      const meta = messageMeta.get(messageID);
+      if (meta && !meta.counted) {
+        meta.counted = true;
+        prov.messages += 1;
+        model.messages += 1;
+        rollup.grandTotal.messages += 1;
+      }
+    }
+    rollup.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  let lastRollupWriteAt = 0;
+  let rollupWriteInFlight = false;
+  async function writeRollup(force) {
+    if (disabled) return;
+    const now = Date.now();
+    if (!force && now - lastRollupWriteAt < ROLLUP_DEBOUNCE_MS) return;
+    if (rollupWriteInFlight) return;
+    rollupWriteInFlight = true;
+    try {
+      if (!await ensureDir()) return;
+      const tmp = `${rollupPath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 10)}`;
+      try {
+        await fs4.writeFile(tmp, JSON.stringify(rollup, null, 2) + "\n", "utf8");
+        await fs4.rename(tmp, rollupPath);
+        lastRollupWriteAt = now;
+      } catch (err) {
+        warnOnce("rollup-write", err);
+        try {
+          await fs4.unlink(tmp);
+        } catch {
+        }
+      }
+    } finally {
+      rollupWriteInFlight = false;
+    }
+  }
+  async function appendJsonl(line) {
+    if (disabled) return;
+    if (!await ensureDir()) return;
+    const text = JSON.stringify(line) + "\n";
+    if (Buffer.byteLength(text, "utf8") > MAX_LINE_BYTES) {
+      warnOnce(
+        "line-too-long",
+        `skipping event for ${line.messageID} \u2014 serialized size exceeds ${MAX_LINE_BYTES}B`
+      );
+      return;
+    }
+    try {
+      await fs4.appendFile(jsonlPath, text, "utf8");
+    } catch (err) {
+      warnOnce("jsonl-append", err);
+    }
+  }
+  async function warmUp() {
+    try {
+      const raw = await fs4.readFile(jsonlPath, "utf8");
+      const byMsg = /* @__PURE__ */ new Map();
+      for (const rawLine of raw.split("\n")) {
+        if (!rawLine) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(rawLine);
+        } catch {
+          continue;
+        }
+        if (!parsed.messageID) continue;
+        const existing = byMsg.get(parsed.messageID);
+        const tokensTotal = readTokens(parsed.tokensTotal);
+        const next = {
+          providerID: parsed.providerID,
+          modelID: parsed.modelID,
+          costTotal: Number(parsed.costTotal) || 0,
+          tokensTotal,
+          everFinalized: (existing?.everFinalized ?? false) || !!parsed.finalized,
+          lastCostTotal: Number(parsed.costTotal) || 0,
+          lastTokensTotal: tokensTotal
+        };
+        byMsg.set(parsed.messageID, next);
+      }
+      for (const [messageID, state] of byMsg) {
+        const prov = rollup.byProvider[state.providerID] ??= {
+          cost: 0,
+          tokens: zeroTokens(),
+          messages: 0,
+          byModel: {}
+        };
+        const model = prov.byModel[state.modelID] ??= {
+          cost: 0,
+          tokens: zeroTokens(),
+          messages: 0
+        };
+        prov.cost += state.lastCostTotal;
+        model.cost += state.lastCostTotal;
+        rollup.grandTotal.cost += state.lastCostTotal;
+        prov.tokens = addTokens(prov.tokens, state.lastTokensTotal);
+        model.tokens = addTokens(model.tokens, state.lastTokensTotal);
+        rollup.grandTotal.tokens = addTokens(
+          rollup.grandTotal.tokens,
+          state.lastTokensTotal
+        );
+        if (state.everFinalized) {
+          prov.messages += 1;
+          model.messages += 1;
+          rollup.grandTotal.messages += 1;
+        } else {
+          lastSeen.set(messageID, {
+            cost: state.lastCostTotal,
+            tokens: state.lastTokensTotal
+          });
+          messageMeta.set(messageID, {
+            providerID: state.providerID,
+            modelID: state.modelID,
+            // We've already added its costs to the rollup. On finalization
+            // we'll apply only any remaining delta, and `counted: false`
+            // lets us bump the message counter exactly once.
+            counted: false
+          });
+        }
+      }
+      rollup.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    } catch (err) {
+      const e = err;
+      if (e && e.code === "ENOENT") {
+        return;
+      }
+      warnOnce("warmup", err);
+    }
+  }
+  await warmUp();
+  return {
+    event: async ({ event }) => {
+      if (event.type !== "message.updated") return;
+      const info = event.properties.info;
+      if (!info || info.role !== "assistant") return;
+      const assistantInfo = info;
+      const messageID = String(assistantInfo.id ?? "");
+      const sessionID = String(assistantInfo.sessionID ?? "");
+      const providerID = String(assistantInfo.providerID ?? "unknown");
+      const modelID = String(assistantInfo.modelID ?? "unknown");
+      if (!messageID) return;
+      const costNow = Number(assistantInfo.cost) || 0;
+      const tokensNow = readTokens(assistantInfo.tokens);
+      const finalized = assistantInfo.time != null && assistantInfo.time.completed != null;
+      const existingMeta = messageMeta.get(messageID);
+      messageMeta.set(messageID, {
+        providerID,
+        modelID,
+        counted: existingMeta?.counted ?? false
+      });
+      const prior = lastSeen.get(messageID) ?? { cost: 0, tokens: zeroTokens() };
+      let costDelta = costNow - prior.cost;
+      let tokensDelta = subTokens(tokensNow, prior.tokens);
+      if (costDelta < 0 || tokensDelta.input < 0 || tokensDelta.output < 0 || tokensDelta.reasoning < 0 || tokensDelta.cache.read < 0 || tokensDelta.cache.write < 0) {
+        warnOnce(
+          "negative-delta",
+          `clamping negative delta on message ${messageID} (likely a retry/reset)`
+        );
+        costDelta = Math.max(0, costDelta);
+        tokensDelta = clampTokens(tokensDelta);
+      }
+      lastSeen.set(messageID, { cost: costNow, tokens: tokensNow });
+      const hasDelta = anyNonZero(costDelta, tokensDelta);
+      if (!hasDelta && !finalized) {
+        return;
+      }
+      if (hasDelta || finalized) {
+        applyToRollup(providerID, modelID, costDelta, tokensDelta, finalized, messageID);
+      }
+      const line = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionID,
+        messageID,
+        providerID,
+        modelID,
+        costDelta,
+        tokensDelta,
+        costTotal: costNow,
+        tokensTotal: tokensNow,
+        finalized
+      };
+      await appendJsonl(line);
+      await writeRollup(finalized);
+      if (finalized) {
+        lastSeen.delete(messageID);
+        messageMeta.delete(messageID);
+      }
+    }
+  };
+};
+var cost_tracker_default = plugin3;
+
+// src/plugins/pilot-plugin.ts
+import * as path5 from "path";
+var PILOT_SESSION_TITLE_PREFIX = "pilot/";
+var FORBIDDEN_BUILDER_BASH_PREFIXES = [
+  "git commit",
+  "git push",
+  "git tag",
+  "git checkout ",
+  "git switch ",
+  "git branch",
+  "git restore --source",
+  "git reset",
+  "gh pr ",
+  "gh release "
+];
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "patch", "multiedit"]);
+var plugin4 = async ({ client }) => {
+  const sessionCache = /* @__PURE__ */ new Map();
+  return {
+    "tool.execute.before": async (input, output) => {
+      const info = await classifySession(client, sessionCache, input.sessionID);
+      if (info.kind === "pilot-builder") {
+        if (input.tool === "bash") {
+          enforceBuilderBashDeny(output.args);
+        }
+      } else if (info.kind === "pilot-planner") {
+        if (EDIT_TOOLS.has(input.tool)) {
+          await enforcePlannerEditScope(output.args, info.plansDir);
+        }
+      }
+    }
+  };
+};
+var pilot_plugin_default = plugin4;
+async function classifySession(client, cache, sessionID) {
+  const cached = cache.get(sessionID);
+  if (cached !== void 0) return cached;
+  let title = "";
+  let directory = "";
+  try {
+    const r = await client.session.get({ path: { id: sessionID } });
+    const data = r.data;
+    title = data?.title ?? "";
+    directory = data?.directory ?? "";
+  } catch {
+    const v2 = { kind: "non-pilot" };
+    cache.set(sessionID, v2);
+    return v2;
+  }
+  if (title.startsWith(PILOT_SESSION_TITLE_PREFIX)) {
+    const rest = title.slice(PILOT_SESSION_TITLE_PREFIX.length);
+    const slash = rest.indexOf("/");
+    if (slash > 0) {
+      const runId = rest.slice(0, slash);
+      const taskId = rest.slice(slash + 1);
+      const v2 = { kind: "pilot-builder", runId, taskId };
+      cache.set(sessionID, v2);
+      return v2;
+    }
+  }
+  const plansDir = inferPlannerPlansDir(directory);
+  if (plansDir !== null) {
+    const v2 = { kind: "pilot-planner", plansDir };
+    cache.set(sessionID, v2);
+    return v2;
+  }
+  const v = { kind: "non-pilot" };
+  cache.set(sessionID, v);
+  return v;
+}
+function inferPlannerPlansDir(directory) {
+  if (directory.length === 0) return null;
+  const norm = directory.replace(/[\\/]+$/, "");
+  const sepRegex = /[\\/]/;
+  const parts = norm.split(sepRegex);
+  if (parts.length < 2) return null;
+  const last = parts[parts.length - 1];
+  const prev = parts[parts.length - 2];
+  if (last === "plans" && prev === "pilot") return norm;
+  return null;
+}
+function enforceBuilderBashDeny(args) {
+  const command = extractBashCommand(args);
+  if (command === null) return;
+  const trimmed = command.trimStart();
+  for (const prefix of FORBIDDEN_BUILDER_BASH_PREFIXES) {
+    if (trimmed.startsWith(prefix) || // Exact match for `git branch` (no trailing space) — the prefix
+    // already has no trailing space; covered.
+    trimmed === prefix.trimEnd()) {
+      throw new Error(
+        `pilot-plugin: pilot-builder is not permitted to run \`${prefix.trim()}\` commands (the worker handles commits/pushes/branches). If this is the right thing to do, respond with STOP: <reason>.`
+      );
+    }
+  }
+}
+function extractBashCommand(args) {
+  if (typeof args !== "object" || args === null) return null;
+  const o = args;
+  if (typeof o.command === "string") return o.command;
+  if (typeof o.cmd === "string") return o.cmd;
+  if (typeof o.body === "object" && o.body !== null && typeof o.body.command === "string") {
+    return o.body.command;
+  }
+  return null;
+}
+async function enforcePlannerEditScope(args, plansDir) {
+  const target = extractTargetPath(args);
+  if (target === null) return;
+  const abs = path5.isAbsolute(target) ? target : path5.resolve(plansDir, target);
+  const normTarget = path5.normalize(abs);
+  const normPlans = path5.normalize(plansDir).replace(/[\\/]+$/, "");
+  if (normTarget === normPlans || normTarget.startsWith(normPlans + path5.sep) || normTarget.startsWith(normPlans + "/")) {
+    return;
+  }
+  throw new Error(
+    `pilot-plugin: pilot-planner is restricted to the plans directory (${plansDir}). The path ${JSON.stringify(target)} is outside scope. Save your YAML plan inside the plans dir.`
+  );
+}
+function extractTargetPath(args) {
+  if (typeof args !== "object" || args === null) return null;
+  const o = args;
+  if (typeof o.filePath === "string") return o.filePath;
+  if (typeof o.path === "string") return o.path;
+  if (typeof o.file === "string") return o.file;
+  return null;
+}
+
+// src/plugins/tool-hooks.ts
+import * as crypto from "crypto";
+import * as fs5 from "fs";
+import * as path6 from "path";
+import * as os3 from "os";
+import { execFile as execFileCb2 } from "child_process";
+import { promisify as promisify7 } from "util";
+var exec6 = promisify7(execFileCb2);
+var EDIT_TOOLS2 = /* @__PURE__ */ new Set(["edit", "write", "patch", "multiedit"]);
+var TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var DEFAULT_BACKPRESSURE_THRESHOLD = 6e3;
+var DEFAULT_BACKPRESSURE_HEAD = 300;
+var DEFAULT_BACKPRESSURE_TAIL = 200;
+var DEFAULT_BACKPRESSURE_TOOLS = /* @__PURE__ */ new Set(["bash", "read", "glob", "grep"]);
+var DEFAULT_PER_TOOL_SHAPES = {
+  read: "skip",
+  // Read has its own limit/offset; double-truncation violates that contract.
+  glob: "skip",
+  // glob output is a path list; middle-truncation makes it unusable.
+  bash: "tail",
+  // Failures and exit codes are at the end of the stream.
+  grep: "head-with-count"
+  // First N matches verbatim + count tail; middle-truncation breaks match blocks.
+};
+var DEFAULT_GREP_HEAD_MATCHES = 20;
+var DEFAULT_BASH_TAIL_CHARS = 4e3;
+var DEFAULT_VERIFY_TIMEOUT_MS = 15e3;
+var TSC_MAX_BUFFER = 2 * 1024 * 1024;
+var VERIFY_MAX_ERRORS = 10;
+var DEFAULT_LOOP_THRESHOLD = 5;
+var sessions = /* @__PURE__ */ new Map();
+function getSession(sessionID) {
+  let s = sessions.get(sessionID);
+  if (!s) {
+    s = {
+      editCounts: /* @__PURE__ */ new Map(),
+      readCache: /* @__PURE__ */ new Map(),
+      callSeq: 0,
+      lastVerifyTs: 0,
+      directory: null
+    };
+    sessions.set(sessionID, s);
+  }
+  s.callSeq++;
+  return s;
+}
+function isValidShape(s) {
+  return s === "skip" || s === "head-tail" || s === "tail" || s === "head-with-count";
+}
+function resolveConfig(config, pluginOptions) {
+  const raw = pluginOptions?.toolHooks ?? config.harness?.toolHooks ?? {};
+  const bp = raw.backpressure ?? {};
+  const vl = raw.verifyLoop ?? {};
+  const ld = raw.loopDetection ?? {};
+  const rd = raw.readDedup ?? {};
+  const userPerTool = bp.perTool && typeof bp.perTool === "object" ? bp.perTool : {};
+  const perTool = {};
+  for (const tool6 of ["bash", "read", "glob", "grep"]) {
+    const u = userPerTool[tool6] ?? {};
+    perTool[tool6] = {
+      threshold: typeof u.threshold === "number" ? u.threshold : void 0,
+      headChars: typeof u.headChars === "number" ? u.headChars : void 0,
+      tailChars: typeof u.tailChars === "number" ? u.tailChars : void 0,
+      shape: isValidShape(u.shape) ? u.shape : DEFAULT_PER_TOOL_SHAPES[tool6] ?? "head-tail",
+      grepHeadMatches: typeof u.grepHeadMatches === "number" ? u.grepHeadMatches : void 0
+    };
+  }
+  return {
+    backpressure: {
+      enabled: bp.enabled !== false,
+      threshold: typeof bp.threshold === "number" ? bp.threshold : DEFAULT_BACKPRESSURE_THRESHOLD,
+      headChars: typeof bp.headChars === "number" ? bp.headChars : DEFAULT_BACKPRESSURE_HEAD,
+      tailChars: typeof bp.tailChars === "number" ? bp.tailChars : DEFAULT_BACKPRESSURE_TAIL,
+      tools: Array.isArray(bp.tools) ? new Set(bp.tools) : DEFAULT_BACKPRESSURE_TOOLS,
+      perTool
+    },
+    verifyLoop: {
+      enabled: vl.enabled !== false,
+      timeoutMs: typeof vl.timeoutMs === "number" ? vl.timeoutMs : DEFAULT_VERIFY_TIMEOUT_MS
+    },
+    loopDetection: {
+      enabled: ld.enabled !== false,
+      threshold: typeof ld.threshold === "number" ? ld.threshold : DEFAULT_LOOP_THRESHOLD
+    },
+    readDedup: {
+      enabled: rd.enabled !== false
+    }
+  };
+}
+function getToolOutputDir() {
+  const stateHome = process.env["XDG_STATE_HOME"] || path6.join(os3.homedir(), ".local", "state");
+  return path6.join(stateHome, "harness-opencode", "tool-output");
+}
+function hashContent(content) {
+  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function extractFilePath(args) {
+  if (typeof args !== "object" || args === null) return null;
+  const o = args;
+  if (typeof o.filePath === "string") return o.filePath;
+  if (typeof o.path === "string") return o.path;
+  if (typeof o.file === "string") return o.file;
+  return null;
+}
+function looksLikeBashFailure(output) {
+  if (/Exit code:\s*[1-9]\d*/i.test(output)) return true;
+  if (/\bexited with code [1-9]/i.test(output)) return true;
+  if (/\bcommand failed\b/i.test(output)) return true;
+  if (/\bERROR\b/.test(output) && output.length < 500) return true;
+  return false;
+}
+async function resolveSessionDir(client, sess, sessionID) {
+  if (sess.directory) return sess.directory;
+  try {
+    const r = await client.session.get({ path: { id: sessionID } });
+    const data = r.data;
+    sess.directory = data?.directory ?? process.cwd();
+  } catch {
+    sess.directory = process.cwd();
+  }
+  return sess.directory;
+}
+function isUnderToolOutputDir(filePath) {
+  try {
+    const abs = path6.resolve(filePath);
+    const spillDir = path6.resolve(getToolOutputDir());
+    return abs === spillDir || abs.startsWith(spillDir + path6.sep);
+  } catch {
+    return false;
+  }
+}
+function takeGrepHead(text, maxMatches) {
+  const blocks = text.split(/\n\n+/);
+  if (blocks.length <= maxMatches) {
+    return { head: text, matchesKept: blocks.length, matchesOmitted: 0 };
+  }
+  const kept = blocks.slice(0, maxMatches);
+  return {
+    head: kept.join("\n\n"),
+    matchesKept: kept.length,
+    matchesOmitted: blocks.length - maxMatches
+  };
+}
+function applyBackpressure(cfg, toolName, callID, output, args) {
+  if (!cfg.enabled) return;
+  if (!cfg.tools.has(toolName)) return;
+  const perTool = cfg.perTool[toolName];
+  const shape = perTool?.shape ?? "head-tail";
+  if (shape === "skip") return;
+  if (toolName === "read") {
+    const fp = extractFilePath(args);
+    if (fp && isUnderToolOutputDir(fp)) return;
+  }
+  const text = output.output;
+  const threshold = perTool?.threshold ?? cfg.threshold;
+  if (text.length <= threshold) return;
+  if (toolName === "bash" && looksLikeBashFailure(text)) return;
+  let diskPath = null;
+  try {
+    const dir = getToolOutputDir();
+    fs5.mkdirSync(dir, { recursive: true });
+    diskPath = path6.join(dir, `${callID}.txt`);
+    fs5.writeFileSync(diskPath, text);
+  } catch {
+  }
+  const pathNote = diskPath ? ` Full output saved to: ${diskPath}` : "";
+  if (shape === "tail") {
+    const tailChars2 = perTool?.tailChars ?? (toolName === "bash" ? DEFAULT_BASH_TAIL_CHARS : cfg.tailChars);
+    const tail2 = text.slice(-tailChars2);
+    const omitted2 = text.length - tail2.length;
+    output.output = `... [${omitted2} chars truncated \u2014 ${text.length} total.${pathNote}]
+
+${tail2}`;
+    return;
+  }
+  if (shape === "head-with-count") {
+    const maxMatches = perTool?.grepHeadMatches ?? DEFAULT_GREP_HEAD_MATCHES;
+    const { head: head2, matchesOmitted } = takeGrepHead(text, maxMatches);
+    if (matchesOmitted === 0) {
+      const fallbackHead = text.slice(0, perTool?.headChars ?? cfg.headChars);
+      const fallbackTail = text.slice(-(perTool?.tailChars ?? cfg.tailChars));
+      const omitted2 = text.length - fallbackHead.length - fallbackTail.length;
+      output.output = `${fallbackHead}
+
+... [${omitted2} chars truncated \u2014 ${text.length} total.${pathNote}]
+
+${fallbackTail}`;
+      return;
+    }
+    const spillNote = diskPath ? ` \u2014 full output at ${diskPath}` : "";
+    output.output = `${head2}
+
+... [${matchesOmitted} more matches${spillNote}]`;
+    return;
+  }
+  const headChars = perTool?.headChars ?? cfg.headChars;
+  const tailChars = perTool?.tailChars ?? cfg.tailChars;
+  const head = text.slice(0, headChars);
+  const tail = text.slice(-tailChars);
+  const omitted = text.length - headChars - tailChars;
+  output.output = `${head}
+
+... [${omitted} chars truncated \u2014 ${text.length} total.${pathNote}]
+
+${tail}`;
+}
+async function runPostEditVerify(cfg, client, sess, sessionID, filePath, output) {
+  if (!cfg.enabled) return;
+  const ext = path6.extname(filePath).toLowerCase();
+  if (!TS_EXTENSIONS.has(ext)) return;
+  const now = Date.now();
+  if (now - sess.lastVerifyTs < 2e3) return;
+  sess.lastVerifyTs = now;
+  const cwd = await resolveSessionDir(client, sess, sessionID);
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), cfg.timeoutMs);
+    let raw;
+    try {
+      const { stdout, stderr } = await exec6(
+        "npx",
+        ["tsc", "--noEmit", "--pretty", "false"],
+        {
+          maxBuffer: TSC_MAX_BUFFER,
+          cwd,
+          encoding: "utf8",
+          signal: controller.signal
+        }
+      );
+      raw = String(stdout || "");
+      if (stderr) raw += `
+${String(stderr)}`;
+    } catch (err) {
+      const e = err;
+      if (e.killed || e.code === "ABORT_ERR") return;
+      raw = String(e.stdout || "");
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!raw.trim()) return;
+    const errors = parseTscOutput(raw);
+    const normPath = path6.resolve(cwd, filePath);
+    const fileErrors = errors.filter((e) => {
+      const errPath = path6.isAbsolute(e.file) ? e.file : path6.resolve(cwd, e.file);
+      return path6.normalize(errPath) === path6.normalize(normPath);
+    });
+    if (fileErrors.length === 0) return;
+    const { rows } = dedupeAndCap(fileErrors, VERIFY_MAX_ERRORS);
+    const lines = rows.map(formatRow);
+    output.output += `
+
+--- POST-EDIT DIAGNOSTICS (${fileErrors.length} error${fileErrors.length !== 1 ? "s" : ""} in ${path6.basename(filePath)}) ---
+` + lines.join("\n") + `
+--- Fix these before proceeding ---`;
+  } catch {
+  }
+}
+function checkEditLoop(cfg, sess, filePath, output) {
+  if (!cfg.enabled) return;
+  const count = (sess.editCounts.get(filePath) ?? 0) + 1;
+  sess.editCounts.set(filePath, count);
+  if (count >= cfg.threshold && count % cfg.threshold === 0) {
+    output.output += `
+
+--- LOOP WARNING ---
+You've edited ${path6.basename(filePath)} ${count} times this session. Consider reconsidering your approach \u2014 are you stuck in a loop? Step back and think about whether a different strategy would be more effective.
+---`;
+  }
+}
+function checkReadDedup(cfg, sess, filePath, output) {
+  if (!cfg.enabled) return false;
+  if (!filePath) return false;
+  const hash = hashContent(output.output);
+  const cached = sess.readCache.get(filePath);
+  if (cached && cached.hash === hash) {
+    output.output = `[File unchanged since tool call #${cached.callSeq}. Content identical (hash: ${hash}). See earlier read for full text.]`;
+    return true;
+  }
+  sess.readCache.set(filePath, { hash, callSeq: sess.callSeq });
+  return false;
+}
+var pluginConfig = null;
+var storedPluginOptions;
+var plugin5 = async ({ client }, options) => {
+  storedPluginOptions = options;
+  return {
+    config: async (config) => {
+      pluginConfig = resolveConfig(config, storedPluginOptions);
+    },
+    "tool.execute.after": async (input, output) => {
+      const cfg = pluginConfig ?? resolveConfig({}, storedPluginOptions);
+      const sess = getSession(input.sessionID);
+      const toolName = input.tool;
+      if (toolName === "read") {
+        const fp = extractFilePath(input.args);
+        const deduped = checkReadDedup(cfg.readDedup, sess, fp, output);
+        if (deduped) return;
+      }
+      if (EDIT_TOOLS2.has(toolName)) {
+        const fp = extractFilePath(input.args);
+        if (fp) {
+          checkEditLoop(cfg.loopDetection, sess, fp, output);
+          await runPostEditVerify(
+            cfg.verifyLoop,
+            client,
+            sess,
+            input.sessionID,
+            fp,
+            output
+          );
+        }
+      }
+      applyBackpressure(cfg.backpressure, toolName, input.callID, output, input.args);
+    }
+  };
+};
+var tool_hooks_default = plugin5;
+
+// src/plugins/telemetry.ts
+import { extname as extname2 } from "path";
+
+// src/telemetry.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { homedir as homedir4 } from "os";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync } from "fs";
+import { join as join8 } from "path";
+var APP_KEY = "A-US-3617699429";
+var ENDPOINT = "https://us.aptabase.com/api/v0/event";
+var PKG_NAME = "@glrs-dev/harness-plugin-opencode";
+var PKG_VERSION = true ? "0.2.0" : "dev";
+var DISABLED = process.env.HARNESS_OPENCODE_TELEMETRY === "0" || process.env.HARNESS_OPENCODE_TELEMETRY === "false" || process.env.DO_NOT_TRACK === "1" || process.env.CI === "true";
+var SESSION_ID = randomUUID();
+function getInstallId() {
+  const dir = join8(homedir4(), ".config", "harness-opencode");
+  const file = join8(dir, "install-id");
+  try {
+    if (existsSync(file)) return readFileSync3(file, "utf8").trim();
+    mkdirSync3(dir, { recursive: true });
+    const id = createHash2("sha256").update(randomUUID()).digest("hex").slice(0, 16);
+    writeFileSync3(file, id, { mode: 384 });
+    return id;
+  } catch {
+    return "anon";
+  }
+}
+var ALLOWED_PROPS = /* @__PURE__ */ new Set([
+  "tool",
+  "outcome",
+  "duration_ms",
+  "edit_kind",
+  "ops_count",
+  "retry_count",
+  "diagnostics_count",
+  "ext",
+  "stale",
+  "error_class",
+  "subagent",
+  "memory_op",
+  "tool_category"
+]);
+function clean(p) {
+  const out = {};
+  for (const [k, v] of Object.entries(p)) {
+    if (!ALLOWED_PROPS.has(k)) continue;
+    if (typeof v === "string" || typeof v === "number") out[k] = v;
+    else if (typeof v === "boolean") out[k] = v ? 1 : 0;
+  }
+  return out;
+}
+var installId = DISABLED ? "" : getInstallId();
+function track(eventName, props = {}) {
+  if (DISABLED) return;
+  fetch(ENDPOINT, {
+    method: "POST",
+    headers: {
+      "App-Key": APP_KEY,
+      "Content-Type": "application/json",
+      "User-Agent": `${PKG_NAME}/${PKG_VERSION} node/${process.version}`
+    },
+    body: JSON.stringify({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: SESSION_ID,
+      eventName,
+      systemProps: {
+        isDebug: process.env.NODE_ENV !== "production",
+        osName: process.platform,
+        osVersion: process.release?.name ?? "node",
+        locale: (process.env.LANG ?? "en").split(".")[0] ?? "en",
+        appVersion: PKG_VERSION,
+        appBuildNumber: PKG_VERSION,
+        sdkVersion: "harness-opencode-fetch@1",
+        engineName: "node",
+        engineVersion: process.version
+      },
+      props: { ...clean(props), install: installId.slice(0, 8) }
+    })
+  }).catch(() => {
+  });
+}
+
+// src/plugins/telemetry.ts
+var plugin6 = async () => {
+  if (DISABLED) {
+    return {};
+  }
+  track("plugin.loaded");
+  const sessionStart = Date.now();
+  let toolCalls = 0;
+  const callTimings = /* @__PURE__ */ new Map();
+  return {
+    "tool.execute.before": async (input, _output) => {
+      callTimings.set(input.callID, Date.now());
+    },
+    "tool.execute.after": async (input, output) => {
+      toolCalls++;
+      const t0 = callTimings.get(input.callID);
+      callTimings.delete(input.callID);
+      const duration_ms = t0 ? Date.now() - t0 : 0;
+      const outStr = String(output.output ?? "");
+      const failed = output.metadata?.error != null || output.metadata?.exitCode != null && output.metadata.exitCode !== 0;
+      const outcome = failed ? "error" : "success";
+      if (input.tool === "hashline_edit") {
+        const filePath = String(input.args?.target_filepath ?? "");
+        const ext = extname2(filePath);
+        const isHashMismatch = /hash.*mismatch|stale/i.test(outStr);
+        const isNotFound = /not.*found/i.test(outStr);
+        track("hashline.edit", {
+          outcome,
+          duration_ms,
+          ext,
+          stale: isHashMismatch,
+          error_class: failed ? isHashMismatch ? "hash_mismatch" : isNotFound ? "file_not_found" : "other" : void 0
+        });
+      } else if (input.tool?.startsWith("serena_")) {
+        track("serena.call", {
+          tool: input.tool.replace("serena_", ""),
+          duration_ms,
+          outcome
+        });
+      } else if (input.tool?.startsWith("memory_")) {
+        track("memory.call", {
+          memory_op: input.tool.replace("memory_", ""),
+          duration_ms,
+          outcome
+        });
+      } else {
+        track("tool.call", {
+          tool: input.tool,
+          duration_ms,
+          outcome
+        });
+      }
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.idle") {
+        track("session.ended", {
+          duration_ms: Date.now() - sessionStart,
+          ops_count: toolCalls
+        });
+      }
+    }
+  };
+};
+var telemetry_default = plugin6;
+
+// src/index.ts
+var BUNDLED_VERSION = readOurPackageVersion(import.meta.url);
+async function checkForUpdate(client) {
+  if (process.env["HARNESS_OPENCODE_UPDATE_CHECK"] === "0") return;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch(
+      `https://registry.npmjs.org/${PACKAGE_NAME}/latest`,
+      { signal: controller.signal }
+    );
+    clearTimeout(timer);
+    if (!res.ok) return;
+    const data = await res.json();
+    const latest = data.version;
+    if (latest && latest !== BUNDLED_VERSION) {
+      const refresh = await refreshPluginCache(BUNDLED_VERSION, latest).catch(
+        (err) => ({
+          outcome: "error",
+          message: err.message,
+          fromVersion: BUNDLED_VERSION,
+          toVersion: latest
+        })
+      );
+      const toastMessage = refresh.outcome === "refreshed" ? `You have ${BUNDLED_VERSION}. Next OpenCode restart will auto-update.` : refresh.outcome === "disabled" ? `You have ${BUNDLED_VERSION}. Auto-update disabled; restart to pick up the new version (cache may need refresh).` : refresh.outcome === "non-exact-pin" ? `You have ${BUNDLED_VERSION}. Cache uses a custom version spec \u2014 run: bun update ${PACKAGE_NAME}` : (
+        // cache-missing / not-our-package / already-current / error
+        `You have ${BUNDLED_VERSION}. Restart OpenCode to refresh (${refresh.outcome}).`
+      );
+      try {
+        await client.tui.showToast({
+          body: {
+            title: `${PACKAGE_NAME} ${latest} available`,
+            message: toastMessage,
+            variant: "info",
+            duration: 8e3
+          }
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var plugin7 = async (input, options) => {
+  const pluginOptions = options ?? {};
+  loadDotenv(input.directory);
+  checkForUpdate(input.client).catch(() => {
+  });
+  const autopilotHooks = await autopilot_default(input);
+  const notifyHooks = await notify_default(input);
+  const costTrackerHooks = await cost_tracker_default(input);
+  const pilotHooks = await pilot_plugin_default(input);
+  const toolHooks = await tool_hooks_default(input, pluginOptions);
+  const telemetryHooks = await telemetry_default(input);
+  const hooks = {
+    // Config hook: register agents, commands, MCPs, skills
+    config: async (config) => {
+      applyConfig(config, pluginOptions);
+      if (autopilotHooks.config) await autopilotHooks.config(config);
+      if (notifyHooks.config) await notifyHooks.config(config);
+      if (costTrackerHooks.config) await costTrackerHooks.config(config);
+      if (toolHooks.config) await toolHooks.config(config);
+    },
+    // Custom tools
+    tool: createTools(),
+    // Event handlers from sub-plugins
+    event: async (input2) => {
+      if (autopilotHooks.event) await autopilotHooks.event(input2);
+      if (notifyHooks.event) await notifyHooks.event(input2);
+      if (costTrackerHooks.event) await costTrackerHooks.event(input2);
+      if (telemetryHooks.event) await telemetryHooks.event(input2);
+    }
+  };
+  if (autopilotHooks["chat.params"] !== void 0) {
+    hooks["chat.params"] = autopilotHooks["chat.params"];
+  }
+  if (autopilotHooks["chat.message"] !== void 0) {
+    hooks["chat.message"] = autopilotHooks["chat.message"];
+  }
+  if (autopilotHooks["experimental.session.compacting"] !== void 0) {
+    hooks["experimental.session.compacting"] = autopilotHooks["experimental.session.compacting"];
+  }
+  const hasTelemetryBefore = telemetryHooks["tool.execute.before"] !== void 0;
+  const hasPilotBefore = pilotHooks["tool.execute.before"] !== void 0;
+  if (hasTelemetryBefore || hasPilotBefore) {
+    hooks["tool.execute.before"] = async (input2, output) => {
+      if (hasTelemetryBefore) await telemetryHooks["tool.execute.before"](input2, output);
+      if (hasPilotBefore) await pilotHooks["tool.execute.before"](input2, output);
+    };
+  }
+  const hasToolHooksAfter = toolHooks["tool.execute.after"] !== void 0;
+  const hasTelemetryAfter = telemetryHooks["tool.execute.after"] !== void 0;
+  if (hasToolHooksAfter || hasTelemetryAfter) {
+    hooks["tool.execute.after"] = async (input2, output) => {
+      if (hasToolHooksAfter) await toolHooks["tool.execute.after"](input2, output);
+      if (hasTelemetryAfter) await telemetryHooks["tool.execute.after"](input2, output);
+    };
+  }
+  return hooks;
+};
+var src_default = plugin7;
+export {
+  src_default as default
+};