opencode-ship 0.2.0

package/dist/cli.js

@@ -0,0 +1,2484 @@
+#!/usr/bin/env node
+// opencode-ship CLI v0.2.0
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/installer/catalog.js
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+function getTemplateSet() {
+  return TEMPLATE_SET;
+}
+var packageRoot, TEMPLATE_SET, CATALOG, POINTER_ENTRIES;
+var init_catalog = __esm({
+  "src/installer/catalog.js"() {
+    packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+    TEMPLATE_SET = "v0.2.0";
+    CATALOG = [
+      {
+        kind: "plugin",
+        path: ".opencode/plugin/opencode-ship.js",
+        source: resolve(packageRoot, "dist/plugin.js"),
+        mode: 420
+      },
+      {
+        kind: "agent",
+        path: ".opencode/agents/delivery-reviewer.md",
+        source: resolve(packageRoot, "assets/agents/delivery-reviewer.md"),
+        mode: 420
+      },
+      {
+        kind: "agent",
+        path: ".opencode/agents/delivery-verifier.md",
+        source: resolve(packageRoot, "assets/agents/delivery-verifier.md"),
+        mode: 420
+      },
+      {
+        kind: "skill",
+        path: ".opencode/skills/delivery-workflow/SKILL.md",
+        source: resolve(packageRoot, "assets/skills/delivery-workflow/SKILL.md"),
+        mode: 420
+      },
+      {
+        kind: "skill",
+        path: ".opencode/skills/planning-research-checkpoint/SKILL.md",
+        source: resolve(packageRoot, "assets/skills/planning-research-checkpoint/SKILL.md"),
+        mode: 420
+      }
+    ];
+    POINTER_ENTRIES = [
+      {
+        pointer: "/agent/build/permission/delivery_inspect",
+        strategy: "value",
+        value: "allow"
+      },
+      {
+        pointer: "/agent/build/permission/delivery_issue",
+        strategy: "value",
+        value: "allow"
+      },
+      {
+        pointer: "/agent/build/permission/delivery_worktree",
+        strategy: "value",
+        value: "allow"
+      },
+      {
+        pointer: "/agent/build/permission/delivery_verify",
+        strategy: "value",
+        value: "deny"
+      },
+      {
+        pointer: "/agent/build/permission/delivery_review",
+        strategy: "value",
+        value: "deny"
+      },
+      {
+        pointer: "/agent/build/permission/delivery_pr",
+        strategy: "value",
+        value: "allow"
+      },
+      {
+        pointer: "/agent/build/permission/delivery_ready",
+        strategy: "value",
+        value: "allow"
+      },
+      {
+        pointer: "/agent/build/permission/delivery_merge",
+        strategy: "value",
+        value: "ask"
+      },
+      {
+        pointer: "/agent/build/permission/delivery_cleanup",
+        strategy: "value",
+        value: "allow"
+      },
+      {
+        pointer: "/agent/build/permission/task/delivery-reviewer",
+        strategy: "value",
+        value: "allow"
+      },
+      {
+        pointer: "/agent/build/permission/task/delivery-verifier",
+        strategy: "value",
+        value: "allow"
+      }
+    ];
+  }
+});
+
+// src/installer/json-pointer.js
+var json_pointer_exports = {};
+__export(json_pointer_exports, {
+  getPointer: () => getPointer,
+  parsePointer: () => parsePointer,
+  pointerPath: () => pointerPath,
+  removePointer: () => removePointer,
+  setPointer: () => setPointer,
+  stableStringify: () => stableStringify
+});
+function unescape(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function escape(token) {
+  return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function* parsePointer(pointer) {
+  if (typeof pointer !== "string" || pointer === "") return;
+  if (pointer[0] !== "/") {
+    yield "";
+    return;
+  }
+  const trimmed = pointer.slice(1);
+  if (trimmed === "") return;
+  for (const token of trimmed.split("/")) yield unescape(token);
+}
+function getPointer(doc, pointer) {
+  if (pointer === "" || pointer === "/") return void 0;
+  let current = doc;
+  for (const token of parsePointer(pointer)) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof token === "string" && token.includes("=")) return void 0;
+    current = current?.[token];
+  }
+  return current;
+}
+function setPointer(doc, pointer, value) {
+  const tokens = [...parsePointer(pointer)];
+  if (tokens.length === 0) return value;
+  if (!isObject(doc)) return value;
+  const root = { ...doc };
+  let cursor = root;
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const key = tokens[i];
+    const next = cursor[key];
+    const copy = isObject(next) ? { ...next } : Array.isArray(next) ? [...next] : {};
+    cursor[key] = copy;
+    cursor = copy;
+  }
+  cursor[tokens[tokens.length - 1]] = value;
+  return root;
+}
+function removePointer(doc, pointer) {
+  const tokens = [...parsePointer(pointer)];
+  if (tokens.length === 0) return doc;
+  if (!isObject(doc)) return doc;
+  const root = { ...doc };
+  let cursor = root;
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const key = tokens[i];
+    const copy = isObject(cursor[key]) ? { ...cursor[key] } : { ...cursor[key] };
+    cursor[key] = copy;
+    cursor = copy;
+  }
+  delete cursor[tokens[tokens.length - 1]];
+  return root;
+}
+function isObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (isObject(value)) {
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function pointerPath(segments) {
+  return "/" + segments.map((s) => escape(String(s))).join("/");
+}
+var init_json_pointer = __esm({
+  "src/installer/json-pointer.js"() {
+  }
+});
+
+// src/installer/hash.js
+import { createHash } from "node:crypto";
+function bytesHash(buffer) {
+  return createHash("sha256").update(buffer).digest("hex");
+}
+function bytesHashString(text) {
+  return bytesHash(Buffer.from(text, "utf8"));
+}
+var init_hash = __esm({
+  "src/installer/hash.js"() {
+    init_json_pointer();
+  }
+});
+
+// src/installer/root-config.js
+var root_config_exports = {};
+__export(root_config_exports, {
+  applyOwnedPointers: () => applyOwnedPointers,
+  defaultRootConfigPath: () => defaultRootConfigPath,
+  findRootConfig: () => findRootConfig,
+  formatRootConfig: () => formatRootConfig,
+  formatRootConfigPreserving: () => formatRootConfigPreserving,
+  parseRootConfigPreservingOrder: () => parseRootConfigPreservingOrder,
+  readRootConfig: () => readRootConfig,
+  synthesizeDefaultRootConfig: () => synthesizeDefaultRootConfig
+});
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+function findRootConfig(repoRoot) {
+  for (const rel of ROOT_PATH_CANDIDATES) {
+    const abs = resolve3(repoRoot, rel);
+    if (existsSync2(abs)) return { path: abs, relative: rel, format: rel.endsWith(".jsonc") ? "jsonc" : "json" };
+  }
+  return { path: null, relative: ROOT_PATH_CANDIDATES[0], format: "json" };
+}
+function defaultRootConfigPath(repoRoot) {
+  return resolve3(repoRoot, ROOT_PATH_CANDIDATES[0]);
+}
+function readRootConfig(absPath) {
+  if (!existsSync2(absPath)) {
+    return { ok: false, error: { kind: "missing", path: absPath } };
+  }
+  const raw = readFileSync(absPath, "utf8");
+  const stripped = stripJsonc(raw);
+  try {
+    const value = JSON.parse(stripped);
+    return {
+      ok: true,
+      path: absPath,
+      raw,
+      sha256: bytesHashString(raw),
+      value,
+      before: snapshotValues(value),
+      format: absPath.endsWith(".jsonc") ? "jsonc" : "json"
+    };
+  } catch (e) {
+    return { ok: false, error: { kind: "parse", path: absPath, message: e.message } };
+  }
+}
+function snapshotValues(doc) {
+  const out = {};
+  for (const entry of POINTER_ENTRIES) {
+    out[entry.pointer] = getPointer(doc, entry.pointer);
+  }
+  return out;
+}
+function stripJsonc(text) {
+  let stripped = "";
+  let i = 0;
+  let inString = false;
+  let escape2 = false;
+  while (i < text.length) {
+    const ch = text[i];
+    if (inString) {
+      stripped += ch;
+      if (escape2) {
+        escape2 = false;
+      } else if (ch === "\\") {
+        escape2 = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      stripped += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i += 1;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i += 1;
+      i += 2;
+      continue;
+    }
+    stripped += ch;
+    i += 1;
+  }
+  return stripped.replace(/,\s*([}\]])/g, "$1");
+}
+function applyOwnedPointers(rootDoc, { pointerEntries = POINTER_ENTRIES, allowEqualValues = true } = {}) {
+  const result = { doc: rootDoc, applied: [], skipped: [] };
+  let doc = rootDoc;
+  for (const entry of pointerEntries) {
+    const existing = getPointer(doc, entry.pointer);
+    if (existing === void 0) {
+      doc = setPointer(doc, entry.pointer, entry.value);
+      result.applied.push({ pointer: entry.pointer, value: entry.value });
+      continue;
+    }
+    if (existing === entry.value) {
+      if (allowEqualValues) {
+        result.skipped.push({ pointer: entry.pointer, reason: "already equal" });
+      }
+      continue;
+    }
+    result.skipped.push({
+      pointer: entry.pointer,
+      reason: "different existing value",
+      existing,
+      desired: entry.value
+    });
+  }
+  return result;
+}
+function synthesizeDefaultRootConfig() {
+  return {
+    $schema: "https://opencode.ai/config.json",
+    agent: {
+      build: {
+        permission: {
+          delivery_inspect: "allow",
+          delivery_issue: "allow",
+          delivery_worktree: "allow",
+          delivery_verify: "deny",
+          delivery_review: "deny",
+          delivery_pr: "allow",
+          delivery_ready: "allow",
+          delivery_merge: "ask",
+          delivery_cleanup: "allow",
+          task: {
+            "delivery-reviewer": "allow",
+            "delivery-verifier": "allow"
+          }
+        }
+      }
+    }
+  };
+}
+function formatRootConfig(value) {
+  return JSON.stringify(stripSourceOrder(value), null, 2) + "\n";
+}
+function stripSourceOrder(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const out = Array.isArray(value) ? [] : {};
+  const order = Array.isArray(value.__sourceOrder__) ? value.__sourceOrder__ : null;
+  const seen = /* @__PURE__ */ new Set();
+  if (order) {
+    for (const k of order) {
+      if (k === "__sourceOrder__") continue;
+      if (!(k in value)) continue;
+      seen.add(k);
+      out[k] = stripSourceOrder(value[k]);
+    }
+  }
+  for (const k of Object.keys(value)) {
+    if (k === "__sourceOrder__") continue;
+    if (seen.has(k)) continue;
+    out[k] = stripSourceOrder(value[k]);
+  }
+  return out;
+}
+function formatRootConfigPreserving(value) {
+  return formatRootConfig(value);
+}
+function parseRootConfigPreservingOrder(text) {
+  const parser = new RootConfigParser(text);
+  const value = parser.parseValue(
+    0,
+    /*atTop*/
+    true
+  );
+  const isJsonc = text.includes("//") || text.includes("/*");
+  return { value, format: isJsonc ? "jsonc" : "json" };
+}
+var ROOT_PATH_CANDIDATES, RootConfigParser;
+var init_root_config = __esm({
+  "src/installer/root-config.js"() {
+    init_json_pointer();
+    init_hash();
+    init_catalog();
+    ROOT_PATH_CANDIDATES = ["opencode.json", "opencode.jsonc"];
+    RootConfigParser = class {
+      constructor(text) {
+        this.text = text;
+        this.pos = 0;
+      }
+      skipWS() {
+        while (this.pos < this.text.length) {
+          const ch = this.text[this.pos];
+          if (ch === " " || ch === "\n" || ch === "	" || ch === "\r") {
+            this.pos += 1;
+            continue;
+          }
+          if (ch === "/" && this.text[this.pos + 1] === "/") {
+            while (this.pos < this.text.length && this.text[this.pos] !== "\n") this.pos += 1;
+            continue;
+          }
+          if (ch === "/" && this.text[this.pos + 1] === "*") {
+            this.pos += 2;
+            while (this.pos < this.text.length && !(this.text[this.pos] === "*" && this.text[this.pos + 1] === "/")) this.pos += 1;
+            this.pos += 2;
+            continue;
+          }
+          break;
+        }
+      }
+      parseValue(depth, atTop) {
+        this.skipWS();
+        const ch = this.text[this.pos];
+        if (ch === "{") return this.parseObject(depth, atTop);
+        if (ch === "[") return this.parseArray(depth);
+        if (ch === '"') return this.parseString();
+        if (ch === "-" || ch >= "0" && ch <= "9") return this.parseNumber();
+        if (this.text.startsWith("true", this.pos)) {
+          this.pos += 4;
+          return true;
+        }
+        if (this.text.startsWith("false", this.pos)) {
+          this.pos += 5;
+          return false;
+        }
+        if (this.text.startsWith("null", this.pos)) {
+          this.pos += 4;
+          return null;
+        }
+        throw new Error(`unexpected token at ${this.pos}: ${this.text.slice(this.pos, this.pos + 8)}`);
+      }
+      parseObject(depth, atTop) {
+        const out = /* @__PURE__ */ Object.create(null);
+        out.__sourceOrder__ = [];
+        this.pos += 1;
+        while (this.pos < this.text.length) {
+          this.skipWS();
+          if (this.text[this.pos] === "}") {
+            this.pos += 1;
+            return out;
+          }
+          const key = this.parseString();
+          out.__sourceOrder__.push(key);
+          this.skipWS();
+          if (this.text[this.pos] !== ":") throw new Error(`expected : at ${this.pos}`);
+          this.pos += 1;
+          out[key] = this.parseValue(depth + 1, false);
+          this.skipWS();
+          if (this.text[this.pos] === ",") {
+            this.pos += 1;
+            continue;
+          }
+          if (this.text[this.pos] === "}") {
+            this.pos += 1;
+            return out;
+          }
+          throw new Error(`expected , or } at ${this.pos}`);
+        }
+        throw new Error("unterminated object");
+      }
+      parseArray(depth) {
+        const out = [];
+        this.pos += 1;
+        while (this.pos < this.text.length) {
+          this.skipWS();
+          if (this.text[this.pos] === "]") {
+            this.pos += 1;
+            return out;
+          }
+          out.push(this.parseValue(depth + 1, false));
+          this.skipWS();
+          if (this.text[this.pos] === ",") {
+            this.pos += 1;
+            continue;
+          }
+          if (this.text[this.pos] === "]") {
+            this.pos += 1;
+            return out;
+          }
+          throw new Error(`expected , or ] at ${this.pos}`);
+        }
+        throw new Error("unterminated array");
+      }
+      parseString() {
+        if (this.text[this.pos] !== '"') throw new Error(`expected " at ${this.pos}`);
+        this.pos += 1;
+        let out = "";
+        while (this.pos < this.text.length) {
+          const ch = this.text[this.pos];
+          if (ch === "\\") {
+            const next = this.text[this.pos + 1];
+            out += ch + next;
+            this.pos += 2;
+            continue;
+          }
+          if (ch === '"') {
+            this.pos += 1;
+            return JSON.parse('"' + out + '"');
+          }
+          out += ch;
+          this.pos += 1;
+        }
+        throw new Error("unterminated string");
+      }
+      parseNumber() {
+        const start = this.pos;
+        if (this.text[this.pos] === "-") this.pos += 1;
+        while (this.pos < this.text.length && /[0-9.eE+\-]/.test(this.text[this.pos])) this.pos += 1;
+        return Number(this.text.slice(start, this.pos));
+      }
+    };
+  }
+});
+
+// src/installer/lock.js
+var lock_exports = {};
+__export(lock_exports, {
+  CURRENT_LOCK_SCHEMA: () => CURRENT_LOCK_SCHEMA,
+  computeIntegrity: () => computeIntegrity,
+  lockPath: () => lockPath,
+  migrateLegacyLock: () => migrateLegacyLock,
+  readLock: () => readLock,
+  validateIntegrity: () => validateIntegrity,
+  writeLock: () => writeLock
+});
+import { readFile as readFile4, writeFile as writeFile2, rename as rename2, mkdir as mkdir2 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { dirname as dirname3, resolve as resolve4 } from "node:path";
+function lockPath(repoRoot) {
+  return resolve4(repoRoot, ".opencode", "ship.lock.json");
+}
+async function readLock(repoRoot) {
+  const path = lockPath(repoRoot);
+  if (!existsSync4(path)) return null;
+  try {
+    const raw = await readFile4(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeLock(repoRoot, lock) {
+  const path = lockPath(repoRoot);
+  await mkdir2(dirname3(path), { recursive: true });
+  const integrity = computeIntegrity(lock);
+  const finalLock = { ...lock, integrity };
+  const raw = JSON.stringify(finalLock, null, 2) + "\n";
+  const tmp = `${path}.tmp`;
+  await writeFile2(tmp, raw, "utf8");
+  await rename2(tmp, path);
+  return path;
+}
+function computeIntegrity(lock) {
+  const { integrity: _ignored, ...without } = lock ?? {};
+  void _ignored;
+  return {
+    lockSha256: bytesHashString(stableStringify(without))
+  };
+}
+async function validateIntegrity(lock) {
+  if (!lock?.integrity?.lockSha256) return false;
+  const expected = computeIntegrity(lock).lockSha256;
+  return expected === lock.integrity.lockSha256;
+}
+async function migrateLegacyLock(repoRoot) {
+  const legacy = resolve4(repoRoot, ".opencode", "delivery.lock.json");
+  if (!existsSync4(legacy)) return null;
+  try {
+    const raw = await readFile4(legacy, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.contractVersion !== 1 || typeof parsed.adapterSha256 !== "string") return null;
+    return {
+      kind: "legacy-lock",
+      sourcePath: legacy,
+      payload: { contractVersion: 1, adapterSha256: parsed.adapterSha256, writtenAt: parsed.writtenAt ?? null },
+      sha256: bytesHashString(raw)
+    };
+  } catch {
+    return null;
+  }
+}
+var CURRENT_LOCK_SCHEMA;
+var init_lock = __esm({
+  "src/installer/lock.js"() {
+    init_hash();
+    init_json_pointer();
+    CURRENT_LOCK_SCHEMA = 1;
+  }
+});
+
+// src/installer/cli-args.js
+var USAGE = `opencode-ship <command> [options]
+
+Commands:
+  init        Install or update managed files in this project.
+  diff        Show what would change without writing.
+  update      Apply pending updates after recovering the journal.
+  doctor      Validate environment, lock, and references.
+  uninstall   Remove managed files that still match the lock.
+  --version   Print the version and exit.
+  --help      Show this usage and exit.
+
+Options:
+  --root <path>          Project root (defaults to cwd).
+  --config <path>        Override the config file location (init only).
+  --force-config         Rewrite the user config from detection (init only).
+  --force-root-config    Create opencode.json when absent (init only).
+  --strict-doctor        Fail init when doctor reports unhealthy checks.
+  --replace-managed      Replace locally-modified managed files (update only).
+  --purge-config         Remove ship.config.json when uninstalling.
+  --json                 Emit a JSON envelope instead of human output.
+`;
+function parseFlags(argv) {
+  const options = {
+    rootPath: null,
+    configPath: null,
+    json: false,
+    replaceManaged: false,
+    purgeConfig: false,
+    forceConfig: false,
+    forceRootConfig: false,
+    strictDoctor: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") options.json = true;
+    else if (arg === "--replace-managed") options.replaceManaged = true;
+    else if (arg === "--purge-config") options.purgeConfig = true;
+    else if (arg === "--force-config") options.forceConfig = true;
+    else if (arg === "--force-root-config") options.forceRootConfig = true;
+    else if (arg === "--strict-doctor") options.strictDoctor = true;
+    else if (arg === "--root") options.rootPath = argv[++i];
+    else if (arg === "--config") options.configPath = argv[++i];
+    else if (arg === "-h" || arg === "--help") return { help: true };
+    else if (arg === "-v" || arg === "--version") return { version: true };
+    else return { error: `unknown flag ${arg}` };
+  }
+  return options;
+}
+function parseCommand(argv) {
+  for (const arg of argv) {
+    if (arg === "--help" || arg === "-h") return { command: "help" };
+    if (arg === "--version" || arg === "-v") return { command: "version" };
+  }
+  const [cmd, ...rest] = argv;
+  if (!cmd) return { command: "help" };
+  const flags = parseFlags(rest);
+  if ("help" in flags) return { command: "help" };
+  if ("version" in flags) return { command: "version" };
+  if ("error" in flags) return { error: flags.error };
+  switch (cmd) {
+    case "init":
+    case "diff":
+    case "update":
+    case "doctor":
+    case "uninstall":
+      return { command: cmd, options: flags };
+    default:
+      return { error: `unknown command ${cmd}` };
+  }
+}
+function helpText() {
+  return USAGE;
+}
+
+// src/installer/executor.js
+init_catalog();
+import { existsSync as existsSync8 } from "node:fs";
+import { mkdir as mkdir4, readFile as readFile7, rename as rename4, unlink as unlink2, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname5, resolve as resolve9 } from "node:path";
+
+// src/installer/planner.js
+init_catalog();
+init_hash();
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile3, stat } from "node:fs/promises";
+
+// src/installer/config.js
+import { readFile, writeFile, rename, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+
+// schema/ship-config.schema.json
+var ship_config_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://github.com/Viktorxyz/opencode-delivery/schema/ship-config.schema.json",
+  title: "opencode-ship user config",
+  type: "object",
+  required: ["schemaVersion"],
+  additionalProperties: false,
+  properties: {
+    schemaVersion: { const: 1 },
+    owner: {
+      type: "string",
+      description: "Optional override for the issue/manifest owner field. Defaults to the agent's local user.name."
+    },
+    project: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        remote: { type: "string", minLength: 1 },
+        repository: { type: "string", pattern: "^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$" },
+        defaultBranch: { type: "string", minLength: 1 },
+        packageManager: { enum: ["npm", "pnpm", "yarn", "bun"] },
+        detectOverrides: { type: "boolean", description: "Permit detection to refresh previously persisted values." }
+      }
+    },
+    delivery: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        worktree: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            root: { type: "string", minLength: 1 },
+            branchTemplate: { type: "string", minLength: 1 },
+            bootstrap: {
+              type: "array",
+              items: {
+                type: "array",
+                items: { type: "string", minLength: 1 },
+                minItems: 1
+              }
+            }
+          }
+        },
+        verification: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            commands: {
+              type: "array",
+              minItems: 1,
+              items: {
+                type: "object",
+                required: ["id", "argv"],
+                additionalProperties: false,
+                properties: {
+                  id: { type: "string", minLength: 1 },
+                  argv: {
+                    type: "array",
+                    items: { type: "string", minLength: 1 },
+                    minItems: 1
+                  },
+                  timeoutMs: { type: "integer", minimum: 1 }
+                }
+              }
+            },
+            requireCleanDiffAfter: { type: "boolean" },
+            invalidateOnHeadChange: { type: "boolean" }
+          }
+        },
+        review: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            agent: { type: "string", minLength: 1 },
+            required: { type: "boolean" },
+            invalidateOnHeadChange: { type: "boolean" }
+          }
+        },
+        ci: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            driver: { const: "github-status-checks" },
+            requiredChecks: {
+              type: "array",
+              items: { type: "string", minLength: 1 },
+              uniqueItems: true
+            },
+            wait: { type: "boolean" },
+            flakyRetry: { type: "integer", enum: [0, 1] }
+          }
+        },
+        ready: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            requires: {
+              type: "array",
+              items: { enum: ["review", "local-verification", "remote-ci"] },
+              uniqueItems: true
+            },
+            stopAfterReady: { type: "boolean" }
+          }
+        },
+        merge: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            strategy: { const: "squash" },
+            policy: { const: "explicit-user-request-only" },
+            requireFreshGates: { type: "boolean" }
+          }
+        },
+        cleanup: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            when: { const: "next-task" },
+            requireUnpublishedGuard: { type: "boolean" }
+          }
+        }
+      }
+    },
+    tasks: {
+      type: "object",
+      description: "Optional override of the managed-file paths. Use only to relocate a target.",
+      additionalProperties: false,
+      properties: {
+        pluginPath: { type: "string", pattern: "^\\.opencode/.+\\.js$" },
+        agentsDir: { type: "string", pattern: "^\\.opencode/agents/?$" },
+        skillsDir: { type: "string", pattern: "^\\.opencode/skills/?$" }
+      }
+    }
+  }
+};
+
+// src/installer/validation.js
+var FORMAT_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+function isObject2(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function validate(value, schema, pointer, issues) {
+  if (!isObject2(schema)) return;
+  if (schema.const !== void 0 && value !== schema.const) {
+    issues.push(`${pointer}: expected const ${JSON.stringify(schema.const)}, got ${JSON.stringify(value)}`);
+    return;
+  }
+  if (schema.enum !== void 0 && !schema.enum.includes(value)) {
+    issues.push(`${pointer}: expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`);
+    return;
+  }
+  const type = schema.type;
+  if (type !== void 0) {
+    const actual = Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
+    if (type !== actual) {
+      if (!(type === "integer" && typeof value === "number" && Number.isInteger(value))) {
+        issues.push(`${pointer}: expected ${type}, got ${actual}`);
+        return;
+      }
+    }
+  }
+  if (type === "string") {
+    if (schema.minLength !== void 0 && value.length < schema.minLength) {
+      issues.push(`${pointer}: shorter than minLength ${schema.minLength}`);
+    }
+    if (schema.pattern !== void 0) {
+      const re = new RegExp(schema.pattern);
+      if (!re.test(value)) issues.push(`${pointer}: does not match pattern ${schema.pattern}`);
+    }
+    if (schema.format === "date-time" && !FORMAT_DATE_TIME.test(value)) {
+      issues.push(`${pointer}: not a date-time string`);
+    }
+  }
+  if (type === "integer" || type === "number") {
+    if (schema.minimum !== void 0 && value < schema.minimum) {
+      issues.push(`${pointer}: less than minimum ${schema.minimum}`);
+    }
+    if (schema.maximum !== void 0 && value > schema.maximum) {
+      issues.push(`${pointer}: greater than maximum ${schema.maximum}`);
+    }
+    if (schema.enum !== void 0) {
+    }
+  }
+  if (type === "array") {
+    if (schema.minItems !== void 0 && value.length < schema.minItems) {
+      issues.push(`${pointer}: fewer items than minItems ${schema.minItems}`);
+    }
+    if (Array.isArray(schema.items)) {
+      value.forEach((entry, i) => validate(entry, schema.items[i] ?? {}, `${pointer}/${i}`, issues));
+    } else if (schema.items) {
+      if (schema.uniqueItems) {
+        const seen = /* @__PURE__ */ new Set();
+        value.forEach((entry, i) => {
+          const key = JSON.stringify(entry);
+          if (seen.has(key)) issues.push(`${pointer}/${i}: duplicate unique item`);
+          seen.add(key);
+        });
+      }
+      value.forEach((entry, i) => validate(entry, schema.items, `${pointer}/${i}`, issues));
+    }
+  }
+  if (type === "object") {
+    if (Array.isArray(schema.required)) {
+      for (const key of schema.required) {
+        if (!(key in value)) issues.push(`${pointer}: missing required field ${key}`);
+      }
+    }
+    if (schema.additionalProperties === false && isObject2(schema.properties)) {
+      for (const key of Object.keys(value)) {
+        if (!(key in schema.properties)) issues.push(`${pointer}: unknown field ${key}`);
+      }
+    }
+    if (isObject2(schema.properties)) {
+      for (const key of Object.keys(schema.properties)) {
+        if (key in value) validate(value[key], schema.properties[key], `${pointer}/${key}`, issues);
+      }
+    }
+  }
+}
+function validateSchema(value, schema) {
+  const issues = [];
+  validate(value, schema, "#", issues);
+  return { ok: issues.length === 0, issues };
+}
+
+// src/installer/config.js
+init_json_pointer();
+init_hash();
+function configPath(repoRoot) {
+  return resolve2(repoRoot, ".opencode", "ship.config.json");
+}
+async function loadConfig(repoRoot) {
+  const path = configPath(repoRoot);
+  if (!existsSync(path)) return null;
+  const raw = await readFile(path, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    return { ok: false, error: { kind: "parse", path, message: e.message } };
+  }
+  const validation = validateSchema(parsed, ship_config_schema_default);
+  if (!validation.ok) {
+    return { ok: false, error: { kind: "contract", path, issues: validation.issues } };
+  }
+  return {
+    ok: true,
+    path,
+    raw,
+    sha256: bytesHashString(raw),
+    canonicalSha256: bytesHashString(stableStringify(parsed)),
+    value: parsed
+  };
+}
+async function writeConfig(repoRoot, value) {
+  const path = configPath(repoRoot);
+  await mkdir(dirname2(path), { recursive: true });
+  const raw = JSON.stringify(value, null, 2) + "\n";
+  const tmp = `${path}.tmp`;
+  await writeFile(tmp, raw, "utf8");
+  await rename(tmp, path);
+  return { path, raw, sha256: bytesHashString(raw) };
+}
+function renderDefaultConfig(detection, overrides = {}) {
+  const pm = detection?.packageManager ?? "npm";
+  const safeBootstrap = Array.isArray(detection?.worktreeBootstrap) && detection.worktreeBootstrap.length ? detection.worktreeBootstrap : [["npm", "install"]];
+  const safeVerification = Array.isArray(detection?.verificationPlan) && detection.verificationPlan.length ? detection.verificationPlan.map((step) => ({ id: step.id, argv: step.argv })) : [{ id: "typecheck", argv: ["npm", "run", "typecheck"] }];
+  const repo = detection?.repository ?? overrides.repository ?? "owner/repo";
+  return {
+    schemaVersion: 1,
+    project: {
+      remote: detection?.remote ?? "origin",
+      repository: repo,
+      defaultBranch: detection?.defaultBranch ?? "main",
+      packageManager: pm,
+      detectOverrides: false
+    },
+    delivery: {
+      worktree: {
+        root: detection?.worktreeRoot ?? ".worktrees",
+        branchTemplate: "{actor}/{slug}",
+        bootstrap: safeBootstrap
+      },
+      verification: {
+        commands: safeVerification,
+        requireCleanDiffAfter: true,
+        invalidateOnHeadChange: true
+      },
+      review: { agent: "delivery-reviewer", required: true, invalidateOnHeadChange: true },
+      ci: {
+        driver: "github-status-checks",
+        requiredChecks: ["delivery-verify"],
+        wait: true,
+        flakyRetry: 1
+      },
+      ready: { requires: ["review", "local-verification", "remote-ci"], stopAfterReady: true },
+      merge: { strategy: "squash", policy: "explicit-user-request-only", requireFreshGates: true },
+      cleanup: { when: "next-task", requireUnpublishedGuard: true }
+    }
+  };
+}
+
+// src/installer/planner.js
+init_json_pointer();
+init_catalog();
+init_root_config();
+init_root_config();
+async function readBytes(path) {
+  if (!existsSync3(path)) return null;
+  const buf = await readFile3(path);
+  const fileStat = await stat(path);
+  return { bytes: buf, hash: bytesHashString(buf.toString("utf8")), mode: fileStat.mode & 511 };
+}
+async function readDesiredBytes(source) {
+  if (!source || !existsSync3(source)) return null;
+  const buf = await readFile3(source);
+  return { bytes: buf, hash: bytesHashString(buf.toString("utf8")) };
+}
+function lookupLockedFile(lock, targetPath) {
+  if (!lock?.files) return null;
+  return lock.files.find((entry) => entry.path === targetPath) ?? null;
+}
+async function planManagedFile({ entry, repoRoot, lock, allowUnowned }) {
+  const targetPath = `${repoRoot}/${entry.path}`;
+  const locked = lookupLockedFile(lock, entry.path);
+  const current = await readBytes(targetPath);
+  const desired = await readDesiredBytes(entry.source);
+  if (!current) {
+    return {
+      kind: "create",
+      op: "file",
+      target: targetPath,
+      relPath: entry.path,
+      kindOf: entry.kind,
+      bytes: desired?.bytes ?? Buffer.alloc(0),
+      sha256: desired?.hash,
+      mode: 420,
+      reason: "managed file missing"
+    };
+  }
+  if (desired.hash === current.hash) {
+    if (locked?.sha256 === current.hash) {
+      return { kind: "noop", op: "file", target: targetPath, relPath: entry.path };
+    }
+    return {
+      kind: "converge",
+      op: "file",
+      target: targetPath,
+      relPath: entry.path,
+      reason: "current bytes already equal desired; refresh lock only"
+    };
+  }
+  if (locked?.sha256 === current.hash) {
+    return {
+      kind: "update",
+      op: "file",
+      target: targetPath,
+      relPath: entry.path,
+      bytes: desired?.bytes ?? Buffer.alloc(0),
+      sha256: desired?.hash,
+      mode: 420,
+      reason: "safe update: previous lock matches current bytes"
+    };
+  }
+  if (locked?.sha256 && locked.sha256 !== current.hash && allowUnowned) {
+    return {
+      kind: "update",
+      op: "file",
+      target: targetPath,
+      relPath: entry.path,
+      bytes: desired?.bytes ?? Buffer.alloc(0),
+      sha256: desired?.hash,
+      mode: 420,
+      reason: "force update: lock present, current bytes modified"
+    };
+  }
+  return {
+    kind: "conflict",
+    op: "file",
+    target: targetPath,
+    relPath: entry.path,
+    currentSha: current.hash,
+    previousSha: locked?.sha256 ?? null,
+    desiredSha: desired?.hash,
+    reason: locked?.sha256 == null ? "managed file already exists; bytes differ from upstream" : "managed file is locally modified"
+  };
+}
+async function planFileInstall({ repoRoot, lock, allowUnowned = false }) {
+  const plan = [];
+  for (const entry of CATALOG) {
+    plan.push(await planManagedFile({ entry, repoRoot, lock, allowUnowned }));
+  }
+  return plan;
+}
+async function planUninstall({ repoRoot, lock }) {
+  if (!lock) return [];
+  const plan = [];
+  for (const entry of lock.files ?? []) {
+    const targetPath = `${repoRoot}/${entry.path}`;
+    const current = await readBytes(targetPath);
+    if (!current) continue;
+    if (current.hash !== entry.sha256) {
+      plan.push({
+        kind: "conflict",
+        op: "file",
+        target: targetPath,
+        relPath: entry.path,
+        reason: "managed file is locally modified; refusing to delete"
+      });
+      continue;
+    }
+    plan.push({ kind: "delete", op: "file", target: targetPath, relPath: entry.path });
+  }
+  return plan;
+}
+async function planConfigSynthesis({ repoRoot, detection, lock, forceOverwrite }) {
+  const existing = await loadConfig(repoRoot);
+  if (existing?.ok && !forceOverwrite) {
+    return {
+      kind: "noop",
+      op: "config",
+      relPath: ".opencode/ship.config.json",
+      target: existing.path,
+      currentSha: existing.sha256,
+      desiredSha: existing.sha256,
+      configValue: existing.value,
+      reason: "user config already present"
+    };
+  }
+  const desiredValue = renderDefaultConfig(detection);
+  const desiredJson = JSON.stringify(desiredValue, null, 2) + "\n";
+  const desiredSha = bytesHashString(desiredJson);
+  const kind = existing?.ok && forceOverwrite ? "update" : "create";
+  return {
+    kind,
+    op: "config",
+    relPath: ".opencode/ship.config.json",
+    target: `${repoRoot}/.opencode/ship.config.json`,
+    currentSha: existing?.ok ? existing.sha256 : null,
+    desiredSha,
+    bytes: Buffer.from(desiredJson, "utf8"),
+    configValue: desiredValue,
+    reason: existing?.ok ? "user config overwritten via --force-config" : "synthesising a default config from detection"
+  };
+}
+async function planRootConfigApply({ repoRoot, lock, forceRepair }) {
+  const detected = findRootConfig(repoRoot);
+  const target = detected.path ?? defaultRootConfigPath(repoRoot);
+  const previous = lock?.manager?.rootDocuments?.find((d) => d.path === detected.relative);
+  const fileMissing = !existsSync3(target);
+  if (fileMissing && !forceRepair) {
+    return {
+      kind: "noop",
+      op: "root-config",
+      target,
+      relPath: detected.relative,
+      reason: "no root opencode.json present",
+      edits: []
+    };
+  }
+  if (fileMissing && forceRepair) {
+    const { synthesizeDefaultRootConfig: synthesizeDefaultRootConfig2, formatRootConfig: formatRootConfig3 } = await Promise.resolve().then(() => (init_root_config(), root_config_exports));
+    const doc = synthesizeDefaultRootConfig2();
+    const bytes2 = Buffer.from(formatRootConfig3(doc), "utf8");
+    const newSha2 = bytesHashString(stableStringify(doc));
+    const installedPointers2 = [];
+    return {
+      kind: "create",
+      op: "root-config",
+      target,
+      relPath: detected.relative,
+      bytes: bytes2,
+      desiredSha: newSha2,
+      currentSha: null,
+      edits: [{ kind: "create", pointer: "(file)", value: "(created)" }],
+      pointerRecords: installedPointers2,
+      format: "json",
+      document: doc,
+      reason: "creating root opencode.json with installer-owned Build permissions"
+    };
+  }
+  const docResult = readRootConfig(target);
+  if (!docResult.ok) {
+    return {
+      kind: "noop",
+      op: "root-config",
+      target,
+      relPath: detected.relative,
+      reason: `root config ${docResult.error.kind}`,
+      edits: []
+    };
+  }
+  const previousPointers = previous?.pointers ?? [];
+  const result = applyOwnedPointers(docResult.value, { allowEqualValues: true });
+  const edits = result.applied.map((a) => ({
+    kind: "create",
+    pointer: a.pointer,
+    value: a.value
+  }));
+  for (const s of result.skipped) {
+    if (s.reason === "already equal") continue;
+    edits.push({ kind: "conflict", pointer: s.pointer, reason: s.reason, existing: s.existing, desired: s.desired });
+  }
+  const { formatRootConfigPreserving: formatRootConfigPreserving2, formatRootConfig: formatRootConfig2 } = await Promise.resolve().then(() => (init_root_config(), root_config_exports));
+  const { parseRootConfigPreservingOrder: parseRootConfigPreservingOrder2 } = await Promise.resolve().then(() => (init_root_config(), root_config_exports));
+  const { setPointer: setPointer2 } = await Promise.resolve().then(() => (init_json_pointer(), json_pointer_exports));
+  let bytes;
+  let docForWrite = result.doc;
+  try {
+    const { value: sourceValue, format: sourceFormat } = parseRootConfigPreservingOrder2(docResult.raw);
+    docForWrite = sourceValue;
+    for (const entry of result.applied) {
+      docForWrite = setPointer2(docForWrite, entry.pointer, entry.value);
+    }
+    bytes = Buffer.from(formatRootConfigPreserving2(docForWrite), "utf8");
+    void sourceFormat;
+  } catch {
+    bytes = Buffer.from(formatRootConfig2(result.doc), "utf8");
+  }
+  const newSha = bytesHashString(stableStringify(docForWrite));
+  const installedPointers = [...previousPointers];
+  for (const e of result.applied) {
+    const idx = installedPointers.findIndex((p) => p.pointer === e.pointer);
+    const previousEntry = docResult.before?.[e.pointer];
+    const next = {
+      pointer: e.pointer,
+      strategy: "value",
+      installedSha256: bytesHashString(stableStringify(e.value)),
+      previous: previousEntry == null ? { existed: false } : { existed: true, value: previousEntry }
+    };
+    if (idx >= 0) installedPointers[idx] = next;
+    else installedPointers.push(next);
+  }
+  return {
+    kind: edits.some((e) => e.kind === "conflict") ? "conflict" : edits.length ? "update" : "noop",
+    op: "root-config",
+    target,
+    relPath: detected.relative,
+    bytes,
+    desiredSha: newSha,
+    currentSha: docResult.sha256 ?? null,
+    edits,
+    pointerRecords: installedPointers,
+    format: docResult.format,
+    document: docForWrite,
+    reason: edits.length === 0 ? "no installer-owned entries missing" : `apply ${result.applied.length} / skip ${result.skipped.length}`
+  };
+}
+
+// src/installer/executor.js
+init_lock();
+init_hash();
+init_json_pointer();
+
+// src/installer/detection/project.js
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
+import { resolve as resolve5, join } from "node:path";
+function runGit(cwd, args) {
+  const r = spawnSync("git", ["-C", cwd, ...args], {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8"
+  });
+  return { status: r.status ?? -1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+}
+function detectPackageManager(repoRoot) {
+  if (existsSync5(join(repoRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync5(join(repoRoot, "yarn.lock"))) return "yarn";
+  if (existsSync5(join(repoRoot, "bun.lockb"))) return "bun";
+  if (existsSync5(join(repoRoot, "package-lock.json"))) return "npm";
+  return null;
+}
+function readPackageJson(repoRoot) {
+  const path = join(repoRoot, "package.json");
+  if (!existsSync5(path)) return null;
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function planFromScripts(pkg, packageManager) {
+  const scripts = pkg?.scripts ?? {};
+  const runner = packageManager === "npm" ? "npm" : packageManager || "npm";
+  const candidate = (name) => typeof scripts[name] === "string" ? scripts[name].trim() : null;
+  if (candidate("verify") || candidate("verify:workspace")) {
+    const name = candidate("verify:workspace") ? "verify:workspace" : "verify";
+    const cmd = candidate(name);
+    return [{ id: "canonical", argv: [runner, "run", name], inferredFrom: "verify", command: cmd }];
+  }
+  const steps = [];
+  if (candidate("typecheck")) steps.push({ id: "typecheck", argv: [runner, "run", "typecheck"], script: "typecheck" });
+  if (candidate("lint")) steps.push({ id: "lint", argv: [runner, "run", "lint"], script: "lint" });
+  if (candidate("test")) steps.push({ id: "test", argv: [runner, "run", "test"], script: "test" });
+  return steps;
+}
+function bootstrapFor(packageManager) {
+  if (packageManager === "pnpm") return [["pnpm", "install", "--frozen-lockfile"]];
+  if (packageManager === "yarn") return [["yarn", "install", "--frozen-lockfile"]];
+  if (packageManager === "bun") return [["bun", "install", "--frozen-lockfile"]];
+  if (packageManager === "npm") return [["npm", "ci"]];
+  return [];
+}
+function parseRepoSlugFromRemote(url) {
+  if (!url) return null;
+  const ssh = url.match(/^git@[^:]+:(.+?)(?:\.git)?$/);
+  if (ssh) return ssh[1].replace(/^\/+|\/+$/g, "");
+  const https = url.match(/^https?:\/\/[^/]+\/(.+?)(?:\.git)?$/);
+  if (https) return https[1].replace(/^\/+|\/+$/g, "");
+  return null;
+}
+function detectRemote(repoRoot) {
+  const remotes = runGit(repoRoot, ["remote", "-v"]);
+  if (remotes.status !== 0) return { candidates: [], primary: null };
+  const lines = remotes.stdout.split("\n").filter(Boolean);
+  const map = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const match = line.match(/^(\S+)\s+(\S+)\s+\((\w+)\)$/);
+    if (!match) continue;
+    const name = match[1];
+    const url = match[2];
+    if (!map.has(name)) map.set(name, { name, url });
+  }
+  const list = Array.from(map.values());
+  const origin = list.find((r) => r.name === "origin") ?? list[0] ?? null;
+  return { candidates: list, primary: origin };
+}
+function detectDefaultBranch(repoRoot, remoteName) {
+  const head = runGit(repoRoot, ["symbolic-ref", `refs/remotes/${remoteName}/HEAD`]);
+  if (head.status === 0) {
+    const ref = head.stdout.trim();
+    const match = ref.match(/^refs\/remotes\/[^/]+\/(.+)$/);
+    if (match) return match[1];
+  }
+  const local = runGit(repoRoot, ["remote", "show", remoteName]);
+  if (local.status === 0) {
+    const match = local.stdout.match(/HEAD branch:\s*(\S+)/);
+    if (match) return match[1];
+  }
+  const branch = runGit(repoRoot, ["branch", "--list"]);
+  if (branch.status === 0 && /\*\s*main\b/.test(branch.stdout)) return "main";
+  return null;
+}
+function detectOwner(repoRoot) {
+  const user = runGit(repoRoot, ["config", "--get", "user.name"]);
+  if (user.status === 0 && user.stdout.trim()) return user.stdout.trim();
+  const fallback = process.env.USER ?? process.env.USERNAME ?? "opencode-ship";
+  return fallback;
+}
+function detectProject(repoRoot = process.cwd()) {
+  const errors = [];
+  const cwd = resolve5(repoRoot);
+  const inside = runGit(cwd, ["rev-parse", "--show-toplevel"]);
+  if (inside.status !== 0) {
+    errors.push({ kind: "not-a-git-repo", path: cwd, detail: inside.stderr.trim() });
+    return { repoRoot: cwd, errors };
+  }
+  const repoRootActual = inside.stdout.trim();
+  const headBranch = runGit(repoRootActual, ["symbolic-ref", "--short", "HEAD"]);
+  if (headBranch.status !== 0 || headBranch.stdout.trim().length === 0) {
+    errors.push({ kind: "detached-head", path: repoRootActual, detail: headBranch.stderr.trim() });
+  }
+  const remote = detectRemote(repoRootActual);
+  let repository = null;
+  let defaultBranch = null;
+  if (remote.primary) {
+    repository = parseRepoSlugFromRemote(remote.primary.url);
+    defaultBranch = detectDefaultBranch(repoRootActual, remote.primary.name);
+  }
+  if (!repository) {
+    errors.push({ kind: "no-remote", path: repoRootActual, detail: "no usable remote for github detection" });
+  }
+  if (!defaultBranch) {
+    defaultBranch = "main";
+  }
+  const packageJson = readPackageJson(repoRootActual);
+  const packageManager = detectPackageManager(repoRootActual);
+  const verificationPlan = planFromScripts(packageJson, packageManager);
+  const worktreeBootstrap = bootstrapFor(packageManager);
+  const owner = detectOwner(repoRootActual);
+  return {
+    repoRoot: repoRootActual,
+    repository,
+    defaultBranch,
+    remote: remote.primary?.name ?? null,
+    remoteCandidates: remote.candidates,
+    packageManager,
+    packageJson,
+    verificationPlan,
+    worktreeBootstrap,
+    worktreeRoot: ".worktrees",
+    owner,
+    headBranch: headBranch.stdout.trim() || null,
+    errors
+  };
+}
+
+// src/installer/executor.js
+init_root_config();
+init_lock();
+
+// src/installer/transaction.js
+import {
+  writeFile as writeFile3,
+  rename as rename3,
+  readFile as readFile5,
+  unlink,
+  mkdir as mkdir3,
+  stat as stat2,
+  open
+} from "node:fs/promises";
+import { existsSync as existsSync6 } from "node:fs";
+import { dirname as dirname4, resolve as resolve6 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+function gitDir(repoRoot) {
+  const r = spawnSync2("git", ["-C", repoRoot, "rev-parse", "--path-format=absolute", "--git-dir"], {
+    encoding: "utf8"
+  });
+  if (r.status !== 0) return null;
+  const trimmed = r.stdout.trim();
+  return trimmed ? resolve6(repoRoot, trimmed) : null;
+}
+function lockDir(repoRoot) {
+  return resolve6(gitDir(repoRoot) ?? repoRoot, "opencode-ship");
+}
+function transactionLockPath(repoRoot) {
+  return resolve6(lockDir(repoRoot), ".txn.lock");
+}
+function journalPath(repoRoot, txnId) {
+  return resolve6(lockDir(repoRoot), `.txn-${txnId}.journal`);
+}
+async function acquireLock(repoRoot, txnId) {
+  const dir = lockDir(repoRoot);
+  await mkdir3(dir, { recursive: true });
+  await writeFile3(
+    transactionLockPath(repoRoot),
+    JSON.stringify({ pid: process.pid, txnId, startedAt: (/* @__PURE__ */ new Date()).toISOString() }),
+    { flag: "wx" }
+  );
+}
+async function releaseLock(repoRoot) {
+  try {
+    await unlink(transactionLockPath(repoRoot));
+  } catch {
+  }
+}
+async function fsyncDir(path) {
+  try {
+    const handle = await open(path, "r");
+    await handle.sync();
+    await handle.close();
+  } catch {
+  }
+}
+function randomToken() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+async function captureOriginal(target) {
+  if (!existsSync6(target)) return null;
+  try {
+    const bytes = await readFile5(target);
+    const fileStat = await stat2(target);
+    return { bytes, mode: fileStat.mode & 511 };
+  } catch {
+    return null;
+  }
+}
+function asMode(mode) {
+  return typeof mode === "number" ? mode : 420;
+}
+async function writeJournal(repoRoot, txnId, journal) {
+  await writeFile3(journalPath(repoRoot, txnId), JSON.stringify(journal, null, 2), "utf8");
+}
+async function clearJournal(repoRoot, txnId) {
+  if (!txnId) return;
+  try {
+    await unlink(journalPath(repoRoot, txnId));
+  } catch {
+  }
+}
+async function recover(repoRoot) {
+  const dir = lockDir(repoRoot);
+  if (!existsSync6(dir)) return { recovered: false };
+  const { readdir } = await import("node:fs/promises");
+  const names = await readdir(dir).catch(() => []);
+  const journals = names.filter((n) => n.startsWith(".txn-") && n.endsWith(".journal"));
+  if (!journals.length) return { recovered: false };
+  let totalRecovered = 0;
+  for (const name of journals) {
+    let payload;
+    try {
+      const raw = await readFile5(resolve6(dir, name), "utf8");
+      payload = JSON.parse(raw);
+    } catch {
+      await unlink(resolve6(dir, name)).catch(() => null);
+      continue;
+    }
+    const journal = payload;
+    for (const entry of [...journal.entries ?? []].reverse()) {
+      if (entry.op !== "promote") continue;
+      if (entry.original) {
+        try {
+          await writeFile3(entry.target, entry.original.bytes, { mode: entry.original.mode ?? 420 });
+        } catch {
+        }
+      } else if (entry.staged) {
+        try {
+          await rename3(entry.staged, entry.target);
+        } catch {
+          try {
+            await unlink(entry.staged);
+          } catch {
+          }
+        }
+      }
+    }
+    await unlink(resolve6(dir, name)).catch(() => null);
+    totalRecovered += 1;
+  }
+  await releaseLock(repoRoot);
+  return { recovered: totalRecovered > 0, recoveredCount: totalRecovered };
+}
+async function executePlan({ repoRoot, plan, newLockBuilder }) {
+  const recovered = await recover(repoRoot);
+  const txnId = `txn-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+  try {
+    await acquireLock(repoRoot, txnId);
+  } catch (e) {
+    return { ok: false, error: { kind: "lock-held", message: e?.message ?? String(e) } };
+  }
+  const journal = { repoRoot, txnId, startedAt: (/* @__PURE__ */ new Date()).toISOString(), entries: [] };
+  await writeJournal(repoRoot, txnId, journal);
+  try {
+    for (const op of plan) {
+      if (op.op !== "file") continue;
+      if (op.kind === "conflict" || op.kind === "noop" || op.kind === "converge") continue;
+      const original = await captureOriginal(op.target);
+      if (op.kind === "delete") {
+        if (!existsSync6(op.target)) continue;
+        const backup = `${op.target}.txn-${randomToken()}-backup`;
+        await rename3(op.target, backup);
+        journal.entries.push({
+          op: "promote",
+          target: op.target,
+          staged: backup,
+          original,
+          kind: "delete"
+        });
+      } else {
+        const tempPath = `${op.target}.txn-${randomToken()}`;
+        await mkdir3(dirname4(op.target), { recursive: true });
+        await writeFile3(tempPath, op.bytes ?? Buffer.alloc(0), { mode: asMode(op.mode) });
+        const h = await open(tempPath, "r+");
+        await h.sync();
+        await h.close();
+        await rename3(tempPath, op.target);
+        journal.entries.push({
+          op: "promote",
+          target: op.target,
+          staged: tempPath,
+          original,
+          kind: op.kind
+        });
+      }
+      await fsyncDir(dirname4(op.target));
+      await writeJournal(repoRoot, txnId, journal);
+    }
+    if (newLockBuilder) {
+      const lockValue = await newLockBuilder();
+      const { writeLock: writer } = await Promise.resolve().then(() => (init_lock(), lock_exports));
+      const lockPathTarget = `${repoRoot}/.opencode/ship.lock.json`;
+      journal.entries.push({
+        op: "promote",
+        target: lockPathTarget,
+        staged: lockPathTarget,
+        original: await captureOriginal(lockPathTarget),
+        kind: "lock"
+      });
+      await writer(repoRoot, lockValue);
+      await writeJournal(repoRoot, txnId, journal);
+    }
+    await clearJournal(repoRoot, txnId);
+    return { ok: true, txnId, recovered: recovered.recovered ?? false, recoveredCount: recovered.recoveredCount ?? 0 };
+  } catch (e) {
+    await rollback(repoRoot, journal);
+    return { ok: false, error: { kind: "transaction-failed", message: e?.message ?? String(e) } };
+  } finally {
+    await releaseLock(repoRoot);
+  }
+}
+async function rollback(repoRoot, journal) {
+  for (const entry of [...journal.entries ?? []].reverse()) {
+    if (entry.op !== "promote") continue;
+    if (entry.original) {
+      try {
+        await writeFile3(entry.target, entry.original.bytes, { mode: entry.original.mode ?? 420 });
+      } catch {
+      }
+    } else if (entry.staged) {
+      try {
+        await rename3(entry.staged, entry.target);
+      } catch {
+        try {
+          await unlink(entry.staged);
+        } catch {
+        }
+      }
+    } else {
+      try {
+        await unlink(entry.target);
+      } catch {
+      }
+    }
+    if (entry.staged && entry.staged !== entry.target && existsSync6(entry.staged)) {
+      try {
+        await unlink(entry.staged);
+      } catch {
+      }
+    }
+  }
+  if (journal.txnId) await clearJournal(repoRoot, journal.txnId);
+}
+
+// src/installer/migration.js
+init_lock();
+import { readFile as readFile6 } from "node:fs/promises";
+import { existsSync as existsSync7 } from "node:fs";
+import { resolve as resolve8 } from "node:path";
+
+// src/installer/ship-adapter.js
+import { resolve as resolve7 } from "node:path";
+
+// src/installer/migration.js
+function legacyAdapterPath(repoRoot) {
+  return resolve8(repoRoot, ".opencode", "delivery.json");
+}
+function legacyLockPath(repoRoot) {
+  return resolve8(repoRoot, ".opencode", "delivery.lock.json");
+}
+function legacyPluginPath(repoRoot) {
+  return resolve8(repoRoot, ".opencode", "plugin", "delivery.ts");
+}
+async function detectLegacyShapes(repoRoot) {
+  const out = {
+    adapter: false,
+    legacyLock: false,
+    plugin: false,
+    reviewer: false,
+    verifier: false
+  };
+  if (existsSync7(legacyAdapterPath(repoRoot))) out.adapter = true;
+  if (existsSync7(legacyLockPath(repoRoot))) out.legacyLock = true;
+  if (existsSync7(legacyPluginPath(repoRoot))) out.plugin = true;
+  if (existsSync7(resolve8(repoRoot, ".opencode/agents/delivery-reviewer.md"))) out.reviewer = true;
+  if (existsSync7(resolve8(repoRoot, ".opencode/agents/delivery-verifier.md"))) out.verifier = true;
+  return out;
+}
+async function readLegacyAdapter(repoRoot) {
+  const path = legacyAdapterPath(repoRoot);
+  if (!existsSync7(path)) return null;
+  try {
+    const raw = await readFile6(path, "utf8");
+    return { path, raw, value: JSON.parse(raw) };
+  } catch {
+    return null;
+  }
+}
+async function migration({ repoRoot, lock, forceRepair }) {
+  const shapes = await detectLegacyShapes(repoRoot);
+  const legacy = await readLegacyAdapter(repoRoot);
+  const config = await loadConfig(repoRoot);
+  const actions = [];
+  if (legacy && !config?.ok) {
+    await writeConfig(repoRoot, legacyToShipConfig(legacy.value));
+    actions.push({ kind: "seeded-config", from: legacy.path });
+  }
+  if (legacy && shapes.legacyLock && !lock?.manager) {
+    actions.push({ kind: "kept-legacy-lock", path: legacyLockPath(repoRoot) });
+  }
+  if (shapes.plugin && existsSync7(resolve8(repoRoot, ".opencode/plugin/opencode-ship.js"))) {
+    if (!forceRepair) {
+      actions.push({ kind: "candidate-remove-legacy-plugin", path: legacyPluginPath(repoRoot) });
+    }
+  }
+  return { shapes, actions, legacyPresent: Boolean(legacy) };
+}
+function legacyToShipConfig(legacy) {
+  if (!legacy || typeof legacy !== "object") return renderDefaultConfig({});
+  return {
+    schemaVersion: 1,
+    project: {
+      remote: legacy.repository?.remote ?? "origin",
+      repository: legacy.repository?.defaultBranch?.name ?? legacy.repository?.remote ?? "owner/repo",
+      defaultBranch: legacy.repository?.defaultBranch?.name ?? "main",
+      packageManager: "npm",
+      detectOverrides: false
+    },
+    delivery: {
+      worktree: {
+        root: legacy.worktree?.root ?? ".worktrees",
+        branchTemplate: legacy.worktree?.branchTemplate ?? "{actor}/{slug}",
+        bootstrap: Array.isArray(legacy.worktree?.bootstrap) ? legacy.worktree.bootstrap : [["npm", "install"]]
+      },
+      verification: {
+        commands: legacy.verification?.commands?.length ? legacy.verification.commands : [{ id: "typecheck", argv: ["npm", "run", "typecheck"] }],
+        requireCleanDiffAfter: legacy.verification?.requireCleanDiffAfter ?? true,
+        invalidateOnHeadChange: legacy.verification?.invalidateOnHeadChange ?? true
+      },
+      review: legacy.review ?? { agent: "delivery-reviewer", required: true, invalidateOnHeadChange: true },
+      ci: legacy.ci ?? {
+        driver: "github-status-checks",
+        requiredChecks: ["delivery-verify"],
+        wait: true,
+        flakyRetry: 1
+      },
+      ready: legacy.ready ?? { requires: ["review", "local-verification", "remote-ci"], stopAfterReady: true },
+      merge: legacy.merge ?? { strategy: "squash", policy: "explicit-user-request-only", requireFreshGates: true },
+      cleanup: legacy.cleanup ?? { when: "next-task", requireUnpublishedGuard: true }
+    }
+  };
+}
+
+// src/installer/executor.js
+async function readCurrentBytes(targetPath) {
+  if (!existsSync8(targetPath)) return null;
+  const buf = await readFile7(targetPath);
+  return { bytes: buf, hash: bytesHashString(buf.toString("utf8")) };
+}
+async function previewInstall({ rootPath, replaceManaged, forceConfig, forceRootConfig }) {
+  const detection = detectProject(rootPath ?? process.cwd());
+  if (detection.errors.some((e) => e.kind === "not-a-git-repo")) {
+    return { ok: false, error: { kind: "invalid-project", errors: detection.errors } };
+  }
+  const repoRoot = detection.repoRoot;
+  const lock = await readLock(repoRoot);
+  const migrationReport = await migration({ repoRoot, lock, forceRepair: false });
+  const configPlan = await planConfigSynthesis({
+    repoRoot,
+    detection,
+    lock,
+    forceOverwrite: Boolean(forceConfig)
+  });
+  const filePlan = await planFileInstall({ repoRoot, lock, allowUnowned: Boolean(replaceManaged) });
+  const rootPlan = await planRootConfigApply({ repoRoot, lock, forceRepair: Boolean(forceRootConfig) });
+  const plan = [...filePlan ?? [], configPlan, rootPlan];
+  const conflicts = plan.filter((p) => p && p.kind === "conflict");
+  const summary = summarise(plan);
+  return { ok: true, repoRoot, detection, lock, plan, conflicts, summary, migrationReport };
+}
+async function previewUninstall({ rootPath }) {
+  const detection = detectProject(rootPath ?? process.cwd());
+  if (detection.errors.some((e) => e.kind === "not-a-git-repo")) {
+    return { ok: false, error: { kind: "invalid-project" } };
+  }
+  const repoRoot = detection.repoRoot;
+  const lock = await readLock(repoRoot);
+  if (!lock) {
+    return { ok: true, repoRoot, lock, plan: [], conflicts: [], summary: summarise([]) };
+  }
+  const plan = await planUninstall({ repoRoot, lock });
+  const conflicts = plan.filter((p) => p.kind === "conflict");
+  return { ok: true, repoRoot, lock, plan, conflicts, summary: summarise(plan) };
+}
+function summarise(plan) {
+  const counts = { create: 0, update: 0, noop: 0, delete: 0, conflict: 0, converge: 0, lock: 0, config: 0, rootConfig: 0 };
+  for (const op of plan) {
+    if (!op) continue;
+    if (op.op === "lock") counts.lock += 1;
+    else if (op.op === "config") counts.config += 1;
+    else if (op.op === "root-config") counts.rootConfig += 1;
+    else if (counts[op.kind] !== void 0) counts[op.kind] += 1;
+  }
+  return counts;
+}
+async function assembleLock({ repoRoot, plan, lock, configPlan, rootPlan }) {
+  const files = [];
+  const remain = lock?.files?.filter((f) => !plan.some((op) => op?.relPath === f.path)) ?? [];
+  for (const op of plan) {
+    if (!op || op.op !== "file") continue;
+    if (op.kind === "delete" || op.kind === "conflict") continue;
+    const entry = CATALOG.find((c) => c.path === op.relPath);
+    if (!entry) continue;
+    let hash = op.sha256;
+    if (!hash && op.target) {
+      const cur = await readCurrentBytes(op.target);
+      if (cur) hash = cur.hash;
+    }
+    files.push({
+      path: op.relPath,
+      sha256: hash ?? null,
+      mode: 420,
+      template: relativeTemplate(entry.source),
+      kind: entry.kind
+    });
+  }
+  for (const f of remain) {
+    files.push({ ...f });
+  }
+  const configSha = configPlan?.kind === "create" || configPlan?.kind === "update" ? configPlan.desiredSha : configPlan?.kind === "noop" ? configPlan.currentSha : null;
+  const rootPointers = rootPlan?.pointerRecords ?? lock?.manager?.rootDocuments?.[0]?.pointers ?? [];
+  return {
+    contractVersion: 1,
+    manager: {
+      schemaVersion: 1,
+      name: "opencode-ship",
+      version: "0.2.0",
+      templateSet: getTemplateSet(),
+      appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      config: {
+        path: ".opencode/ship.config.json",
+        sha256: configSha ?? lock?.manager?.config?.sha256 ?? "",
+        existed: Boolean(lock?.manager?.config?.existed)
+      },
+      rootDocuments: rootPlan?.kind && rootPlan.kind !== "noop" && rootPlan?.target ? [{
+        path: rootPlan.relPath,
+        format: rootPlan.format ?? "json",
+        pointers: rootPointers
+      }] : lock?.manager?.rootDocuments ?? []
+    },
+    files,
+    cleanupPending: lock?.cleanupPending ?? []
+  };
+}
+async function commitInstall(preview, { json, command }) {
+  if (!preview.ok) {
+    return {
+      ok: false,
+      command,
+      plan: [],
+      conflicts: [],
+      summary: summarise([]),
+      diagnostics: [preview.error?.kind ?? "invalid-project"],
+      /** @type {any} */
+      extra: { exitCode: 2, repoRoot: null, migrationReport: null }
+    };
+  }
+  const { repoRoot, plan, conflicts, migrationReport } = preview;
+  const filePlans = plan.filter((op) => op.op === "file");
+  const configPlan = plan.find((op) => op.op === "config");
+  const rootPlan = plan.find((op) => op.op === "root-config");
+  const fileOnly = filePlans;
+  if (conflicts.length > 0) {
+    return {
+      ok: false,
+      command,
+      plan,
+      conflicts,
+      summary: summarise(plan),
+      diagnostics: ["hash conflict; refuse to overwrite"],
+      /** @type {any} */
+      extra: { exitCode: 3, repoRoot, migrationReport }
+    };
+  }
+  const newLockObject = await assembleLock({
+    repoRoot,
+    plan: fileOnly,
+    lock: preview.lock,
+    configPlan,
+    rootPlan
+  });
+  const txPlan = await stageFiles(fileOnly, repoRoot);
+  if (configPlan && (configPlan.kind === "create" || configPlan.kind === "update")) {
+    txPlan.push({
+      op: "file",
+      kind: configPlan.kind === "create" ? "create" : "update",
+      target: configPlan.target,
+      bytes: configPlan.bytes,
+      mode: 420,
+      relPath: configPlan.relPath
+    });
+  }
+  if (rootPlan && (rootPlan.kind === "create" || rootPlan.kind === "update")) {
+    txPlan.push({
+      op: "file",
+      kind: rootPlan.kind,
+      target: rootPlan.target,
+      bytes: rootPlan.bytes,
+      mode: 420,
+      relPath: rootPlan.relPath
+    });
+  }
+  const tx = await executePlan({
+    repoRoot,
+    plan: txPlan,
+    newLockBuilder: async () => newLockObject
+  });
+  if (!tx.ok) {
+    return {
+      ok: false,
+      command,
+      plan,
+      conflicts: [],
+      summary: summarise(plan),
+      diagnostics: [tx.error?.message ?? "transaction failure"],
+      extra: { exitCode: 4, repoRoot, migrationReport, recovered: false }
+    };
+  }
+  return {
+    ok: true,
+    command,
+    plan,
+    conflicts: [],
+    summary: summarise(plan),
+    diagnostics: [],
+    extra: { exitCode: 0, repoRoot, migrationReport, recovered: tx.recovered }
+  };
+}
+async function stageFiles(filePlan, repoRoot) {
+  const out = [];
+  for (const op of filePlan) {
+    if (op.kind === "conflict" || op.kind === "noop" || op.kind === "converge" || op.kind === "delete") continue;
+    out.push({
+      op: "file",
+      kind: op.kind,
+      target: op.target,
+      bytes: op.bytes ?? Buffer.alloc(0),
+      mode: op.mode ?? 420
+    });
+  }
+  return out;
+}
+function serializePlan(plan) {
+  return plan.filter(Boolean).map((op) => {
+    if (!op) return null;
+    const { bytes, ...rest } = op;
+    if (bytes && Buffer.isBuffer(bytes)) {
+      return { ...rest, bytesLength: bytes.length };
+    }
+    return rest;
+  });
+}
+function relativeTemplate(source) {
+  if (typeof source !== "string") return source;
+  const prefix = `${process.cwd()}/`;
+  if (source.startsWith(prefix)) return source.slice(prefix.length);
+  return source;
+}
+
+// src/installer/commands/doctor.js
+init_lock();
+import { existsSync as existsSync9, readFileSync as readFileSync3 } from "node:fs";
+import { spawnSync as spawnSync3 } from "node:child_process";
+init_hash();
+init_root_config();
+import { resolve as resolve10 } from "node:path";
+
+// src/installer/report.js
+var REPORT_VERSION = 1;
+function pad(p) {
+  return p.replace(/^/, "  ");
+}
+function summarise2(plan) {
+  const counts = { create: 0, update: 0, noop: 0, delete: 0, conflict: 0, converge: 0 };
+  for (const op of plan) {
+    if (counts[op.kind] !== void 0) counts[op.kind] += 1;
+  }
+  return counts;
+}
+function renderHuman({ command, plan, conflicts, summary, diagnostics = [] }) {
+  const head = `# opencode-ship ${command}`;
+  if (!plan.length && !conflicts.length) {
+    return [head, "", "No changes.", ...diagnostics.map((d) => pad(`- ${d}`))].join("\n");
+  }
+  const sections = [head, "", `## Plan`];
+  for (const op of plan) {
+    sections.push(pad(`- ${op.kind.padEnd(9)} ${op.relPath ?? op.target}${op.reason ? ` \u2014 ${op.reason}` : ""}`));
+  }
+  if (conflicts.length) {
+    sections.push("", `## Conflicts (${conflicts.length})`);
+    for (const c of conflicts) {
+      sections.push(pad(`- ${c.relPath ?? c.target}: ${c.reason}`));
+    }
+  }
+  if (diagnostics.length) {
+    sections.push("", "## Diagnostics");
+    for (const d of diagnostics) sections.push(pad(`- ${d}`));
+  }
+  sections.push("", `Summary: ${JSON.stringify(summary)}`);
+  return sections.join("\n");
+}
+function renderJson({ command, plan, conflicts, summary, diagnostics = [], exitCode }) {
+  return JSON.stringify({
+    reportVersion: REPORT_VERSION,
+    command,
+    status: conflicts.length > 0 ? "conflict" : "ok",
+    plan,
+    conflicts,
+    summary,
+    diagnostics,
+    exitCode
+  }, null, 2);
+}
+
+// src/installer/commands/doctor.js
+function checkNode() {
+  return { name: "node>=22.6.0", ok: /^v2[2-9]/.test(process.version), detail: process.version };
+}
+function checkGit() {
+  const r = spawnSync3("git", ["--version"], { encoding: "utf8" });
+  return { name: "git installed", ok: r.status === 0, detail: r.status === 0 ? r.stdout.trim() : "git not on PATH" };
+}
+function checkGh() {
+  const r = spawnSync3("gh", ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  return { name: "gh installed", ok: r.status === 0, detail: r.status === 0 ? r.stdout.trim() : "gh CLI not on PATH" };
+}
+function checkGhAuth() {
+  const envToken = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+  if (!envToken) {
+    return { name: "gh auth status", ok: false, detail: "no GH_TOKEN / GITHUB_TOKEN in environment; gh auth skipped" };
+  }
+  const r = spawnSync3("gh", ["auth", "status"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  return {
+    name: "gh auth status",
+    ok: r.status === 0,
+    detail: r.status === 0 ? "authenticated (token)" : (r.stderr || r.stdout || "").trim() || "no session"
+  };
+}
+async function checkLock(repoRoot) {
+  const lock = await readLock(repoRoot);
+  if (!lock) return { name: "lock present", ok: false, detail: "missing" };
+  const integrityOk = await validateIntegrity(lock);
+  return {
+    name: "lock present",
+    ok: integrityOk,
+    detail: integrityOk ? `v0.2 manager@${lock.manager?.version ?? "?"}` : "integrity mismatch"
+  };
+}
+async function checkConfig(repoRoot) {
+  const r = await loadConfig(repoRoot);
+  return {
+    name: "ship.config.json valid",
+    ok: Boolean(r?.ok),
+    detail: r?.ok ? "loaded" : r?.error?.kind ?? "missing"
+  };
+}
+function checkPlugin(repoRoot) {
+  const path = resolve10(repoRoot, ".opencode/plugin/opencode-ship.js");
+  if (!existsSync9(path)) return { name: "plugin", ok: false, detail: "missing" };
+  try {
+    const buf = readFileSync3(path, "utf8");
+    return { name: "plugin", ok: buf.includes("opencode-ship"), detail: "loaded" };
+  } catch (e) {
+    return { name: "plugin", ok: false, detail: e.message };
+  }
+}
+function checkAgents(repoRoot) {
+  const reviewer = resolve10(repoRoot, ".opencode/agents/delivery-reviewer.md");
+  const verifier = resolve10(repoRoot, ".opencode/agents/delivery-verifier.md");
+  return {
+    name: "canonical agents",
+    ok: existsSync9(reviewer) && existsSync9(verifier),
+    detail: existsSync9(reviewer) && existsSync9(verifier) ? "loaded" : "missing"
+  };
+}
+function checkSkills(repoRoot) {
+  const a = resolve10(repoRoot, ".opencode/skills/delivery-workflow/SKILL.md");
+  const b = resolve10(repoRoot, ".opencode/skills/planning-research-checkpoint/SKILL.md");
+  return {
+    name: "canonical skills",
+    ok: existsSync9(a) && existsSync9(b),
+    detail: existsSync9(a) && existsSync9(b) ? "loaded" : "missing"
+  };
+}
+async function checkManagedHashes(repoRoot) {
+  const lock = await readLock(repoRoot);
+  if (!lock) return { name: "managed hashes", ok: false, detail: "no lock" };
+  const drift = [];
+  for (const entry of lock.files ?? []) {
+    const p = resolve10(repoRoot, entry.path);
+    if (!existsSync9(p)) {
+      drift.push(`missing:${entry.path}`);
+      continue;
+    }
+    const buf = readFileSync3(p, "utf8");
+    const actual = bytesHashString(buf);
+    if (actual !== entry.sha256) drift.push(`drift:${entry.path}`);
+  }
+  return { name: "managed hashes", ok: drift.length === 0, detail: drift.length ? drift.join(",") : "match" };
+}
+async function checkRootConfig(repoRoot) {
+  const { findRootConfig: findRootConfig2 } = await Promise.resolve().then(() => (init_root_config(), root_config_exports));
+  const candidate = findRootConfig2(repoRoot);
+  if (!candidate.path) return { name: "root config owned entries", ok: true, detail: "absent (no work)" };
+  const result = readRootConfig(candidate.path);
+  if (!result.ok) return { name: "root config owned entries", ok: false, detail: `root config ${result.error.kind}` };
+  const r = applyOwnedPointers(result.value);
+  const conflict = r.skipped.find((s) => s.reason === "different existing value");
+  return {
+    name: "root config owned entries",
+    ok: !conflict,
+    detail: conflict ? `conflict on ${conflict.pointer}` : `applied=${r.applied.length}, skipped=${r.skipped.length}`
+  };
+}
+function writeEnvelope({ command, plan, summary, diagnostics, json, exitCode }) {
+  const conflicts = plan.filter((p) => p.kind === "conflict");
+  if (json) {
+    process.stdout.write(renderJson({ command, plan, conflicts, summary, diagnostics, exitCode }) + "\n");
+  } else {
+    process.stdout.write(renderHuman({ command, plan, conflicts, summary, diagnostics }) + "\n");
+  }
+}
+async function runDoctor({ rootPath, json, writeOutput = true }) {
+  const detection = detectProject(rootPath ?? process.cwd());
+  if (detection.errors.some((e) => e.kind === "not-a-git-repo")) {
+    const issues2 = ["not in a git repository"];
+    const checks2 = [];
+    const plan2 = checks2.map((c) => ({
+      kind: c.ok ? "noop" : "conflict",
+      op: "check",
+      target: c.name,
+      relPath: c.name,
+      reason: c.detail
+    }));
+    const summary2 = summarise2(plan2);
+    if (writeOutput) writeEnvelope({ command: "doctor", plan: plan2, summary: summary2, diagnostics: issues2, json, exitCode: 2 });
+    process.exitCode = 2;
+    return { issues: issues2, exitCode: 2, plan: plan2, checks: checks2 };
+  }
+  const repoRoot = detection.repoRoot;
+  const checks = [
+    checkNode(),
+    checkGit(),
+    checkGh(),
+    checkGhAuth(),
+    await checkLock(repoRoot),
+    await checkConfig(repoRoot),
+    checkPlugin(repoRoot),
+    checkAgents(repoRoot),
+    checkSkills(repoRoot),
+    await checkManagedHashes(repoRoot),
+    await checkRootConfig(repoRoot)
+  ];
+  const issues = checks.filter((c) => !c.ok).map((c) => `${c.name}: ${c.detail}`);
+  const plan = checks.map((c) => ({
+    kind: c.ok ? "noop" : "conflict",
+    op: "check",
+    target: c.name,
+    relPath: c.name,
+    reason: c.detail
+  }));
+  const summary = summarise2(plan);
+  const exitCode = issues.length === 0 ? 0 : 1;
+  if (writeOutput) writeEnvelope({ command: "doctor", plan, summary, diagnostics: issues, json, exitCode });
+  process.exitCode = exitCode;
+  return { issues, exitCode, plan, checks };
+}
+
+// src/installer/commands/init.js
+async function runInit(options) {
+  const preview = await previewInstall({
+    rootPath: options.rootPath ?? null,
+    replaceManaged: false,
+    forceConfig: Boolean(options.forceConfig),
+    forceRootConfig: Boolean(options.forceRootConfig)
+  });
+  if (!preview.ok) {
+    return emitFailure(2, preview.error?.kind ?? "invalid-project", options.json, "init");
+  }
+  const committed = await commitInstall(preview, { json: options.json, command: "init" });
+  let exitCode = committed.extra?.exitCode ?? 0;
+  if (!committed || exitCode !== 0) {
+    if (exitCode === 2) return emitFailure(2, committed?.diagnostics?.[0] ?? "invalid project", options.json, "init");
+    if (exitCode === 3) return emitFailure(3, committed?.diagnostics?.[0] ?? "conflict", options.json, "init");
+    if (exitCode === 4) return emitFailure(4, committed?.diagnostics?.[0] ?? "transaction failure", options.json, "init");
+    return emitFailure(exitCode, committed?.diagnostics?.[0] ?? "unknown", options.json, "init");
+  }
+  const doctor = await runDoctor({
+    rootPath: options.rootPath ?? null,
+    json: Boolean(options.json),
+    writeOutput: false
+  });
+  committed.extra = { ...committed.extra ?? {}, doctor: { issues: doctor.issues, checks: doctor.checks, exitCode: doctor.exitCode } };
+  committed.diagnostics = [...committed.diagnostics ?? [], ...doctor.issues ?? []];
+  if (doctor.issues && doctor.issues.length > 0) {
+    committed.diagnostics = [`doctor: ${doctor.issues.length} check(s) unhealthy`, ...committed.diagnostics];
+    if (options.strictDoctor) {
+      exitCode = 1;
+    }
+  }
+  if (options.json) {
+    const envelope = {
+      reportVersion: 1,
+      command: "init",
+      status: exitCode === 0 ? "ok" : "warning",
+      plan: serializePlan(committed.plan ?? []),
+      conflicts: committed.conflicts ?? [],
+      summary: committed.summary ?? {},
+      diagnostics: committed.diagnostics ?? [],
+      doctor: doctor.issues ?? [],
+      doctorChecks: doctor.checks ?? [],
+      exitCode
+    };
+    Object.assign(envelope, committed.extra ?? {}, { doctor: doctor.issues ?? [] });
+    process.stdout.write(JSON.stringify(envelope, null, 2) + "\n");
+  } else if (exitCode !== 0) {
+    process.stdout.write(`opencode-ship: doctor reported ${doctor.issues.length} unhealthy check(s)
+`);
+  } else {
+    process.stdout.write(`opencode-ship: installed; doctor OK
+`);
+  }
+  process.exitCode = exitCode;
+  return { ok: exitCode === 0, exitCode };
+}
+function emitFailure(code, message, json, command) {
+  if (json) {
+    process.stdout.write(JSON.stringify({
+      reportVersion: 1,
+      command,
+      status: "error",
+      plan: [],
+      conflicts: [],
+      summary: { create: 0, update: 0, noop: 0, delete: 0, conflict: 0, converge: 0 },
+      diagnostics: [message],
+      exitCode: code
+    }, null, 2) + "\n");
+  } else {
+    process.stdout.write(`opencode-ship: ${message}
+`);
+  }
+  process.exitCode = code;
+  return { ok: false, exitCode: code };
+}
+
+// src/installer/commands/diff.js
+function summarise3(plan) {
+  const counts = { create: 0, update: 0, noop: 0, delete: 0, conflict: 0, converge: 0, lock: 0, config: 0, rootConfig: 0 };
+  for (const op of plan) {
+    if (!op) continue;
+    if (op.op === "lock") counts.lock += 1;
+    else if (op.op === "config") counts.config += 1;
+    else if (op.op === "root-config") counts.rootConfig += 1;
+    else if (counts[op.kind] !== void 0) counts[op.kind] += 1;
+  }
+  return counts;
+}
+function serializePlan2(plan) {
+  return plan.filter(Boolean).map((op) => {
+    if (!op) return null;
+    const { bytes, ...rest } = op;
+    if (bytes && Buffer.isBuffer(bytes)) {
+      return { ...rest, bytesLength: bytes.length };
+    }
+    return rest;
+  });
+}
+async function runDiff(options) {
+  const preview = await previewInstall({
+    rootPath: options.rootPath ?? null,
+    replaceManaged: false,
+    forceConfig: false,
+    forceRootConfig: false
+  });
+  if (!preview.ok) {
+    if (options.json) {
+      process.stdout.write(JSON.stringify({
+        reportVersion: 1,
+        command: "diff",
+        status: "error",
+        plan: [],
+        conflicts: [],
+        summary: { create: 0, update: 0, noop: 0, delete: 0, conflict: 0, converge: 0 },
+        diagnostics: [preview.error?.kind ?? "invalid-project"],
+        exitCode: 2
+      }, null, 2) + "\n");
+    } else {
+      process.stdout.write(`opencode-ship: ${preview.error?.kind ?? "invalid-project"}
+`);
+    }
+    process.exitCode = 2;
+    return { ok: false, exitCode: 2 };
+  }
+  const { plan, conflicts, migrationReport } = preview;
+  const summary = summarise3(plan);
+  const changes = summary.create + summary.update + summary.delete + summary.conflict;
+  if (options.json) {
+    process.stdout.write(JSON.stringify({
+      reportVersion: 1,
+      command: "diff",
+      status: conflicts.length > 0 ? "conflict" : changes ? "changed" : "noop",
+      plan: serializePlan2(plan),
+      conflicts,
+      summary,
+      diagnostics: [],
+      migrationReport,
+      exitCode: changes ? 1 : 0
+    }, null, 2) + "\n");
+  } else {
+    const head = "# opencode-ship diff";
+    const lines = [head, "", "## Plan"];
+    for (const op of plan.filter(Boolean)) {
+      const bytesHint = op.bytes ? `${op.bytes.length ?? 0}b` : "";
+      lines.push(`  - ${op.kind.padEnd(9)} ${op.op} ${op.relPath ?? op.target}${bytesHint ? ` (${bytesHint})` : ""}${op.reason ? ` \u2014 ${op.reason}` : ""}`);
+    }
+    if (conflicts.length) {
+      lines.push("", `## Conflicts (${conflicts.length})`);
+      for (const c of conflicts) lines.push(`  - ${c.relPath ?? c.target}: ${c.reason}`);
+    }
+    lines.push("", `Summary: ${JSON.stringify(summary)}`);
+    process.stdout.write(lines.join("\n") + "\n");
+  }
+  process.exitCode = changes ? 1 : 0;
+  return { ok: true, exitCode: changes ? 1 : 0 };
+}
+
+// src/installer/commands/update.js
+async function runUpdate(options) {
+  const preview = await previewInstall({
+    rootPath: options.rootPath,
+    replaceManaged: options.replaceManaged,
+    forceConfig: options.forceConfig,
+    forceRootConfig: options.forceRootConfig
+  });
+  if (!preview.ok) {
+    return emitFailure2(2, preview.error?.kind ?? "invalid-project", options.json, "update");
+  }
+  if (preview.conflicts.length > 0 && !options.replaceManaged) {
+    return emitFailure2(3, "modified managed files; rerun with --replace-managed", options.json, "update");
+  }
+  const committed = await commitInstall(preview, { json: options.json, command: "update" });
+  if (options.json) {
+    process.stdout.write(JSON.stringify({
+      reportVersion: 1,
+      command: "update",
+      status: committed.extra?.exitCode === 0 ? "ok" : "error",
+      plan: serializePlan(committed.plan ?? []),
+      conflicts: committed.conflicts ?? [],
+      summary: committed.summary ?? {},
+      diagnostics: committed.diagnostics ?? [],
+      exitCode: committed.extra?.exitCode ?? 0,
+      ...committed.extra ?? {}
+    }, null, 2) + "\n");
+  } else if (committed.extra?.exitCode === 0) {
+    process.stdout.write(`opencode-ship: update OK
+`);
+  }
+  process.exitCode = committed.extra?.exitCode ?? 0;
+  return committed;
+}
+function emitFailure2(code, message, json, command) {
+  if (json) {
+    process.stdout.write(JSON.stringify({
+      reportVersion: 1,
+      command,
+      status: "error",
+      plan: [],
+      conflicts: [],
+      summary: { create: 0, update: 0, noop: 0, delete: 0, conflict: 0, converge: 0 },
+      diagnostics: [message],
+      exitCode: code
+    }, null, 2) + "\n");
+  } else {
+    process.stdout.write(`opencode-ship: ${message}
+`);
+  }
+  process.exitCode = code;
+  return { ok: false, exitCode: code };
+}
+
+// src/installer/commands/uninstall.js
+import { unlink as unlink3 } from "node:fs/promises";
+import { existsSync as existsSync10 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
+async function runUninstall(options) {
+  const preview = await previewUninstall({ rootPath: options.rootPath });
+  if (!preview.ok) {
+    return emitFailure3(2, preview.error?.kind ?? "invalid-project", options.json);
+  }
+  const { repoRoot, plan, conflicts, summary } = preview;
+  if (conflicts.length > 0) {
+    return emitReport(plan, conflicts, summary, options.json, 3, ["modified managed files; refusing to delete"]);
+  }
+  const tx = await executePlan({ repoRoot, plan, newLockBuilder: null });
+  if (!tx.ok) {
+    return emitFailure3(4, tx.error?.message ?? "transaction failure", options.json);
+  }
+  const lockPath2 = resolve11(repoRoot, ".opencode", "ship.lock.json");
+  if (existsSync10(lockPath2)) await unlink3(lockPath2).catch(() => null);
+  if (options.purgeConfig) {
+    await unlink3(configPath(repoRoot)).catch(() => null);
+  }
+  return emitReport(plan, [], summary, options.json, 0, [tx.recovered ? "journal recovered before uninstall" : ""].filter(Boolean));
+}
+function emitFailure3(code, message, json) {
+  if (json) {
+    process.stdout.write(JSON.stringify({
+      reportVersion: 1,
+      command: "uninstall",
+      status: "error",
+      plan: [],
+      conflicts: [],
+      summary: { create: 0, update: 0, noop: 0, delete: 0, conflict: 0, converge: 0 },
+      diagnostics: [message],
+      exitCode: code
+    }, null, 2) + "\n");
+  } else {
+    process.stdout.write(`opencode-ship: ${message}
+`);
+  }
+  process.exitCode = code;
+  return { ok: false, exitCode: code };
+}
+function emitReport(plan, conflicts, summary, json, exitCode, diagnostics) {
+  const safePlan = plan.map((op) => {
+    const { bytes, ...rest } = op ?? {};
+    return bytes && Buffer.isBuffer(bytes) ? { ...rest, bytesLength: bytes.length } : rest;
+  });
+  if (json) {
+    process.stdout.write(JSON.stringify({
+      reportVersion: 1,
+      command: "uninstall",
+      status: conflicts.length > 0 ? "conflict" : exitCode === 0 ? "ok" : "error",
+      plan: safePlan,
+      conflicts,
+      summary,
+      diagnostics,
+      exitCode
+    }, null, 2) + "\n");
+  } else {
+    const head = "# opencode-ship uninstall";
+    const lines = [head, "", "## Plan"];
+    for (const op of plan) lines.push(`  - ${op.kind.padEnd(9)} ${op.relPath ?? op.target}${op.reason ? ` \u2014 ${op.reason}` : ""}`);
+    if (conflicts.length) {
+      lines.push("", `## Conflicts (${conflicts.length})`);
+      for (const c of conflicts) lines.push(`  - ${c.relPath ?? c.target}: ${c.reason}`);
+    }
+    lines.push("", `Summary: ${JSON.stringify(summary)}`);
+    process.stdout.write(lines.join("\n") + "\n");
+  }
+  process.exitCode = exitCode;
+  return { ok: true, exitCode };
+}
+
+// src/cli.js
+var VERSION = "0.2.0";
+async function main() {
+  const parsed = parseCommand(process.argv.slice(2));
+  if (parsed.command === "help") {
+    process.stdout.write(helpText() + "\n");
+    process.exitCode = 0;
+    return;
+  }
+  if (parsed.command === "version") {
+    process.stdout.write(`opencode-ship ${VERSION}
+`);
+    process.exitCode = 0;
+    return;
+  }
+  if ("error" in parsed) {
+    process.stdout.write(`opencode-ship: ${parsed.error}
+
+${helpText()}`);
+    process.exitCode = 2;
+    return;
+  }
+  const options = parsed.options ?? {};
+  const opts = options;
+  switch (parsed.command) {
+    case "init":
+      await runInit({ json: !!opts.json, rootPath: opts.rootPath, forceConfig: !!opts.forceConfig, forceRootConfig: !!opts.forceRootConfig, strictDoctor: !!opts.strictDoctor });
+      return;
+    case "diff":
+      await runDiff({ json: !!opts.json, rootPath: opts.rootPath });
+      return;
+    case "update":
+      await runUpdate({ json: !!opts.json, rootPath: opts.rootPath, replaceManaged: !!opts.replaceManaged, forceConfig: !!opts.forceConfig, forceRootConfig: !!opts.forceRootConfig });
+      return;
+    case "doctor":
+      await runDoctor({ json: !!opts.json, rootPath: opts.rootPath });
+      return;
+    case "uninstall":
+      await runUninstall({ json: !!opts.json, rootPath: opts.rootPath, purgeConfig: !!opts.purgeConfig });
+      return;
+    default:
+      process.stdout.write(helpText() + "\n");
+      process.exitCode = 2;
+  }
+}
+main().catch((e) => {
+  process.stderr.write(`opencode-ship: internal failure: ${e?.message ?? String(e)}
+`);
+  if (e?.stack) process.stderr.write(e.stack + "\n");
+  process.exitCode = 4;
+});