cc-agent-harness 0.0.1

package/dist/chunk-R6VGYQOH.js

@@ -0,0 +1,771 @@
+#!/usr/bin/env node
+import {
+  anyConfigExists,
+  loadConfig,
+  projectConfigExists
+} from "./chunk-3P72TGGQ.js";
+
+// src/adapter/detector.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/adapter/rust.ts
+import { existsSync } from "fs";
+import { join } from "path";
+var RustAdapter = class {
+  name = "rust";
+  async detect(cwd) {
+    return existsSync(join(cwd, "Cargo.toml"));
+  }
+  getCommands() {
+    return [
+      { name: "fmt", command: "cargo fmt", description: "Format Rust code" },
+      { name: "test", command: "cargo test", description: "Run Rust tests" },
+      { name: "clippy", command: "cargo clippy --tests", description: "Run Clippy lints" },
+      { name: "build", command: "cargo build", description: "Build project" }
+    ];
+  }
+  getHealthChecks() {
+    return [
+      {
+        name: "cargo-installed",
+        check: async () => {
+          try {
+            const { execSync: execSync2 } = await import("child_process");
+            execSync2("cargo --version", { stdio: "pipe" });
+            return { status: "pass", message: "cargo is available" };
+          } catch {
+            return { status: "fail", message: "cargo not found in PATH" };
+          }
+        }
+      }
+    ];
+  }
+};
+
+// src/adapter/typescript.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var TypeScriptAdapter = class {
+  name = "typescript";
+  async detect(cwd) {
+    return existsSync2(join2(cwd, "tsconfig.json")) || existsSync2(join2(cwd, "package.json"));
+  }
+  getCommands() {
+    return [
+      { name: "build", command: "npm run build", description: "Build TypeScript project" },
+      { name: "test", command: "npm test", description: "Run tests" },
+      { name: "lint", command: "npm run lint", description: "Run linter" }
+    ];
+  }
+  getHealthChecks() {
+    return [
+      {
+        name: "node-version",
+        check: async () => {
+          const major = parseInt(process.versions.node.split(".")[0], 10);
+          if (major >= 22) {
+            return { status: "pass", message: `Node.js v${process.versions.node}` };
+          }
+          return {
+            status: "warn",
+            message: `Node.js v${process.versions.node} (>=22 recommended)`
+          };
+        }
+      }
+    ];
+  }
+};
+
+// src/adapter/python.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var PythonAdapter = class {
+  name = "python";
+  async detect(cwd) {
+    return existsSync3(join3(cwd, "pyproject.toml")) || existsSync3(join3(cwd, "setup.py")) || existsSync3(join3(cwd, "requirements.txt"));
+  }
+  getCommands() {
+    return [
+      { name: "test", command: "pytest", description: "Run Python tests" },
+      { name: "lint", command: "ruff check .", description: "Run linter" },
+      { name: "fmt", command: "ruff format .", description: "Format Python code" }
+    ];
+  }
+  getHealthChecks() {
+    return [
+      {
+        name: "python-installed",
+        check: async () => {
+          try {
+            const { execSync: execSync2 } = await import("child_process");
+            const out = execSync2("python3 --version", { stdio: "pipe" }).toString().trim();
+            return { status: "pass", message: out };
+          } catch {
+            return { status: "fail", message: "python3 not found in PATH" };
+          }
+        }
+      }
+    ];
+  }
+};
+
+// src/adapter/registry.ts
+var BUILT_IN_ADAPTERS = [
+  new RustAdapter(),
+  new TypeScriptAdapter(),
+  new PythonAdapter()
+];
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  constructor(additionalAdapters = []) {
+    for (const adapter of BUILT_IN_ADAPTERS) {
+      this.adapters.set(adapter.name, adapter);
+    }
+    for (const adapter of additionalAdapters) {
+      this.adapters.set(adapter.name, adapter);
+    }
+  }
+  register(adapter) {
+    this.adapters.set(adapter.name, adapter);
+  }
+  get(name) {
+    return this.adapters.get(name);
+  }
+  list() {
+    return [...this.adapters.values()];
+  }
+  async detect(cwd) {
+    for (const adapter of this.adapters.values()) {
+      if (await adapter.detect(cwd)) return adapter;
+    }
+    return null;
+  }
+  count() {
+    const builtin = BUILT_IN_ADAPTERS.length;
+    const total = this.adapters.size;
+    return { builtin, custom: total - builtin, total };
+  }
+};
+
+// src/adapter/detector.ts
+var defaultRegistry = new AdapterRegistry();
+async function detectProjectType(cwd) {
+  return defaultRegistry.detect(cwd);
+}
+function detectLanguage(cwd) {
+  const signals = {
+    rust: existsSync4(join4(cwd, "Cargo.toml")),
+    typescript: existsSync4(join4(cwd, "package.json")) || existsSync4(join4(cwd, "tsconfig.json")),
+    python: existsSync4(join4(cwd, "pyproject.toml")) || existsSync4(join4(cwd, "setup.py")) || existsSync4(join4(cwd, "requirements.txt"))
+  };
+  const detected = Object.entries(signals).filter(([, v]) => v);
+  if (detected.length > 1) return "multi";
+  if (detected.length === 1) return detected[0][0];
+  return "typescript";
+}
+
+// src/config/defaults.ts
+var BUILT_IN_AGENTS = [
+  { name: "architect-low", domain: "analysis", tier: "low" },
+  { name: "architect-medium", domain: "analysis", tier: "medium" },
+  { name: "architect", domain: "analysis", tier: "high" },
+  { name: "executor-low", domain: "execution", tier: "low" },
+  { name: "executor", domain: "execution", tier: "medium" },
+  { name: "executor-high", domain: "execution", tier: "high" },
+  { name: "explore", domain: "search", tier: "low" },
+  { name: "explore-medium", domain: "search", tier: "medium" },
+  { name: "explore-high", domain: "search", tier: "high" },
+  { name: "researcher-low", domain: "research", tier: "low" },
+  { name: "researcher", domain: "research", tier: "medium" },
+  { name: "designer-low", domain: "frontend", tier: "low" },
+  { name: "designer", domain: "frontend", tier: "medium" },
+  { name: "designer-high", domain: "frontend", tier: "high" },
+  { name: "writer", domain: "docs", tier: "low" },
+  { name: "vision", domain: "visual", tier: "medium" },
+  { name: "planner", domain: "planning", tier: "high" },
+  { name: "critic", domain: "critique", tier: "high" },
+  { name: "analyst", domain: "pre-planning", tier: "high" },
+  { name: "qa-tester", domain: "testing", tier: "medium" },
+  { name: "qa-tester-high", domain: "testing", tier: "high" },
+  { name: "security-reviewer-low", domain: "security", tier: "low" },
+  { name: "security-reviewer", domain: "security", tier: "high" },
+  { name: "build-fixer-low", domain: "build", tier: "low" },
+  { name: "build-fixer", domain: "build", tier: "medium" },
+  { name: "tdd-guide-low", domain: "tdd", tier: "low" },
+  { name: "tdd-guide", domain: "tdd", tier: "medium" },
+  { name: "code-reviewer-low", domain: "code-review", tier: "low" },
+  { name: "code-reviewer", domain: "code-review", tier: "high" },
+  { name: "scientist-low", domain: "data-science", tier: "low" },
+  { name: "scientist", domain: "data-science", tier: "medium" },
+  { name: "scientist-high", domain: "data-science", tier: "high" }
+];
+
+// src/agent/registry.ts
+var AgentRegistry = class {
+  agents;
+  constructor(customAgents = []) {
+    this.agents = /* @__PURE__ */ new Map();
+    for (const agent of BUILT_IN_AGENTS) {
+      this.agents.set(agent.name, agent);
+    }
+    for (const agent of customAgents) {
+      this.agents.set(agent.name, agent);
+    }
+  }
+  get(name) {
+    return this.agents.get(name);
+  }
+  list() {
+    return [...this.agents.values()];
+  }
+  listByDomain(domain) {
+    return this.list().filter((a) => a.domain === domain);
+  }
+  listByTier(tier) {
+    return this.list().filter((a) => a.tier === tier);
+  }
+  domains() {
+    return [...new Set(this.list().map((a) => a.domain))];
+  }
+  count() {
+    const builtin = BUILT_IN_AGENTS.length;
+    const total = this.agents.size;
+    return { builtin, custom: total - builtin, total };
+  }
+};
+
+// src/skill/manager.ts
+import { readdir, stat } from "fs/promises";
+import { join as join6, resolve } from "path";
+import { existsSync as existsSync6 } from "fs";
+
+// src/skill/validator.ts
+import { readFile } from "fs/promises";
+import { join as join5 } from "path";
+import { existsSync as existsSync5 } from "fs";
+async function validateSkill(skillDir) {
+  const errors = [];
+  const warnings = [];
+  let name = null;
+  let description = null;
+  const skillMdPath = join5(skillDir, "SKILL.md");
+  if (!existsSync5(skillMdPath)) {
+    errors.push("Missing SKILL.md");
+    return { valid: false, name, description, errors, warnings };
+  }
+  const content = await readFile(skillMdPath, "utf-8");
+  const frontmatter = extractFrontmatter(content);
+  if (!frontmatter) {
+    errors.push("SKILL.md missing YAML frontmatter (---...--- block)");
+    return { valid: false, name, description, errors, warnings };
+  }
+  name = frontmatter.name ?? null;
+  description = frontmatter.description ?? null;
+  if (!name) errors.push("Frontmatter missing required 'name' field");
+  if (!description) errors.push("Frontmatter missing required 'description' field");
+  const metadataYaml = join5(skillDir, "metadata.yaml");
+  if (!existsSync5(metadataYaml)) {
+    warnings.push("No metadata.yaml (recommended for skill metadata)");
+  }
+  return { valid: errors.length === 0, name, description, errors, warnings };
+}
+function extractFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fields = {};
+  const lines = match[1].split("\n");
+  let currentKey = null;
+  let currentValue = "";
+  for (const line of lines) {
+    const kvMatch = line.match(/^(\w[\w-]*):\s*(.*)/);
+    if (kvMatch) {
+      if (currentKey) fields[currentKey] = currentValue.trim();
+      currentKey = kvMatch[1];
+      currentValue = kvMatch[2];
+    } else if (currentKey && (line.startsWith("  ") || line.startsWith("	"))) {
+      currentValue += " " + line.trim();
+    }
+  }
+  if (currentKey) fields[currentKey] = currentValue.trim();
+  return fields;
+}
+
+// src/skill/manager.ts
+async function discoverSkills(directories, cwd) {
+  const base = cwd ?? process.cwd();
+  const skills = [];
+  for (const dir of directories) {
+    const absDir = resolve(base, dir);
+    if (!existsSync6(absDir)) continue;
+    const entries = await readdir(absDir);
+    for (const entry of entries) {
+      const skillDir = join6(absDir, entry);
+      const info = await stat(skillDir);
+      if (!info.isDirectory()) continue;
+      const skillMd = join6(skillDir, "SKILL.md");
+      if (!existsSync6(skillMd)) continue;
+      const validation = await validateSkill(skillDir);
+      skills.push({
+        name: validation.name ?? entry,
+        description: validation.description ?? "",
+        path: skillDir,
+        valid: validation.valid
+      });
+    }
+  }
+  return skills;
+}
+
+// src/runtime/harness.ts
+import { dirname as dirname3, resolve as resolve5 } from "path";
+import { mkdir as mkdir2, writeFile } from "fs/promises";
+
+// src/audit/logger.ts
+import { appendFile, mkdir } from "fs/promises";
+import { resolve as resolve2, dirname } from "path";
+var DEFAULT_LOG_DIR = ".harness/logs";
+var LOG_FILE = "audit.jsonl";
+var AuditLogger = class {
+  logPath;
+  constructor(cwd, logDir) {
+    this.logPath = resolve2(cwd, logDir ?? DEFAULT_LOG_DIR, LOG_FILE);
+  }
+  async log(kind, message, data) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      kind,
+      message,
+      data
+    };
+    await mkdir(dirname(this.logPath), { recursive: true });
+    await appendFile(this.logPath, JSON.stringify(entry) + "\n", "utf-8");
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+};
+
+// src/context/pipeline.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve3, dirname as dirname2, relative, sep } from "path";
+var ContextPipeline = class {
+  blocks = [];
+  addBlock(tag, content, priority = 50) {
+    this.blocks.push({ tag, content, priority });
+  }
+  async addProjectDoc(cwd) {
+    const agentsMd = resolve3(cwd, "AGENTS.md");
+    if (existsSync7(agentsMd)) {
+      const content = await readFile2(agentsMd, "utf-8");
+      this.addBlock("project-doc", content, 10);
+    }
+  }
+  /**
+   * Walk from projectRoot to cwd, collecting AGENTS.md files.
+   * Deeper files override shallower ones (later blocks have higher priority).
+   */
+  async addHierarchicalDocs(cwd, projectRoot) {
+    const root = projectRoot ?? await findProjectRoot(cwd);
+    const docs = collectAgentsMdFiles(root, cwd);
+    for (let i = 0; i < docs.length; i++) {
+      const filePath = docs[i];
+      const content = await readFile2(filePath, "utf-8");
+      const depth = i;
+      this.addBlock(`agents-md-${depth}`, content, 10 + depth);
+    }
+  }
+  async addSkillsSummary(config, cwd) {
+    const skills = await discoverSkills(config.skills.directories, cwd);
+    if (skills.length === 0) return;
+    const lines = ["Available skills:"];
+    for (const skill of skills) {
+      if (skill.valid) {
+        lines.push(`- ${skill.name}: ${skill.description}`);
+      }
+    }
+    this.addBlock("skills", lines.join("\n"), 30);
+  }
+  addCustomRules(rules) {
+    if (rules.length === 0) return;
+    const content = rules.map((r) => `- ${r}`).join("\n");
+    this.addBlock("custom-rules", content, 20);
+  }
+  addRaw(tag, content, priority) {
+    this.addBlock(tag, content, priority);
+  }
+  build(options) {
+    const sorted = [...this.blocks].sort((a, b) => a.priority - b.priority);
+    const tagStyle = options?.tagStyle ?? "markdown";
+    const parts = [];
+    for (const block of sorted) {
+      const [open, close] = formatTags(block.tag, tagStyle);
+      if (open) parts.push(open);
+      parts.push(block.content);
+      if (close) parts.push(close);
+      parts.push("");
+    }
+    return {
+      blocks: sorted,
+      rendered: parts.join("\n").trim()
+    };
+  }
+  clear() {
+    this.blocks = [];
+  }
+};
+function formatTags(tag, style) {
+  switch (style) {
+    case "xml":
+      return [`<${tag}>`, `</${tag}>`];
+    case "markdown":
+      return [`<!-- ${tag} -->`, `<!-- /${tag} -->`];
+    case "none":
+      return [null, null];
+  }
+}
+function collectAgentsMdFiles(root, cwd) {
+  const files = [];
+  let current = resolve3(root);
+  const target = resolve3(cwd);
+  const steps = relative(current, target).split(sep).filter(Boolean);
+  const collect = (dir) => {
+    const agentsMd = resolve3(dir, "AGENTS.md");
+    if (existsSync7(agentsMd)) {
+      files.push(agentsMd);
+    }
+  };
+  collect(current);
+  for (const step of steps) {
+    current = resolve3(current, step);
+    if (!target.startsWith(current)) break;
+    collect(current);
+  }
+  return files;
+}
+async function findProjectRoot(cwd) {
+  let dir = resolve3(cwd);
+  while (true) {
+    if (existsSync7(resolve3(dir, ".harness")) || existsSync7(resolve3(dir, ".git"))) {
+      return dir;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) return cwd;
+    dir = parent;
+  }
+}
+
+// src/feature/registry.ts
+var FeatureRegistry = class {
+  specs = /* @__PURE__ */ new Map();
+  overrides = /* @__PURE__ */ new Map();
+  aliases = /* @__PURE__ */ new Map();
+  aliasUsages = [];
+  register(spec) {
+    this.specs.set(spec.id, spec);
+  }
+  registerMany(specs) {
+    for (const spec of specs) {
+      this.register(spec);
+    }
+  }
+  registerAlias(legacyKey, featureId) {
+    this.aliases.set(legacyKey, featureId);
+  }
+  registerAliases(aliasMap) {
+    for (const [legacy, id] of Object.entries(aliasMap)) {
+      this.registerAlias(legacy, id);
+    }
+  }
+  applyOverrides(overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      const spec = this.findByKey(key);
+      if (spec) {
+        if (spec.stage === "removed") continue;
+        this.overrides.set(spec.id, value);
+      }
+    }
+  }
+  isEnabled(id) {
+    const resolved = this.resolveAlias(id);
+    const override = this.overrides.get(resolved);
+    if (override !== void 0) return override;
+    const spec = this.specs.get(resolved);
+    if (!spec) return false;
+    if (spec.stage === "removed") return false;
+    return spec.defaultEnabled;
+  }
+  get(id) {
+    const resolved = this.resolveAlias(id);
+    return this.specs.get(resolved);
+  }
+  list() {
+    return [...this.specs.values()];
+  }
+  listByStage(stage) {
+    return this.list().filter((s) => s.stage === stage);
+  }
+  listEnabled() {
+    return this.list().filter((s) => this.isEnabled(s.id));
+  }
+  count() {
+    const total = this.specs.size;
+    const enabled = this.listEnabled().length;
+    return { total, enabled, disabled: total - enabled };
+  }
+  getAliasUsages() {
+    return [...this.aliasUsages];
+  }
+  resolveAlias(key) {
+    const mapped = this.aliases.get(key);
+    if (mapped) {
+      this.aliasUsages.push(`Legacy key "${key}" resolved to "${mapped}"`);
+      return mapped;
+    }
+    return key;
+  }
+  findByKey(key) {
+    const resolved = this.resolveAlias(key);
+    const direct = this.specs.get(resolved);
+    if (direct) return direct;
+    for (const spec of this.specs.values()) {
+      if (spec.key === resolved || spec.id === resolved) return spec;
+    }
+    return void 0;
+  }
+};
+
+// src/hook/discovery.ts
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve4 } from "path";
+import { parse as parseYaml } from "yaml";
+var HOOKS_FILE_NAMES = ["hooks.yaml", "hooks.json"];
+async function discoverHooks(cwd) {
+  const handlers = [];
+  const harnessDir = resolve4(cwd, ".harness");
+  for (const fileName of HOOKS_FILE_NAMES) {
+    const filePath = resolve4(harnessDir, fileName);
+    if (!existsSync8(filePath)) continue;
+    const content = await readFile3(filePath, "utf-8");
+    const parsed = fileName.endsWith(".json") ? JSON.parse(content) : parseYaml(content);
+    if (parsed && Array.isArray(parsed.hooks)) {
+      for (const hook of parsed.hooks) {
+        if (hook.event && hook.command) {
+          handlers.push({
+            event: hook.event,
+            command: hook.command,
+            matcher: hook.matcher
+          });
+        }
+      }
+    }
+    break;
+  }
+  return handlers;
+}
+
+// src/hook/dispatcher.ts
+import { execSync } from "child_process";
+var HookDispatcher = class {
+  handlers;
+  constructor(handlers) {
+    this.handlers = handlers;
+  }
+  async dispatch(event, cwd, data) {
+    const matching = this.handlers.filter((h) => h.event === event);
+    if (matching.length === 0) return [];
+    const payload = {
+      event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      cwd,
+      data
+    };
+    const payloadJson = JSON.stringify(payload);
+    const results = [];
+    for (const handler of matching) {
+      if (handler.matcher && data) {
+        const matchValue = String(data.match ?? "");
+        if (matchValue && !matchValue.includes(handler.matcher)) continue;
+      }
+      const start = Date.now();
+      try {
+        const stdout = execSync(handler.command, {
+          cwd,
+          input: payloadJson,
+          stdio: ["pipe", "pipe", "pipe"],
+          timeout: 3e4
+        }).toString();
+        results.push({
+          handler,
+          exitCode: 0,
+          stdout,
+          stderr: "",
+          durationMs: Date.now() - start
+        });
+      } catch (err) {
+        const execErr = err;
+        results.push({
+          handler,
+          exitCode: execErr.status ?? 1,
+          stdout: execErr.stdout?.toString() ?? "",
+          stderr: execErr.stderr?.toString() ?? "",
+          durationMs: Date.now() - start
+        });
+      }
+    }
+    return results;
+  }
+  hasHandlers(event) {
+    return this.handlers.some((h) => h.event === event);
+  }
+};
+
+// src/runtime/harness.ts
+var HarnessRuntime = class _HarnessRuntime {
+  cwd;
+  hasProjectConfig;
+  hasAnyConfig;
+  config;
+  adapter;
+  agentRegistry;
+  featureRegistry;
+  hookDispatcher;
+  auditLogger;
+  constructor(args) {
+    this.cwd = args.cwd;
+    this.hasProjectConfig = args.hasProjectConfig;
+    this.hasAnyConfig = args.hasAnyConfig;
+    this.config = args.config;
+    this.adapter = args.adapter;
+    this.hookDispatcher = args.hookDispatcher;
+    this.auditLogger = args.auditLogger;
+    this.featureRegistry = args.featureRegistry;
+    this.agentRegistry = new AgentRegistry(args.config?.agents.definitions ?? []);
+  }
+  static async create(opts) {
+    const cwd = opts?.cwd ?? process.cwd();
+    const hasProjectConfig = projectConfigExists(cwd);
+    const hasAnyConfig = anyConfigExists(cwd);
+    if (opts?.requireProjectConfig && !hasProjectConfig) {
+      throw new Error("No harness project configuration found. Run `agent-harness setup` first.");
+    }
+    const config = hasProjectConfig ? await loadConfig({ cwd }) : void 0;
+    const adapter = await detectProjectType(cwd);
+    const handlers = hasProjectConfig ? await discoverHooks(cwd) : [];
+    const featureRegistry = buildFeatureRegistry(config);
+    return new _HarnessRuntime({
+      cwd,
+      hasProjectConfig,
+      hasAnyConfig,
+      config,
+      adapter,
+      hookDispatcher: new HookDispatcher(handlers),
+      auditLogger: new AuditLogger(cwd),
+      featureRegistry
+    });
+  }
+  listTasks() {
+    const tasks = /* @__PURE__ */ new Map();
+    if (this.adapter) {
+      for (const command of this.adapter.getCommands()) {
+        tasks.set(command.name, toRuntimeTask(command, "adapter", this.adapter.name));
+      }
+    }
+    if (this.config) {
+      for (const [name, command] of Object.entries(this.config.workflows.commands)) {
+        tasks.set(name, {
+          name,
+          command,
+          description: `Workflow command "${name}"`,
+          source: "workflow"
+        });
+      }
+    }
+    return [...tasks.values()].sort((a, b) => a.name.localeCompare(b.name));
+  }
+  getTask(name) {
+    return this.listTasks().find((task) => task.name === name);
+  }
+  listFeatureStates() {
+    const configuredFeatures = this.config?.features ?? {};
+    return this.featureRegistry.list().map((spec) => ({
+      spec,
+      enabled: this.featureRegistry.isEnabled(spec.id),
+      configured: Object.prototype.hasOwnProperty.call(configuredFeatures, spec.key),
+      configuredValue: configuredFeatures[spec.key]
+    }));
+  }
+  async dispatchHooks(event, data) {
+    if (!this.hasProjectConfig || !this.hookDispatcher.hasHandlers(event)) {
+      return [];
+    }
+    const results = await this.hookDispatcher.dispatch(event, this.cwd, data);
+    await this.log("hook.executed", `Executed ${results.length} hook(s) for ${event}`, {
+      event,
+      results: results.map((result) => ({
+        command: result.handler.command,
+        exitCode: result.exitCode,
+        durationMs: result.durationMs
+      }))
+    });
+    return results;
+  }
+  async log(kind, message, data) {
+    if (!this.hasProjectConfig && kind !== "setup") {
+      return;
+    }
+    await this.auditLogger.log(kind, message, data);
+  }
+  async buildContext(opts) {
+    const pipeline = new ContextPipeline();
+    await pipeline.addHierarchicalDocs(this.cwd);
+    if (this.config && (opts?.includeCustomRules ?? true)) {
+      pipeline.addCustomRules(this.config.templates.agents_md.custom_rules);
+    }
+    if (this.config && (opts?.includeSkills ?? true)) {
+      await pipeline.addSkillsSummary(this.config, this.cwd);
+    }
+    return pipeline.build({ tagStyle: opts?.tagStyle ?? "markdown" });
+  }
+  async writeContext(opts) {
+    const result = await this.buildContext(opts);
+    const outputPath = resolve5(this.cwd, opts.outputPath);
+    await mkdir2(dirname3(outputPath), { recursive: true });
+    await writeFile(outputPath, result.rendered + "\n", "utf-8");
+    return result;
+  }
+};
+function toRuntimeTask(command, source, adapterName) {
+  return {
+    name: command.name,
+    command: command.command,
+    description: command.description,
+    source,
+    adapterName
+  };
+}
+function buildFeatureRegistry(config) {
+  const registry = new FeatureRegistry();
+  const configured = config?.features ?? {};
+  for (const key of Object.keys(configured)) {
+    registry.register({
+      id: key,
+      key,
+      stage: "experimental",
+      defaultEnabled: false,
+      description: `Feature flag configured via "${key}"`
+    });
+  }
+  registry.applyOverrides(configured);
+  return registry;
+}
+
+export {
+  detectLanguage,
+  AgentRegistry,
+  discoverSkills,
+  HarnessRuntime
+};
+//# sourceMappingURL=chunk-R6VGYQOH.js.map