opencode-ship 1.1.2-rc.2 → 1.1.2

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// opencode-ship CLI v1.1.2-rc.2
+// opencode-ship CLI v1.1.2
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -110,7 +110,7 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 var PACKAGE_VERSION, TEMPLATE_SET;
 var init_version = __esm({
   "src/version.js"() {
-    PACKAGE_VERSION = "1.1.2-rc.2";
+    PACKAGE_VERSION = "1.1.2";
     TEMPLATE_SET = `v${PACKAGE_VERSION}`;
   }
 });
@@ -359,6 +359,9 @@ var init_catalog = __esm({
 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] !== "/") {
@@ -421,6 +424,9 @@ function stableStringify(value) {
   }
   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"() {
   }
@@ -858,6 +864,126 @@ var init_config = __esm({
   }
 });
 
+// src/installer/lock.js
+import { readFile as readFile2, writeFile as writeFile2, rename as rename2, mkdir as mkdir2 } from "node:fs/promises";
+import { existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname4, resolve as resolve5, posix } from "node:path";
+function lockPath(repoRoot) {
+  return resolve5(repoRoot, ".opencode", "ship.lock.json");
+}
+function computeIntegrity(lock) {
+  const { integrity: _ignored, ...without } = lock ?? {};
+  void _ignored;
+  return {
+    lockSha256: bytesHashString(stableStringify(without))
+  };
+}
+function normalizeLegacyLock(lock) {
+  if (!lock || typeof lock !== "object") return lock;
+  const { cleanupPending: _drop, ...rest } = lock;
+  void _drop;
+  return rest;
+}
+function validateLock(rawLock) {
+  if (rawLock === null || rawLock === void 0) {
+    return { ok: true, kind: "missing", issues: [] };
+  }
+  if (typeof rawLock !== "object" || Array.isArray(rawLock)) {
+    return { ok: false, kind: "shape", issues: ["lock root must be an object"] };
+  }
+  const issues = [];
+  let kind = "ok";
+  if (rawLock.contractVersion !== CURRENT_LOCK_SCHEMA && rawLock.contractVersion !== 3 && rawLock.contractVersion !== 2 && rawLock.contractVersion !== 1) {
+    issues.push(`unsupported contractVersion: ${JSON.stringify(rawLock.contractVersion)} (expected ${CURRENT_LOCK_SCHEMA}, 3, 2, or 1)`);
+    kind = "schema";
+  }
+  const manager = rawLock.manager;
+  if (manager === void 0) {
+    issues.push("manager section missing");
+    kind = kind === "ok" ? "shape" : kind;
+  } else if (typeof manager !== "object" || manager === null) {
+    issues.push("manager section must be an object");
+    kind = kind === "ok" ? "shape" : kind;
+  } else if (manager.schemaVersion !== CURRENT_LOCK_SCHEMA && manager.schemaVersion !== 3 && manager.schemaVersion !== 2 && manager.schemaVersion !== 1) {
+    issues.push(`unsupported manager.schemaVersion: ${JSON.stringify(manager.schemaVersion)} (expected ${CURRENT_LOCK_SCHEMA}, 3, 2, or 1)`);
+    kind = "schema";
+  } else if (manager.name !== "opencode-ship") {
+    issues.push(`unknown manager.name: ${JSON.stringify(manager.name)}`);
+    kind = "shape";
+  } else if (rawLock.contractVersion >= 2 && manager.schemaVersion >= 2 && manager.profile !== void 0 && manager.profile !== "core" && manager.profile !== "engineering") {
+    issues.push(`invalid manager.profile: ${JSON.stringify(manager.profile)} (expected one of: engineering, core [legacy])`);
+    kind = "shape";
+  }
+  if (!rawLock.files || !Array.isArray(rawLock.files)) {
+    issues.push("files must be an array");
+    kind = kind === "ok" ? "shape" : kind;
+  } else {
+    for (const entry of rawLock.files) {
+      if (!entry || typeof entry !== "object" || !isSafeManagedPath(entry.path)) {
+        issues.push(`unsafe managed file path: ${JSON.stringify(entry?.path)}`);
+        kind = kind === "ok" ? "shape" : kind;
+      }
+    }
+  }
+  if (!rawLock.integrity || typeof rawLock.integrity !== "object") {
+    issues.push("integrity section missing");
+    kind = kind === "ok" ? "shape" : kind;
+  } else {
+    const expected = computeIntegrity(rawLock).lockSha256;
+    if (expected !== rawLock.integrity.lockSha256) {
+      issues.push(`integrity mismatch: stored ${rawLock.integrity.lockSha256} != computed ${expected}`);
+      kind = "integrity";
+    }
+  }
+  return { ok: issues.length === 0, kind, issues };
+}
+function isSafeManagedPath(value) {
+  if (typeof value !== "string" || value.length === 0 || value.includes("\\")) return false;
+  if (posix.isAbsolute(value) || posix.normalize(value) !== value) return false;
+  return value.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+async function readValidatedLock(repoRoot) {
+  const path = lockPath(repoRoot);
+  if (!existsSync5(path)) {
+    return { kind: "missing", lock: null, issues: [] };
+  }
+  let raw;
+  try {
+    const text = await readFile2(path, "utf8");
+    raw = JSON.parse(text);
+  } catch (e) {
+    return {
+      kind: "integrity",
+      lock: null,
+      issues: [`unable to parse lock JSON: ${e?.message ?? String(e)}`]
+    };
+  }
+  const validation = validateLock(raw);
+  if (validation.ok) {
+    return {
+      kind: validation.kind,
+      lock: normalizeLegacyLock(raw),
+      issues: []
+    };
+  }
+  return { kind: validation.kind, lock: null, issues: validation.issues };
+}
+function isSetupComplete(lock) {
+  if (!lock || typeof lock !== "object") return false;
+  const manager = lock.manager;
+  if (!manager || typeof manager !== "object") return false;
+  return manager.setupComplete === true;
+}
+var CURRENT_LOCK_SCHEMA;
+var init_lock = __esm({
+  "src/installer/lock.js"() {
+    init_hash();
+    init_json_pointer();
+    init_profile();
+    CURRENT_LOCK_SCHEMA = 4;
+  }
+});
+
 // src/installer/plan-mode-permissions.js
 function planModePermissions() {
   return {
@@ -865,7 +991,8 @@ function planModePermissions() {
       bash: DENY_DEFAULT,
       edit: {
         "*": DENY_DEFAULT,
-        [PLANS_GLOB]: ALLOW_PLANS
+        [PLANS_GLOB]: ALLOW_PLANS,
+        [SUPERPOWERS_GLOB]: ALLOW_PLANS
       },
       webfetch: DENY_DEFAULT,
       task: DENY_DEFAULT,
@@ -881,13 +1008,64 @@ function planModePermissions() {
     }
   };
 }
-var PLAN_PATH_PREFIX, DENY_DEFAULT, ALLOW_PLANS, PLANS_GLOB;
+function promotePlanEditIfString(doc) {
+  const edit = readPath(doc, ["agent", "plan", "permission", "edit"]);
+  if (edit === void 0) {
+    return { doc, record: null };
+  }
+  if (typeof edit === "string") {
+    const next = setPath(doc, ["agent", "plan", "permission", "edit"], { "*": edit });
+    const record = {
+      pointer: PLAN_EDIT_PARENT_POINTER,
+      previous: { existed: true, value: edit },
+      promotion: true
+    };
+    return { doc: next, record };
+  }
+  if (edit && typeof edit === "object" && !Array.isArray(edit)) {
+    if (Object.prototype.hasOwnProperty.call(edit, SUPERPOWERS_GLOB) && edit[SUPERPOWERS_GLOB] === "deny") {
+      return { doc, record: { conflict: true, pointer: PLAN_EDIT_GLOB_POINTER } };
+    }
+    return { doc, record: null };
+  }
+  return { doc, record: null };
+}
+function readPath(doc, tokens) {
+  let cursor = doc;
+  for (const token of tokens) {
+    if (cursor === null || cursor === void 0) return void 0;
+    cursor = cursor[token];
+  }
+  return cursor;
+}
+function setPath(doc, tokens, value) {
+  if (!doc || typeof doc !== "object" || Array.isArray(doc)) return doc;
+  const root = Array.isArray(doc) ? [...doc] : { ...doc };
+  let cursor = root;
+  for (let i = 0; i < tokens.length - 1; i += 1) {
+    const key = tokens[i];
+    const next = cursor[key];
+    const copy = next && typeof next === "object" && !Array.isArray(next) ? { ...next } : {};
+    cursor[key] = copy;
+    cursor = copy;
+  }
+  cursor[tokens[tokens.length - 1]] = value;
+  return root;
+}
+var PLAN_PATH_PREFIX, SUPERPOWERS_PATH_PREFIX, DENY_DEFAULT, ALLOW_PLANS, PLANS_GLOB, SUPERPOWERS_GLOB, PLAN_EDIT_GLOB, PLAN_EDIT_PLANS_GLOB, PLAN_EDIT_GLOB_POINTER, PLAN_EDIT_PLANS_GLOB_POINTER, PLAN_EDIT_PARENT_POINTER;
 var init_plan_mode_permissions = __esm({
   "src/installer/plan-mode-permissions.js"() {
     PLAN_PATH_PREFIX = ".git/opencode-ship/plans";
+    SUPERPOWERS_PATH_PREFIX = "docs/superpowers";
     DENY_DEFAULT = "deny";
     ALLOW_PLANS = "allow";
     PLANS_GLOB = `${PLAN_PATH_PREFIX}/**`;
+    SUPERPOWERS_GLOB = `${SUPERPOWERS_PATH_PREFIX}/**`;
+    PLAN_EDIT_GLOB = SUPERPOWERS_GLOB;
+    PLAN_EDIT_PLANS_GLOB = PLANS_GLOB;
+    PLAN_EDIT_GLOB_POINTER = "/agent/plan/permission/edit/docs~1superpowers~1**";
+    PLAN_EDIT_PLANS_GLOB_POINTER = "/agent/plan/permission/edit/.git~1opencode-ship~1plans~1**";
+    PLAN_EDIT_PARENT_POINTER = "/agent/plan/permission/edit";
   }
 });
 
@@ -907,21 +1085,21 @@ __export(root_config_exports, {
   readRootConfig: () => readRootConfig,
   synthesizeDefaultRootConfig: () => synthesizeDefaultRootConfig
 });
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
-import { readFile as readFile2 } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
 function findRootConfig(repoRoot) {
   for (const rel of ROOT_PATH_CANDIDATES) {
-    const abs = resolve5(repoRoot, rel);
-    if (existsSync5(abs)) return { path: abs, relative: rel, format: rel.endsWith(".jsonc") ? "jsonc" : "json" };
+    const abs = resolve6(repoRoot, rel);
+    if (existsSync6(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 resolve5(repoRoot, ROOT_PATH_CANDIDATES[0]);
+  return resolve6(repoRoot, ROOT_PATH_CANDIDATES[0]);
 }
 function readRootConfig(absPath) {
-  if (!existsSync5(absPath)) {
+  if (!existsSync6(absPath)) {
     return { ok: false, error: { kind: "missing", path: absPath } };
   }
   const raw = readFileSync3(absPath, "utf8");
@@ -952,15 +1130,15 @@ function stripJsonc(text) {
   let stripped = "";
   let i = 0;
   let inString = false;
-  let escape = false;
+  let escape2 = false;
   while (i < text.length) {
     const ch = text[i];
     if (inString) {
       stripped += ch;
-      if (escape) {
-        escape = false;
+      if (escape2) {
+        escape2 = false;
       } else if (ch === "\\") {
-        escape = true;
+        escape2 = true;
       } else if (ch === '"') {
         inString = false;
       }
@@ -1011,6 +1189,7 @@ function applyOwnedPointers(rootDoc, { pointerEntries = POINTER_ENTRIES, allowEq
       desired: entry.value
     });
   }
+  result.doc = doc;
   return result;
 }
 function applyPlanModeOwnership(rootDoc, { pointer = PLAN_MODE_POINTER, block = planModePermissions().build } = {}) {
@@ -1025,20 +1204,11 @@ function synthesizeDefaultRootConfig() {
   return {
     $schema: "https://opencode.ai/config.json",
     agent: {
-      build: {
+      plan: {
         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"
+          edit: {
+            [PLAN_EDIT_GLOB]: "allow",
+            [PLAN_EDIT_PLANS_GLOB]: "allow"
           }
         }
       }
@@ -1306,114 +1476,6 @@ var init_root_config = __esm({
   }
 });
 
-// src/installer/lock.js
-import { readFile as readFile4, writeFile as writeFile2, rename as rename2, mkdir as mkdir2 } from "node:fs/promises";
-import { existsSync as existsSync8 } from "node:fs";
-import { dirname as dirname4, resolve as resolve6 } from "node:path";
-function lockPath(repoRoot) {
-  return resolve6(repoRoot, ".opencode", "ship.lock.json");
-}
-function computeIntegrity(lock) {
-  const { integrity: _ignored, ...without } = lock ?? {};
-  void _ignored;
-  return {
-    lockSha256: bytesHashString(stableStringify(without))
-  };
-}
-function normalizeLegacyLock(lock) {
-  if (!lock || typeof lock !== "object") return lock;
-  const { cleanupPending: _drop, ...rest } = lock;
-  void _drop;
-  return rest;
-}
-function validateLock(rawLock) {
-  if (rawLock === null || rawLock === void 0) {
-    return { ok: true, kind: "missing", issues: [] };
-  }
-  if (typeof rawLock !== "object" || Array.isArray(rawLock)) {
-    return { ok: false, kind: "shape", issues: ["lock root must be an object"] };
-  }
-  const issues = [];
-  let kind = "ok";
-  if (rawLock.contractVersion !== CURRENT_LOCK_SCHEMA && rawLock.contractVersion !== 3 && rawLock.contractVersion !== 2 && rawLock.contractVersion !== 1) {
-    issues.push(`unsupported contractVersion: ${JSON.stringify(rawLock.contractVersion)} (expected ${CURRENT_LOCK_SCHEMA}, 3, 2, or 1)`);
-    kind = "schema";
-  }
-  const manager = rawLock.manager;
-  if (manager === void 0) {
-    issues.push("manager section missing");
-    kind = kind === "ok" ? "shape" : kind;
-  } else if (typeof manager !== "object" || manager === null) {
-    issues.push("manager section must be an object");
-    kind = kind === "ok" ? "shape" : kind;
-  } else if (manager.schemaVersion !== CURRENT_LOCK_SCHEMA && manager.schemaVersion !== 3 && manager.schemaVersion !== 2 && manager.schemaVersion !== 1) {
-    issues.push(`unsupported manager.schemaVersion: ${JSON.stringify(manager.schemaVersion)} (expected ${CURRENT_LOCK_SCHEMA}, 3, 2, or 1)`);
-    kind = "schema";
-  } else if (manager.name !== "opencode-ship") {
-    issues.push(`unknown manager.name: ${JSON.stringify(manager.name)}`);
-    kind = "shape";
-  } else if (rawLock.contractVersion >= 2 && manager.schemaVersion >= 2 && manager.profile !== void 0 && manager.profile !== "core" && manager.profile !== "engineering") {
-    issues.push(`invalid manager.profile: ${JSON.stringify(manager.profile)} (expected one of: engineering, core [legacy])`);
-    kind = "shape";
-  }
-  if (!rawLock.files || !Array.isArray(rawLock.files)) {
-    issues.push("files must be an array");
-    kind = kind === "ok" ? "shape" : kind;
-  }
-  if (!rawLock.integrity || typeof rawLock.integrity !== "object") {
-    issues.push("integrity section missing");
-    kind = kind === "ok" ? "shape" : kind;
-  } else {
-    const expected = computeIntegrity(rawLock).lockSha256;
-    if (expected !== rawLock.integrity.lockSha256) {
-      issues.push(`integrity mismatch: stored ${rawLock.integrity.lockSha256} != computed ${expected}`);
-      kind = "integrity";
-    }
-  }
-  return { ok: issues.length === 0, kind, issues };
-}
-async function readValidatedLock(repoRoot) {
-  const path = lockPath(repoRoot);
-  if (!existsSync8(path)) {
-    return { kind: "missing", lock: null, issues: [] };
-  }
-  let raw;
-  try {
-    const text = await readFile4(path, "utf8");
-    raw = JSON.parse(text);
-  } catch (e) {
-    return {
-      kind: "integrity",
-      lock: null,
-      issues: [`unable to parse lock JSON: ${e?.message ?? String(e)}`]
-    };
-  }
-  const validation = validateLock(raw);
-  if (validation.ok) {
-    return {
-      kind: validation.kind,
-      lock: normalizeLegacyLock(raw),
-      issues: []
-    };
-  }
-  return { kind: validation.kind, lock: null, issues: validation.issues };
-}
-function isSetupComplete(lock) {
-  if (!lock || typeof lock !== "object") return false;
-  const manager = lock.manager;
-  if (!manager || typeof manager !== "object") return false;
-  return manager.setupComplete === true;
-}
-var CURRENT_LOCK_SCHEMA;
-var init_lock = __esm({
-  "src/installer/lock.js"() {
-    init_hash();
-    init_json_pointer();
-    init_profile();
-    CURRENT_LOCK_SCHEMA = 4;
-  }
-});
-
 // src/installer/agent-renderer.js
 var agent_renderer_exports = {};
 __export(agent_renderer_exports, {
@@ -1482,37 +1544,6 @@ var init_agent_renderer = __esm({
   }
 });
 
-// src/installer/setup-pending.js
-import { existsSync as existsSync14, readFileSync as readFileSync5, unlinkSync, writeFile as writeFile7, mkdir as mkdirAsync } from "node:fs";
-import { promisify } from "node:util";
-import { resolve as resolve13, dirname as dirname9 } from "node:path";
-function setupPendingPath(repoRoot) {
-  return resolve13(repoRoot, REL_PATH);
-}
-async function writeSetupPending(repoRoot, payload) {
-  const path = setupPendingPath(repoRoot);
-  await mkdirAsyncAsync(dirname9(path), { recursive: true });
-  await writeFileAsync(path, JSON.stringify(payload, null, 2) + "\n", "utf8");
-}
-function clearSetupPending(repoRoot) {
-  const path = setupPendingPath(repoRoot);
-  if (!existsSync14(path)) return false;
-  try {
-    unlinkSync(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var writeFileAsync, mkdirAsyncAsync, REL_PATH;
-var init_setup_pending = __esm({
-  "src/installer/setup-pending.js"() {
-    writeFileAsync = promisify(writeFile7);
-    mkdirAsyncAsync = promisify(mkdirAsync);
-    REL_PATH = ".opencode/ship.setup-pending.json";
-  }
-});
-
 // src/installer/setup-state.js
 var setup_state_exports = {};
 __export(setup_state_exports, {
@@ -1521,9 +1552,9 @@ __export(setup_state_exports, {
   modelsComplete: () => modelsComplete,
   setupComplete: () => setupComplete
 });
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { readFile as readFile10 } from "node:fs/promises";
-import { resolve as resolve14, dirname as dirname10 } from "node:path";
+import { resolve as resolve13 } from "node:path";
 function modelsComplete(repoRoot, configValue) {
   if (configValue === void 0) return false;
   return hasCompletedModels(configValue);
@@ -1531,12 +1562,12 @@ function modelsComplete(repoRoot, configValue) {
 async function setupComplete(repoRoot, configValue) {
   const missing = [];
   for (const rel of REQUIRED_DOCS) {
-    const path = resolve14(repoRoot, rel);
-    if (!existsSync15(path)) missing.push(rel);
+    const path = resolve13(repoRoot, rel);
+    if (!existsSync14(path)) missing.push(rel);
   }
-  const agentsPath = resolve14(repoRoot, "AGENTS.md");
+  const agentsPath = resolve13(repoRoot, "AGENTS.md");
   let agentsOk = false;
-  if (existsSync15(agentsPath)) {
+  if (existsSync14(agentsPath)) {
     try {
       const raw = await readFile10(agentsPath, "utf8");
       agentsOk = /##\s+Ship workflow\b/.test(raw);
@@ -1549,9 +1580,7 @@ async function setupComplete(repoRoot, configValue) {
   }
   const lockResult = await readValidatedLock(repoRoot);
   const cfgOk = modelsComplete(repoRoot, configValue);
-  const markerPath = setupPendingPath(repoRoot);
-  if (existsSync15(markerPath)) missing.push("setup-pending marker");
-  const lockOk = lockResult.kind === "ok" || lockResult.kind === "missing";
+  const lockOk = lockResult.kind === "ok" && lockResult.lock?.contractVersion === CURRENT_LOCK_SCHEMA && lockResult.lock?.manager?.schemaVersion === CURRENT_LOCK_SCHEMA;
   const ok = cfgOk && lockOk && missing.length === 0;
   return {
     ok,
@@ -1564,7 +1593,6 @@ var init_setup_state = __esm({
   "src/installer/setup-state.js"() {
     init_config();
     init_lock();
-    init_setup_pending();
     REQUIRED_DOCS = [
       "docs/agents/issue-tracker.md",
       "docs/agents/domain.md",
@@ -1577,161 +1605,1827 @@ var init_setup_state = __esm({
       markerPath: SETUP_PENDING_REL_PATH
     });
   }
-});
-
-// src/installer/cli-args.js
-init_profile();
-var USAGE = `opencode-ship <command> [options]
-
-Commands:
-  init             Install managed files in this project. One-liner: pnpm dlx opencode-ship@latest init
-  diff             Show what would change without writing.
-  update           Apply pending updates after recovering the journal.
-  doctor           Validate environment, lock, and references.
-  setup-complete   Sole writer of lock.manager.setupComplete = true. Validates models + docs + AGENTS.md.
-  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).
-  --profile engineering       Override active profile (engineering 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.
-  --planner-model <id>        Strong planner model id (init only, optional).
-  --builder-model <id>        Cheap builder model id (init only, optional).
-  --final-reviewer-model <id> Final Standards + Spec reviewer model id (init only, optional).
-  --json                      Emit a JSON envelope instead of human output.
+});
+
+// src/installer/cli-args.js
+init_profile();
+var USAGE = `opencode-ship <command> [options]
+
+Commands:
+  init             Install managed files in this project. One-liner: pnpm dlx opencode-ship@latest init
+  diff             Show what would change without writing.
+  update           Apply pending updates after recovering the journal.
+  doctor           Validate environment, lock, and references.
+  setup-complete   Sole writer of lock.manager.setupComplete = true. Validates models + docs + AGENTS.md.
+  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).
+  --profile engineering       Override active profile (engineering 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.
+  --planner-model <id>        Strong planner model id (init only, optional).
+  --builder-model <id>        Cheap builder model id (init only, optional).
+  --final-reviewer-model <id> Final Standards + Spec reviewer model id (init only, optional).
+  --json                      Emit a JSON envelope instead of human output.
+
+After init succeeds, restart OpenCode and run /setup-ship-workflow.
+The setup skill calls 'opencode-ship setup-complete' at the end so
+the lock.manager.setupComplete flag flips to true and the ship
+controller can dispatch.
+`;
+var MODEL_ID_RE = /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
+function parseFlags(argv) {
+  const options = {
+    rootPath: null,
+    profile: null,
+    json: false,
+    replaceManaged: false,
+    purgeConfig: false,
+    forceConfig: false,
+    forceRootConfig: false,
+    strictDoctor: false,
+    plannerModel: null,
+    builderModel: null,
+    finalReviewerModel: null
+  };
+  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 === "--profile") {
+      const value = argv[++i];
+      if (value === void 0) {
+        return { error: "--profile requires a value" };
+      }
+      if (value === "core") {
+        return {
+          error: "the 'core' profile was removed in opencode-ship 1.1.0; only 'engineering' is supported. Run /setup-ship-workflow to migrate."
+        };
+      }
+      if (!isValidProfile(value)) {
+        return { error: `unknown profile '${value}' (expected one of: ${PROFILES.join(", ")})` };
+      }
+      options.profile = value;
+    } else if (arg === "--planner-model" || arg === "--builder-model" || arg === "--final-reviewer-model") {
+      const value = argv[++i];
+      if (value === void 0) return { error: `${arg} requires a value` };
+      if (!MODEL_ID_RE.test(value)) {
+        return { error: `${arg} must be a "<provider>/<model>" id, got ${JSON.stringify(value)}` };
+      }
+      if (arg === "--planner-model") options.plannerModel = value;
+      else if (arg === "--builder-model") options.builderModel = value;
+      else options.finalReviewerModel = value;
+    } 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 "setup-complete":
+    case "uninstall":
+      return { command: cmd, options: flags };
+    default:
+      return { error: `unknown command ${cmd}` };
+  }
+}
+function helpText() {
+  return USAGE;
+}
+
+// src/installer/commands/init.js
+import { promisify as promisify2 } from "node:util";
+import { writeFile as writeFile8, mkdir as mkdirAsync2 } from "node:fs/promises";
+import { dirname as dirname10, resolve as resolvePath } from "node:path";
+
+// src/installer/executor.js
+init_catalog();
+init_version();
+import { existsSync as existsSync13 } from "node:fs";
+import { mkdir as mkdir6, readFile as readFile9, rename as rename5, unlink as unlink3, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname8, resolve as resolve12 } from "node:path";
+
+// src/installer/planner.js
+init_catalog();
+init_hash();
+init_config();
+init_lock();
+init_json_pointer();
+init_root_config();
+import { existsSync as existsSync8 } from "node:fs";
+import { readFile as readFile4, stat } from "node:fs/promises";
+
+// src/installer/root-reconciliation.js
+init_root_config();
+init_json_pointer();
+init_hash();
+init_plan_mode_permissions();
+import { existsSync as existsSync7 } from "node:fs";
+import { join } from "node:path";
+
+// src/installer/root-permissions.js
+init_json_pointer();
+init_plan_mode_permissions();
+var ASK = "ask";
+var ALLOW = "allow";
+var DENY = "deny";
+var SUBAGENT_DEPTH = 2;
+var CONTROLLER_TASK_ALLOW = [
+  "ship-planner",
+  "ship-task-builder",
+  "ship-task-reviewer",
+  "ship-final-standards-reviewer",
+  "ship-final-spec-reviewer",
+  "delivery-verifier"
+];
+var PUBLIC_TOOL_IDS = [
+  "delivery_cleanup",
+  "delivery_github_read",
+  "delivery_inspect",
+  "delivery_issue",
+  "delivery_issue_close",
+  "delivery_issue_comment",
+  "delivery_issue_labels",
+  "delivery_issue_link",
+  "delivery_merge",
+  "delivery_pr",
+  "delivery_publish",
+  "delivery_ready",
+  "delivery_review",
+  "delivery_sync",
+  "delivery_verify",
+  "delivery_worktree",
+  "ship_final_review",
+  "ship_plan_approve",
+  "ship_plan_start",
+  "ship_plan_submit",
+  "ship_resume",
+  "ship_run_start",
+  "ship_skill_audit",
+  "ship_skill_discover",
+  "ship_skill_install",
+  "ship_skill_uninstall",
+  "ship_status",
+  "ship_task_commit",
+  "ship_task_complete",
+  "ship_task_report",
+  "ship_task_review",
+  "ship_task_start"
+];
+var BUILD_TOOL_ALLOW = [
+  "delivery_cleanup",
+  "delivery_inspect",
+  "delivery_issue",
+  "delivery_pr",
+  "delivery_ready",
+  "delivery_worktree",
+  "ship_status",
+  "ship_resume"
+];
+var BUILD_TOOL_ASK = [
+  "ship_plan_approve",
+  "delivery_merge",
+  "delivery_issue_close",
+  "ship_skill_install"
+];
+var CONTROLLER_TOOL_ALLOW = [
+  "delivery_inspect",
+  "delivery_cleanup",
+  "delivery_github_read",
+  "delivery_issue",
+  "delivery_issue_comment",
+  "delivery_issue_labels",
+  "delivery_issue_link",
+  "delivery_worktree",
+  "delivery_pr",
+  "delivery_ready",
+  "delivery_publish",
+  "delivery_sync",
+  "ship_plan_start",
+  "ship_run_start",
+  "ship_task_start",
+  "ship_task_commit",
+  "ship_task_complete",
+  "ship_resume",
+  "ship_status",
+  "ship_skill_discover",
+  "ship_skill_install",
+  "ship_skill_audit",
+  "ship_skill_uninstall"
+];
+var CONTROLLER_TOOL_ASK = [
+  "ship_plan_approve",
+  "delivery_merge",
+  "delivery_issue_close"
+];
+var H = "git";
+var RESET = "--hard";
+var PUSH = "--force";
+var PUSH_SHORT = "-f";
+var STASH = "stash";
+var WTRF = "--force";
+var BRDEL = "-D";
+var FORBIDDEN_BASH_GLOBS = [
+  `${H} ${RESET} *`,
+  `${H} ${PUSH} *`,
+  `${H} ${PUSH_SHORT} *`,
+  `git clean -fd *`,
+  `${H} ${STASH} *`,
+  `${H} worktree remove ${WTRF} *`,
+  `${H} branch ${BRDEL} *`
+];
+var FORBIDDEN_BASH_GLOBS_CONTROLLER = [
+  ...FORBIDDEN_BASH_GLOBS,
+  "rm -rf *",
+  "rm -rf /*"
+];
+function denyMap(globs) {
+  const out = { "*": "allow" };
+  for (const g of globs) out[g] = "deny";
+  return out;
+}
+function toolPermissionMap(allow, ask) {
+  const out = { "*": DENY };
+  for (const id of PUBLIC_TOOL_IDS) out[id] = DENY;
+  for (const id of allow) out[id] = ALLOW;
+  for (const id of ask) out[id] = ASK;
+  return out;
+}
+function rootPermissionMatrix() {
+  return {
+    subagentDepth: SUBAGENT_DEPTH,
+    build: {
+      permission: {
+        task: {
+          "*": "deny",
+          "ship-controller": "allow",
+          "general": "allow",
+          "plan": "deny",
+          "delivery-reviewer": "allow",
+          "delivery-verifier": "allow"
+        },
+        bash: {
+          ...denyMap(FORBIDDEN_BASH_GLOBS),
+          "rm *": "ask"
+        }
+      },
+      tools: {
+        ...toolPermissionMap(BUILD_TOOL_ALLOW, BUILD_TOOL_ASK)
+      }
+    },
+    shipController: {
+      permission: {
+        task: {
+          "*": "deny",
+          ...Object.fromEntries(CONTROLLER_TASK_ALLOW.map((t) => [t, "allow"]))
+        },
+        bash: denyMap(FORBIDDEN_BASH_GLOBS_CONTROLLER)
+      },
+      tools: {
+        ...toolPermissionMap(CONTROLLER_TOOL_ALLOW, CONTROLLER_TOOL_ASK)
+      }
+    }
+  };
+}
+function matrixLeafPointers() {
+  const matrix = rootPermissionMatrix();
+  const out = [];
+  out.push({ pointer: "/subagent_depth", strategy: "value", value: matrix.subagentDepth, scope: "engineering" });
+  const agents = [
+    { name: "build", block: matrix.build },
+    { name: "ship-controller", block: matrix.shipController }
+  ];
+  for (const agent of agents) {
+    const perm = agent.block.permission;
+    for (const category of Object.keys(perm)) {
+      const map = perm[category];
+      for (const key of Object.keys(map)) {
+        const v = map[key];
+        if (v === void 0 || v === null) continue;
+        out.push({
+          pointer: pointerPath(["agent", agent.name, "permission", category, key]),
+          strategy: "value",
+          value: v,
+          scope: "engineering"
+        });
+      }
+    }
+    const tools = agent.block.tools;
+    if (tools && typeof tools === "object") {
+      for (const key of Object.keys(tools)) {
+        const v = tools[key];
+        if (v === void 0 || v === null) continue;
+        out.push({
+          pointer: pointerPath(["agent", agent.name, "permission", key]),
+          strategy: "value",
+          value: v,
+          scope: "engineering"
+        });
+      }
+    }
+  }
+  out.push({ pointer: PLAN_EDIT_GLOB_POINTER, strategy: "value", value: "allow", scope: "engineering" });
+  out.push({ pointer: PLAN_EDIT_PLANS_GLOB_POINTER, strategy: "value", value: "allow", scope: "engineering" });
+  return out;
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+var supportedEols = ["\n", "\r", "\r\n"];
+
+// node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "	";
+  }
+  const indentType = indentValue === "	" ? "	" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      ;
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      ;
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0; i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "	") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0; i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === "\n") {
+        return "\r\n";
+      }
+      return "\r";
+    } else if (ch === "\n") {
+      return "\n";
+    }
+  }
+  return options && options.eol || "\n";
+}
+function isEOL(text, offset) {
+  return "\r\n".indexOf(text.charAt(offset)) !== -1;
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: void 0 };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep2, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep2 === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep2 === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path) {
+  if (!root) {
+    return void 0;
+  }
+  let node = root;
+  for (let segment of path) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return void 0;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return void 0;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return void 0;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
 
-After init succeeds, restart OpenCode and run /setup-ship-workflow.
-The setup skill calls 'opencode-ship setup-complete' at the end so
-the lock.manager.setupComplete flag flips to true and the ship
-controller can dispatch.
-`;
-var MODEL_ID_RE = /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
-function parseFlags(argv) {
-  const options = {
-    rootPath: null,
-    profile: null,
-    json: false,
-    replaceManaged: false,
-    purgeConfig: false,
-    forceConfig: false,
-    forceRootConfig: false,
-    strictDoctor: false,
-    plannerModel: null,
-    builderModel: null,
-    finalReviewerModel: null
-  };
-  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 === "--profile") {
-      const value = argv[++i];
+// node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path = originalPath.slice();
+  const errors = [];
+  const root = parseTree(text, errors);
+  let parent = void 0;
+  let lastSegment = void 0;
+  while (path.length > 0) {
+    lastSegment = path.pop();
+    parent = findNodeAtLocation(root, path);
+    if (parent === void 0 && value !== void 0) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === void 0) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== void 0) {
       if (value === void 0) {
-        return { error: "--profile requires a value" };
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
       }
-      if (value === "core") {
-        return {
-          error: "the 'core' profile was removed in opencode-ship 1.1.0; only 'engineering' is supported. Run /setup-ship-workflow to migrate."
-        };
+    } else {
+      if (value === void 0) {
+        return [];
       }
-      if (!isValidProfile(value)) {
-        return { error: `unknown profile '${value}' (expected one of: ${PROFILES.join(", ")})` };
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
       }
-      options.profile = value;
-    } else if (arg === "--planner-model" || arg === "--builder-model" || arg === "--final-reviewer-model") {
-      const value = argv[++i];
-      if (value === void 0) return { error: `${arg} requires a value` };
-      if (!MODEL_ID_RE.test(value)) {
-        return { error: `${arg} must be a "<provider>/<model>" id, got ${JSON.stringify(value)}` };
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
       }
-      if (arg === "--planner-model") options.plannerModel = value;
-      else if (arg === "--builder-model") options.builderModel = value;
-      else options.finalReviewerModel = value;
-    } 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 withFormatting(text, edit, options);
+    } else if (value === void 0 && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== void 0) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === void 0 ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
   }
-  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" };
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
   }
-  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 "setup-complete":
-    case "uninstall":
-      return { command: cmd, options: flags };
-    default:
-      return { error: `unknown command ${cmd}` };
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
   }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1; i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
 }
-function helpText() {
-  return USAGE;
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
 }
 
-// src/installer/commands/init.js
-import { promisify as promisify2 } from "node:util";
-import { writeFile as writeFile8, mkdir as mkdirAsync2 } from "node:fs/promises";
-import { dirname as dirname11, resolve as resolvePath } from "node:path";
-
-// src/installer/executor.js
-init_catalog();
-init_version();
-import { existsSync as existsSync13 } from "node:fs";
-import { mkdir as mkdir6, readFile as readFile9, rename as rename5, unlink as unlink3, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname8, resolve as resolve12 } from "node:path";
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function modify(text, path, value, options) {
+  return setProperty(text, path, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1; i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
 
-// src/installer/planner.js
-init_catalog();
-init_hash();
-init_config();
-init_json_pointer();
-init_root_config();
-import { existsSync as existsSync7 } from "node:fs";
-import { readFile as readFile3, stat } from "node:fs/promises";
+// src/installer/jsonc-edit.js
+var JsoncEditError = class extends Error {
+  constructor(message, path) {
+    super(`${message} (path=${path ?? "<root>"})`);
+    this.name = "JsoncEditError";
+    this.path = path ?? null;
+  }
+};
+function pointerToPath(pointer) {
+  if (typeof pointer !== "string" || pointer.length === 0) return [];
+  return pointer.split("/").slice(1).map(decodePointerToken);
+}
+function decodePointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function applyJsoncEdits(source, edits) {
+  if (typeof source !== "string") {
+    throw new JsoncEditError("source must be a string", null);
+  }
+  if (!Array.isArray(edits)) {
+    throw new JsoncEditError("edits must be an array", null);
+  }
+  if (edits.length === 0) {
+    return Buffer.from(source, "utf8");
+  }
+  const sorted = [...edits].sort((a, b) => {
+    const da = a.pointer.split("/").length;
+    const db = b.pointer.split("/").length;
+    return da - db;
+  });
+  let working = source;
+  for (const edit of sorted) {
+    if (!edit || typeof edit.pointer !== "string" || !edit.pointer.startsWith("/")) {
+      throw new JsoncEditError(`invalid pointer ${JSON.stringify(edit?.pointer)}`, edit?.pointer ?? null);
+    }
+    if (edit.op !== "set" && edit.op !== "delete") {
+      throw new JsoncEditError(`invalid op ${edit.op}`, edit.pointer);
+    }
+    const path = pointerToPath(edit.pointer);
+    const value = edit.op === "delete" ? void 0 : edit.value;
+    let editOps;
+    try {
+      editOps = modify(working, path, value, {});
+    } catch (err) {
+      throw new JsoncEditError(`modify failed at ${edit.pointer}: ${err?.message ?? err}`, edit.pointer);
+    }
+    working = applyEdits(working, editOps);
+  }
+  const errors = [];
+  parse2(working, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    throw new JsoncEditError(`result is not valid JSON: ${errors[0]?.error ?? errors[0]}`, null);
+  }
+  return Buffer.from(working, "utf8");
+}
+function diffPointers(before, after, pointers) {
+  const edits = [];
+  for (const pointer of pointers) {
+    const prev = readPointer(before, pointer);
+    const next = readPointer(after, pointer);
+    if (next === void 0) {
+      edits.push({ pointer, op: (
+        /** @type {"delete"} */
+        "delete"
+      ) });
+    } else if (prev === void 0 || !stableJsonEqual(prev, next)) {
+      edits.push({ pointer, value: next, op: (
+        /** @type {"set"} */
+        "set"
+      ) });
+    }
+  }
+  return edits;
+}
+function readPointer(doc, pointer) {
+  if (!doc || typeof doc !== "object") return void 0;
+  const tokens = pointer.split("/").slice(1).map(decodePointerToken);
+  let cursor = doc;
+  for (const tok of tokens) {
+    if (cursor === null || cursor === void 0) return void 0;
+    cursor = cursor[tok];
+  }
+  return cursor === void 0 ? void 0 : cursor;
+}
+function stableJsonEqual(a, b) {
+  return canonicalize(a) === canonicalize(b);
+}
+function canonicalize(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
+  const out = {};
+  const keys = Object.keys(value).sort();
+  for (const k of keys) out[k] = canonicalize(value[k]);
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${out[k]}`).join(",")}}`;
+}
 
 // src/installer/root-reconciliation.js
-init_root_config();
-init_json_pointer();
-init_hash();
-init_plan_mode_permissions();
-import { existsSync as existsSync6 } from "node:fs";
-import { join } from "node:path";
 function desiredPointersForProfile(profile) {
-  return POINTER_ENTRIES.map((entry) => ({
-    pointer: entry.pointer,
-    strategy: (
-      /** @type {"value" | "object-entry" | "array-member"} */
-      entry.strategy
-    ),
-    scope: (
-      /** @type {Profile} */
-      "engineering"
-    ),
-    value: entry.value
-  }));
+  return matrixLeafPointers();
 }
 async function planRootReconciliation(input) {
   const profile = input.profile;
@@ -1754,7 +3448,7 @@ async function planRootReconciliation(input) {
       previousDocument: input.previousDocument
     });
   }
-  const fileMissing = !existsSync6(target);
+  const fileMissing = !existsSync7(target);
   if (fileMissing && !input.forceRepair) {
     if (mode === "profile-transition") {
       return {
@@ -1780,6 +3474,9 @@ async function planRootReconciliation(input) {
   let doc;
   if (fileMissing && input.forceRepair) {
     doc = synthesizeDefaultRootConfig();
+    for (const descriptor of descriptors) {
+      doc = setPointer(doc, descriptor.pointer, descriptor.value);
+    }
     const bytes = Buffer.from(formatRootConfig(doc), "utf8");
     return {
       kind: "create",
@@ -1842,7 +3539,22 @@ function reconcileRecordsAfterTransition(descriptors, previousRecords) {
   return out;
 }
 function planInstallRoot({ doc, target, relPath, descriptors, previousRecords }) {
-  const result = applyOwnedPointers(doc.value, {
+  const promotion = promotePlanEditIfString(doc.value);
+  if (promotion.record && promotion.record.conflict) {
+    return {
+      kind: "conflict",
+      op: "root-config",
+      target,
+      relPath,
+      reason: `consumer-owned Plan edit glob is set to deny: ${promotion.record.pointer}`,
+      edits: [{ kind: "conflict", pointer: promotion.record.pointer, reason: "consumer-denied" }],
+      pointerRecords: previousRecords,
+      format: doc.format,
+      document: doc.value
+    };
+  }
+  const sourceDoc = promotion.doc;
+  const result = applyOwnedPointers(sourceDoc, {
     pointerEntries: descriptors.map((d) => ({ pointer: d.pointer, strategy: d.strategy, value: d.value })),
     allowEqualValues: true
   });
@@ -1852,21 +3564,65 @@ function planInstallRoot({ doc, target, relPath, descriptors, previousRecords })
     if (s.reason === "already equal") continue;
     edits.push({ kind: "conflict", pointer: s.pointer, reason: s.reason, existing: s.existing, desired: s.desired });
   }
+  const reorderPointers = equalExceptionsBeforeNewWildcard(sourceDoc, descriptors);
   let docForWrite = result.doc;
+  for (const descriptor of reorderPointers) {
+    docForWrite = setPointer(removePointer(docForWrite, descriptor.pointer), descriptor.pointer, descriptor.value);
+  }
   let bytes;
   try {
-    const { value: sourceValue } = parseRootConfigPreservingOrder(doc.raw ?? "");
-    if (sourceValue && typeof sourceValue === "object") {
-      docForWrite = sourceValue;
-      for (const a of result.applied) {
-        docForWrite = setPointer(docForWrite, a.pointer, a.value);
+    const isJsonc = doc.format === "jsonc";
+    if (isJsonc) {
+      const pointerEdits = diffPointers(
+        doc.value,
+        docForWrite,
+        result.applied.map((a) => a.pointer)
+      );
+      for (const descriptor of reorderPointers) {
+        pointerEdits.push({ pointer: descriptor.pointer, op: "delete" });
+        pointerEdits.push({ pointer: descriptor.pointer, value: descriptor.value, op: "set" });
+      }
+      if (promotion.record) {
+        pointerEdits.push({ pointer: promotion.record.pointer, op: (
+          /** @type {"delete"} */
+          "delete"
+        ) });
+        pointerEdits.push({ pointer: promotion.record.pointer, value: promotion.record.previous.value, op: (
+          /** @type {"set"} */
+          "set"
+        ) });
+      }
+      bytes = applyJsoncEdits(doc.raw ?? "", pointerEdits);
+    } else {
+      const { value: sourceValue } = parseRootConfigPreservingOrder(doc.raw ?? "");
+      if (sourceValue && typeof sourceValue === "object") {
+        docForWrite = sourceValue;
+        if (promotion.record) {
+          docForWrite = setPointer(docForWrite, promotion.record.pointer, { "*": promotion.record.previous.value });
+        }
+        for (const a of result.applied) {
+          docForWrite = setPointer(docForWrite, a.pointer, a.value);
+        }
+        for (const descriptor of reorderPointers) {
+          docForWrite = setPointer(removePointer(docForWrite, descriptor.pointer), descriptor.pointer, descriptor.value);
+        }
       }
+      bytes = Buffer.from(formatRootConfigPreserving(docForWrite), "utf8");
     }
-    bytes = Buffer.from(formatRootConfigPreserving(docForWrite), "utf8");
   } catch {
     bytes = Buffer.from(formatRootConfig(result.doc), "utf8");
   }
   const records = mergePointerRecords(descriptors, previousRecords, result, doc.before);
+  if (promotion.record) {
+    records.push({
+      pointer: promotion.record.pointer,
+      strategy: "value",
+      scope: "engineering",
+      installedSha256: null,
+      previous: promotion.record.previous,
+      promotion: true
+    });
+  }
   return {
     kind: edits.some((e) => e.kind === "conflict") ? "conflict" : edits.length ? "update" : "noop",
     op: "root-config",
@@ -1882,8 +3638,36 @@ function planInstallRoot({ doc, target, relPath, descriptors, previousRecords })
     reason: edits.length === 0 ? "no installer-owned entries missing" : `apply ${result.applied.length} / skip ${result.skipped.length}`
   };
 }
+function equalExceptionsBeforeNewWildcard(doc, descriptors) {
+  const wildcardParents = /* @__PURE__ */ new Set();
+  for (const descriptor of descriptors) {
+    if (!descriptor.pointer.endsWith("/*") || getPointer(doc, descriptor.pointer) !== void 0) continue;
+    wildcardParents.add(descriptor.pointer.slice(0, descriptor.pointer.lastIndexOf("/")));
+  }
+  return descriptors.filter((descriptor) => {
+    if (descriptor.pointer.endsWith("/*")) return false;
+    const parent = descriptor.pointer.slice(0, descriptor.pointer.lastIndexOf("/"));
+    if (!wildcardParents.has(parent)) return false;
+    const existing = getPointer(doc, descriptor.pointer);
+    return existing !== void 0 && stableStringify(existing) === stableStringify(descriptor.value);
+  });
+}
 function planProfileTransitionRoot({ doc, target, relPath, descriptors, previousRecords }) {
   const desired = descriptors;
+  const promotion = promotePlanEditIfString(doc.value);
+  if (promotion.record && promotion.record.conflict) {
+    return {
+      kind: "conflict",
+      op: "root-config",
+      target,
+      relPath,
+      reason: `consumer-owned Plan edit glob is set to deny: ${promotion.record.pointer}`,
+      edits: [{ kind: "conflict", pointer: promotion.record.pointer, reason: "consumer-denied" }],
+      pointerRecords: previousRecords,
+      format: doc.format,
+      document: doc.value
+    };
+  }
   const drift = [];
   for (const rec of previousRecords) {
     const stillDesired = desired.some((d) => d.pointer === rec.pointer && d.scope === rec.scope);
@@ -1909,7 +3693,7 @@ function planProfileTransitionRoot({ doc, target, relPath, descriptors, previous
       pointerRecords: previousRecords
     };
   }
-  let next = JSON.parse(JSON.stringify(doc.value));
+  let next = JSON.parse(JSON.stringify(promotion.doc));
   const edits = [];
   const mergedRecords = previousRecords.map((r) => ({ ...r }));
   const recordIndex = new Map(mergedRecords.map((r, idx) => [r.pointer, idx]));
@@ -1983,22 +3767,68 @@ function planProfileTransitionRoot({ doc, target, relPath, descriptors, previous
   let docForWrite = next;
   let bytes;
   try {
-    const { value: sourceValue } = parseRootConfigPreservingOrder(doc.raw ?? "");
-    if (sourceValue && typeof sourceValue === "object") {
-      docForWrite = sourceValue;
+    const isJsonc = doc.format === "jsonc";
+    if (isJsonc) {
+      const pointerEdits = [];
       for (const e of edits) {
         if (e.kind === "create" || e.kind === "restore") {
-          docForWrite = setPointer(docForWrite, e.pointer, e.value);
+          pointerEdits.push({ pointer: e.pointer, value: e.value, op: (
+            /** @type {"set"} */
+            "set"
+          ) });
         } else if (e.kind === "remove") {
-          docForWrite = removePointer(docForWrite, e.pointer);
+          pointerEdits.push({ pointer: e.pointer, op: (
+            /** @type {"delete"} */
+            "delete"
+          ) });
+        }
+      }
+      if (promotion.record) {
+        pointerEdits.push({ pointer: promotion.record.pointer, op: (
+          /** @type {"delete"} */
+          "delete"
+        ) });
+        pointerEdits.push({ pointer: promotion.record.pointer, value: promotion.record.previous.value, op: (
+          /** @type {"set"} */
+          "set"
+        ) });
+      }
+      bytes = applyJsoncEdits(doc.raw ?? "", pointerEdits);
+      const reparsed = parse2(bytes.toString("utf8"), void 0, { allowTrailingComma: true });
+      docForWrite = collapseEmptyAncestors(reparsed) ?? reparsed;
+    } else {
+      const { value: sourceValue } = parseRootConfigPreservingOrder(doc.raw ?? "");
+      if (sourceValue && typeof sourceValue === "object") {
+        docForWrite = sourceValue;
+        if (promotion.record) {
+          docForWrite = setPointer(docForWrite, promotion.record.pointer, { "*": promotion.record.previous.value });
+        }
+        for (const e of edits) {
+          if (e.kind === "create" || e.kind === "restore") {
+            docForWrite = setPointer(docForWrite, e.pointer, e.value);
+          } else if (e.kind === "remove") {
+            docForWrite = removePointer(docForWrite, e.pointer);
+          }
         }
       }
+      docForWrite = collapseEmptyAncestors(docForWrite) ?? docForWrite;
+      bytes = Buffer.from(formatRootConfigPreserving(docForWrite), "utf8");
     }
-    docForWrite = collapseEmptyAncestors(docForWrite) ?? docForWrite;
-    bytes = Buffer.from(formatRootConfigPreserving(docForWrite), "utf8");
   } catch {
     bytes = Buffer.from(formatRootConfig(collapseEmptyAncestors(next) ?? next), "utf8");
   }
+  if (promotion.record) {
+    if (!recordIndex.has(promotion.record.pointer)) {
+      mergedRecords.push({
+        pointer: promotion.record.pointer,
+        strategy: "value",
+        scope: "engineering",
+        installedSha256: null,
+        previous: promotion.record.previous,
+        promotion: true
+      });
+    }
+  }
   return {
     kind: edits.some((e) => e.kind === "conflict") ? "conflict" : edits.some((e) => e.kind === "create" || e.kind === "remove" || e.kind === "restore") ? "update" : "noop",
     op: "root-config",
@@ -2061,7 +3891,10 @@ function planUninstallRoot({ target, relPath, previousRecords, previousDocument
   }
   let doc = docResult.value;
   const edits = [];
-  for (const rec of previousRecords) {
+  const sortedRecords = [...previousRecords].sort((a, b) => {
+    return b.pointer.split("/").length - a.pointer.split("/").length;
+  });
+  for (const rec of sortedRecords) {
     if (rec.previous && rec.previous.existed) {
       doc = setPointer(doc, rec.pointer, rec.previous.value);
       edits.push({ kind: "restore", pointer: rec.pointer, value: rec.previous.value });
@@ -2076,19 +3909,56 @@ function planUninstallRoot({ target, relPath, previousRecords, previousDocument
   let docForWrite = doc;
   let bytes;
   try {
-    const { value: sourceValue } = parseRootConfigPreservingOrder(docResult.raw ?? "");
-    if (sourceValue && typeof sourceValue === "object") {
-      docForWrite = sourceValue;
+    const isJsonc = docResult.format === "jsonc";
+    if (isJsonc) {
+      const collapsed = collapseEmptyAncestors(doc) ?? doc;
+      const prunePointers = /* @__PURE__ */ new Set();
+      for (const e of edits) {
+        if (e.kind !== "remove") continue;
+        const tokens = e.pointer.split("/").slice(1);
+        for (let i = tokens.length - 1; i > 0; i--) {
+          const ancestor = `/${tokens.slice(0, i).join("/")}`;
+          if (getPointer(collapsed, ancestor) === void 0) prunePointers.add(ancestor);
+        }
+      }
+      const topPrunes = [...prunePointers].sort((a, b) => a.length - b.length).filter((pointer, index, all) => !all.slice(0, index).some((parent) => pointer.startsWith(`${parent}/`)));
+      const pointerEdits = [];
       for (const e of edits) {
         if (e.kind === "restore") {
-          docForWrite = setPointer(docForWrite, e.pointer, e.value);
-        } else if (e.kind === "remove") {
-          docForWrite = removePointer(docForWrite, e.pointer);
+          pointerEdits.push({ pointer: e.pointer, value: e.value, op: (
+            /** @type {"set"} */
+            "set"
+          ) });
+        } else if (e.kind === "remove" && !topPrunes.some((parent) => e.pointer === parent || e.pointer.startsWith(`${parent}/`))) {
+          pointerEdits.push({ pointer: e.pointer, op: (
+            /** @type {"delete"} */
+            "delete"
+          ) });
+        }
+      }
+      for (const pointer of topPrunes) {
+        pointerEdits.push({ pointer, op: (
+          /** @type {"delete"} */
+          "delete"
+        ) });
+      }
+      bytes = applyJsoncEdits(docResult.raw ?? "", pointerEdits);
+      docForWrite = parse2(bytes.toString("utf8"), void 0, { allowTrailingComma: true });
+    } else {
+      const { value: sourceValue } = parseRootConfigPreservingOrder(docResult.raw ?? "");
+      if (sourceValue && typeof sourceValue === "object") {
+        docForWrite = sourceValue;
+        for (const e of edits) {
+          if (e.kind === "restore") {
+            docForWrite = setPointer(docForWrite, e.pointer, e.value);
+          } else if (e.kind === "remove") {
+            docForWrite = removePointer(docForWrite, e.pointer);
+          }
         }
       }
+      docForWrite = collapseEmptyAncestors(docForWrite) ?? docForWrite;
+      bytes = Buffer.from(formatRootConfigPreserving(docForWrite), "utf8");
     }
-    docForWrite = collapseEmptyAncestors(docForWrite);
-    bytes = Buffer.from(formatRootConfigPreserving(docForWrite), "utf8");
   } catch {
     bytes = Buffer.from(formatRootConfig(collapseEmptyAncestors(doc)), "utf8");
   }
@@ -2112,7 +3982,9 @@ function collapseEmptyAncestors(doc) {
   const out = {};
   for (const k of Object.keys(doc)) {
     if (k === "__sourceOrder__") continue;
-    out[k] = collapseEmptyAncestors(doc[k]);
+    const collapsed = collapseEmptyAncestors(doc[k]);
+    if (collapsed === void 0) continue;
+    out[k] = collapsed;
   }
   if (Array.isArray(doc.__sourceOrder__)) {
     out.__sourceOrder__ = doc.__sourceOrder__.filter((k) => k in out);
@@ -2165,6 +4037,7 @@ function mergePointerRecords(descriptors, previousRecords, result, beforeSnapsho
       };
     } else {
       out.push(next);
+      index.set(a.pointer, out.length - 1);
     }
   }
   for (const s of result.skipped) {
@@ -2179,20 +4052,21 @@ function mergePointerRecords(descriptors, previousRecords, result, beforeSnapsho
       installedSha256: bytesHashString(stableStringify(existing ?? null)),
       previous
     });
+    index.set(s.pointer, out.length - 1);
   }
   return out;
 }
 
 // src/installer/planner.js
 async function readBytes(path) {
-  if (!existsSync7(path)) return null;
-  const buf = await readFile3(path);
+  if (!existsSync8(path)) return null;
+  const buf = await readFile4(path);
   const fileStat = await stat(path);
   return { bytes: buf, hash: bytesHashString(buf.toString("utf8")), mode: fileStat.mode & 511 };
 }
 async function readDesiredBytes(source) {
-  if (!source || !existsSync7(source)) return null;
-  const buf = await readFile3(source);
+  if (!source || !existsSync8(source)) return null;
+  const buf = await readFile4(source);
   return { bytes: buf, hash: bytesHashString(buf.toString("utf8")) };
 }
 function lookupLockedFile(lock, targetPath) {
@@ -2332,6 +4206,16 @@ async function planUninstall({ repoRoot, lock }) {
   const plan = [];
   const activeProfile = lock?.manager?.profile ?? "core";
   for (const entry of lock.files ?? []) {
+    if (!isSafeManagedPath(entry?.path)) {
+      plan.push({
+        kind: "conflict",
+        op: "file",
+        target: repoRoot,
+        relPath: entry?.path ?? null,
+        reason: "managed file path is unsafe; refusing filesystem access"
+      });
+      continue;
+    }
     const targetPath = `${repoRoot}/${entry.path}`;
     const current = await readBytes(targetPath);
     if (!current) continue;
@@ -3326,7 +5210,7 @@ async function assembleLock({ repoRoot, plan, lock, configPlan, rootPlan, profil
     manager: {
       schemaVersion: CURRENT_LOCK_SCHEMA,
       name: "opencode-ship",
-      version: "1.1.2-rc.2",
+      version: "1.1.2",
       templateSet: TEMPLATE_SET_ID,
       profile: resolvedProfile,
       appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3345,7 +5229,7 @@ async function assembleLock({ repoRoot, plan, lock, configPlan, rootPlan, profil
     files
   };
 }
-async function commitInstall(preview, { json, command, fullSetupComplete = false }) {
+async function commitInstall(preview, { json, command, fullSetupComplete = false, transactionEntries = [] }) {
   if (!preview.ok) {
     return {
       ok: false,
@@ -3405,6 +5289,7 @@ async function commitInstall(preview, { json, command, fullSetupComplete = false
       relPath: rootPlan.relPath
     });
   }
+  txPlan.push(...transactionEntries);
   const tx = await executePlan({
     repoRoot,
     plan: txPlan,
@@ -3474,12 +5359,12 @@ function relativeTemplate(source) {
 // src/installer/commands/doctor.js
 init_lock();
 init_config();
-import { existsSync as existsSync16, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync5 } from "node:fs";
 import { spawnSync as spawnSync2 } from "node:child_process";
 init_hash();
 init_catalog();
 init_root_config();
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 
 // src/installer/report.js
 var REPORT_VERSION = 1;
@@ -3568,9 +5453,9 @@ function checkPackageIntegrity() {
 function buildSourceHashIndex() {
   const idx = /* @__PURE__ */ new Map();
   for (const entry of CATALOG) {
-    if (!existsSync16(entry.source)) continue;
+    if (!existsSync15(entry.source)) continue;
     try {
-      const buf = readFileSync6(entry.source, "utf8");
+      const buf = readFileSync5(entry.source, "utf8");
       idx.set(entry.source, bytesHashString(buf));
     } catch {
     }
@@ -3581,13 +5466,13 @@ async function checkCatalogInstall(repoRoot, sourceHashes, profile, renderedAgen
   const rows = [];
   const scoped = profile ? filterCatalogByProfile(CATALOG, profile) : CATALOG;
   for (const entry of scoped) {
-    const target = resolve15(repoRoot, entry.path);
-    if (!existsSync16(target)) {
+    const target = resolve14(repoRoot, entry.path);
+    if (!existsSync15(target)) {
       rows.push(`${entry.id}: missing`);
       continue;
     }
     try {
-      const buf = readFileSync6(target, "utf8");
+      const buf = readFileSync5(target, "utf8");
       const actual = bytesHashString(buf);
       const rendered = renderedAgentMap.get(entry.path);
       const expected = rendered ? rendered.sha256 : sourceHashes.get(entry.source);
@@ -3643,12 +5528,12 @@ async function checkManagedHashes(repoRoot, validatedLock) {
   const drift = [];
   const renderedAgents = await loadRenderedAgentOverrides(repoRoot);
   for (const entry of validatedLock.lock.files ?? []) {
-    const p = resolve15(repoRoot, entry.path);
-    if (!existsSync16(p)) {
+    const p = resolve14(repoRoot, entry.path);
+    if (!existsSync15(p)) {
       drift.push(`missing:${entry.path}`);
       continue;
     }
-    const buf = readFileSync6(p, "utf8");
+    const buf = readFileSync5(p, "utf8");
     const actual = bytesHashString(buf);
     if (actual !== entry.sha256) drift.push(`drift:${entry.path}`);
   }
@@ -3781,7 +5666,28 @@ async function runDoctor({ rootPath, profile, json, writeOutput = true }) {
 // src/installer/commands/init.js
 init_catalog();
 init_config();
-init_setup_pending();
+
+// src/installer/setup-pending.js
+import { existsSync as existsSync16, readFileSync as readFileSync6, unlinkSync, writeFile as writeFile7, mkdir as mkdirAsync } from "node:fs";
+import { promisify } from "node:util";
+import { resolve as resolve15, dirname as dirname9 } from "node:path";
+var writeFileAsync = promisify(writeFile7);
+var mkdirAsyncAsync = promisify(mkdirAsync);
+var REL_PATH = ".opencode/ship.setup-pending.json";
+function setupPendingPath(repoRoot) {
+  return resolve15(repoRoot, REL_PATH);
+}
+function isSetupPending(repoRoot) {
+  return existsSync16(setupPendingPath(repoRoot));
+}
+async function writeSetupPending(repoRoot, payload) {
+  const path = setupPendingPath(repoRoot);
+  await mkdirAsyncAsync(dirname9(path), { recursive: true });
+  await writeFileAsync(path, JSON.stringify(payload, null, 2) + "\n", "utf8");
+}
+var SETUP_PENDING_REL_PATH2 = REL_PATH;
+
+// src/installer/commands/init.js
 var writeFileAsync2 = promisify2(writeFile8);
 var mkdirAsyncAsync2 = promisify2(mkdirAsync2);
 async function runInit(options) {
@@ -4046,7 +5952,6 @@ async function runDiff(options) {
 
 // src/installer/commands/update.js
 init_catalog();
-init_setup_pending();
 async function runUpdate(options) {
   try {
     validateCatalog();
@@ -4124,7 +6029,6 @@ function emitFailure2(code, message, json, command) {
 // src/installer/commands/setup-complete.js
 init_config();
 init_setup_state();
-init_setup_pending();
 import { existsSync as existsSync17 } from "node:fs";
 import { resolve as resolve16 } from "node:path";
 async function runSetupComplete(options) {
@@ -4132,7 +6036,6 @@ async function runSetupComplete(options) {
   if (!existsSync17(resolve16(repoRoot, ".git"))) {
     return emitFailure3(2, "not a git repository", options.json);
   }
-  clearSetupPending(repoRoot);
   const config = await loadConfig(repoRoot);
   const configValue = config?.ok ? config.value : null;
   const state = await setupComplete(repoRoot, configValue);
@@ -4145,6 +6048,7 @@ async function runSetupComplete(options) {
   if (!state.ok) {
     return emitFailure3(6, `setup incomplete: ${diagnostics.join("; ")}`, options.json, { state });
   }
+  const markerWasPresent = isSetupPending(repoRoot);
   const preview = await previewInstall({
     rootPath: repoRoot,
     profile: "engineering",
@@ -4161,7 +6065,14 @@ async function runSetupComplete(options) {
   const committed = await commitInstall(preview, {
     json: options.json,
     command: "setup-complete",
-    fullSetupComplete: true
+    fullSetupComplete: true,
+    transactionEntries: markerWasPresent ? [{
+      op: "file",
+      kind: "delete",
+      target: setupPendingPath(repoRoot),
+      relPath: SETUP_PENDING_REL_PATH2,
+      reason: "clear setup-pending marker in the setup-complete transaction"
+    }] : []
   });
   if (committed.extra?.exitCode !== 0) {
     return emitFailure3(committed.extra?.exitCode ?? 1, "commit failed", options.json, { committed });
@@ -4172,6 +6083,7 @@ async function runSetupComplete(options) {
       command: "setup-complete",
       status: "ok",
       setupComplete: true,
+      markerWasPresent,
       requirements: SETUP_REQUIREMENTS,
       plan: serializePlan(committed.plan ?? []),
       summary: committed.summary ?? {},