@mikenguyen69/harness 0.1.0-beta.1

package/dist/paths.js

@@ -0,0 +1,50 @@
+/**
+ * Resolve absolute paths to the three internal product CLIs.
+ * Prefer staged dist/internal/<product>/cli.js; else workspace packages.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+export const packageRoot = join(moduleDir, "..");
+function findPackageRoot(packageName, startDir) {
+    let dir = startDir;
+    while (true) {
+        const candidate = join(dir, "node_modules", packageName);
+        if (existsSync(join(candidate, "package.json")))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`package not found: ${packageName}`);
+}
+function resolveWorkspaceCli(packageName) {
+    const pkgRoot = findPackageRoot(packageName, packageRoot);
+    const cli = join(pkgRoot, "dist", "cli.js");
+    if (!existsSync(cli))
+        throw new Error(`CLI not built for ${packageName}: ${cli}`);
+    return cli;
+}
+function stagedClis() {
+    const system = join(packageRoot, "dist", "internal", "system", "cli.js");
+    const agent = join(packageRoot, "dist", "internal", "agent", "cli.js");
+    const orchestration = join(packageRoot, "dist", "internal", "orchestration", "cli.js");
+    if (existsSync(system) && existsSync(agent) && existsSync(orchestration)) {
+        return { system, agent, orchestration };
+    }
+    return null;
+}
+export function resolveInternalClis() {
+    return (stagedClis() ?? {
+        system: resolveWorkspaceCli("@harness/system"),
+        agent: resolveWorkspaceCli("@harness/agent"),
+        orchestration: resolveWorkspaceCli("@harness/orchestration"),
+    });
+}
+export function readPackageVersion(packageName) {
+    const pkg = JSON.parse(readFileSync(join(findPackageRoot(packageName, packageRoot), "package.json"), "utf8"));
+    return pkg.version;
+}
+//# sourceMappingURL=paths.js.map

package/dist/routes.js

@@ -0,0 +1,93 @@
+/** Facade tail after the leading `harness` token — longest match wins. */
+const ROUTES = [
+    { id: "agent:hook:pre-tool-use", product: "agent", argvPrefix: ["hook", "pre-tool-use"] },
+    { id: "agent:session:started", product: "agent", argvPrefix: ["session", "started"] },
+    { id: "agent:session:heartbeat", product: "agent", argvPrefix: ["session", "heartbeat"] },
+    { id: "agent:session:gate_fired", product: "agent", argvPrefix: ["session", "gate_fired"] },
+    { id: "agent:session:escalated", product: "agent", argvPrefix: ["session", "escalated"] },
+    { id: "agent:session:ended", product: "agent", argvPrefix: ["session", "ended"] },
+    { id: "system:gate:pre", product: "system", argvPrefix: ["gate", "--pre"] },
+    { id: "system:spec:check", product: "system", argvPrefix: ["spec", "check"] },
+    { id: "system:spec:materialize", product: "system", argvPrefix: ["spec", "materialize"] },
+    { id: "system:door:list", product: "system", argvPrefix: ["door", "list"] },
+    { id: "system:door:show", product: "system", argvPrefix: ["door", "show"] },
+    { id: "system:door:approve", product: "system", argvPrefix: ["door", "approve"] },
+    { id: "system:door:reject", product: "system", argvPrefix: ["door", "reject"] },
+    { id: "system:ledger:append", product: "system", argvPrefix: ["ledger", "append"] },
+    { id: "system:ledger:read", product: "system", argvPrefix: ["ledger", "read"] },
+    { id: "system:ledger:verify-chain", product: "system", argvPrefix: ["ledger", "verify-chain"] },
+    { id: "system:board:build", product: "system", argvPrefix: ["board", "build"] },
+    { id: "system:board:serve", product: "system", argvPrefix: ["board", "serve"] },
+    { id: "orchestration:doctor", product: "orchestration", argvPrefix: ["doctor"], injectOrchestrationBins: true },
+    { id: "orchestration:run", product: "orchestration", argvPrefix: ["run"], injectOrchestrationBins: true },
+    { id: "orchestration:resume", product: "orchestration", argvPrefix: ["resume"], injectOrchestrationBins: true },
+    { id: "agent:escalate", product: "agent", argvPrefix: ["escalate"] },
+    { id: "agent:route", product: "agent", argvPrefix: ["route"] },
+    { id: "system:init", product: "system", argvPrefix: ["init"] },
+    { id: "system:verify", product: "system", argvPrefix: ["verify"] },
+    { id: "system:next", product: "system", argvPrefix: ["next"] },
+    { id: "system:claim", product: "system", argvPrefix: ["claim"] },
+    { id: "system:heartbeat", product: "system", argvPrefix: ["heartbeat"] },
+    { id: "system:merge", product: "system", argvPrefix: ["merge"] },
+    { id: "system:attest", product: "system", argvPrefix: ["attest"] },
+    { id: "system:calibrate", product: "system", argvPrefix: ["calibrate"] },
+    { id: "system:digest", product: "system", argvPrefix: ["digest"] },
+].sort((a, b) => b.argvPrefix.length - a.argvPrefix.length);
+/** Report subcommand disambiguation from command-map report_resolution. */
+const REPORT_SUBCOMMANDS = new Map([
+    [
+        "run",
+        {
+            id: "orchestration:report",
+            product: "orchestration",
+            argvPrefix: ["report"],
+            injectOrchestrationBins: true,
+        },
+    ],
+    [
+        "calibration",
+        {
+            id: "system:report",
+            product: "system",
+            argvPrefix: ["report"],
+        },
+    ],
+]);
+function matchesPrefix(argv, prefix) {
+    if (argv.length < prefix.length)
+        return false;
+    for (let i = 0; i < prefix.length; i++) {
+        if (argv[i] !== prefix[i])
+            return false;
+    }
+    return true;
+}
+export function resolveRoute(argv) {
+    if (argv.length === 0)
+        return null;
+    if (argv[0] === "report") {
+        const sub = argv[1];
+        if (sub && REPORT_SUBCOMMANDS.has(sub)) {
+            return REPORT_SUBCOMMANDS.get(sub);
+        }
+        return null;
+    }
+    if (argv[0] === "status") {
+        return "status-skeleton";
+    }
+    for (const route of ROUTES) {
+        if (matchesPrefix(argv, route.argvPrefix)) {
+            return route;
+        }
+    }
+    return null;
+}
+export function buildInternalArgv(route, argv) {
+    if (argv[0] === "report" && (argv[1] === "run" || argv[1] === "calibration")) {
+        return [...route.argvPrefix, ...argv.slice(2)];
+    }
+    const rest = argv.slice(route.argvPrefix.length);
+    return [...route.argvPrefix, ...rest];
+}
+export { ROUTES, REPORT_SUBCOMMANDS };
+//# sourceMappingURL=routes.js.map

package/dist/version.js

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { packageRoot, readPackageVersion } from "./paths.js";
+const facadePkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+/** Prefer staged build-identity.json (no node_modules); else workspace packages. */
+function internalVersions() {
+    const staged = join(packageRoot, "dist", "build-identity.json");
+    if (existsSync(staged)) {
+        return JSON.parse(readFileSync(staged, "utf8"));
+    }
+    return {
+        system: readPackageVersion("@harness/system"),
+        agent: readPackageVersion("@harness/agent"),
+        orchestration: readPackageVersion("@harness/orchestration"),
+    };
+}
+export function formatVersion() {
+    const v = internalVersions();
+    return [
+        `${facadePkg.name} ${facadePkg.version}`,
+        `@harness/system ${v.system}`,
+        `@harness/agent ${v.agent}`,
+        `@harness/orchestration ${v.orchestration}`,
+    ].join("\n") + "\n";
+}
+export function facadeVersion() {
+    return facadePkg.version;
+}
+export { facadePkg };
+//# sourceMappingURL=version.js.map

package/dist/win32-process-group.js

@@ -0,0 +1,360 @@
+/**
+ * Windows process-group spawn + CTRL_BREAK.
+ *
+ * Node's `spawn({ detached: true })` sets DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP,
+ * which hides a new console so GenerateConsoleCtrlEvent from the parent cannot
+ * reach the child. Node has no flag for CREATE_NEW_PROCESS_GROUP alone, so this
+ * module compiles a tiny helper (csc.exe, cached) that:
+ *   - CreateProcessW with CREATE_NEW_PROCESS_GROUP (shared console)
+ *   - assigns the child to a Win32 job with KILL_ON_JOB_CLOSE
+ *   - GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, groupPid) on interrupt
+ *
+ * `process.kill(pid, "SIGBREAK")` is ENOSYS on Node 24 / Windows.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+export const WIN32_CTRL_BREAK_EVENT = 1;
+/** Sidecar the `run` helper polls; written by {@link sendCtrlBreak}. */
+export function win32BreakSignalPath(pid) {
+    return join(tmpdir(), `harness-win32-break-${pid}`);
+}
+const HELPER_SOURCE = `
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+internal static class HarnessWin32Group {
+  const uint CREATE_NEW_PROCESS_GROUP = 0x00000200;
+  const uint CTRL_C_EVENT = 0;
+  const uint CTRL_BREAK_EVENT = 1;
+  const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x2000;
+  const int JobObjectExtendedLimitInformation = 9;
+  const uint WAIT_OBJECT_0 = 0;
+  const uint INFINITE = 0xFFFFFFFF;
+
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  struct STARTUPINFO {
+    public int cb;
+    public IntPtr lpReserved;
+    public IntPtr lpDesktop;
+    public IntPtr lpTitle;
+    public int dwX, dwY, dwXSize, dwYSize, dwXCountChars, dwYCountChars, dwFillAttribute, dwFlags;
+    public short wShowWindow;
+    public short cbReserved2;
+    public IntPtr lpReserved2;
+    public IntPtr hStdInput, hStdOutput, hStdError;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct PROCESS_INFORMATION {
+    public IntPtr hProcess;
+    public IntPtr hThread;
+    public uint dwProcessId;
+    public uint dwThreadId;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct JOBOBJECT_BASIC_LIMIT_INFORMATION {
+    public long PerProcessUserTimeLimit;
+    public long PerJobUserTimeLimit;
+    public uint LimitFlags;
+    public UIntPtr MinimumWorkingSetSize;
+    public UIntPtr MaximumWorkingSetSize;
+    public uint ActiveProcessLimit;
+    public UIntPtr Affinity;
+    public uint PriorityClass;
+    public uint SchedulingClass;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct IO_COUNTERS {
+    public ulong ReadOperationCount, WriteOperationCount, OtherOperationCount;
+    public ulong ReadTransferCount, WriteTransferCount, OtherTransferCount;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
+    public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
+    public IO_COUNTERS IoInfo;
+    public UIntPtr ProcessMemoryLimit, JobMemoryLimit, PeakProcessMemoryUsed, PeakJobMemoryUsed;
+  }
+
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern bool CreateProcessW(
+    string lpApplicationName,
+    StringBuilder lpCommandLine,
+    IntPtr lpProcessAttributes,
+    IntPtr lpThreadAttributes,
+    bool bInheritHandles,
+    uint dwCreationFlags,
+    IntPtr lpEnvironment,
+    string lpCurrentDirectory,
+    ref STARTUPINFO lpStartupInfo,
+    out PROCESS_INFORMATION lpProcessInformation);
+
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);
+
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern IntPtr CreateJobObject(IntPtr lpJobAttributes, string lpName);
+
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern bool AssignProcessToJobObject(IntPtr hJob, IntPtr hProcess);
+
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern bool SetInformationJobObject(IntPtr hJob, int JobObjectInfoClass, IntPtr lpJobObjectInfo, uint cbJobObjectInfoLength);
+
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern uint WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds);
+
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern bool GetExitCodeProcess(IntPtr hProcess, out uint lpExitCode);
+
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern bool CloseHandle(IntPtr hObject);
+
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern bool SetConsoleCtrlHandler(ConsoleCtrlDelegate HandlerRoutine, bool Add);
+
+  delegate bool ConsoleCtrlDelegate(uint dwCtrlType);
+
+  static uint childGroupPid;
+  static ConsoleCtrlDelegate ctrlHandler;
+
+  static int Main(string[] args) {
+    if (args == null || args.Length < 1) {
+      Console.Error.WriteLine("usage: harness-win32-group break <pid> | run --pidfile <p> --cwd <d> -- <cmd> [args]");
+      return 2;
+    }
+    if (args[0] == "break") {
+      if (args.Length < 2) return 2;
+      uint pid;
+      if (!uint.TryParse(args[1], out pid) || pid == 0) return 2;
+      return GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, pid) ? 0 : 1;
+    }
+    if (args[0] == "run") return Run(args);
+    return 2;
+  }
+
+  static bool OnCtrl(uint type) {
+    if (childGroupPid != 0) {
+      GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, childGroupPid);
+    }
+    return true;
+  }
+
+  static int Run(string[] args) {
+    string pidfile = null;
+    string cwd = null;
+    int dash = -1;
+    for (int i = 1; i < args.Length; i++) {
+      if (args[i] == "--") { dash = i; break; }
+      if (args[i] == "--pidfile" && i + 1 < args.Length) { pidfile = args[++i]; continue; }
+      if (args[i] == "--cwd" && i + 1 < args.Length) { cwd = args[++i]; continue; }
+    }
+    if (dash < 0 || dash + 1 >= args.Length || string.IsNullOrEmpty(pidfile)) {
+      Console.Error.WriteLine("run: missing --pidfile or command");
+      return 2;
+    }
+
+    StringBuilder cmd = new StringBuilder();
+    for (int i = dash + 1; i < args.Length; i++) {
+      AppendQuoted(cmd, args[i]);
+    }
+
+    ctrlHandler = new ConsoleCtrlDelegate(OnCtrl);
+    SetConsoleCtrlHandler(ctrlHandler, true);
+
+    IntPtr job = CreateJobObject(IntPtr.Zero, null);
+    if (job != IntPtr.Zero) {
+      EnableKillOnClose(job);
+    }
+
+    STARTUPINFO si = new STARTUPINFO();
+    si.cb = Marshal.SizeOf(typeof(STARTUPINFO));
+    PROCESS_INFORMATION pi;
+    bool ok = CreateProcessW(
+      null,
+      cmd,
+      IntPtr.Zero,
+      IntPtr.Zero,
+      true,
+      CREATE_NEW_PROCESS_GROUP,
+      IntPtr.Zero,
+      string.IsNullOrEmpty(cwd) ? null : cwd,
+      ref si,
+      out pi);
+    if (!ok) {
+      Console.Error.WriteLine("CreateProcessW failed: " + Marshal.GetLastWin32Error());
+      return 1;
+    }
+
+    childGroupPid = pi.dwProcessId;
+    try {
+      File.WriteAllText(pidfile, pi.dwProcessId.ToString());
+    } catch (Exception ex) {
+      Console.Error.WriteLine("pidfile: " + ex.Message);
+    }
+
+    if (job != IntPtr.Zero) {
+      AssignProcessToJobObject(job, pi.hProcess);
+    }
+
+    string breakPath = Path.Combine(Path.GetTempPath(), "harness-win32-break-" + pi.dwProcessId.ToString());
+    while (true) {
+      uint wr = WaitForSingleObject(pi.hProcess, 50);
+      if (wr == WAIT_OBJECT_0) break;
+      if (File.Exists(breakPath)) {
+        try { File.Delete(breakPath); } catch { }
+        GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, pi.dwProcessId);
+      }
+    }
+
+    uint code = 1;
+    GetExitCodeProcess(pi.hProcess, out code);
+    CloseHandle(pi.hThread);
+    CloseHandle(pi.hProcess);
+    if (job != IntPtr.Zero) CloseHandle(job);
+    return (int)code;
+  }
+
+  static void EnableKillOnClose(IntPtr job) {
+    JOBOBJECT_EXTENDED_LIMIT_INFORMATION info = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
+    info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+    int size = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
+    IntPtr ptr = Marshal.AllocHGlobal(size);
+    try {
+      Marshal.StructureToPtr(info, ptr, false);
+      SetInformationJobObject(job, JobObjectExtendedLimitInformation, ptr, (uint)size);
+    } finally {
+      Marshal.FreeHGlobal(ptr);
+    }
+  }
+
+  static void AppendQuoted(StringBuilder sb, string arg) {
+    if (sb.Length > 0) sb.Append(' ');
+    if (arg == null) arg = "";
+    bool quote = arg.Length == 0;
+    for (int i = 0; i < arg.Length; i++) {
+      char c = arg[i];
+      if (c == ' ' || c == '\\t' || c == '"') { quote = true; break; }
+    }
+    if (!quote) { sb.Append(arg); return; }
+    sb.Append('"');
+    int bs = 0;
+    for (int i = 0; i < arg.Length; i++) {
+      char c = arg[i];
+      if (c == '\\\\') { bs++; continue; }
+      if (c == '"') {
+        for (int j = 0; j < bs; j++) sb.Append('\\\\');
+        sb.Append('\\\\');
+        sb.Append('"');
+        bs = 0;
+        continue;
+      }
+      for (int j = 0; j < bs; j++) sb.Append('\\\\');
+      sb.Append(c);
+      bs = 0;
+    }
+    for (int j = 0; j < bs * 2; j++) sb.Append('\\\\');
+    sb.Append('"');
+  }
+}
+`;
+function helperHash() {
+    return createHash("sha256").update(HELPER_SOURCE).digest("hex").slice(0, 12);
+}
+function findCsc() {
+    const windir = process.env.WINDIR ?? "C:\\Windows";
+    const candidates = [
+        join(windir, "Microsoft.NET", "Framework64", "v4.0.30319", "csc.exe"),
+        join(windir, "Microsoft.NET", "Framework", "v4.0.30319", "csc.exe"),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    const where = spawnSync("where.exe", ["csc.exe"], { encoding: "utf8", windowsHide: true });
+    const first = where.stdout?.split(/\r?\n/).map((s) => s.trim()).find((s) => s.length > 0);
+    if (first && existsSync(first))
+        return first;
+    throw new Error("csc.exe not found; cannot compile the Windows process-group helper");
+}
+let cachedHelper;
+export function ensureWin32GroupHelper() {
+    if (cachedHelper && existsSync(cachedHelper))
+        return cachedHelper;
+    const dir = join(tmpdir(), "harness-win32-group");
+    mkdirSync(dir, { recursive: true });
+    const id = helperHash();
+    const exe = join(dir, `harness-win32-group-${id}.exe`);
+    if (existsSync(exe)) {
+        cachedHelper = exe;
+        return exe;
+    }
+    const cs = join(dir, `harness-win32-group-${id}.cs`);
+    writeFileSync(cs, HELPER_SOURCE, "utf8");
+    const csc = findCsc();
+    const compiled = spawnSync(csc, ["/nologo", "/optimize+", `/out:${exe}`, "/target:exe", cs], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (!existsSync(exe)) {
+        throw new Error(`failed to compile Windows process-group helper with ${csc}: ${compiled.stderr || compiled.stdout || compiled.status}`);
+    }
+    cachedHelper = exe;
+    return exe;
+}
+/**
+ * Deliver CTRL_BREAK to a CREATE_NEW_PROCESS_GROUP leader that shares this
+ * console. Never TerminateProcess / taskkill.
+ */
+export function sendCtrlBreak(processGroupId) {
+    writeFileSync(win32BreakSignalPath(processGroupId), "break");
+    const helper = ensureWin32GroupHelper();
+    spawn(helper, ["break", String(processGroupId)], {
+        detached: false,
+        windowsHide: false,
+        stdio: "ignore",
+    }).on("error", () => undefined);
+}
+function waitForPidFile(path, helper, ms = 8_000) {
+    const start = Date.now();
+    const slot = new Int32Array(new SharedArrayBuffer(4));
+    while (Date.now() - start < ms) {
+        if (existsSync(path)) {
+            const n = Number(readFileSync(path, "utf8").trim());
+            if (Number.isInteger(n) && n > 0)
+                return n;
+        }
+        if (helper.exitCode !== null) {
+            throw new Error(`Windows process-group helper exited before pidfile (code ${helper.exitCode})`);
+        }
+        Atomics.wait(slot, 0, 0, 20);
+    }
+    throw new Error(`timed out waiting for Windows process-group pidfile at ${path}`);
+}
+export function spawnWindowsProcessGroup(command, args, options = {}) {
+    const helper = ensureWin32GroupHelper();
+    const id = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const pidFile = join(tmpdir(), `harness-win32-pid-${id}`);
+    const cwd = typeof options.cwd === "string" ? options.cwd : process.cwd();
+    const child = spawn(helper, ["run", "--pidfile", pidFile, "--cwd", cwd, "--", command, ...args], {
+        ...options,
+        detached: false,
+        windowsHide: false,
+    });
+    try {
+        child.groupPid = waitForPidFile(pidFile, child);
+    }
+    catch (err) {
+        child.kill();
+        throw err;
+    }
+    return child;
+}
+//# sourceMappingURL=win32-process-group.js.map

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@mikenguyen69/harness",
+  "version": "0.1.0-beta.1",
+  "description": "One installed `harness` command over the portfolio — routing facade, not a fourth control loop.",
+  "type": "module",
+  "engines": {
+    "node": "24.x"
+  },
+  "files": [
+    "dist",
+    "schema",
+    "profiles",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mikenguyen69/ai-harness.git",
+    "directory": null
+  },
+  "bugs": {
+    "url": "https://github.com/mikenguyen69/ai-harness/issues"
+  },
+  "homepage": "https://github.com/mikenguyen69/ai-harness#readme",
+  "publishConfig": {
+    "tag": "next"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.251",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "picomatch": "^4.0.7",
+    "smol-toml": "^1.8.0",
+    "yaml": "^2.6.0"
+  },
+  "bin": {
+    "harness": "dist/cli.js"
+  }
+}

package/profiles/python/bindings.toml

@@ -0,0 +1,59 @@
+# Python profile — the 10-name vocabulary (ADR 0004) bound to a Python stack
+# (ruff / mypy / pytest). Third stack instance; still zero src changes.
+
+[harness]
+profile_version = "0.0.1"
+
+[gates.spec]
+run = "harness gate spec"
+severity = "blocking"
+cost = "cheap"
+
+[gates.fmt]
+run = "ruff format --check ."
+severity = "blocking"
+cost = "cheap"
+
+[gates.lint]
+run = "ruff check ."
+severity = "changed-lines"
+cost = "cheap"
+
+[gates.types]
+run = "mypy --strict ."
+severity = "blocking"
+cost = "cheap"
+
+[gates.test]
+run = "pytest -q"
+severity = "blocking"
+cost = "cheap"
+
+[gates."sec:deps"]
+run = "pip-audit --strict"
+severity = "changed-lines"
+cost = "cheap"
+snapshot_max_age_days = 7
+
+[gates."sec:secrets"]
+run = "gitleaks detect --no-banner"
+severity = "blocking"
+cost = "cheap"
+
+[gates.arch]
+run = "lint-imports"               # import-linter contracts
+severity = "advisory"
+cost = "cheap"
+
+[gates.contract]
+declined = "no service boundary in the reference python profile; bind per repo (openapi-diff / schemathesis)"
+
+[gates.size]
+run = "harness gate size"
+severity = "blocking"
+cost = "cheap"
+
+[gates."gen:fresh"]
+run = "harness gate gen-fresh"
+severity = "blocking"
+cost = "cheap"