opencode-ship 1.1.0 → 1.1.1-rc.9

package/dist/plugin.js

@@ -1,208 +1,10 @@
-// opencode-ship v1.1.0
+// opencode-ship v1.1.1-rc.9
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/profile.js
-function isValidProfile(name) {
-  return typeof name === "string" && PROFILES.includes(name);
-}
-var PROFILES;
-var init_profile = __esm({
-  "src/profile.js"() {
-    PROFILES = Object.freeze(["engineering"]);
-  }
-});
-
-// src/installer/json-pointer.js
-function isObject2(v) {
-  return v !== null && typeof v === "object" && !Array.isArray(v);
-}
-function stableStringify(value) {
-  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-  if (isObject2(value)) {
-    const keys = Object.keys(value).sort();
-    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-function canonicalJson(value) {
-  return stableStringify(value);
-}
-var init_json_pointer = __esm({
-  "src/installer/json-pointer.js"() {
-  }
-});
-
-// src/installer/hash.js
-import { createHash as createHash8 } from "node:crypto";
-function bytesHash(buffer) {
-  return createHash8("sha256").update(buffer).digest("hex");
-}
-function bytesHashString(text) {
-  return bytesHash(Buffer.from(text, "utf8"));
-}
-var init_hash = __esm({
-  "src/installer/hash.js"() {
-    init_json_pointer();
-  }
-});
-
-// src/installer/lock.js
-var lock_exports = {};
-__export(lock_exports, {
-  CURRENT_LOCK_SCHEMA: () => CURRENT_LOCK_SCHEMA,
-  computeIntegrity: () => computeIntegrity,
-  lockPath: () => lockPath,
-  lockSchemaRevision: () => lockSchemaRevision,
-  migrateLegacyLock: () => migrateLegacyLock,
-  readLock: () => readLock2,
-  readValidatedLock: () => readValidatedLock,
-  validateIntegrity: () => validateIntegrity,
-  validateLock: () => validateLock,
-  writeLock: () => writeLock
-});
-import { readFile as readFile11, writeFile as writeFile10, rename as rename4, mkdir as mkdir12 } from "node:fs/promises";
-import { existsSync as existsSync10 } from "node:fs";
-import { dirname as dirname6, resolve as resolve10 } from "node:path";
-function lockSchemaRevision() {
-  return CURRENT_LOCK_SCHEMA;
-}
-function lockPath(repoRoot) {
-  return resolve10(repoRoot, ".opencode", "ship.lock.json");
-}
-async function readLock2(repoRoot) {
-  const path = lockPath(repoRoot);
-  if (!existsSync10(path)) return null;
-  try {
-    const raw = await readFile11(path, "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function writeLock(repoRoot, lock) {
-  const path = lockPath(repoRoot);
-  await mkdir12(dirname6(path), { recursive: true });
-  const integrity = computeIntegrity(lock);
-  const finalLock = { ...lock, integrity };
-  const raw = JSON.stringify(finalLock, null, 2) + "\n";
-  const tmp = `${path}.tmp`;
-  await writeFile10(tmp, raw, "utf8");
-  await rename4(tmp, path);
-  return path;
-}
-function computeIntegrity(lock) {
-  const { integrity: _ignored, ...without } = lock ?? {};
-  void _ignored;
-  return {
-    lockSha256: bytesHashString(stableStringify(without))
-  };
-}
-async function validateIntegrity(lock) {
-  if (!lock?.integrity?.lockSha256) return false;
-  const expected = computeIntegrity(lock).lockSha256;
-  return expected === lock.integrity.lockSha256;
-}
-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 !== 1 && rawLock.contractVersion !== 2) {
-    issues.push(`unsupported contractVersion: ${JSON.stringify(rawLock.contractVersion)} (expected ${CURRENT_LOCK_SCHEMA}, 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 !== 2 && manager.schemaVersion !== 1) {
-    issues.push(`unsupported manager.schemaVersion: ${JSON.stringify(manager.schemaVersion)} (expected ${CURRENT_LOCK_SCHEMA}, 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 && !isValidProfile(manager.profile)) {
-    issues.push(`invalid manager.profile: ${JSON.stringify(manager.profile)} (expected one of: core, engineering)`);
-    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 (!existsSync10(path)) {
-    return { kind: "missing", lock: null, issues: [] };
-  }
-  let raw;
-  try {
-    const text = await readFile11(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);
-  return { kind: validation.kind, lock: validation.ok ? raw : null, issues: validation.issues };
-}
-async function migrateLegacyLock(repoRoot) {
-  const legacy = resolve10(repoRoot, ".opencode", "delivery.lock.json");
-  if (!existsSync10(legacy)) return null;
-  try {
-    const raw = await readFile11(legacy, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.contractVersion !== 1 || typeof parsed.adapterSha256 !== "string") return null;
-    return {
-      kind: "legacy-lock",
-      sourcePath: legacy,
-      payload: { contractVersion: 1, adapterSha256: parsed.adapterSha256, writtenAt: parsed.writtenAt ?? null },
-      sha256: bytesHashString(raw)
-    };
-  } catch {
-    return null;
-  }
-}
-var CURRENT_LOCK_SCHEMA;
-var init_lock = __esm({
-  "src/installer/lock.js"() {
-    init_hash();
-    init_json_pointer();
-    init_profile();
-    CURRENT_LOCK_SCHEMA = 3;
-  }
-});
-
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -14211,6 +14013,12 @@ function bucketFor(check2) {
   if (check2.state === "failure") return "fail";
   return "pending";
 }
+function finalReviewGateSnapshot(manifest) {
+  return {
+    standards: manifest?.finalStandardsReview ?? null,
+    spec: manifest?.finalSpecReview ?? null
+  };
+}
 function gateSnapshot({ manifest, prHead, checks }) {
   const required2 = manifest.adapter?.ci?.requiredChecks ?? [];
   const observed = checks ?? [];
@@ -14232,6 +14040,7 @@ function gateSnapshot({ manifest, prHead, checks }) {
     prHead: prHead ?? null,
     reviewerSha: manifest?.lastReviewerSha ?? null,
     verifierSha: manifest?.lastVerifierSha ?? null,
+    finalReviews: finalReviewGateSnapshot(manifest ?? {}),
     checks: observed,
     missingChecks: missing,
     failingChecks: failing,
@@ -14241,10 +14050,39 @@ function gateSnapshot({ manifest, prHead, checks }) {
 function checkGates({ manifest, prHead, checks, requires }) {
   const snap = gateSnapshot({ manifest, prHead, checks });
   const need = new Set(requires ?? ["review", "local-verification", "remote-ci"]);
+  const hasDualFinalReview = Boolean(
+    manifest?.finalStandardsReview || manifest?.finalSpecReview
+  );
   if (need.has("review")) {
-    if (!manifest?.lastReviewerSha) return { ok: false, reason: "missing-review", snapshot: snap };
-    if (manifest.lastReviewerSha !== prHead) {
-      return { ok: false, reason: "head-changed-after-review", snapshot: snap };
+    if (hasDualFinalReview) {
+      const standards = manifest?.finalStandardsReview;
+      const spec = manifest?.finalSpecReview;
+      if (!standards || !standards.headSha) {
+        return { ok: false, reason: "missing-final-review", axis: "standards", snapshot: snap };
+      }
+      if (!spec || !spec.headSha) {
+        return { ok: false, reason: "missing-final-review", axis: "spec", snapshot: snap };
+      }
+      if (standards.headSha !== prHead) {
+        return { ok: false, reason: "head-changed-after-final-review", axis: "standards", snapshot: snap };
+      }
+      if (spec.headSha !== prHead) {
+        return { ok: false, reason: "head-changed-after-final-review", axis: "spec", snapshot: snap };
+      }
+      if (standards.headSha !== spec.headSha) {
+        return { ok: false, reason: "final-review-head-mismatch", snapshot: snap };
+      }
+      if ((standards.packageHash ?? null) !== (spec.packageHash ?? null)) {
+        return { ok: false, reason: "final-review-package-mismatch", snapshot: snap };
+      }
+      if ((standards.verdict ?? null) !== "pass" || (spec.verdict ?? null) !== "pass") {
+        return { ok: false, reason: "final-review-failed", snapshot: snap };
+      }
+    } else {
+      if (!manifest?.lastReviewerSha) return { ok: false, reason: "missing-review", snapshot: snap };
+      if (manifest.lastReviewerSha !== prHead) {
+        return { ok: false, reason: "head-changed-after-review", snapshot: snap };
+      }
     }
   }
   if (need.has("local-verification")) {
@@ -14272,6 +14110,17 @@ function gateFailureEnvelope(result) {
       return { kind: "missing-gate", gate: "review" };
     case "missing-verifier":
       return { kind: "missing-gate", gate: "local-verification" };
+    case "missing-final-review":
+      return {
+        kind: "missing-final-review",
+        axis: result.axis
+      };
+    case "final-review-head-mismatch":
+      return { kind: "final-review-head-mismatch" };
+    case "final-review-package-mismatch":
+      return { kind: "final-review-package-mismatch" };
+    case "final-review-failed":
+      return { kind: "final-review-failed" };
     case "head-changed-after-review":
       return {
         kind: "head-changed-after-review",
@@ -14284,6 +14133,12 @@ function gateFailureEnvelope(result) {
         headSha: result.snapshot.prHead ?? "",
         verifierSha: result.snapshot.verifierSha ?? ""
       };
+    case "head-changed-after-final-review":
+      return {
+        kind: "head-changed-after-final-review",
+        axis: result.axis,
+        headSha: result.snapshot.prHead ?? ""
+      };
     case "ci-missing":
       return { kind: "ci-missing", missing: result.snapshot.missingChecks };
     case "ci-failing":
@@ -14918,8 +14773,11 @@ function createPublishTool(deps) {
   };
 }
 
+// src/profile.js
+var PROFILES = Object.freeze(["engineering"]);
+var LEGACY_PROFILES = Object.freeze(["core"]);
+
 // src/installer/engineering-config.js
-init_profile();
 var MODEL_ID_RE = /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
 var DEFAULTS = Object.freeze({
   planner: "openai/gpt-5.6-sol",
@@ -15005,8 +14863,23 @@ function createPlanStartTool(deps) {
   };
 }
 
+// src/installer/json-pointer.js
+function isObject2(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (isObject2(value)) {
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function canonicalJson(value) {
+  return stableStringify(value);
+}
+
 // src/workflow/plan.js
-init_json_pointer();
 import { createHash as createHash3 } from "node:crypto";
 function isPlainObject2(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
@@ -15463,8 +15336,8 @@ function createRunStartTool(deps) {
     if (!workflowId || !SAFE_ID_RE4.test(workflowId)) {
       return failure("run-start", "workflowId required (safe id)", { operationId: opId, retryable: false });
     }
-    const config2 = deps.config ?? null;
-    const expectedModels = config2?.value?.workflow?.models ?? null;
+    const configValue = deps.configValue ?? deps.config?.value ?? null;
+    const expectedModels = configValue?.workflow?.models ?? null;
     if (!expectedModels) {
       return failure("run-start", "run-start requires configured workflow.models", { operationId: opId, retryable: false });
     }
@@ -15577,7 +15450,9 @@ var EVENT_KINDS = Object.freeze({
   TASK_REVIEW: "task-review",
   COMMIT: "commit",
   TASK_COMPLETE: "task-complete",
+  ALL_TASKS_DONE: "all-tasks-done",
   FINAL_REVIEW: "final-review",
+  READY_PENDING: "ready-pending",
   READY: "ready",
   MERGE: "merge",
   BLOCKED: "blocked"
@@ -15656,6 +15531,16 @@ function reduce(state, event) {
         event: recorded(EVENT_KINDS.TASK_DISPATCH, { taskId: event.data.taskId, briefHash: event.data.briefHash, round })
       };
     }
+    case EVENT_KINDS.TASK_REPORT: {
+      if (state.state !== STATES2.RUNNING && state.state !== STATES2.FIX_PENDING || state.activeTask === null) {
+        throw new Error(`run reducer: TASK_REPORT requires running with active task`);
+      }
+      ensureActiveTask(state, event.data.taskId);
+      return {
+        state: nextState({ state: STATES2.RUNNING, round: state.round + 1 }),
+        event: recorded(EVENT_KINDS.TASK_REPORT, { taskId: event.data.taskId, reportHash: event.data.reportHash })
+      };
+    }
     case EVENT_KINDS.TASK_REVIEW: {
       if (state.state !== STATES2.RUNNING && state.state !== STATES2.FIX_PENDING || state.activeTask === null) {
         throw new Error(`run reducer: TASK_REVIEW requires running with active task`);
@@ -15693,15 +15578,43 @@ function reduce(state, event) {
       if (state.state !== STATES2.COMMITTED) {
         throw new Error(`run reducer: TASK_COMPLETE requires state=committed, got ${state.state}`);
       }
+      const moreTasks = event.data.moreTasks === false ? false : true;
+      const completedTasks = [...state.completedTasks, state.taskReady?.taskId].filter(Boolean);
+      const nextStateObj = moreTasks ? { state: STATES2.RUNNING, activeTask: null, taskReady: null, round: 0, failures: 0, completedTasks } : { state: STATES2.ALL_TASKS_DONE, activeTask: null, taskReady: null, completedTasks };
       return {
-        state: nextState({ state: STATES2.RUNNING, activeTask: null, taskReady: null, round: 0, failures: 0 }),
-        event: recorded(EVENT_KINDS.TASK_COMPLETE, { taskId: event.data.taskId })
+        state: nextState(nextStateObj),
+        event: recorded(EVENT_KINDS.TASK_COMPLETE, { taskId: event.data.taskId, moreTasks })
+      };
+    }
+    case EVENT_KINDS.FINAL_REVIEW: {
+      if (state.state !== STATES2.ALL_TASKS_DONE && state.state !== STATES2.READY_PENDING) {
+        throw new Error(`run reducer: FINAL_REVIEW requires state=all-tasks-done|ready-pending, got ${state.state}`);
+      }
+      const nextReadyPending = state.state === STATES2.READY_PENDING ? state : { ...state, state: STATES2.READY_PENDING, finalReview: { [event.data.axis]: event.data.review } };
+      const finalReview = nextReadyPending.finalReview ?? {};
+      finalReview[event.data.axis] = event.data.review;
+      const bothRecorded = finalReview.standards && finalReview.spec;
+      return {
+        state: nextState({
+          state: STATES2.READY_PENDING,
+          finalReview
+        }),
+        event: recorded(EVENT_KINDS.FINAL_REVIEW, {
+          axis: event.data.axis,
+          verdict: event.data.verdict,
+          headSha: event.data.headSha,
+          mergeBaseSha: event.data.mergeBaseSha,
+          packageHash: event.data.packageHash
+        })
       };
     }
     case EVENT_KINDS.READY: {
       if (state.state !== STATES2.COMMITTED && state.state !== STATES2.READY_PENDING) {
         throw new Error(`run reducer: READY requires state=committed|ready-pending, got ${state.state}`);
       }
+      if (state.state === STATES2.READY_PENDING && (!state.finalReview?.standards || !state.finalReview?.spec)) {
+        throw new Error(`run reducer: READY requires both Standards and Spec final reviews`);
+      }
       return {
         state: nextState({ state: STATES2.READY, activeTask: null, completedTasks: state.completedTasks }),
         event: recorded(EVENT_KINDS.READY, { headSha: event.data.headSha })
@@ -16125,8 +16038,8 @@ var ship_config_schema_default = {
     schemaVersion: { enum: [1, 2] },
     profile: {
       type: "string",
-      enum: ["engineering"],
-      description: "Active profile. Engineering is the only supported profile in 1.1.0."
+      enum: ["engineering", "core"],
+      description: "Active profile. Engineering is the only supported profile in 1.1.0; core is accepted on read for legacy consumer migration."
     },
     owner: {
       type: "string",
@@ -16289,6 +16202,28 @@ var ship_config_schema_default = {
           }
         }
       }
+    },
+    skillDiscovery: {
+      type: "object",
+      additionalProperties: false,
+      description: "Trusted-auto skill discovery policy. Default mode is trusted-auto with the canonical owner allowlist and install-count threshold.",
+      properties: {
+        mode: {
+          type: "string",
+          enum: ["suggest-only", "trusted-auto", "disabled"]
+        },
+        trustedOwners: {
+          type: "array",
+          items: { type: "string", pattern: "^[A-Za-z0-9_.-]+$" }
+        },
+        minInstalls: { type: "integer", minimum: 0 },
+        maxAutoInstall: { type: "integer", minimum: 0, maximum: 20 },
+        blocklist: {
+          type: "array",
+          items: { type: "string", pattern: "^[A-Za-z0-9_./-]+$" }
+        },
+        requireImmutableRef: { type: "boolean" }
+      }
     }
   }
 };
@@ -16394,9 +16329,16 @@ function validateSchema(value, schema) {
   return { ok: issues.length === 0, issues };
 }
 
+// src/installer/hash.js
+import { createHash as createHash8 } from "node:crypto";
+function bytesHash(buffer) {
+  return createHash8("sha256").update(buffer).digest("hex");
+}
+function bytesHashString(text) {
+  return bytesHash(Buffer.from(text, "utf8"));
+}
+
 // src/installer/config.js
-init_json_pointer();
-init_hash();
 function configPath(repoRoot) {
   return resolve9(repoRoot, ".opencode", "ship.config.json");
 }
@@ -16467,8 +16409,23 @@ function renderDefaultConfig(detection, overrides = {}) {
   };
 }
 
-// src/plugin.js
-init_lock();
+// src/installer/lock.js
+import { readFile as readFile11, writeFile as writeFile10, rename as rename4, mkdir as mkdir12 } from "node:fs/promises";
+import { existsSync as existsSync10 } from "node:fs";
+import { dirname as dirname6, resolve as resolve10 } from "node:path";
+function lockPath(repoRoot) {
+  return resolve10(repoRoot, ".opencode", "ship.lock.json");
+}
+async function readLock2(repoRoot) {
+  const path = lockPath(repoRoot);
+  if (!existsSync10(path)) return null;
+  try {
+    const raw = await readFile11(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 
 // src/installer/detection/project.js
 import { spawnSync as spawnSync5 } from "node:child_process";
@@ -16616,17 +16573,14 @@ function detectProject(repoRoot = process.cwd()) {
 // src/installer/cleanup.js
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { resolve as pathResolve } from "node:path";
-init_json_pointer();
-init_json_pointer();
-init_hash();
-init_lock();
+import { existsSync as existsSync12, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "node:fs";
 function spawn5(repoRoot, args) {
   const r = spawnSync6("git", ["-C", repoRoot, ...args], { encoding: "utf8" });
   return { status: r.status ?? -1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
 }
 function casDeleteBranch2(repoRoot, branch, expectedSha) {
   const argv = ["update-ref", "-d"];
-  if (expectedSha && /^[0-9a-f]{7,}$/i.test(expectedSha)) {
+  if (expectedSha && /^[0-9f]{7,}$/i.test(expectedSha)) {
     argv.push(`refs/heads/${branch}`, expectedSha);
   } else {
     argv.push(`refs/heads/${branch}`);
@@ -16640,19 +16594,26 @@ function safeRemoveWorktree2(repoRoot, target) {
 function worktreeRootOf(adapter) {
   return adapter?.worktree?.root ?? ".worktrees";
 }
-async function loadLockMemo(repoRoot) {
-  return readLock2(repoRoot);
+async function cleanupPendingPath(repoRoot) {
+  const common = await resolveGitCommonDir(repoRoot);
+  return pathResolve(opencodeShipStateDir(common), "cleanup-pending.json");
 }
-async function writeLockMemo(repoRoot, lock) {
-  const { writeLock: writer } = await Promise.resolve().then(() => (init_lock(), lock_exports));
-  await writer(repoRoot, lock);
+async function loadCleanupPending(repoRoot) {
+  const path = await cleanupPendingPath(repoRoot);
+  if (!existsSync12(path)) return [];
+  try {
+    const raw = await readFileSync2(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
 }
-async function appendCleanupPending(repoRoot, entry) {
-  const lock = await loadLockMemo(repoRoot);
-  if (!lock) return null;
-  const next = [...lock.cleanupPending ?? [], entry];
-  await writeLockMemo(repoRoot, { ...lock, cleanupPending: dedupePending(next) });
-  return lock;
+async function saveCleanupPending(repoRoot, entries) {
+  const path = await cleanupPendingPath(repoRoot);
+  const dir = pathResolve(path, "..");
+  if (!existsSync12(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, JSON.stringify(dedupePending(entries), null, 2) + "\n", "utf8");
 }
 function dedupePending(entries) {
   const seen = /* @__PURE__ */ new Set();
@@ -16665,6 +16626,12 @@ function dedupePending(entries) {
   }
   return out;
 }
+async function appendCleanupPending(repoRoot, entry) {
+  const current = await loadCleanupPending(repoRoot);
+  const next = [...current, entry];
+  await saveCleanupPending(repoRoot, next);
+  return next;
+}
 function reject(reason, extra = {}) {
   return { ok: false, reason, ...extra };
 }
@@ -16774,10 +16741,10 @@ function flattenShipConfig(ship) {
 }
 
 // src/version.js
-import { readFileSync as readFileSync2, existsSync as existsSync12 } from "node:fs";
+import { readFileSync as readFileSync3, existsSync as existsSync13 } from "node:fs";
 import { dirname as dirname7, resolve as resolve13 } from "node:path";
 import { fileURLToPath } from "node:url";
-var PACKAGE_VERSION = "1.1.0";
+var PACKAGE_VERSION = "1.1.1-rc.9";
 var TEMPLATE_SET = `v${PACKAGE_VERSION}`;
 
 // src/plugin.js
@@ -17178,11 +17145,14 @@ var factories = {
   runStart: {
     args: {
       workflowId: tool.schema.string(),
+      revision: tool.schema.number().optional(),
+      sha256: tool.schema.string().optional(),
       operationId: tool.schema.string().optional()
     },
     build: (rt) => createRunStartTool({
       repoRoot: rt.repoRoot,
-      owner: rt.owner
+      owner: rt.owner,
+      configValue: rt.configValue
     })
   },
   taskReport: {