@adamchanadam/agent-handoff-kit 0.1.0

package/bin/agent-handoff-kit.mjs

@@ -0,0 +1,675 @@
+#!/usr/bin/env node
+
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { copyFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(__dirname, "..");
+
+const mappings = [
+  ["runtime-core/AGENTS.core.md", "AGENTS.md"],
+  ["runtime-core/CLAUDE.md", "CLAUDE.md"],
+  ["runtime-core/GEMINI.md", "GEMINI.md"],
+  ["runtime-core/SESSION_HANDOFF.md", "dev/SESSION_HANDOFF.md"],
+  ["runtime-core/SESSION_LOG.md", "dev/SESSION_LOG.md"],
+  ["runtime-core/PROJECT_INDEX.md", "dev/PROJECT_INDEX.md"],
+  ["runtime-core/DOC_SYNC_REGISTRY.md", "dev/DOC_SYNC_REGISTRY.md"],
+  ["runtime-core/RULE_PACKS.md", "dev/RULE_PACKS.md"],
+  ["packs/safety.md", "dev/rules/safety.md"],
+  ["packs/coding.md", "dev/rules/coding.md"],
+  ["packs/writing.md", "dev/rules/writing.md"],
+  ["packs/research.md", "dev/rules/research.md"],
+  ["packs/agent-governance.md", "dev/rules/agent-governance.md"],
+  ["packs/release.md", "dev/rules/release.md"],
+  ["packs/knowledge.md", "dev/rules/knowledge.md"],
+  ["packs/communication.md", "dev/rules/communication.md"]
+];
+
+const requiredTargets = mappings.map(([, target]) => target);
+const managedCoreStart = "<!-- BEGIN Agent Handoff Kit managed core -->";
+const managedCoreEnd = "<!-- END Agent Handoff Kit managed core -->";
+
+const requiredAnchors = [
+  {
+    target: "AGENTS.md",
+    label: "startup read order",
+    snippets: [
+      "## 1. Startup Reads",
+      "dev/SESSION_HANDOFF.md",
+      "dev/SESSION_LOG.md",
+      "dev/PROJECT_INDEX.md",
+      "dev/RULE_PACKS.md",
+      "Agent Handoff Kit v<version>",
+      "continuity ready",
+      "Reachable is not the same as ingested",
+      "Do not treat unread sources as absent"
+    ]
+  },
+  {
+    target: "AGENTS.md",
+    label: "closeout intent and full handoff",
+    snippets: [
+      "Detect end-of-session or handoff intent",
+      "收工",
+      "wrap up",
+      "handoff",
+      "Reconcile `dev/SESSION_HANDOFF.md`",
+      "Add a concise entry to `dev/SESSION_LOG.md`",
+      "next-session opening message",
+      "fenced `text` code block",
+      "handoff saved",
+      "📋 Next session: copy and paste the whole block below",
+      "State Reconciliation Check",
+      "Do not append a new state snapshot"
+    ]
+  },
+  {
+    target: "dev/SESSION_HANDOFF.md",
+    label: "handoff workspace and opening message schema",
+    snippets: [
+      "ack:section:current-baseline",
+      "ack:section:durable-anchors",
+      "ack:section:closeout-reconciled-state",
+      "ack:section:task-understanding-summary",
+      "ack:section:active-objective",
+      "ack:section:next-priorities",
+      "ack:section:risks-blockers",
+      "ack:section:validation-qc",
+      "ack:section:workspace-identity",
+      "ack:section:sync-status",
+      "ack:section:next-task-required-reading",
+      "ack:section:state-reconciliation-check",
+      "ack:section:next-session-opening-message",
+      "📋 Next session: copy and paste the whole block below",
+      "```text",
+      "Read in order:",
+      "dev/DOC_SYNC_REGISTRY.md"
+    ]
+  },
+  {
+    target: "dev/SESSION_LOG.md",
+    label: "session log event and opening message schema",
+    snippets: [
+      "Record what actually happened in the session",
+      "## Entry Template",
+      "- **QC:**",
+      "- **Sync:**",
+      "- **Log maintenance:**",
+      "### Next Session Opening Message",
+      "📋 Next session: copy and paste the whole block below",
+      "```text",
+      "Read in order:",
+      "dev/DOC_SYNC_REGISTRY.md"
+    ]
+  },
+  {
+    target: "dev/SESSION_HANDOFF.md",
+    label: "handoff log archive continuity",
+    snippets: [
+      "ack:section:handoff-sufficiency-check",
+      "ack:section:state-reconciliation-check",
+      "ack:field:stale-snapshots-left",
+      "ack:field:opening-message-matches-current-state",
+      "without searching old log history",
+      "SESSION_LOG.md` carries recent evidence",
+      "do not create an archive directory by default"
+    ]
+  },
+  {
+    target: "dev/SESSION_LOG.md",
+    label: "log retention and evidence schema",
+    snippets: [
+      "kept, summarized, or archived",
+      "Do not remove validation evidence",
+      "latest opening message",
+      "not current state"
+    ]
+  },
+  {
+    target: "dev/PROJECT_INDEX.md",
+    label: "template version metadata",
+    snippets: [
+      "Agent Handoff Kit template version",
+      "0.1.0"
+    ]
+  },
+  {
+    target: "dev/rules/safety.md",
+    label: "safety pack high-risk anchors",
+    snippets: [
+      "deleting, overwriting, moving, renaming",
+      "filesystem root, drive root",
+      "cmd /c rmdir",
+      "git reset --hard",
+      "external APIs, SDKs, CLIs",
+      "secret values"
+    ]
+  }
+];
+
+const schemaChecks = [
+  {
+    target: "dev/SESSION_HANDOFF.md",
+    label: "handoff required sections",
+    checks: [
+      section("current-baseline", "Current Baseline"),
+      section("durable-anchors", "Durable Anchors"),
+      section("closeout-reconciled-state", "Closeout-Reconciled State"),
+      section("task-understanding-summary", "Task Understanding Summary"),
+      section("active-objective", "Active Objective"),
+      section("next-priorities", "Next Priorities"),
+      section("next-task-required-reading", "Next Task Required Reading"),
+      section("risks-blockers", "Risks / Blockers"),
+      section("validation-qc", "Validation / QC"),
+      section("workspace-identity", "Workspace Identity"),
+      section("sync-status", "Sync Status"),
+      section("state-reconciliation-check", "State Reconciliation Check"),
+      section("handoff-sufficiency-check", "Handoff Sufficiency Check"),
+      section("next-session-opening-message", "Next Session Opening Message"),
+      marker("field", "stale-snapshots-left", "Stale snapshots left in this handoff"),
+      marker("field", "opening-message-matches-current-state", "Opening message matches current state"),
+      marker("field", "state-sections-rewritten-or-confirmed", "State sections rewritten or confirmed current"),
+      marker("field", "user-intent", "User intent:"),
+      marker("field", "task-essence", "Task essence:"),
+      marker("field", "success-criteria", "Success criteria:")
+    ]
+  },
+  {
+    target: "dev/SESSION_HANDOFF.md",
+    label: "handoff opening message structure",
+    checks: [
+      includes("📋 Next session: copy and paste the whole block below"),
+      includes("```text"),
+      includes("Work in "),
+      includes("Read in order:"),
+      includes("If this root does not match the expected project root")
+    ]
+  },
+  {
+    target: "dev/SESSION_LOG.md",
+    label: "session log entry fields",
+    checks: [
+      heading("Entry Template"),
+      includes("- **ID:**"),
+      includes("- **Summary:**"),
+      includes("- **Changed:**"),
+      includes("- **Done:**"),
+      includes("- **QC:**"),
+      includes("- **Sync:**"),
+      includes("- **Pending:**"),
+      includes("- **Risks:**"),
+      includes("- **Log maintenance:**")
+    ]
+  },
+  {
+    target: "dev/PROJECT_INDEX.md",
+    label: "project index tables",
+    checks: [
+      heading("Stack"),
+      heading("Directory Map"),
+      heading("Entry Points"),
+      heading("Fact Base"),
+      heading("External Sources"),
+      heading("Local QC Commands"),
+      heading("Workspace Identity"),
+      heading("Change Hotspots"),
+      heading("Maintenance Rule"),
+      tableHeader("Path", "Role", "Read when"),
+      tableHeader("Source", "Role", "Required before", "Access method", "Last verified"),
+      tableHeader("Source", "Role", "Required before", "Access method", "Write-back rule", "Last verified"),
+      tableHeader("Check", "Command", "Run before", "Last verified"),
+      tableHeader("Change type", "Likely files", "Required checks")
+    ]
+  },
+  {
+    target: "dev/DOC_SYNC_REGISTRY.md",
+    label: "doc sync registry status vocabulary",
+    checks: [
+      heading("Status Vocabulary"),
+      includes("confirmed"),
+      includes("unverified"),
+      includes("pending"),
+      includes("blocked"),
+      includes("not_applicable"),
+      tableHeader("Change type", "Also check/update", "Verification")
+    ]
+  },
+  {
+    target: "dev/RULE_PACKS.md",
+    label: "rule pack router coverage",
+    checks: [
+      heading("Routing Rule"),
+      includes("Load the minimum set"),
+      includes("cannot weaken core safety"),
+      includes("dev/rules/safety.md"),
+      includes("dev/rules/coding.md"),
+      includes("dev/rules/research.md"),
+      includes("dev/rules/release.md")
+    ]
+  }
+];
+
+main().catch((error) => {
+  console.error(`agent-handoff-kit: ${error.message}`);
+  process.exitCode = 1;
+});
+
+async function main() {
+  const version = await readPackageVersion();
+  const { command, options } = parseArgs(process.argv.slice(2));
+  if (!command || options.help) {
+    printHelp(version);
+    return;
+  }
+
+  const root = path.resolve(options.root ?? process.cwd());
+
+  if (command === "init" || command === "upgrade") {
+    await runInstall(command, root, options, version);
+    return;
+  }
+
+  if (command === "doctor") {
+    await runDoctor(root, version);
+    return;
+  }
+
+  throw new Error(`unknown command "${command}"`);
+}
+
+function parseArgs(args) {
+  const options = {};
+  let command;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (!command && !arg.startsWith("-")) {
+      command = arg;
+      continue;
+    }
+    if (arg === "--dry-run") options.dryRun = true;
+    else if (arg === "--yes" || arg === "-y") options.yes = true;
+    else if (arg === "--help" || arg === "-h") options.help = true;
+    else if (arg === "--root") options.root = args[++i];
+    else throw new Error(`unknown option "${arg}"`);
+  }
+
+  return { command, options };
+}
+
+async function runInstall(command, root, options, version) {
+  const mode = await detectMode(root);
+  const plan = await buildPlan(root, command);
+  printPlan(command, root, mode, plan, version);
+
+  if (options.dryRun) {
+    console.log("\ndry-run: no files written");
+    if (plan.some((item) => item.action === "conflict")) process.exitCode = 1;
+    return;
+  }
+
+  if (!options.yes) {
+    const ok = await confirmWrite();
+    if (!ok) {
+      console.log("cancelled: no files written");
+      return;
+    }
+  }
+
+  const created = [];
+  const merged = [];
+  const conflicts = plan.filter((item) => item.action === "conflict");
+  const stamp = migrationStamp();
+  const migrationDir = path.join(root, "dev/governance_migrations", stamp);
+  const backupDir = path.join(migrationDir, "backup");
+
+  for (const item of plan) {
+    if (item.action !== "create") continue;
+    await mkdir(path.dirname(item.targetAbs), { recursive: true });
+    await copyFile(item.sourceAbs, item.targetAbs);
+    created.push(item.targetRel);
+  }
+
+  for (const item of plan) {
+    if (item.action !== "merge") continue;
+    const backupPath = path.join(backupDir, item.targetRel);
+    await mkdir(path.dirname(backupPath), { recursive: true });
+    await copyFile(item.targetAbs, backupPath);
+    await writeFile(item.targetAbs, item.mergedText, "utf8");
+    merged.push(item.targetRel);
+  }
+
+  const report = await writeMigrationReport(root, command, mode, plan, created, merged, conflicts, migrationDir, backupDir);
+  console.log(`\ncreated: ${created.length}`);
+  console.log(`merged: ${merged.length}`);
+  console.log(`skipped existing: ${plan.filter((item) => item.action === "skip").length}`);
+  console.log(`conflict: ${conflicts.length}`);
+  if (merged.length > 0) console.log(`backup: ${path.relative(root, backupDir)}`);
+  console.log(`migration report: ${path.relative(root, report)}`);
+  console.log("next: Follow AGENTS.md");
+  console.log("tip: Describe your task directly; the AI will choose the working mode and relevant rule packs.");
+  if (conflicts.length > 0) process.exitCode = 1;
+}
+
+async function runDoctor(root, version) {
+  printCard(version, "doctor ready", "o.o");
+  const rows = [];
+  for (const target of requiredTargets) {
+    rows.push({ target, ok: await exists(path.join(root, target)) });
+  }
+
+  const missing = rows.filter((row) => !row.ok);
+  console.log(`root: ${root}`);
+  console.log(`required files: ${rows.length}`);
+  for (const row of rows) {
+    console.log(`${row.ok ? "ok" : "missing"}  ${row.target}`);
+  }
+
+  if (missing.length > 0) {
+    console.log(`\nstatus: failed (${missing.length} missing)`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const anchorRows = await checkRequiredAnchors(root);
+  const anchorFailures = anchorRows.filter((row) => !row.ok);
+  console.log(`\nrequired anchors: ${anchorRows.length}`);
+  for (const row of anchorRows) {
+    console.log(`${row.ok ? "ok" : "missing"}  ${row.target} (${row.label})`);
+  }
+
+  if (anchorFailures.length > 0) {
+    console.log(`\nstatus: failed (${anchorFailures.length} anchor checks failed)`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const schemaRows = await checkSchema(root);
+  const schemaFailures = schemaRows.filter((row) => !row.ok);
+  console.log(`\nschema checks: ${schemaRows.length}`);
+  for (const row of schemaRows) {
+    console.log(`${row.ok ? "ok" : "missing"}  ${row.target} (${row.label})`);
+    if (!row.ok && row.missing.length > 0) {
+      console.log(`  missing: ${row.missing.join("; ")}`);
+    }
+  }
+
+  if (schemaFailures.length > 0) {
+    console.log(`\nstatus: failed (${schemaFailures.length} schema checks failed)`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log("\nstatus: passed");
+}
+
+async function checkRequiredAnchors(root) {
+  const rows = [];
+  for (const rule of requiredAnchors) {
+    const filePath = path.join(root, rule.target);
+    let text = "";
+    try {
+      text = await readFile(filePath, "utf8");
+    } catch {
+      rows.push({ target: rule.target, label: rule.label, ok: false });
+      continue;
+    }
+
+    rows.push({
+      target: rule.target,
+      label: rule.label,
+      ok: rule.snippets.every((snippet) => text.includes(snippet))
+    });
+  }
+  return rows;
+}
+
+async function checkSchema(root) {
+  const rows = [];
+  for (const rule of schemaChecks) {
+    const filePath = path.join(root, rule.target);
+    let text = "";
+    try {
+      text = await readFile(filePath, "utf8");
+    } catch {
+      rows.push({ target: rule.target, label: rule.label, ok: false, missing: ["file unreadable"] });
+      continue;
+    }
+    const missing = rule.checks
+      .filter((check) => !check.test(text))
+      .map((check) => check.label);
+    rows.push({
+      target: rule.target,
+      label: rule.label,
+      ok: missing.length === 0,
+      missing
+    });
+  }
+  return rows;
+}
+
+function includes(snippet) {
+  return {
+    label: snippet,
+    test: (text) => text.includes(snippet)
+  };
+}
+
+function heading(title) {
+  return {
+    label: `heading: ${title}`,
+    test: (text) => new RegExp(`^## ${escapeRegExp(title)}\\s*$`, "m").test(text)
+  };
+}
+
+function marker(type, id, legacyText) {
+  const semanticMarker = `ack:${type}:${id}`;
+  return {
+    label: `${type}: ${id}`,
+    test: (text) => text.includes(semanticMarker) || (legacyText ? text.includes(legacyText) : false)
+  };
+}
+
+function section(id, legacyHeading) {
+  const check = marker("section", id, null);
+  return {
+    label: `section: ${id}`,
+    test: (text) => check.test(text) || heading(legacyHeading).test(text)
+  };
+}
+
+function tableHeader(...cells) {
+  const line = `| ${cells.join(" | ")} |`;
+  return {
+    label: `table: ${cells.join(" / ")}`,
+    test: (text) => text.includes(line)
+  };
+}
+
+async function buildPlan(root, command) {
+  const plan = [];
+  for (const [sourceRel, targetRel] of mappings) {
+    const sourceAbs = path.join(packageRoot, sourceRel);
+    const targetAbs = path.join(root, targetRel);
+    const sourceText = await readFile(sourceAbs, "utf8");
+    if (await exists(targetAbs)) {
+      const targetText = await readFile(targetAbs, "utf8");
+      plan.push(classifyExistingFile(command, sourceRel, targetRel, sourceAbs, targetAbs, sourceText, targetText));
+      continue;
+    }
+    plan.push({
+      sourceRel,
+      targetRel,
+      sourceAbs,
+      targetAbs,
+      action: "create"
+    });
+  }
+  return plan;
+}
+
+function classifyExistingFile(command, sourceRel, targetRel, sourceAbs, targetAbs, sourceText, targetText) {
+  const base = { sourceRel, targetRel, sourceAbs, targetAbs };
+  if (targetText === sourceText) return { ...base, action: "skip", reason: "already current" };
+  if (command !== "upgrade") return { ...base, action: "skip", reason: "init preserves existing files" };
+  if (targetRel === "AGENTS.md") {
+    if (hasRequiredAnchor(targetRel, targetText)) return { ...base, action: "skip", reason: "required anchors already present" };
+    return {
+      ...base,
+      action: "merge",
+      reason: "append managed core while preserving existing AGENTS.md content",
+      mergedText: mergeManagedBlock(targetText, sourceText)
+    };
+  }
+  if ((targetRel === "CLAUDE.md" || targetRel === "GEMINI.md") && !targetText.includes("AGENTS.md")) {
+    return { ...base, action: "conflict", reason: "existing bridge does not route to AGENTS.md" };
+  }
+  return { ...base, action: "skip", reason: "preserve existing file" };
+}
+
+function mergeManagedBlock(targetText, sourceText) {
+  const block = `${managedCoreStart}\n${sourceText.trim()}\n${managedCoreEnd}`;
+  const existingBlock = new RegExp(`${escapeRegExp(managedCoreStart)}[\\s\\S]*?${escapeRegExp(managedCoreEnd)}`);
+  if (existingBlock.test(targetText)) return `${targetText.replace(existingBlock, block).trimEnd()}\n`;
+  return `${targetText.trimEnd()}\n\n${block}\n`;
+}
+
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function hasRequiredAnchor(targetRel, text) {
+  return requiredAnchors
+    .filter((rule) => rule.target === targetRel)
+    .every((rule) => rule.snippets.every((snippet) => text.includes(snippet)));
+}
+
+async function detectMode(root) {
+  const hasAgents = await exists(path.join(root, "AGENTS.md"));
+  const hasProjectIndex = await exists(path.join(root, "dev/PROJECT_INDEX.md"));
+  const hasDocSync = await exists(path.join(root, "dev/DOC_SYNC_REGISTRY.md"));
+  if (!hasAgents && !hasProjectIndex && !hasDocSync) return "first-install";
+  if (hasAgents && hasProjectIndex && hasDocSync) return "upgrade-existing";
+  if (hasAgents) {
+    const text = await readFile(path.join(root, "AGENTS.md"), "utf8");
+    if (text.includes("SESSION_HANDOFF") || text.includes("SESSION_LOG")) return "migrate-monolith";
+  }
+  return "partial";
+}
+
+function printPlan(command, root, mode, plan, version) {
+  printCard(version, "continuity ready", "o.o");
+  console.log(`command: ${command}`);
+  console.log(`current directory: ${process.cwd()}`);
+  console.log(`selected root: ${root}`);
+  console.log(`mode: ${mode}`);
+  console.log("");
+  for (const action of ["create", "merge", "skip", "conflict"]) {
+    const items = plan.filter((item) => item.action === action);
+    console.log(`${action}: ${items.length}`);
+    for (const item of items) console.log(`  ${item.targetRel}${item.reason ? ` - ${item.reason}` : ""}`);
+  }
+  console.log(`\nbackup: ${plan.filter((item) => item.action === "merge").length}`);
+}
+
+async function confirmWrite() {
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question("Write missing Agent Handoff Kit files? Type yes to continue: ");
+    return answer.trim().toLowerCase() === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+async function writeMigrationReport(root, command, mode, plan, created, merged, conflicts, migrationDir, backupDir) {
+  const reportPath = path.join(migrationDir, "migration-report.md");
+  await mkdir(migrationDir, { recursive: true });
+  const skipped = plan.filter((item) => item.action === "skip").map((item) => item.targetRel);
+  const text = [
+    "# Agent Handoff Kit Migration Report",
+    "",
+    `Command: ${command}`,
+    `Mode: ${mode}`,
+    `Root: ${root}`,
+    `Created: ${new Date().toISOString()}`,
+    "",
+    "## Created",
+    ...listOrNone(created),
+    "",
+    "## Merged",
+    ...listOrNone(merged),
+    "",
+    "## Skipped Existing",
+    ...listOrNone(skipped),
+    "",
+    "## Conflicts",
+    ...listOrNone(conflicts.map((item) => `${item.targetRel} - ${item.reason}`)),
+    "",
+    "## Backup",
+    merged.length > 0 ? `- ${path.relative(root, backupDir)}` : "- none",
+    "",
+    "## Notes",
+    "- Existing files are preserved unless the installer can perform a bounded merge.",
+    "- Files that cannot be safely merged are reported as conflicts and are not overwritten."
+  ].join("\n");
+  await writeFile(reportPath, `${text}\n`, "utf8");
+  return reportPath;
+}
+
+function migrationStamp() {
+  return new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+
+async function readPackageVersion() {
+  try {
+    const text = await readFile(path.join(packageRoot, "package.json"), "utf8");
+    return JSON.parse(text).version ?? "version unverified";
+  } catch {
+    return "version unverified";
+  }
+}
+
+function printCard(version, status, eyes) {
+  console.log(`   /\\_/\\   Agent Handoff Kit v${version}`);
+  console.log(`  ( ${eyes} )  ${status}`);
+  console.log("   > ^ <");
+  console.log("");
+}
+
+function listOrNone(items) {
+  if (items.length === 0) return ["- none"];
+  return items.map((item) => `- ${item}`);
+}
+
+async function exists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function printHelp(version) {
+  printCard(version, "continuity ready", "o.o");
+  console.log(`Agent Handoff Kit
+
+Usage:
+  agent-handoff-kit init [--dry-run] [--yes] [--root <path>]
+  agent-handoff-kit upgrade [--dry-run] [--yes] [--root <path>]
+  agent-handoff-kit doctor [--root <path>]
+
+Commands:
+  init      Plan or install missing core files and rule packs.
+  upgrade   Preserve existing files; merge safe core updates or report conflicts.
+  doctor    Check required installed files.
+
+Working modes:
+  Describe your task directly. The AI chooses relevant rule packs for coding,
+  research, writing, knowledge sync, release, or mixed tasks.
+`);
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@adamchanadam/agent-handoff-kit",
+  "version": "0.1.0",
+  "description": "Lightweight agent harness for project memory, handoff, and multi-session continuity.",
+  "type": "module",
+  "bin": {
+    "agent-handoff-kit": "bin/agent-handoff-kit.mjs"
+  },
+  "files": [
+    "bin/",
+    "runtime-core/",
+    "packs/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "doctor": "node bin/agent-handoff-kit.mjs doctor --root .",
+    "dry-run": "node bin/agent-handoff-kit.mjs init --dry-run --root .",
+    "qa:prototype": "node scripts/check-public-prototype.mjs",
+    "qa:packs": "node scripts/check-pack-scenarios.mjs",
+    "qa:upgrade": "node scripts/check-upgrade-safety.mjs",
+    "qa:release": "node scripts/check-release-readiness.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}