ai-dev-harness 0.1.0

package/README.md

@@ -0,0 +1,131 @@
+# AI Dev Harness
+
+Auditable TypeScript CLI harness that wraps Codex CLI or Claude Code, retrieves context from CodeGraph and Knowledge Graph MCP services, verifies changes, and writes local run evidence.
+
+This repository is a distributable Harness package:
+
+- CLI: `dist/cli.js`
+- Claude/Codex conversation integration installer
+- Claude Skill package installed into `.claude/skills/ai-dev-harness/`
+- Agent helper scripts installed into `.harness/ai-dev-harness/scripts/`
+- Git-native project skills installed into `skills/`
+
+## Quick Start
+
+```bash
+npm install
+npm run build
+node dist/cli.js init
+node dist/cli.js run --task "fix a small bug" --skill fix_bug --agent codex
+```
+
+The CLI is intended to be installed inside a business Git repository. `init` creates `harness.yaml`, `skills/`, `AGENTS.md`, `TOOLS.md`, `SKILLS.md`, and `runs/`.
+`harness run` must execute inside a Git repository; if it is launched elsewhere, the harness writes intake/audit evidence and exits nonzero.
+
+## Commands
+
+```bash
+node dist/cli.js init
+node dist/cli.js run --task "add refund flow tests" --skill write_tests --agent claude
+node dist/cli.js run --task "analyze download startup flow. Do not modify repository files." --skill update_docs --agent claude --live
+node dist/cli.js verify --run <run_id_or_path>
+node dist/cli.js summarize --run <run_id_or_path>
+node dist/cli.js install-integration --agent both --target <repo>
+```
+
+## Claude/Codex Conversation Trigger
+
+Install conversation integration into a business repository:
+
+```bash
+node "E:\ai native\dist\cli.js" install-integration --agent both --target "C:\path\to\repo"
+```
+
+This creates:
+
+- `.claude/skills/ai-dev-harness/SKILL.md` for Claude Code.
+- An `AGENTS.md` Harness section for Codex.
+- `.harness/ai-dev-harness/scripts/run-harness.ps1`
+- `.harness/ai-dev-harness/scripts/read-evidence.ps1`
+
+Then, inside Claude Code or Codex, ask naturally:
+
+```text
+Use AI Dev Harness to run update_docs: analyze the download startup flow. Do not modify repository files.
+```
+
+or:
+
+```text
+Use Harness to run fix_bug: fix the download resume progress issue.
+```
+
+The generated integration uses `--live`, so the current conversation terminal can see Harness stages and agent output as the run progresses.
+
+The installed Skill prefers the helper script:
+
+```bash
+powershell -ExecutionPolicy Bypass -File ".harness/ai-dev-harness/scripts/run-harness.ps1" -Task "<task>" -Skill fix_bug -Agent claude -Live
+```
+
+The direct CLI command remains available as a fallback:
+
+```bash
+node "E:\ai native\dist\cli.js" run --task "<task>" --skill fix_bug --agent claude --live
+```
+
+## Configuration
+
+Edit `harness.yaml` in the business repository:
+
+```yaml
+agents:
+  codex:
+    command: codex exec --full-auto -
+  claude:
+    command: claude -p -
+mcp:
+  codegraph:
+    url: http://localhost:7331/mcp
+  knowledgeGraph:
+    url: http://localhost:7332/mcp
+  timeoutMs: 15000
+verify:
+  defaultCommands:
+    - name: git status
+      command: git status --short
+audit:
+  path: runs
+```
+
+The agent command receives the generated prompt on stdin. CodeGraph and Knowledge Graph MCP are queried first; if either service is unavailable, the run is marked degraded and the harness falls back to local Git/file context.
+If the agent command or verification fails, the run still writes all evidence files and then exits nonzero so CI can treat the run as failed.
+
+## Run Evidence
+
+Each `run` creates `runs/<run_id>/` with:
+
+- `intake.json`
+- `mcp_queries.jsonl`
+- `context_pack.md`
+- `agent_prompt.md`
+- `plan.md`
+- `execution.log`
+- `git_diff.patch`
+- `verify.json`
+- `summary.md`
+- `persist_suggestions.md`
+- `audit.jsonl`
+
+Knowledge Graph updates are not applied automatically in v1. Review `persist_suggestions.md` before writing them back.
+
+## Engineering Prompt Contracts
+
+Generated skills and agent prompts use a company-grade execution contract:
+
+- Analysis Contract: restate the task, list assumptions, affected areas, risks, and missing context.
+- Execution Contract: make only task-relevant minimal changes; no opportunistic refactors or broad cleanup.
+- Verification Contract: run configured verification or record why checks could not run.
+- Report Contract: summarize intent or root cause, changed files, verification, residual risk, and knowledge suggestions.
+
+The test suite verifies that initialized skills and run evidence include these contracts.

package/dist/agent.js

@@ -0,0 +1,100 @@
+import { appendFile, readFile, writeFile } from "node:fs/promises";
+import { git, runCommand, truncate } from "./utils.js";
+function renderPrompt(input, contextPack) {
+    return `You are running inside an auditable AI development harness. Treat this as a company engineering task, not a casual chat.
+
+Task:
+${input.task}
+
+Skill:
+${input.skill.name}
+
+Execution Contract:
+1. Analysis first.
+   - Restate the task in one or two sentences.
+   - Identify assumptions, affected files/modules, relevant CodeGraph context, relevant Knowledge Graph context, and risks.
+   - If required context is missing or confidence is low, stop and report what is missing instead of guessing.
+2. Plan before editing.
+   - Provide a minimal step-by-step plan.
+   - Keep the plan limited to the requested task.
+3. Safe execution.
+   - Make the smallest task-relevant change.
+   - Do not perform opportunistic refactors, formatting-only sweeps, dependency upgrades, broad renames, or unrelated cleanup.
+   - Preserve public interfaces and backward compatibility unless explicitly instructed otherwise.
+   - Do not update Knowledge Graph directly.
+4. Verification discipline.
+   - Harness will run configured verification after you finish.
+   - Only run extra commands when needed to understand or validate the task.
+   - Report any verification you could not run and why.
+5. Required final report.
+   - Root cause or implementation intent.
+   - Files changed.
+   - Verification performed or deferred.
+   - Residual risk.
+   - Knowledge persistence suggestions.
+
+Output Format:
+## Impact Analysis
+## Plan
+## Execution Notes
+## Verification Notes
+## Final Report
+
+Project Rules:
+- Respect AGENTS.md, TOOLS.md, and SKILLS.md when present.
+- Work inside this repository only.
+- Leave an auditable, reviewable result.
+
+Context pack:
+${contextPack}
+`;
+}
+async function executeAgent(input) {
+    const contextPack = await readFile(input.contextPackPath, "utf8");
+    const prompt = renderPrompt(input, contextPack);
+    await writeFile(input.promptPath, prompt, "utf8");
+    await appendFile(input.executionLogPath, `# Agent: ${input.agent}\n# Command: ${input.command}\n\n`, "utf8");
+    const result = await runCommand(input.command, input.cwd, prompt, 10 * 60 * 1000, {
+        live: input.live,
+        stdoutPrefix: `[${input.agent}] `,
+        stderrPrefix: `[${input.agent}:stderr] `
+    });
+    await appendFile(input.executionLogPath, `## STDOUT\n${result.stdout}\n\n## STDERR\n${result.stderr}\n`, "utf8");
+    const changedFilesRaw = await git(input.cwd, "diff --name-only");
+    const diff = await git(input.cwd, "diff --no-ext-diff");
+    const changedFiles = changedFilesRaw ? changedFilesRaw.split(/\r?\n/).filter(Boolean) : [];
+    return {
+        status: result.exitCode === 0 ? "success" : "failed",
+        exitCode: result.exitCode,
+        stdout: truncate(result.stdout, 8000),
+        stderr: truncate(result.stderr, 8000),
+        changedFiles,
+        diff,
+        error: result.exitCode === 0 ? undefined : `Agent command failed with exit code ${result.exitCode}`
+    };
+}
+export class CodexAdapter {
+    command;
+    name = "codex";
+    constructor(command) {
+        this.command = command;
+    }
+    run(input) {
+        return executeAgent({ ...input, agent: this.name, command: this.command });
+    }
+}
+export class ClaudeAdapter {
+    command;
+    name = "claude";
+    constructor(command) {
+        this.command = command;
+    }
+    run(input) {
+        return executeAgent({ ...input, agent: this.name, command: this.command });
+    }
+}
+export function createAgentAdapter(agent, config) {
+    if (agent === "codex")
+        return new CodexAdapter(config.agents.codex.command);
+    return new ClaudeAdapter(config.agents.claude.command);
+}

package/dist/audit.js

@@ -0,0 +1,21 @@
+import { appendFile, writeFile } from "node:fs/promises";
+import { ensureDir, nowIso } from "./utils.js";
+export class AuditLogger {
+    auditPath;
+    constructor(auditPath) {
+        this.auditPath = auditPath;
+    }
+    async event(event) {
+        const line = JSON.stringify({ timestamp: nowIso(), ...event });
+        await appendFile(this.auditPath, `${line}\n`, "utf8");
+    }
+}
+export async function writeJson(filePath, value) {
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+export async function prepareRunFiles(paths) {
+    await ensureDir(paths.runDir);
+    await writeJson(paths.intake, {});
+    await writeFile(paths.mcpQueries, "", "utf8");
+    await writeFile(paths.audit, "", "utf8");
+}

package/dist/cli.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { AuditLogger, prepareRunFiles, writeJson } from "./audit.js";
+import { createAgentAdapter } from "./agent.js";
+import { loadConfig, loadSkill } from "./config.js";
+import { buildContextPack } from "./context.js";
+import { initHarness } from "./init.js";
+import { installIntegration } from "./integration.js";
+import { makeRunPaths } from "./runPaths.js";
+import { writeSummary } from "./summarize.js";
+import { runVerify } from "./verify.js";
+import { git, pathExists } from "./utils.js";
+function parseArgs(argv) {
+    const [command = "help", ...rest] = argv;
+    const args = {};
+    for (let i = 0; i < rest.length; i += 1) {
+        const item = rest[i];
+        if (!item.startsWith("--"))
+            continue;
+        const key = item.slice(2);
+        const next = rest[i + 1];
+        if (!next || next.startsWith("--"))
+            args[key] = true;
+        else {
+            args[key] = next;
+            i += 1;
+        }
+    }
+    return { command, args };
+}
+function usage() {
+    return `AI Dev Harness
+
+Usage:
+  harness init
+  harness run --task <text> --skill <name> --agent <codex|claude>
+  harness run --task <text> --skill <name> --agent <codex|claude> --live
+  harness verify --run <run_id_or_path>
+  harness summarize --run <run_id_or_path>
+  harness install-integration --agent <claude|codex|both> [--target <repo>] [--command <harness command>]
+`;
+}
+function requireString(args, key) {
+    const value = args[key];
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`Missing required --${key}`);
+    return value;
+}
+function requireAgent(value) {
+    if (value !== "codex" && value !== "claude")
+        throw new Error(`Invalid agent: ${value}. Expected codex or claude.`);
+    return value;
+}
+function quoteCommandPath(filePath) {
+    return `"${filePath.replace(/"/g, '\\"')}"`;
+}
+async function resolveRunDir(cwd, runArg) {
+    const direct = path.resolve(cwd, runArg);
+    if (await pathExists(direct))
+        return direct;
+    const config = await loadConfig(cwd);
+    const underAudit = path.join(cwd, config.audit.path, runArg);
+    if (await pathExists(underAudit))
+        return underAudit;
+    throw new Error(`Run not found: ${runArg}`);
+}
+async function commandInit(cwd) {
+    const result = await initHarness(cwd);
+    console.log(`Initialized AI Dev Harness in ${cwd}`);
+    console.log(`Created ${result.created.length} file(s), skipped ${result.skipped.length} existing file(s).`);
+}
+function sayLive(live, message) {
+    if (live)
+        console.log(`[harness] ${message}`);
+}
+async function commandRun(cwd, args) {
+    const task = requireString(args, "task");
+    const skillName = requireString(args, "skill");
+    const agentName = requireAgent(requireString(args, "agent"));
+    const live = Boolean(args.live);
+    const config = await loadConfig(cwd);
+    const skill = await loadSkill(cwd, skillName);
+    const paths = makeRunPaths(cwd, config, task);
+    await prepareRunFiles(paths);
+    const audit = new AuditLogger(paths.audit);
+    sayLive(live, `run started: skill=${skillName} agent=${agentName}`);
+    sayLive(live, `evidence directory: ${paths.runDir}`);
+    await audit.event({ stage: "intake", event: "run_started", status: "started", detail: { task, skill: skillName, agent: agentName } });
+    const isGitRepo = Boolean(await git(cwd, "rev-parse --show-toplevel"));
+    const intake = {
+        task,
+        skill: skillName,
+        agent: agentName,
+        cwd,
+        isGitRepo,
+        gitStatus: await git(cwd, "status --short"),
+        startedAt: new Date().toISOString()
+    };
+    await writeJson(paths.intake, intake);
+    if (!isGitRepo) {
+        await audit.event({
+            stage: "intake",
+            event: "git_repo_check",
+            status: "failed",
+            detail: "Current directory is not a Git repository. Run inside a business Git repository before executing harness run."
+        });
+        await audit.event({ stage: "run", event: "run_finished", status: "failed" });
+        throw new Error(`harness run must execute inside a Git repository. Evidence: ${paths.runDir}`);
+    }
+    sayLive(live, "building context pack with MCP first, local fallback second");
+    await audit.event({ stage: "context_pack", event: "build_started", status: "started" });
+    const contextPack = await buildContextPack({
+        cwd,
+        task,
+        config,
+        skill,
+        contextPackPath: paths.contextPack,
+        mcpLogPath: paths.mcpQueries,
+        audit
+    });
+    await audit.event({
+        stage: "context_pack",
+        event: "build_finished",
+        status: contextPack.degraded ? "degraded" : "succeeded"
+    });
+    sayLive(live, `context pack ${contextPack.degraded ? "degraded" : "ready"}: ${paths.contextPack}`);
+    const plan = `# Execution Plan
+
+The selected agent must:
+1. Read the context pack.
+2. Produce impact analysis.
+3. Make the smallest safe change.
+4. Leave enough evidence for review.
+5. Allow the harness to run verification and summarize results.
+`;
+    await writeFile(paths.plan, plan, "utf8");
+    await audit.event({ stage: "plan", event: "plan_written", status: "succeeded", detail: { path: paths.plan } });
+    sayLive(live, `plan written: ${paths.plan}`);
+    const adapter = createAgentAdapter(agentName, config);
+    const agentCommand = agentName === "codex" ? config.agents.codex.command : config.agents.claude.command;
+    sayLive(live, `executing ${adapter.name}: ${agentCommand}`);
+    await audit.event({ stage: "execute", event: "agent_started", status: "started", detail: { agent: adapter.name, command: agentCommand } });
+    let agentResult;
+    try {
+        agentResult = await adapter.run({
+            cwd,
+            task,
+            skill,
+            contextPackPath: paths.contextPack,
+            promptPath: paths.agentPrompt,
+            executionLogPath: paths.executionLog,
+            live
+        });
+        await audit.event({
+            stage: "execute",
+            event: "agent_finished",
+            status: agentResult.status === "success" ? "succeeded" : "failed",
+            detail: { exitCode: agentResult.exitCode, changedFiles: agentResult.changedFiles, error: agentResult.error }
+        });
+    }
+    catch (error) {
+        agentResult = {
+            status: "failed",
+            exitCode: null,
+            stdout: "",
+            stderr: "",
+            changedFiles: [],
+            diff: "",
+            error: error instanceof Error ? error.message : String(error)
+        };
+        await audit.event({ stage: "execute", event: "agent_error", status: "failed", detail: agentResult.error });
+    }
+    await writeFile(paths.gitDiff, agentResult.diff, "utf8");
+    sayLive(live, `agent finished: status=${agentResult.status} changedFiles=${agentResult.changedFiles.length}`);
+    sayLive(live, "running verification commands");
+    await audit.event({ stage: "verify", event: "verify_started", status: "started" });
+    const verifyResult = await runVerify(cwd, config, skill, paths.verify);
+    await audit.event({ stage: "verify", event: "verify_finished", status: verifyResult.status === "passed" ? "succeeded" : "failed", detail: verifyResult });
+    sayLive(live, `verification ${verifyResult.status}: ${paths.verify}`);
+    await writeSummary({
+        task,
+        skillName,
+        agentName,
+        agentResult,
+        verifyResult,
+        gitDiffPath: paths.gitDiff,
+        summaryPath: paths.summary,
+        persistPath: paths.persistSuggestions
+    });
+    await audit.event({ stage: "summarize", event: "summary_written", status: "succeeded" });
+    await audit.event({ stage: "persist", event: "suggestions_written", status: "succeeded" });
+    sayLive(live, `summary written: ${paths.summary}`);
+    sayLive(live, `persist suggestions written: ${paths.persistSuggestions}`);
+    const runPassed = verifyResult.status === "passed" && agentResult.status === "success";
+    await audit.event({ stage: "run", event: "run_finished", status: runPassed ? "succeeded" : "failed" });
+    console.log(`Run complete: ${paths.runId}`);
+    console.log(`Evidence: ${paths.runDir}`);
+    if (!runPassed)
+        throw new Error(`Harness run failed. Evidence: ${paths.runDir}`);
+}
+async function commandInstallIntegration(cwd, args) {
+    const rawAgent = String(args.agent ?? "both");
+    if (rawAgent !== "claude" && rawAgent !== "codex" && rawAgent !== "both") {
+        throw new Error(`Invalid --agent ${rawAgent}. Expected claude, codex, or both.`);
+    }
+    const targetDir = typeof args.target === "string" ? path.resolve(cwd, args.target) : cwd;
+    const packageRoot = path.resolve(path.dirname(process.argv[1]), "..");
+    const harnessCommand = typeof args.command === "string" ? args.command : `node ${quoteCommandPath(path.resolve(process.argv[1]))}`;
+    const result = await installIntegration({ targetDir, harnessCommand, agent: rawAgent, packageRoot });
+    console.log(`Installed AI Dev Harness conversation integration in ${targetDir}`);
+    console.log(`Created: ${result.created.length ? result.created.join(", ") : "(none)"}`);
+    console.log(`Updated: ${result.updated.length ? result.updated.join(", ") : "(none)"}`);
+    console.log(`Skipped: ${result.skipped.length ? result.skipped.join(", ") : "(none)"}`);
+}
+async function commandVerify(cwd, args) {
+    const runDir = await resolveRunDir(cwd, requireString(args, "run"));
+    const intake = JSON.parse(await readFile(path.join(runDir, "intake.json"), "utf8"));
+    const config = await loadConfig(cwd);
+    const skill = await loadSkill(cwd, intake.skill);
+    const result = await runVerify(cwd, config, skill, path.join(runDir, "verify.json"));
+    const audit = new AuditLogger(path.join(runDir, "audit.jsonl"));
+    await audit.event({ stage: "verify", event: "verify_rerun", status: result.status === "passed" ? "succeeded" : "failed", detail: result });
+    console.log(`Verify ${result.status}: ${runDir}`);
+}
+async function commandSummarize(cwd, args) {
+    const runDir = await resolveRunDir(cwd, requireString(args, "run"));
+    const intake = JSON.parse(await readFile(path.join(runDir, "intake.json"), "utf8"));
+    const verifyPath = path.join(runDir, "verify.json");
+    const verifyResult = (await pathExists(verifyPath))
+        ? JSON.parse(await readFile(verifyPath, "utf8"))
+        : undefined;
+    const changedFilesRaw = await git(cwd, "diff --name-only");
+    const agentResult = {
+        status: "success",
+        exitCode: 0,
+        stdout: "",
+        stderr: "",
+        changedFiles: changedFilesRaw ? changedFilesRaw.split(/\r?\n/).filter(Boolean) : [],
+        diff: await git(cwd, "diff --no-ext-diff")
+    };
+    await writeFile(path.join(runDir, "git_diff.patch"), agentResult.diff, "utf8");
+    await writeSummary({
+        task: intake.task,
+        skillName: intake.skill,
+        agentName: intake.agent,
+        agentResult,
+        verifyResult,
+        gitDiffPath: path.join(runDir, "git_diff.patch"),
+        summaryPath: path.join(runDir, "summary.md"),
+        persistPath: path.join(runDir, "persist_suggestions.md")
+    });
+    const audit = new AuditLogger(path.join(runDir, "audit.jsonl"));
+    await audit.event({ stage: "summarize", event: "summary_rerun", status: "succeeded" });
+    console.log(`Summary refreshed: ${runDir}`);
+}
+async function main() {
+    const cwd = process.cwd();
+    const { command, args } = parseArgs(process.argv.slice(2));
+    if (command === "help" || command === "--help" || command === "-h") {
+        console.log(usage());
+        return;
+    }
+    if (command === "init")
+        return commandInit(cwd);
+    if (command === "run")
+        return commandRun(cwd, args);
+    if (command === "verify")
+        return commandVerify(cwd, args);
+    if (command === "summarize")
+        return commandSummarize(cwd, args);
+    if (command === "install-integration")
+        return commandInstallIntegration(cwd, args);
+    throw new Error(`Unknown command: ${command}\n${usage()}`);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/config.js

@@ -0,0 +1,156 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { pathExists, readTextIfExists } from "./utils.js";
+export const defaultConfig = {
+    agents: {
+        codex: { command: "codex exec --full-auto -" },
+        claude: { command: "claude -p -" }
+    },
+    mcp: {
+        codegraph: { url: "http://localhost:7331/mcp" },
+        knowledgeGraph: { url: "http://localhost:7332/mcp" },
+        timeoutMs: 15000
+    },
+    verify: {
+        defaultCommands: [{ name: "git status", command: "git status --short" }]
+    },
+    audit: { path: "runs" },
+    context: {
+        fallbackInclude: ["AGENTS.md", "TOOLS.md", "SKILLS.md", "README.md", "package.json", "src"],
+        exclude: ["node_modules", ".git", "dist", "build", ".next", "coverage", "runs"]
+    }
+};
+export function renderYaml(value, indent = 0) {
+    const pad = " ".repeat(indent);
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => {
+            if (typeof item === "object" && item !== null) {
+                const entries = Object.entries(item);
+                if (!entries.length)
+                    return `${pad}- {}`;
+                const [firstKey, firstValue] = entries[0];
+                const first = typeof firstValue === "object" && firstValue !== null
+                    ? `${pad}- ${firstKey}:\n${renderYaml(firstValue, indent + 4)}`
+                    : `${pad}- ${firstKey}: ${String(firstValue)}`;
+                const rest = entries
+                    .slice(1)
+                    .map(([key, child]) => {
+                    if (typeof child === "object" && child !== null)
+                        return `${pad}  ${key}:\n${renderYaml(child, indent + 4)}`;
+                    return `${pad}  ${key}: ${String(child)}`;
+                })
+                    .join("\n");
+                return rest ? `${first}\n${rest}` : first;
+            }
+            return `${pad}- ${String(item)}`;
+        })
+            .join("\n");
+    }
+    if (typeof value === "object" && value !== null) {
+        return Object.entries(value)
+            .map(([key, item]) => {
+            if (typeof item === "object" && item !== null)
+                return `${pad}${key}:\n${renderYaml(item, indent + 2)}`;
+            return `${pad}${key}: ${String(item)}`;
+        })
+            .join("\n");
+    }
+    return `${pad}${String(value)}`;
+}
+export function defaultConfigYaml() {
+    return `${renderYaml(defaultConfig)}\n`;
+}
+function readScalar(raw) {
+    const value = raw.trim().replace(/^["']|["']$/g, "");
+    if (/^\d+$/.test(value))
+        return Number(value);
+    return value;
+}
+function parseVerifyCommands(text) {
+    const commands = [];
+    const itemRegex = /-\s*name:\s*([^\n]+)\n\s+command:\s*([^\n]+)/g;
+    for (const match of text.matchAll(itemRegex)) {
+        commands.push({ name: String(readScalar(match[1])), command: String(readScalar(match[2])) });
+    }
+    const simpleRegex = /-\s+([^\n:]+)$/gm;
+    if (commands.length === 0) {
+        for (const match of text.matchAll(simpleRegex))
+            commands.push({ name: match[1].trim(), command: match[1].trim() });
+    }
+    return commands;
+}
+function parseStringList(text) {
+    return [...text.matchAll(/-\s+(.+)$/gm)].map((m) => String(readScalar(m[1])));
+}
+function topSection(text, key) {
+    const match = text.match(new RegExp(`^${key}:\\n([\\s\\S]*?)(?=^[a-zA-Z][\\w]*:|$)`, "m"));
+    return match?.[1] ?? "";
+}
+function scalar(text, regex, fallback) {
+    const match = text.match(regex);
+    return match ? readScalar(match[1]) : fallback;
+}
+function blockList(text, key) {
+    const match = text.match(new RegExp(`^\\s*${key}:\\n([\\s\\S]*?)(?=^\\s*[a-zA-Z][\\w]*:|^\\S|$)`, "m"));
+    return match ? parseStringList(match[1]) : [];
+}
+export async function loadConfig(cwd) {
+    const configPath = path.join(cwd, "harness.yaml");
+    if (!(await pathExists(configPath)))
+        return defaultConfig;
+    const text = await readFile(configPath, "utf8");
+    const verifyRoot = topSection(text, "verify");
+    const verifySection = verifyRoot.match(/defaultCommands:\n([\s\S]*?)(?=^\S|^  [a-zA-Z][\w]*:|$)/m)?.[1] ?? "";
+    const contextSection = topSection(text, "context");
+    return {
+        agents: {
+            codex: {
+                command: String(scalar(text, /agents:\n[\s\S]*?codex:\n\s+command:\s*([^\n]+)/m, defaultConfig.agents.codex.command))
+            },
+            claude: {
+                command: String(scalar(text, /agents:\n[\s\S]*?claude:\n\s+command:\s*([^\n]+)/m, defaultConfig.agents.claude.command))
+            }
+        },
+        mcp: {
+            codegraph: {
+                url: String(scalar(text, /mcp:\n[\s\S]*?codegraph:\n\s+url:\s*([^\n]+)/m, defaultConfig.mcp.codegraph.url))
+            },
+            knowledgeGraph: {
+                url: String(scalar(text, /mcp:\n[\s\S]*?knowledgeGraph:\n\s+url:\s*([^\n]+)/m, defaultConfig.mcp.knowledgeGraph.url))
+            },
+            timeoutMs: Number(scalar(text, /mcp:\n[\s\S]*?timeoutMs:\s*([^\n]+)/m, defaultConfig.mcp.timeoutMs))
+        },
+        verify: {
+            defaultCommands: parseVerifyCommands(verifySection).length
+                ? parseVerifyCommands(verifySection)
+                : defaultConfig.verify.defaultCommands
+        },
+        audit: { path: String(scalar(text, /audit:\n\s+path:\s*([^\n]+)/m, defaultConfig.audit.path)) },
+        context: {
+            fallbackInclude: blockList(contextSection, "fallbackInclude").length
+                ? blockList(contextSection, "fallbackInclude")
+                : defaultConfig.context.fallbackInclude,
+            exclude: blockList(contextSection, "exclude").length
+                ? blockList(contextSection, "exclude")
+                : defaultConfig.context.exclude
+        }
+    };
+}
+export async function loadSkill(cwd, name) {
+    const dir = path.join(cwd, "skills", name);
+    if (!(await pathExists(path.join(dir, "SKILL.md")))) {
+        throw new Error(`Skill not found: ${name}. Expected ${path.join(dir, "SKILL.md")}`);
+    }
+    const markdown = await readTextIfExists(path.join(dir, "SKILL.md"));
+    const verifyText = await readTextIfExists(path.join(dir, "verify.yaml"));
+    const contextText = await readTextIfExists(path.join(dir, "context.yaml"));
+    return {
+        name,
+        dir,
+        markdown,
+        verifyCommands: parseVerifyCommands(verifyText),
+        contextQueries: blockList(contextText, "queries"),
+        fallbackInclude: blockList(contextText, "fallbackInclude")
+    };
+}