@dombaras/agent-harness 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 @dombaras/agent-harness contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -24,51 +24,86 @@ npx @dombaras/agent-harness init --target /path/to/project --name "MyApp" --doma
 
 # non-interactive
 npx @dombaras/agent-harness init --target . --yes
+
+# preview what would change, without writing anything
+npx @dombaras/agent-harness init --target . --dry-run
 ```
 
 `init` writes:
 
 | Path | Content | Ownership |
 |---|---|---|
-| `AGENTS.md` | root dispatcher | harness (overwrite) |
-| `.opencode/agents/*.md` | 13 persona subagent defs (with `model:` pins) | harness (overwrite) |
-| `.agents/AGENTS.md` | full operating rulebook | harness (overwrite) |
-| `.agents/rules/00-operating.md` | always-loaded rules summary | harness (overwrite) |
+| `AGENTS.md` | root dispatcher (points to the rulebook) | harness (overwrite) |
+| `.opencode/agents/*.md` | 13 persona subagent defs (with `model:` pins + `permission`/`steps`/`temperature`/`hidden`) | harness (overwrite) |
+| `.agents/AGENTS.md` | full canonical operating rulebook | harness (overwrite) |
+| `.agents/rules/00-operating.md` | always-loaded rules summary (wired into `opencode.json` `instructions`) | harness (overwrite) |
 | `.agents/skills/*/SKILL.md` | persona instruction skills | harness (overwrite) |
-| `opencode.json` | main/small model routing | harness (overwrite) |
-| `scripts/qa/*` | `test:dispatch` / `test:governance` gates | harness (overwrite) |
-| `.agents/memory/*` | project data (domain-map, stack-versions, handoff, locations, model-routing) | **project** (create-if-missing) |
-| `.harness.json` | deployed version + project profile | harness |
+| `opencode.json` | main/small model routing + `instructions` | harness (**merged**, see below) |
+| `scripts/qa/*` | `test:dispatch` / `test:governance` gates + QA-script wiring check | harness (overwrite) |
+| `.agents/memory/*` | project data (domain-map, stack-versions, handoff, locations, model-routing, history) | **project** (create-if-missing) |
+| `.harness.json` | deployed version + project profile + per-file checksums | harness |
+
+### `opencode.json` is merged, not clobbered
+
+The harness owns only `$schema`, `model`, `small_model`, and its own
+`instructions` entry (`.agents/rules/00-operating.md`). Every other key your
+project adds — `permission`, `mcp`, `plugin`, custom `instructions`, etc. — is
+preserved across `init`/`update`.
 
 ## Placeholders
 
 Templates use `{{PROJECT_NAME}}` and `{{PROJECT_DOMAIN}}`; `init` substitutes
 them from `--name` / `--domain` (or prompts, or `.harness.json`). Domain facts
-that are genuinely project-specific (entity model, catalog sources, visibility
+that are genuinely project-specific (entity model, external sources, visibility
 tiers, trust tiers) live in `.agents/memory/domain-map.md`, which `init`
-scaffolds for you to fill in — the skills reference it instead of hardcoding
-domain assumptions.
+scaffolds for you to fill in — the skills and rules reference memory instead of
+hardcoding domain assumptions.
 
-## Model routing
+## Model routing & enforcement
 
 - Concrete models are set in `.opencode/agents/<name>.md` (`model:` field) and
   `opencode.json` (`model` + `small_model`).
+- Personas also carry mechanical guardrails in frontmatter:
+  - thinkers (`planner`, `product-manager`) → `permission: { edit: deny, bash: deny }`
+  - `qa-architect`, `handoff` → `permission: { bash: deny }`
+  - deterministic personas → `temperature: 0.1`
+  - all personas → a `steps:` cap (cost ceiling)
+  - `planner`, `handoff` → `hidden: true`
 - `.agents/skills/*/SKILL.md` carries a `model:` label only (informational).
 - `npx @dombaras/agent-harness list` prints the persona → model mapping.
 - `npm run test:dispatch` mechanically verifies model pins against
   `scripts/qa/models.allowlist.txt`.
 
+## QA gates
+
+- `npm run test:dispatch` — persona model-pin preflight + persona↔skill parity.
+- `npm run test:governance` — session wrap-up dispatch-log enforcement.
+- `node scripts/qa/check-qa-scripts.js` — warns (or `--strict` fails) when the
+  DoD-referenced runtime QA tiers aren't wired into `package.json`.
+
+The harness ships only these gates. The runtime QA tiers (`test:quick`,
+`test:routes`, `test:api`, `test:verify`, `test:security`) and their backing
+scripts are **project-provided** — the rulebook references them, and
+`check-qa-scripts.js` reminds you if they're missing.
+
 ## Update
 
 ```bash
 npx @dombaras/agent-harness update --target /path/to/project
 ```
 
-Overwrites harness-owned files, preserves `.agents/memory/*`.
+- Overwrites harness-owned files, preserves `.agents/memory/*`.
+- **Non-destructive**: if a harness-owned file was modified locally since the
+  last deploy (tracked by checksum in `.harness.json`), it is backed up to
+  `.harness-backup/<timestamp>/` before overwrite.
+- `opencode.json` is merged (project keys preserved).
+- `--dry-run` previews the plan without writing.
 
 ## Develop
 
 ```bash
+npm test          # node --test
+npm run lint      # syntax-check the CLI + QA scripts
 node bin/agent-harness.js list
 node bin/agent-harness.js init --target /tmp/demo --name Demo --yes
 ```

package/bin/agent-harness.js

@@ -1,31 +1,43 @@
 #!/usr/bin/env node
 "use strict";
 /*
- * agent-harness — deploy the LibraryOS agent harness (personas, skills, rules,
- * model routing, QA gates) into a target project.
+ * agent-harness — deploy the agent harness (personas, skills, rules, model
+ * routing, QA gates) into a target project.
  *
  * Commands:
- *   init   [--target <dir>] [--name <project>] [--domain <desc>] [--yes]
- *   update [--target <dir>]
- *   list                                   (list personas + models)
+ *   init   [--target <dir>] [--name <project>] [--domain <desc>] [--yes] [--dry-run]
+ *   update [--target <dir>] [--dry-run]
+ *   list
+ *   --version | -v
+ *   --help | -h
  *
- * `init` materializes templates/ into the target and substitutes {{
- * PROJECT_NAME }} / {{ PROJECT_DOMAIN }}. `.agents/memory/*` files are only
- * created when absent (project data). Harness-owned files are overwritten.
+ * `init`/`update` materialize templates/ into the target and substitute {{
+ * PROJECT_NAME }} / {{ PROJECT_DOMAIN }}.
+ *
+ * Ownership model:
+ *   - `.agents/memory/*` is project data -> create-if-missing (never overwrite).
+ *   - `opencode.json` is MERGED: harness manages $schema/model/small_model/
+ *     instructions; every other key the project adds is preserved.
+ *   - all other harness-owned files are overwritten. If a harness-owned file was
+ *     modified locally since the last deploy (tracked by checksum in
+ *     `.harness.json`), it is backed up to `.harness-backup/<timestamp>/` first.
  */
 
 const fs = require("fs");
 const path = require("path");
+const crypto = require("crypto");
 const readline = require("readline");
 
 const PKG = require("../package.json");
 const TEMPLATES_DIR = path.resolve(__dirname, "..", "templates");
 const CONFIG_FILE = ".harness.json";
+const BACKUP_DIR = ".harness-backup";
+
+// ---------------------------------------------------------------- helpers
 
-// Files the harness owns and overwrites on every run.
-// `.agents/memory/*` is project data -> create-if-missing only.
 function listFiles(dir, base = dir) {
   const out = [];
+  if (!fs.existsSync(dir)) return out;
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
     const abs = path.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...listFiles(abs, base));
@@ -37,82 +49,167 @@ function listFiles(dir, base = dir) {
 function substitute(text, vars) {
   let out = text;
   for (const [key, value] of Object.entries(vars)) {
-    out = out.split("{{" + key + "}}").join(value);
+    out = out.split("{{" + key + "}}").join(value == null ? "" : String(value));
   }
   return out;
 }
 
+function relKey(rel) {
+  return rel.split(path.sep).join("/");
+}
+
 function isMemoryFile(rel) {
-  return rel.split(path.sep).includes(".agents") &&
-    rel.split(path.sep).includes("memory");
+  const parts = rel.split(path.sep);
+  return parts.includes(".agents") && parts.includes("memory");
+}
+
+function isOpencodeJson(rel) {
+  return relKey(rel) === "opencode.json";
 }
 
-function writeFileIfAbsent(targetAbs, content) {
-  if (fs.existsSync(targetAbs)) return "skip";
-  fs.mkdirSync(path.dirname(targetAbs), { recursive: true });
-  fs.writeFileSync(targetAbs, content, "utf8");
-  return "create";
+function sha256(str) {
+  return crypto.createHash("sha256").update(str, "utf8").digest("hex");
+}
+
+function safeJson(text, fallback) {
+  if (text == null) return fallback;
+  try {
+    return JSON.parse(text);
+  } catch (_) {
+    return fallback;
+  }
 }
 
 function readConfig(target) {
   const p = path.join(target, CONFIG_FILE);
-  if (fs.existsSync(p)) {
-    try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch (_) { return {}; }
-  }
+  if (fs.existsSync(p)) return safeJson(fs.readFileSync(p, "utf8"), {});
   return {};
 }
 
-function ask(question, fallback) {
-  if (process.argv.includes("--yes")) return Promise.resolve(fallback || "");
+function ask(question, fallback, yes) {
+  if (yes) return Promise.resolve(fallback || "");
   if (!process.stdin.isTTY) return Promise.resolve(fallback || "");
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
-    rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
   });
 }
 
 function resolveVars(target, args) {
   const existing = readConfig(target);
-  const nameFlag = args["--name"];
-  const domainFlag = args["--domain"];
-  const projectName = nameFlag || existing.projectName || path.basename(target);
-  return { projectName, domainFlag, existing, VARIABLES: { PROJECT_NAME: projectName, PROJECT_DOMAIN: domainFlag || existing.projectDomain || "" } };
+  const projectName = args["--name"] || existing.projectName || path.basename(target);
+  const projectDomain = args["--domain"] || existing.projectDomain || "";
+  return {
+    projectName,
+    projectDomain,
+    existing,
+    VARIABLES: { PROJECT_NAME: projectName, PROJECT_DOMAIN: projectDomain },
+  };
 }
 
-function printPersonas(templatesDir) {
-  const agents = path.join(templatesDir, ".opencode", "agents");
-  console.log("Personas (model routing):\n");
-  for (const f of fs.readdirSync(agents).sort()) {
-    const src = fs.readFileSync(path.join(agents, f), "utf8");
-    const model = (src.match(/^model:\s*(.+)$/m) || [])[1] || "?";
-    console.log(`  ${f.replace(/\.md$/, "").padEnd(22)} -> ${model}`);
-  }
+// ---------------------------------------------------------------- opencode.json
+
+function templateOpencodeJson() {
+  const p = path.join(TEMPLATES_DIR, "opencode.json");
+  return safeJson(fs.readFileSync(p, "utf8"), {});
 }
 
-async function init(target, args) {
-  if (!fs.existsSync(TEMPLATES_DIR)) {
-    console.error("templates/ directory not found next to this CLI.");
-    process.exit(1);
+// Merge harness-managed keys into the project's existing opencode.json,
+// preserving every other key the project has added.
+function mergeOpencodeJson(target, variables) {
+  const harness = safeJson(
+    substitute(fs.readFileSync(path.join(TEMPLATES_DIR, "opencode.json"), "utf8"), variables),
+    {}
+  );
+  const p = path.join(target, "opencode.json");
+  const existing = fs.existsSync(p) ? safeJson(fs.readFileSync(p, "utf8"), {}) : {};
+
+  const merged = { ...existing, ...harness };
+  if (Array.isArray(harness.instructions)) {
+    const prior = Array.isArray(existing.instructions) ? existing.instructions : [];
+    merged.instructions = [...new Set([...prior, ...harness.instructions])];
   }
-  const { projectName, domainFlag, VARIABLES } = resolveVars(target, args);
+  return JSON.stringify(merged, null, 2) + "\n";
+}
+
+// ---------------------------------------------------------------- deploy
 
-  let projectDomain = VARIABLES.PROJECT_DOMAIN;
-  if (!domainFlag && !readConfig(target).projectDomain) {
+function backup(target, rel, content) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const dest = path.join(target, BACKUP_DIR, stamp, relKey(rel));
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, content, "utf8");
+}
+
+async function deploy(target, opts) {
+  const { name, domain, yes, dryRun, isUpdate } = opts || {};
+  const existing = readConfig(target);
+  const projectName = name || existing.projectName || path.basename(target);
+  let projectDomain = domain || existing.projectDomain || "";
+  if (!projectDomain && !isUpdate && !yes && process.stdin.isTTY) {
     projectDomain = await ask(`Project domain (one line) for "${projectName}": `, "");
   }
-  VARIABLES.PROJECT_DOMAIN = projectDomain;
+  const VARIABLES = { PROJECT_NAME: projectName, PROJECT_DOMAIN: projectDomain };
+
+  const previousFiles = existing.files || {};
+  const actions = [];
+  const manifest = {};
 
-  const stats = { overwritten: 0, created: 0, skipped: 0 };
   for (const { abs, rel } of listFiles(TEMPLATES_DIR)) {
-    const content = substitute(fs.readFileSync(abs, "utf8"), VARIABLES);
+    const key = relKey(rel);
     const targetAbs = path.join(target, rel);
+
+    if (isOpencodeJson(rel)) {
+      const merged = mergeOpencodeJson(target, VARIABLES);
+      const current = fs.existsSync(targetAbs) ? fs.readFileSync(targetAbs, "utf8") : null;
+      if (current == null) actions.push({ rel: key, kind: "create" });
+      else if (current !== merged) actions.push({ rel: key, kind: "merge" });
+      else actions.push({ rel: key, kind: "unchanged" });
+      manifest[key] = sha256(merged);
+      if (!dryRun) {
+        fs.mkdirSync(path.dirname(targetAbs), { recursive: true });
+        fs.writeFileSync(targetAbs, merged, "utf8");
+      }
+      continue;
+    }
+
     if (isMemoryFile(rel)) {
-      const r = writeFileIfAbsent(targetAbs, content);
-      if (r === "create") stats.created++; else stats.skipped++;
+      if (fs.existsSync(targetAbs)) {
+        actions.push({ rel: key, kind: "preserve" });
+      } else {
+        actions.push({ rel: key, kind: "create" });
+        if (!dryRun) {
+          fs.mkdirSync(path.dirname(targetAbs), { recursive: true });
+          fs.writeFileSync(targetAbs, substitute(fs.readFileSync(abs, "utf8"), VARIABLES), "utf8");
+        }
+      }
+      continue; // project data: never tracked in the manifest
+    }
+
+    // harness-owned file
+    const content = substitute(fs.readFileSync(abs, "utf8"), VARIABLES);
+    if (fs.existsSync(targetAbs)) {
+      const current = fs.readFileSync(targetAbs, "utf8");
+      if (current !== content) {
+        const deployedHash = previousFiles[key];
+        const locallyModified = !!deployedHash && deployedHash !== sha256(current);
+        actions.push({ rel: key, kind: locallyModified ? "overwrite (backup)" : "overwrite" });
+        if (locallyModified && !dryRun) backup(target, rel, current);
+      } else {
+        actions.push({ rel: key, kind: "unchanged" });
+        manifest[key] = previousFiles[key] || sha256(content);
+        continue;
+      }
     } else {
+      actions.push({ rel: key, kind: "create" });
+    }
+    manifest[key] = sha256(content);
+    if (!dryRun) {
       fs.mkdirSync(path.dirname(targetAbs), { recursive: true });
       fs.writeFileSync(targetAbs, content, "utf8");
-      stats.overwritten++;
     }
   }
 
@@ -120,12 +217,39 @@ async function init(target, args) {
     version: PKG.version,
     projectName,
     projectDomain,
-    initializedAt: new Date().toISOString(),
+    initializedAt: existing.initializedAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    files: manifest,
   };
-  fs.writeFileSync(path.join(target, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n", "utf8");
+  if (!dryRun) {
+    fs.writeFileSync(path.join(target, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n", "utf8");
+  }
 
-  console.log(`\nagent-harness v${PKG.version} initialized "${projectName}" in ${target}`);
-  console.log(`  ${stats.overwritten} harness files written, ${stats.created} memory files created, ${stats.skipped} existing memory files preserved.\n`);
+  return { projectName, projectDomain, actions, dryRun: !!dryRun };
+}
+
+function summarize(actions) {
+  const counts = {};
+  for (const a of actions) counts[a.kind] = (counts[a.kind] || 0) + 1;
+  return counts;
+}
+
+function printSummary(result, isUpdate) {
+  const { projectName, actions, dryRun } = result;
+  const verb = isUpdate
+    ? (dryRun ? "Would update" : "Updated")
+    : (dryRun ? "Would initialize" : "Initialized");
+  console.log(`\nagent-harness v${PKG.version} ${verb.toLowerCase()} "${projectName}"` + (dryRun ? " (dry run)" : ""));
+  for (const a of actions) console.log(`  [${a.kind}] ${a.rel}`);
+  const counts = summarize(actions);
+  console.log(
+    `\n  ${counts.create || 0} created, ${counts.overwrite || 0} overwritten, ` +
+      `${counts["overwrite (backup)"] || 0} backed up (locally modified), ` +
+      `${counts.merge || 0} merged, ${counts.preserve || 0} preserved, ${counts.unchanged || 0} unchanged.`
+  );
+}
+
+function printNextSteps() {
   console.log("  Next steps:");
   console.log("   1. Fill in `.agents/memory/domain-map.md` and `.agents/memory/stack-versions.md`.");
   console.log("   2. Add QA gate scripts to package.json:");
@@ -134,36 +258,116 @@ async function init(target, args) {
   console.log("   3. Restart your agent CLI (config is read once at startup).\n");
 }
 
-function update(target) {
-  const { projectName, VARIABLES } = resolveVars(target, {});
-  console.log(`Updating harness in ${target} (project "${projectName}")...`);
-  return init(target, { "--name": projectName, "--domain": VARIABLES.PROJECT_DOMAIN });
+function printUsage() {
+  console.log(
+    `agent-harness v${PKG.version}\n\n` +
+      `Usage:\n` +
+      `  agent-harness init   [--target <dir>] [--name <project>] [--domain <desc>] [--yes] [--dry-run]\n` +
+      `  agent-harness update [--target <dir>] [--dry-run]\n` +
+      `  agent-harness list\n` +
+      `  agent-harness --version | -v\n` +
+      `  agent-harness --help | -h\n`
+  );
 }
 
-function main() {
-  const args = process.argv.slice(2);
-  const cmd = args[0] || "help";
+function printPersonas(templatesDir) {
+  const agents = path.join(templatesDir, ".opencode", "agents");
+  console.log("Personas (model routing):\n");
+  for (const f of fs.readdirSync(agents).sort()) {
+    const src = fs.readFileSync(path.join(agents, f), "utf8");
+    const model = (src.match(/^model:\s*(.+)$/m) || [])[1] || "?";
+    console.log(`  ${f.replace(/\.md$/, "").padEnd(22)} -> ${model}`);
+  }
+}
+
+// ---------------------------------------------------------------- commands
+
+async function init(target, flags) {
+  if (!fs.existsSync(TEMPLATES_DIR)) {
+    console.error("templates/ directory not found next to this CLI.");
+    process.exit(1);
+  }
+  const result = await deploy(target, {
+    name: flags["--name"],
+    domain: flags["--domain"],
+    yes: !!flags["--yes"],
+    dryRun: !!flags["--dry-run"],
+    isUpdate: false,
+  });
+  printSummary(result, false);
+  if (!result.dryRun) printNextSteps();
+}
+
+async function update(target, flags) {
+  if (!fs.existsSync(TEMPLATES_DIR)) {
+    console.error("templates/ directory not found next to this CLI.");
+    process.exit(1);
+  }
+  const result = await deploy(target, {
+    yes: true,
+    dryRun: !!flags["--dry-run"],
+    isUpdate: true,
+  });
+  printSummary(result, true);
+}
+
+function parseArgs(argv) {
   const flags = {};
-  for (let i = 1; i < args.length; i++) {
-    if (args[i] === "--target" || args[i] === "--name" || args[i] === "--domain") {
-      flags[args[i]] = args[i + 1]; i++;
-    }
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--target" || a === "--name" || a === "--domain") flags[a] = argv[++i];
+    else if (a === "--dry-run" || a === "--yes" || a === "-y") flags[a] = true;
   }
+  return flags;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+  if (cmd === "--version" || cmd === "-v") return console.log(PKG.version);
+  if (cmd === "--help" || cmd === "-h" || !cmd || cmd === "help") return printUsage();
+
+  const flags = parseArgs(args.slice(1));
   const target = path.resolve(flags["--target"] || process.cwd());
 
   switch (cmd) {
     case "init":
-      init(target, flags).catch((e) => { console.error(e); process.exit(1); });
+      init(target, flags).catch((e) => {
+        console.error(e);
+        process.exit(1);
+      });
       break;
     case "update":
-      update(target).catch((e) => { console.error(e); process.exit(1); });
+      update(target, flags).catch((e) => {
+        console.error(e);
+        process.exit(1);
+      });
       break;
     case "list":
       printPersonas(TEMPLATES_DIR);
       break;
     default:
-      console.log(`agent-harness v${PKG.version}\n\nUsage:\n  agent-harness init   [--target <dir>] [--name <project>] [--domain <desc>] [--yes]\n  agent-harness update [--target <dir>]\n  agent-harness list`);
+      console.error(`Unknown command: ${cmd}\n`);
+      printUsage();
+      process.exitCode = 1;
   }
 }
 
-main();
+if (require.main === module) main();
+
+module.exports = {
+  listFiles,
+  substitute,
+  isMemoryFile,
+  isOpencodeJson,
+  sha256,
+  readConfig,
+  resolveVars,
+  mergeOpencodeJson,
+  deploy,
+  printPersonas,
+  TEMPLATES_DIR,
+  CONFIG_FILE,
+  BACKUP_DIR,
+  PKG,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dombaras/agent-harness",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Reusable multi-agent harness for AI-assisted development: personas, skills, operating rules, model routing, and QA gates. Deploy into any project with `npx @dombaras/agent-harness init`.",
   "bin": {
     "agent-harness": "bin/agent-harness.js"
@@ -11,8 +11,13 @@
   "files": [
     "bin/",
     "templates/",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
+  "scripts": {
+    "test": "node --test",
+    "lint": "node --check bin/agent-harness.js && node --check templates/scripts/qa/check-dispatch-config.js && node --check templates/scripts/qa/governance.js && node --check templates/scripts/qa/check-qa-scripts.js"
+  },
   "keywords": [
     "opencode",
     "agents",