opencode-ship 1.1.7 → 1.1.9-rc.1

package/dist/core.d.ts

@@ -100,6 +100,7 @@ export interface PullRequestSummary {
   draft: boolean;
   mergeable: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
   mergeStateStatus: string;
+  state: "OPEN" | "CLOSED" | "MERGED" | "UNKNOWN";
   merged: boolean;
   mergedAt: string | null;
 }
@@ -330,6 +331,12 @@ export interface CleanupToolInput {
   taskId: string;
 }
 
+export interface AbandonToolInput {
+  taskId: string;
+  subject: string;
+  operationId?: string;
+}
+
 export type Envelope<TKind extends string, TData> = { kind: TKind } & TData;
 
 // ---------------------------------------------------------------------------
@@ -581,3 +588,14 @@ export declare function createCleanupTool(deps: BaseToolDeps): (input: CleanupTo
   | Envelope<"branch-delete-failed", { stderr: string }>
   | Envelope<"unsafe-cleanup", { signals: readonly string[] }>
 >;
+
+export declare function createAbandonTool(deps: BaseToolDeps): (input: AbandonToolInput) => Promise<
+  | { contractVersion: 2; ok: true; kind: "abandon"; operationId: string; idempotent: boolean; data: {
+    taskId: string;
+    intentHash: string;
+    removedWorktree: boolean;
+    deletedBranch: boolean;
+    deletedManifest: boolean;
+  } }
+  | { contractVersion: 2; ok: false; kind: "abandon"; operationId: string; retryable: boolean; message: string; details: { kind: string } }
+>;

package/dist/core.js

@@ -1,4 +1,4 @@
-// opencode-ship/core v1.1.7
+// opencode-ship/core v1.1.9-rc.1
 
 // src/adapter.js
 import { readFile, writeFile, mkdir, rename } from "node:fs/promises";
@@ -851,7 +851,7 @@ function validateGhArgv(argv) {
 
 // src/drivers/gh-cli.js
 function defaultRunner(cwd, env) {
-  return (args) => new Promise((resolve10, reject) => {
+  return (args) => new Promise((resolve11, reject) => {
     const proc = spawn2("gh", args, {
       cwd,
       env,
@@ -863,7 +863,7 @@ function defaultRunner(cwd, env) {
     proc.stdout.on("data", (d) => stdout += d.toString());
     proc.stderr.on("data", (d) => stderr += d.toString());
     proc.on("error", reject);
-    proc.on("close", (status) => resolve10({ status: status ?? -1, stdout, stderr }));
+    proc.on("close", (status) => resolve11({ status: status ?? -1, stdout, stderr }));
   });
 }
 function viewFields() {
@@ -1100,6 +1100,19 @@ Closes #${issueNumber}`;
       ]);
       return fields.headRefOid;
     },
+    async readIssue({ repo, number }) {
+      if (typeof number !== "number") throw new Error("readIssue: number is required");
+      if (!parseRepoSlug(repo)) throw new Error(`readIssue: invalid repo slug ${repo}`);
+      return ghJson(run, [
+        "issue",
+        "view",
+        String(number),
+        "--repo",
+        repo,
+        "--json",
+        "title,body"
+      ]);
+    },
     async runCommand(argv) {
       if (!Array.isArray(argv) || argv.length === 0) {
         throw new Error("runCommand: argv must be a non-empty array");
@@ -1400,6 +1413,60 @@ function createInspectTool(deps) {
   };
 }
 
+// src/runtime/stages.js
+function progressLine(stage, extra = {}) {
+  switch (stage) {
+    case "setup":
+      return "Setup: ready.";
+    case "discover":
+      return extra.count > 0 ? `Discover: ${extra.count} skills installed.` : "Discover: none (catalog only).";
+    case "plan":
+      return `Plan: ${extra.path}`;
+    case "track":
+      return `Track: issue #${extra.number}.`;
+    case "build":
+      return `Build: task ${extra.k}/${extra.n} ${extra.title}.`;
+    case "review":
+      return extra.ok ? "Review: pass." : "Review: fail (see notes).";
+    case "verify":
+      return extra.ok ? "Verify: pass." : "Verify: fail.";
+    case "ready":
+      return `Ready: PR #${extra.number}.`;
+    case "merge":
+      return `Merge: ${extra.sha}.`;
+    case "cleanup":
+      return "Cleanup: done.";
+    default:
+      return null;
+  }
+}
+function nextLine(stage) {
+  switch (stage) {
+    case "setup":
+      return "Next: tell me what you want to build.";
+    case "discover":
+      return "Next: I will use these skills while building.";
+    case "plan":
+      return "Next: say if this is the product you want.";
+    case "approve":
+      return "Next: start building now, or continue later.";
+    case "track":
+      return "Next: building starts.";
+    case "build":
+    case "review":
+    case "verify":
+      return "Next: I keep going.";
+    case "ready":
+      return "Next: say if I should merge it.";
+    case "merge":
+      return "Next: cleanup.";
+    case "cleanup":
+      return "Next: tell me what to build next.";
+    default:
+      return null;
+  }
+}
+
 // src/tools/delivery-issue.js
 function createIssueTool(deps) {
   return async function issue(input) {
@@ -1409,13 +1476,16 @@ function createIssueTool(deps) {
     if (!input.branch) return { kind: "missing-input", field: "branch" };
     const existing = await readManifest(deps.repoRoot, input.taskId);
     if (existing) {
+      const stage2 = "track";
       return {
         contractVersion: 1,
         created: false,
         issueNumber: existing.issueNumber,
         issueUrl: `https://github.com/${deps.repoSlug}/issues/${existing.issueNumber}`,
         manifestPath: "preserved",
-        preserved: true
+        preserved: true,
+        progress: progressLine(stage2, { number: existing.issueNumber }),
+        next: nextLine(stage2)
       };
     }
     const ensured = await deps.driver.ensureIssue({
@@ -1453,12 +1523,15 @@ function createIssueTool(deps) {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const path = await writeManifest(deps.repoRoot, next);
+    const stage = "track";
     return {
       contractVersion: 1,
       created: ensured.created,
       issueNumber: ensured.summary.number,
       issueUrl: ensured.summary.url,
-      manifestPath: path
+      manifestPath: path,
+      progress: progressLine(stage, { number: ensured.summary.number }),
+      next: nextLine(stage)
     };
   };
 }
@@ -1532,6 +1605,9 @@ function createWorktreeTool(deps) {
         expectedRoot: resolve7(deps.repoRoot, worktreeRoot)
       };
     }
+    if (m.schemaVersion >= 2 && !m.workflowId) {
+      return { kind: "missing-workflow-link", taskId: m.taskId };
+    }
     const remote = deps.remote ?? "origin";
     const hasRemote = remoteExists(remote, deps.repoRoot);
     if (hasRemote) {
@@ -2496,7 +2572,15 @@ function createReadyTool(deps) {
         data: { headSha: prHead, taskId: input.taskId }
       });
     }
-    return { contractVersion: 1, manifestPath: path, pr: m.prNumber, workflowId };
+    const stage = "ready";
+    return {
+      contractVersion: 1,
+      manifestPath: path,
+      pr: m.prNumber,
+      workflowId,
+      progress: progressLine(stage, { number: m.prNumber }),
+      next: nextLine(stage)
+    };
   };
 }
 
@@ -2558,7 +2642,16 @@ function createMergeTool(deps) {
           data: { mergeSha: merged2.mergeSha ?? merged2.mergeCommitSha ?? merged2.headSha }
         });
       }
-      return { kind: "merge", contractVersion: 1, manifestPath: path, pr: m.prNumber, taskId: m.taskId };
+      const stage = "merge";
+      return {
+        kind: "merge",
+        contractVersion: 1,
+        manifestPath: path,
+        pr: m.prNumber,
+        taskId: m.taskId,
+        progress: progressLine(stage, { sha: merged2.headSha.slice(0, 7) }),
+        next: nextLine(stage)
+      };
     }
     if (pr.merged) {
       return recordMerged(pr, `reconciled external merge as ${input.subject}`);
@@ -2770,16 +2863,439 @@ function createCleanupTool(deps) {
       contractVersion: 1,
       manifestPath: null,
       removedPath: wtPath,
-      bootstrapRecovery: isBootstrapRecovery
+      bootstrapRecovery: isBootstrapRecovery,
+      progress: progressLine("cleanup"),
+      next: nextLine("cleanup")
+    };
+  };
+}
+
+// src/tools/delivery-abandon.js
+import { join as join10 } from "node:path";
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync8 } from "node:fs";
+
+// src/state/abandon-store.js
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+var SAFE_ID_RE2 = /^[A-Za-z0-9._-]{1,128}$/;
+var HASH_RE2 = /^[0-9a-f]{64}$/;
+function abandonDir(commonDir, taskId) {
+  return join8(commonDir, "opencode-ship", "delivery", "abandoned", taskId);
+}
+function intentPathFor(commonDir, taskId) {
+  return join8(abandonDir(commonDir, taskId), "intent.json");
+}
+function completionPathFor(commonDir, taskId) {
+  return join8(abandonDir(commonDir, taskId), "completion.json");
+}
+async function readJsonOrNull2(path) {
+  try {
+    return JSON.parse(await readFile7(path, "utf8"));
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function withoutIntentHash(record) {
+  const copy = { ...record ?? {} };
+  delete copy.intentHash;
+  return copy;
+}
+function hashAbandonIntent(record) {
+  return createHash7("sha256").update(canonicalJson(withoutIntentHash(record)), "utf8").digest("hex");
+}
+async function readAbandon(repoRoot, taskId) {
+  const commonDir = await resolveGitCommonDir(repoRoot);
+  if (!SAFE_ID_RE2.test(String(taskId ?? ""))) {
+    return { intent: null, completion: null };
+  }
+  return {
+    intent: await readJsonOrNull2(intentPathFor(commonDir, taskId)),
+    completion: await readJsonOrNull2(completionPathFor(commonDir, taskId))
+  };
+}
+async function publishOrReuse(path, record) {
+  try {
+    await publishImmutableJson(path, record);
+    return { ok: true, record, idempotent: false };
+  } catch (err) {
+    const message = String(err?.message ?? err);
+    if (!message.includes("already exists")) throw err;
+    const existing = await readJsonOrNull2(path);
+    if (existing && canonicalJson(existing) === canonicalJson(record)) {
+      return { ok: true, record: existing, idempotent: true };
+    }
+    return { ok: false, kind: "abandon-conflict" };
+  }
+}
+async function publishAbandonIntent(repoRoot, record) {
+  const taskId = String(record?.taskId ?? "");
+  if (!SAFE_ID_RE2.test(taskId)) {
+    return { ok: false, kind: "invalid-task-id" };
+  }
+  const sealed = { ...withoutIntentHash(record), intentHash: hashAbandonIntent(record) };
+  const commonDir = await resolveGitCommonDir(repoRoot);
+  return publishOrReuse(intentPathFor(commonDir, taskId), sealed);
+}
+async function publishAbandonCompletion(repoRoot, record) {
+  const taskId = String(record?.taskId ?? "");
+  const intentHash = String(record?.intentHash ?? "");
+  if (!SAFE_ID_RE2.test(taskId)) {
+    return { ok: false, kind: "invalid-task-id" };
+  }
+  if (!HASH_RE2.test(intentHash)) {
+    return { ok: false, kind: "invalid-intent-hash" };
+  }
+  const commonDir = await resolveGitCommonDir(repoRoot);
+  return publishOrReuse(completionPathFor(commonDir, taskId), record);
+}
+
+// src/skills/worktree.js
+import { execFile } from "node:child_process";
+import { promises as fs, existsSync as existsSync7 } from "node:fs";
+import { resolve as resolve9, dirname as dirname3, sep, isAbsolute, join as join9 } from "node:path";
+function listRegisteredWorktrees(mainRepo) {
+  return new Promise((resolveP, rejectP) => {
+    execFile(
+      "git",
+      ["-C", mainRepo, "worktree", "list", "--porcelain", "-z"],
+      { shell: false, maxBuffer: 1024 * 1024 },
+      (err, stdout) => {
+        if (err) return rejectP(err);
+        const records = parsePorcelain(stdout);
+        const mainRecord = records.shift();
+        const mainPath = mainRecord?.worktree ? resolve9(mainRecord.worktree) : null;
+        const linked = [];
+        for (const r of records) {
+          if (!r.worktree) continue;
+          const p = resolve9(r.worktree);
+          if (mainPath && p === mainPath) continue;
+          linked.push({ path: p, branch: r.HEAD ?? null });
+        }
+        resolveP(linked);
+      }
+    );
+  });
+}
+function parsePorcelain(text) {
+  const tokens = text.split("\0");
+  const out = [];
+  let current = {};
+  for (const tok of tokens) {
+    if (tok.length === 0) {
+      if (Object.keys(current).length > 0) {
+        out.push(current);
+        current = {};
+      }
+      continue;
+    }
+    const idx = tok.indexOf(" ");
+    const key = idx === -1 ? tok : tok.slice(0, idx);
+    const value = idx === -1 ? "" : tok.slice(idx + 1);
+    if (key === "branch") {
+      current.HEAD = value.startsWith("refs/heads/") ? value : `refs/heads/${value}`;
+    } else {
+      current[key] = value;
+    }
+  }
+  if (Object.keys(current).length > 0) out.push(current);
+  return out;
+}
+async function validateLinkedWorktree(mainRepo, worktreePath, options = {}) {
+  const main = resolve9(mainRepo);
+  if (!existsSync7(main)) {
+    return { ok: false, kind: "missing", message: `main repository ${main} does not exist` };
+  }
+  if (!worktreePath) {
+    return { ok: false, kind: "unlinked", message: "worktreePath is required" };
+  }
+  const wt = resolve9(worktreePath);
+  if (!existsSync7(wt)) {
+    return { ok: false, kind: "missing", message: `worktree ${wt} does not exist` };
+  }
+  const isCurrent = wt === main;
+  if (isCurrent) {
+    const gitEntry = options.allowCurrentLinked ? await fs.lstat(join9(main, ".git")).catch(() => null) : null;
+    if (!gitEntry?.isFile()) {
+      return { ok: false, kind: "main", message: "installs into the main worktree are forbidden" };
+    }
+  }
+  let cursor = wt;
+  while (cursor !== dirname3(cursor)) {
+    const stat2 = await fs.lstat(cursor).catch(() => null);
+    if (stat2?.isSymbolicLink()) {
+      return {
+        ok: false,
+        kind: "ancestor-symlink",
+        message: `worktree path contains a symlink at ${cursor}`
+      };
+    }
+    cursor = dirname3(cursor);
+  }
+  const real = await fs.realpath(wt).catch(() => null);
+  if (real && real !== wt) {
+    return {
+      ok: false,
+      kind: "symlink",
+      message: `worktree ${wt} resolves through a symlink to ${real}`
+    };
+  }
+  const linked = await listRegisteredWorktrees(main);
+  const matched = linked.find((entry) => entry.path === wt);
+  if (!matched) {
+    return {
+      ok: false,
+      kind: "unlinked",
+      message: `worktree ${wt} is not registered (git worktree list)`
     };
+  }
+  return { ok: true, path: wt, registered: !!matched };
+}
+
+// src/tools/envelope.js
+import { randomBytes as randomBytes2 } from "node:crypto";
+var CONTRACT_VERSION = 2;
+function operationId(prefix = "op") {
+  return `${prefix}-${Date.now().toString(36)}-${randomBytes2(4).toString("hex")}`;
+}
+function success(kind, data, options = {}) {
+  if (typeof kind !== "string" || kind.length === 0) {
+    throw new Error("envelope.success: kind must be a non-empty string");
+  }
+  return {
+    contractVersion: CONTRACT_VERSION,
+    ok: true,
+    kind,
+    operationId: options.operationId ?? operationId(kind),
+    idempotent: options.idempotent !== false,
+    data
+  };
+}
+function failure(kind, message, options = {}) {
+  if (typeof kind !== "string" || kind.length === 0) {
+    throw new Error("envelope.failure: kind must be a non-empty string");
+  }
+  if (typeof message !== "string" || message.length === 0) {
+    throw new Error("envelope.failure: message must be a non-empty string");
+  }
+  const details = options.details ?? {};
+  return {
+    contractVersion: CONTRACT_VERSION,
+    ok: false,
+    kind,
+    operationId: options.operationId ?? operationId(`${kind}-err`),
+    retryable: options.retryable === true,
+    message,
+    details
+  };
+}
+
+// src/tools/delivery-abandon.js
+import { readFile as readFile8 } from "node:fs/promises";
+function runGit2(args, cwd) {
+  return spawnSync4("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env
+  });
+}
+function defaultRemoveWorktree(repoRoot, path) {
+  return runGit2(["worktree", "remove", path], repoRoot);
+}
+function defaultDeleteBranch(repoRoot, branch, expectedSha) {
+  const args = ["update-ref", "-d", `refs/heads/${branch}`];
+  if (expectedSha && /^[0-9a-f]{7,}$/i.test(expectedSha)) args.push(expectedSha);
+  return runGit2(args, repoRoot);
+}
+function branchExists(repoRoot, branch) {
+  return runGit2(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], repoRoot).status === 0;
+}
+function remoteBranchHead(repoRoot, remote, branch) {
+  const r = runGit2(["ls-remote", "--heads", remote, branch], repoRoot);
+  if (r.status !== 0) return { ok: false, sha: null, present: false };
+  const line = r.stdout.split("\n").find((row) => row.includes(`refs/heads/${branch}`));
+  if (!line) return { ok: true, sha: null, present: false };
+  return { ok: true, sha: line.split(/\s+/)[0], present: true };
+}
+function unpublishedAhead(repoRoot, remote, branch) {
+  const r = runGit2(["rev-list", "--count", `${remote}/${branch}..${branch}`], repoRoot);
+  if (r.status !== 0) return null;
+  const n = parseInt(r.stdout.trim(), 10);
+  return Number.isFinite(n) ? n : null;
+}
+function refuse(opId, kind, extras = {}) {
+  return failure("abandon", kind, {
+    operationId: opId,
+    retryable: false,
+    details: { kind, ...extras }
+  });
+}
+async function readRunSnapshot(repoRoot, workflowId) {
+  try {
+    const common = await resolveGitCommonDir(repoRoot);
+    const path = join10(opencodeShipStateDir(common), "runs", workflowId, "run.json");
+    if (!existsSync8(path)) return null;
+    return JSON.parse(await readFile8(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function validateLiveAttempt({ deps, manifest, subject, opId }) {
+  if (!manifest.prNumber) return refuse(opId, "missing-pr");
+  if (!manifest.worktreePath) return refuse(opId, "missing-worktree-path");
+  const pr = await deps.driver.readPullRequest({
+    repo: deps.repoSlug,
+    number: manifest.prNumber
+  });
+  if (pr.merged || pr.state === "MERGED") return refuse(opId, "pr-merged");
+  if (pr.state !== "CLOSED") return refuse(opId, "pr-open");
+  if (pr.headRefName && pr.headRefName !== manifest.branch) {
+    return refuse(opId, "branch-mismatch", { expected: manifest.branch, received: pr.headRefName });
+  }
+  if (pr.baseRefName && pr.baseRefName !== manifest.baseBranch) {
+    return refuse(opId, "base-mismatch", { expected: manifest.baseBranch, received: pr.baseRefName });
+  }
+  const linked = await validateLinkedWorktree(deps.repoRoot, manifest.worktreePath);
+  if (!linked.ok) {
+    return refuse(opId, "invalid-worktree", { reason: linked.kind, message: linked.message });
+  }
+  if (!isWorktreeClean(linked.path)) return refuse(opId, "dirty-worktree");
+  if (isRebaseInProgress(linked.path)) return refuse(opId, "rebase-in-progress");
+  const head = currentHead(linked.path);
+  if (!head || head !== manifest.lastPrHeadSha || head !== pr.headSha) {
+    return refuse(opId, "head-mismatch", {
+      local: head ?? "",
+      manifest: manifest.lastPrHeadSha ?? "",
+      pr: pr.headSha ?? ""
+    });
+  }
+  const remote = deps.remote ?? "origin";
+  const remoteHead = remoteBranchHead(linked.path, remote, manifest.branch);
+  if (remoteHead.ok && remoteHead.present && remoteHead.sha !== head) {
+    return refuse(opId, "remote-diverged", { local: head, remote: remoteHead.sha });
+  }
+  const ahead = unpublishedAhead(linked.path, remote, manifest.branch);
+  if (ahead !== null && ahead > 0) {
+    return refuse(opId, "has-unpublished-commits", { ahead, branch: manifest.branch, remote });
+  }
+  if (manifest.workflowId) {
+    const snapshot = await readRunSnapshot(deps.repoRoot, manifest.workflowId);
+    if (snapshot?.state === "ready") return refuse(opId, "workflow-ready");
+    if (snapshot?.state === "merged") return refuse(opId, "workflow-merged");
+  }
+  return {
+    ok: true,
+    intent: {
+      schemaVersion: 1,
+      taskId: manifest.taskId,
+      issueNumber: manifest.issueNumber,
+      prNumber: manifest.prNumber,
+      branch: manifest.branch,
+      worktreePath: linked.path,
+      headSha: head,
+      workflowId: manifest.workflowId ?? null,
+      subject,
+      requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+async function resumeCleanup({ deps, intent, opId }) {
+  const removeWorktree = deps.removeWorktree ?? defaultRemoveWorktree;
+  const deleteBranch = deps.deleteBranch ?? defaultDeleteBranch;
+  const removeManifest = deps.deleteManifest ?? deleteManifest;
+  let removedWorktree = !existsSync8(intent.worktreePath);
+  if (!removedWorktree) {
+    let removed;
+    try {
+      removed = await Promise.resolve(removeWorktree(deps.repoRoot, intent.worktreePath));
+    } catch (err) {
+      return refuse(opId, "remove-failed", { stderr: String(err?.message ?? err) });
+    }
+    if (removed?.status !== 0 && existsSync8(intent.worktreePath)) {
+      return refuse(opId, "remove-failed", { stderr: removed?.stderr ?? "" });
+    }
+    removedWorktree = !existsSync8(intent.worktreePath);
+  }
+  let deletedBranch = !branchExists(deps.repoRoot, intent.branch);
+  if (!deletedBranch) {
+    let deleted;
+    try {
+      deleted = await Promise.resolve(deleteBranch(deps.repoRoot, intent.branch, intent.headSha));
+    } catch (err) {
+      return refuse(opId, "branch-delete-failed", { stderr: String(err?.message ?? err) });
+    }
+    if (deleted?.status !== 0 && branchExists(deps.repoRoot, intent.branch)) {
+      return refuse(opId, "branch-delete-failed", { stderr: deleted?.stderr ?? "" });
+    }
+    deletedBranch = !branchExists(deps.repoRoot, intent.branch);
+  }
+  try {
+    await Promise.resolve(removeManifest(deps.repoRoot, intent.taskId));
+  } catch (err) {
+    return refuse(opId, "manifest-delete-failed", { stderr: String(err?.message ?? err) });
+  }
+  const remaining = await readManifest(deps.repoRoot, intent.taskId);
+  const deletedManifest = remaining === null;
+  const completion = {
+    schemaVersion: 1,
+    taskId: intent.taskId,
+    intentHash: intent.intentHash,
+    removedWorktree,
+    deletedBranch,
+    deletedManifest,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const published = await publishAbandonCompletion(deps.repoRoot, completion);
+  if (!published.ok) return refuse(opId, published.kind);
+  return success("abandon", {
+    taskId: intent.taskId,
+    intentHash: intent.intentHash,
+    removedWorktree,
+    deletedBranch,
+    deletedManifest
+  }, { operationId: opId, idempotent: published.idempotent === true });
+}
+function createAbandonTool(deps) {
+  return async function abandon(input) {
+    const opId = input.operationId ?? `abandon-${Date.now().toString(36)}`;
+    const taskId = String(input.taskId ?? "");
+    const subject = String(input.subject ?? "").trim();
+    if (!taskId) return refuse(opId, "missing-input", { field: "taskId" });
+    if (!subject) return refuse(opId, "missing-input", { field: "subject" });
+    const existing = await readAbandon(deps.repoRoot, taskId);
+    if (existing.completion) {
+      return success("abandon", {
+        taskId,
+        intentHash: existing.completion.intentHash,
+        removedWorktree: existing.completion.removedWorktree,
+        deletedBranch: existing.completion.deletedBranch,
+        deletedManifest: existing.completion.deletedManifest
+      }, { operationId: opId, idempotent: true });
+    }
+    if (existing.intent) {
+      if (existing.intent.subject !== subject || existing.intent.taskId !== taskId) {
+        return refuse(opId, "abandon-conflict");
+      }
+      return resumeCleanup({ deps, intent: existing.intent, opId });
+    }
+    const manifest = await readManifest(deps.repoRoot, taskId);
+    if (!manifest) return refuse(opId, "missing-manifest", { taskId });
+    const validated = await validateLiveAttempt({ deps, manifest, subject, opId });
+    if (!validated.ok) return validated;
+    const publishedIntent = await publishAbandonIntent(deps.repoRoot, validated.intent);
+    if (!publishedIntent.ok) return refuse(opId, publishedIntent.kind);
+    return resumeCleanup({ deps, intent: publishedIntent.record, opId });
   };
 }
 
 // src/version.js
-import { readFileSync, existsSync as existsSync7 } from "node:fs";
-import { dirname as dirname3, resolve as resolve9 } from "node:path";
+import { readFileSync, existsSync as existsSync9 } from "node:fs";
+import { dirname as dirname4, resolve as resolve10 } from "node:path";
 import { fileURLToPath } from "node:url";
-var PACKAGE_VERSION = "1.1.7";
+var PACKAGE_VERSION = "1.1.9-rc.1";
 var TEMPLATE_SET = `v${PACKAGE_VERSION}`;
 export {
   ADAPTER_CONTRACT_VERSION,
@@ -2793,6 +3309,7 @@ export {
   bucketFor,
   canTransition,
   checkGates,
+  createAbandonTool,
   createCleanupTool,
   createGhDriver,
   createGhStub,