@sven1103/opencode-worktree-workflow 0.6.3 → 1.0.0-alpha.1

package/src/index.js

@@ -1,637 +1,351 @@
+import { tool } from "@opencode-ai/plugin";
+import { realpathSync } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 
-import { parse } from "jsonc-parser";
-import { tool } from "@opencode-ai/plugin";
-
-const DEFAULTS = {
-  branchPrefix: "wt/",
-  remote: "origin",
-  baseBranch: null,
-  worktreeRoot: ".worktrees/$REPO",
-  cleanupMode: "preview",
-  protectedBranches: [],
-};
-
-const RESULT_SCHEMA_VERSION = "1.0.0";
-
-async function pathExists(targetPath) {
-  try {
-    await fs.access(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function isMissingGitRepositoryError(message) {
-  return /not a git repository/i.test(message);
-}
-
-function isMissingRemoteError(message, remote) {
-  return new RegExp(`No such remote:?\s+${remote}|does not appear to be a git repository|Could not read from remote repository`, "i").test(message);
-}
-
-async function readJsonFile(filePath) {
-  if (!(await pathExists(filePath))) {
-    return null;
-  }
-
-  const source = await fs.readFile(filePath, "utf8");
-  const data = parse(source);
-  return data && typeof data === "object" ? data : null;
-}
-
-function normalizeBranchPrefix(prefix) {
-  if (!prefix) {
-    return "";
-  }
-
-  return prefix.endsWith("/") ? prefix : `${prefix}/`;
-}
-
-function slugifyTitle(title) {
-  return title
-    .normalize("NFKD")
-    .replace(/[\u0300-\u036f]/g, "")
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .replace(/-{2,}/g, "-");
-}
-
-function formatRootTemplate(template, repoRoot) {
-  const repoName = path.basename(repoRoot);
-  return template
-    .replaceAll("$REPO", repoName)
-    .replaceAll("$ROOT", repoRoot)
-    .replaceAll("$ROOT_PARENT", path.dirname(repoRoot));
-}
-
-function parseShortBranch(branchRef) {
-  const prefix = "refs/heads/";
-  return branchRef.startsWith(prefix) ? branchRef.slice(prefix.length) : branchRef;
-}
-
-function parseWorktreeList(output) {
-  const entries = [];
-  let current = null;
-
-  for (const rawLine of output.split("\n")) {
-    const line = rawLine.trim();
-    if (!line) {
-      if (current) {
-        entries.push(current);
-        current = null;
-      }
-      continue;
-    }
-
-    if (line.startsWith("worktree ")) {
-      if (current) {
-        entries.push(current);
-      }
-      current = { path: line.slice("worktree ".length) };
-      continue;
-    }
-
-    if (!current) {
-      continue;
-    }
-
-    if (line.startsWith("HEAD ")) {
-      current.head = line.slice("HEAD ".length);
-      continue;
-    }
-
-    if (line.startsWith("branch ")) {
-      current.branchRef = line.slice("branch ".length);
-      current.branch = parseShortBranch(current.branchRef);
-      continue;
-    }
-
-    if (line === "detached") {
-      current.detached = true;
-    }
-  }
-
-  if (current) {
-    entries.push(current);
-  }
-
-  return entries;
-}
-
-function shellQuote(value) {
-  return `'${String(value).replaceAll("'", `'"'"'`)}'`;
-}
-
-function formatWorktreeSummary(item) {
-  return `${item.branch || "(detached)"} -> ${item.path}${item.head ? ` (${item.head.slice(0, 12)})` : ""}`;
-}
-
-function formatCopyPasteCommands(item) {
-  const selector = item.branch || item.path;
-  const branchFlag = item.status === "safe" ? "-d" : "-D";
+import { createWorktreeWorkflowService, __internalService, isMissingGitRepositoryError, isMissingRemoteError } from "./core/worktree-service.js";
+import {
+  buildWorkspaceContext,
+  buildWtCleanCommandPromptParts,
+  buildWtNewCommandPromptParts,
+  classifyToolExecution,
+  decideContinuity,
+  deriveTaskTitle,
+  deriveWorkspaceRole,
+  extractHandoffArtifactPath,
+  getToolRewritePolicy,
+  hasOpaqueRepoRootAbsoluteReference,
+  inferTaskLifecycleTransition,
+  rewriteRepoScopedPathIntoWorktree,
+} from "./core/task-binding.js";
+import { createRuntimeStateStore } from "./runtime/state-store.js";
 
-  return [
-    `  copy: /wt-clean apply ${selector}`,
-    `  git:  git worktree remove ${shellQuote(item.path)} && git branch ${branchFlag} ${shellQuote(item.branch)}`,
-  ];
-}
-
-function formatPreviewSection(title, items, { includeCommands = false } = {}) {
-  if (items.length === 0) {
-    return [title, "- none"];
-  }
-
-  const lines = [title];
-
-  for (const item of items) {
-    lines.push(`- ${formatWorktreeSummary(item)}: ${item.reason}`);
-
-    if (includeCommands && item.branch) {
-      lines.push(...formatCopyPasteCommands(item));
-    }
-  }
-
-  return lines;
+function publishStructuredResult(context, result) {
+  context.metadata({ metadata: { result } });
+  return result.message || JSON.stringify(result, null, 2);
 }
 
-function formatPreview(grouped, defaultBranch) {
-  return [
-    `Worktrees connected to this repository against ${defaultBranch}:`,
-    "",
-    ...formatPreviewSection("Safe to clean automatically:", grouped.safe, { includeCommands: true }),
-    "",
-    ...formatPreviewSection("Needs review before cleanup:", grouped.review, { includeCommands: true }),
-    "",
-    ...formatPreviewSection("Not cleanable here:", grouped.blocked),
-    "",
-    "Run `/wt-clean apply` to remove only the safe group.",
-    "Run `/wt-clean apply <branch-or-path>` to also remove selected review items.",
-  ].join("\n");
-}
+const WORKSPACE_SYSTEM_CONTEXT_MARKER = "Active workspace context:";
 
-function formatPrepareSummary(result) {
+function formatWorkspaceSystemContext(workspaceContext) {
   return [
-    `Created worktree for "${result.title}".`,
-    `- branch: ${result.branch}`,
-    `- worktree: ${result.worktree_path}`,
-    `- default branch: ${result.default_branch}`,
-    `- base branch: ${result.base_branch}`,
-    `- base ref: ${result.base_ref}`,
-    `- base commit: ${result.base_commit}`,
+    WORKSPACE_SYSTEM_CONTEXT_MARKER,
+    `- task_id: ${workspaceContext.task_id}`,
+    `- task_title: ${workspaceContext.task_title}`,
+    `- worktree_path: ${workspaceContext.worktree_path}`,
+    "Policy: operate within this worktree for repository actions.",
   ].join("\n");
 }
 
-function formatCleanupSummary(defaultBranch, removed, failed, requestedSelectors) {
-  const lines = [`Cleaned worktrees relative to ${defaultBranch}:`];
-
-  if (removed.length === 0) {
-    lines.push("- none removed");
-  } else {
-    for (const item of removed) {
-      const modeLabel = item.selected ? "selected" : "auto";
-      lines.push(`- removed (${modeLabel}) ${item.branch} -> ${item.path}`);
-    }
-  }
-
-  if (requestedSelectors.length > 0) {
-    lines.push("");
-    lines.push("Requested selectors:");
-    for (const selector of requestedSelectors) {
-      lines.push(`- ${selector}`);
-    }
-  }
-
-  if (failed.length > 0) {
-    lines.push("");
-    lines.push("Cleanup skipped for:");
-    for (const item of failed) {
-      lines.push(`- ${item.branch || item.selector} -> ${item.path || "(no path)"}: ${item.reason}`);
+function createGitRunner($, directory) {
+  return async function git(args, options = {}) {
+    const cwd = options.cwd ?? directory;
+    const command = `git ${args.map((arg) => $.escape(String(arg))).join(" ")}`;
+    const result = await $`${{ raw: command }}`.cwd(cwd).quiet().nothrow();
+    const stdout = result.text().trim();
+    const stderr = result.stderr.toString("utf8").trim();
+    if (!options.allowFailure && result.exitCode !== 0) {
+      throw new Error(stderr || stdout || `Git command failed: ${command}`);
     }
-  }
-
-  return lines.join("\n");
-}
-
-function toStructuredCleanupItem(item) {
-  return {
-    branch: item.branch ?? null,
-    worktree_path: item.path ?? item.worktree_path ?? null,
-    head: item.head ?? null,
-    status: item.status ?? null,
-    reason: item.reason ?? null,
-    detached: Boolean(item.detached),
-    selectable: typeof item.selectable === "boolean" ? item.selectable : null,
+    return { stdout, stderr, exitCode: result.exitCode };
   };
 }
 
-function toStructuredCleanupFailure(item) {
-  return {
-    selector: item.selector ?? null,
-    branch: item.branch ?? null,
-    worktree_path: item.path ?? item.worktree_path ?? null,
-    head: item.head ?? null,
-    status: item.status ?? null,
-    reason: item.reason ?? null,
-    detached: Boolean(item.detached),
-    selectable: typeof item.selectable === "boolean" ? item.selectable : null,
-  };
-}
-
-function buildPrepareResult({ title, branch, worktreePath, defaultBranch, baseBranch, baseRef, baseCommit }) {
-  const result = {
-    schema_version: RESULT_SCHEMA_VERSION,
-    ok: true,
-    title,
-    branch,
-    worktree_path: worktreePath,
-    default_branch: defaultBranch,
-    base_branch: baseBranch,
-    base_ref: baseRef,
-    base_commit: baseCommit,
-    created: true,
-  };
-
-  return {
-    ...result,
-    message: formatPrepareSummary(result),
-  };
+function resolveSafeHandoffPath({ rawPath, repoRoot, directory }) {
+  if (typeof rawPath !== "string" || !rawPath.trim()) return null;
+  const candidate = path.resolve(path.isAbsolute(rawPath) ? rawPath : path.join(directory, rawPath));
+  const normalized = candidate.split(path.sep).join("/");
+  const safePattern = /\/\.opencode\/sessions\/[A-Za-z0-9_-]+\/handoffs\/[A-Za-z0-9._-]+\.json$/;
+  if (!safePattern.test(normalized)) return null;
+  const base = path.resolve(repoRoot);
+  const canonicalBase = (() => {
+    try {
+      return realpathSync(base);
+    } catch {
+      return base;
+    }
+  })();
+  const canonicalCandidate = (() => {
+    try {
+      return realpathSync(candidate);
+    } catch {
+      return candidate;
+    }
+  })();
+  const relative = path.relative(canonicalBase, canonicalCandidate);
+  const insideRepo = relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+  if (!insideRepo) return null;
+  return canonicalCandidate;
 }
 
-function publishStructuredResult(context, result) {
-  context.metadata({
-    metadata: {
-      result,
+async function enrichHandoffArtifact(filePath, workspaceContext) {
+  const source = await fs.readFile(filePath, "utf8");
+  const parsed = JSON.parse(source);
+  const payload = parsed && typeof parsed === "object" && typeof parsed.payload === "object" ? parsed.payload : {};
+  const next = {
+    ...parsed,
+    payload: {
+      ...payload,
+      ...workspaceContext,
     },
-  });
-
-  return result.message || JSON.stringify(result, null, 2);
-}
-
-function buildCleanupPreviewResult({ defaultBranch, baseBranch, baseRef, grouped }) {
-  const structuredGroups = {
-    safe: grouped.safe.map(toStructuredCleanupItem),
-    review: grouped.review.map(toStructuredCleanupItem),
-    blocked: grouped.blocked.map(toStructuredCleanupItem),
-  };
-
-  return {
-    schema_version: RESULT_SCHEMA_VERSION,
-    ok: true,
-    mode: "preview",
-    default_branch: defaultBranch,
-    base_branch: baseBranch,
-    base_ref: baseRef,
-    groups: structuredGroups,
-    message: formatPreview(grouped, baseBranch),
   };
+  await fs.writeFile(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }
 
-function buildCleanupApplyResult({ defaultBranch, baseBranch, baseRef, removed, failed, requestedSelectors }) {
-  return {
-    schema_version: RESULT_SCHEMA_VERSION,
-    ok: true,
-    mode: "apply",
-    default_branch: defaultBranch,
-    base_branch: baseBranch,
-    base_ref: baseRef,
-    requested_selectors: requestedSelectors,
-    removed: removed.map((item) => ({
-      ...toStructuredCleanupItem(item),
-      selected: Boolean(item.selected),
-    })),
-    failed: failed.map(toStructuredCleanupFailure),
-    message: formatCleanupSummary(baseBranch, removed, failed, requestedSelectors),
-  };
-}
-
-function splitCleanupToken(value) {
-  if (typeof value !== "string") {
-    return [];
+async function readJsonIfExists(filePath) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+    throw error;
   }
-
-  return value
-    .trim()
-    .split(/\s+/)
-    .filter(Boolean);
 }
 
-function parseCleanupRawArguments(raw) {
-  const tokens = splitCleanupToken(raw);
-
-  if (tokens[0] === "apply") {
-    return {
-      mode: "apply",
-      selectors: tokens.slice(1),
-    };
-  }
-
-  if (tokens[0] === "preview") {
-    return {
-      mode: "preview",
-      selectors: tokens.slice(1),
-    };
-  }
-
-  return {
-    mode: null,
-    selectors: tokens,
-  };
+function inferLifecycleSignalFromResultArtifact(resultArtifact) {
+  const status = typeof resultArtifact?.status === "string" ? resultArtifact.status : "";
+  const resultType = typeof resultArtifact?.result_type === "string" ? resultArtifact.result_type : "";
+  if (status === "blocked" || resultType === "blocked") return "block";
+  if (status === "done" || resultType === "implementation_summary") return "complete";
+  return null;
 }
 
-function normalizeCleanupArgs(args, config) {
-  const selectors = Array.isArray(args.selectors) ? [...args.selectors] : [];
-  const normalizedSelectors = [];
-  const rawArgs = parseCleanupRawArguments(args.raw);
-  let explicitMode = rawArgs.mode;
-
-  if (rawArgs.selectors.length > 0) {
-    selectors.unshift(...rawArgs.selectors);
-  }
-
-  if (typeof args.mode === "string" && args.mode.trim()) {
-    const modeValue = args.mode.trim();
-    if (modeValue === "apply" || modeValue === "preview") {
-      explicitMode = modeValue;
-    } else {
-      selectors.unshift(...splitCleanupToken(modeValue));
-    }
-  }
-
-  for (const selector of selectors) {
-    if (typeof selector !== "string") {
-      continue;
-    }
-
-    if (selector.includes(" ")) {
-      normalizedSelectors.push(...splitCleanupToken(selector));
-      continue;
-    }
-
-    normalizedSelectors.push(selector);
+async function resolveTaskResultLifecycleSignal(handoffPath) {
+  const handoff = await readJsonIfExists(handoffPath);
+  if (!handoff || typeof handoff !== "object") return null;
+  const handoffID = typeof handoff.handoff_id === "string" ? handoff.handoff_id : null;
+  if (!handoffID) return null;
+  const sessionDir = path.dirname(path.dirname(handoffPath));
+  const resultsDir = path.join(sessionDir, "results");
+  let resultFiles = [];
+  try {
+    resultFiles = await fs.readdir(resultsDir);
+  } catch (error) {
+    if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) throw error;
   }
-
-  const inlineApply = normalizedSelectors[0] === "apply";
-
-  if (inlineApply) {
-    normalizedSelectors.shift();
+  const candidates = [];
+  for (const fileName of resultFiles) {
+    if (!fileName.endsWith(".json")) continue;
+    const filePath = path.join(resultsDir, fileName);
+    const artifact = await readJsonIfExists(filePath);
+    if (!artifact || artifact.source_handoff_id !== handoffID) continue;
+    const signal = inferLifecycleSignalFromResultArtifact(artifact);
+    if (!signal) continue;
+    candidates.push({ filePath, artifact, signal });
   }
-
-  const mode = explicitMode === "apply" || inlineApply ? "apply" : explicitMode || config.cleanupMode;
-
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => {
+    const aCreated = typeof a.artifact?.created_at === "string" ? a.artifact.created_at : "";
+    const bCreated = typeof b.artifact?.created_at === "string" ? b.artifact.created_at : "";
+    return aCreated.localeCompare(bCreated);
+  });
+  const latest = candidates[candidates.length - 1];
   return {
-    mode,
-    selectors: normalizedSelectors,
+    signal: latest.signal,
+    handoff,
+    result_artifact_path: latest.filePath,
   };
 }
 
 export const __internal = {
-  RESULT_SCHEMA_VERSION,
-  buildCleanupApplyResult,
-  buildCleanupPreviewResult,
-  buildPrepareResult,
-  classifyEntry,
+  RESULT_SCHEMA_VERSION: __internalService.RESULT_SCHEMA_VERSION,
+  ...__internalService,
   isMissingGitRepositoryError,
   isMissingRemoteError,
-  parseCleanupRawArguments,
-  normalizeCleanupArgs,
-  toStructuredCleanupFailure,
-  toStructuredCleanupItem,
+  decideContinuity,
+  classifyToolExecution,
+  deriveTaskTitle,
+  deriveWorkspaceRole,
+  extractHandoffArtifactPath,
+  buildWorkspaceContext,
+  inferTaskLifecycleTransition,
+  getToolRewritePolicy,
+  rewriteRepoScopedPathIntoWorktree,
+  hasOpaqueRepoRootAbsoluteReference,
 };
 
-function selectorMatches(item, selector) {
-  const normalized = path.resolve(selector);
-  return item.branch === selector || item.path === normalized;
-}
-
-function classifyEntry(entry, repoRoot, activeWorktree, protectedBranches, mergedIntoBase) {
-  const entryPath = path.resolve(entry.path);
-  const branchName = entry.branch;
-  const item = {
-    branch: branchName,
-    path: entryPath,
-    head: entry.head,
-    detached: Boolean(entry.detached),
-  };
-
-  if (!branchName || entry.detached) {
-    return {
-      ...item,
-      status: "blocked",
-      reason: !branchName ? "no branch" : "detached HEAD",
-      selectable: false,
-    };
-  }
-
-  if (entryPath === path.resolve(repoRoot)) {
-    return {
-      ...item,
-      status: "blocked",
-      reason: entryPath === activeWorktree ? "repository root, current worktree, protected branch" : "repository root",
-      selectable: false,
-    };
-  }
-
-  if (entryPath === activeWorktree) {
-    return {
-      ...item,
-      status: "blocked",
-      reason: "current worktree",
-      selectable: false,
-    };
-  }
-
-  if (protectedBranches.has(branchName)) {
-    return {
-      ...item,
-      status: "blocked",
-      reason: "protected branch",
-      selectable: false,
-    };
-  }
-
-  if (mergedIntoBase) {
-    return {
-      ...item,
-      status: "safe",
-      reason: "merged into base branch by git ancestry",
-      selectable: true,
-    };
-  }
-
-  return {
-    ...item,
-    status: "review",
-    reason: "not merged into base branch by git ancestry",
-    selectable: true,
-  };
-}
-
 export const WorktreeWorkflowPlugin = async ({ $, directory }) => {
-  async function git(args, options = {}) {
-    const cwd = options.cwd ?? directory;
-    const command = `git ${args.map((arg) => $.escape(String(arg))).join(" ")}`;
-    const result = await $`${{ raw: command }}`.cwd(cwd).quiet().nothrow();
-    const stdout = result.text().trim();
-    const stderr = result.stderr.toString("utf8").trim();
+  const service = createWorktreeWorkflowService({
+    directory,
+    git: createGitRunner($, directory),
+    stateStore: createRuntimeStateStore(),
+  });
 
-    if (!options.allowFailure && result.exitCode !== 0) {
-      throw new Error(stderr || stdout || `Git command failed: ${command}`);
+  async function onToolExecuteBefore(input) {
+    const toolName = input?.tool?.name ?? input?.toolName;
+    const args = input?.args || {};
+    const classification = classifyToolExecution({ toolName, args });
+    if (classification.bypass) return input;
+    const rewritePolicy = getToolRewritePolicy({ toolName });
+
+    const sessionID = input?.sessionID ?? input?.context?.sessionID;
+    let binding = null;
+
+    if (classification.requiresIsolation) {
+      if (!sessionID) throw new Error(`Isolation required for ${toolName || "tool"} but sessionID is missing.`);
+      const repoRoot = await service.getRepoRoot();
+      for (const key of rewritePolicy.opaqueArgKeys) {
+        if (hasOpaqueRepoRootAbsoluteReference({ value: args[key], repoRoot })) {
+          throw new Error(`Blocked: ${toolName} ${key} includes repo-root absolute path that cannot be safely rewritten.`);
+        }
+      }
+      binding = await service.ensureActiveWorktree({
+        sessionID,
+        title: deriveTaskTitle({ toolName, args, sessionID }),
+        workspaceRole: deriveWorkspaceRole({ subagentType: args.subagent_type }),
+      });
+    } else if (sessionID) {
+      const repoRoot = await service.getRepoRoot();
+      const { activeTask } = await service.getSessionBinding({ repoRoot, sessionID });
+      if (activeTask?.worktree_path) binding = { repoRoot, task: activeTask };
     }
 
-    return {
-      stdout,
-      stderr,
-      exitCode: result.exitCode,
-    };
-  }
+    if (!binding) return input;
 
-  async function getRepoRoot() {
-    try {
-      const result = await git(["rev-parse", "--show-toplevel"]);
-      return result.stdout;
-    } catch (error) {
-      if (isMissingGitRepositoryError(error.message || "")) {
-        throw new Error(
-          "This command must run inside a git repository. Initialize a repository first or run it from an existing repo root.",
-        );
+    if (toolName === "task") {
+      const handoffPath = resolveSafeHandoffPath({
+        rawPath: extractHandoffArtifactPath(args.prompt),
+        repoRoot: binding.repoRoot,
+        directory,
+      });
+      if (!handoffPath) {
+        throw new Error("Blocked: Task delegation prompt must reference a safe handoff artifact path.");
       }
-
-      throw error;
+      const workspaceContext = buildWorkspaceContext({ task: binding.task, workspaceRole: deriveWorkspaceRole({ subagentType: args.subagent_type }) });
+      await enrichHandoffArtifact(handoffPath, workspaceContext);
+      return {
+        ...input,
+        args: {
+          ...args,
+          prompt: `${args.prompt}\n\nWorkspace binding:\n- task_id: ${workspaceContext.task_id}\n- worktree_path: ${workspaceContext.worktree_path}\n- workspace_role: ${workspaceContext.workspace_role}`,
+        },
+      };
     }
-  }
 
-  async function loadWorkflowConfig(repoRoot) {
-    const [projectConfig, projectConfigC, sidecarConfig] = await Promise.all([
-      readJsonFile(path.join(repoRoot, "opencode.json")),
-      readJsonFile(path.join(repoRoot, "opencode.jsonc")),
-      readJsonFile(path.join(repoRoot, ".opencode", "worktree-workflow.json")),
-    ]);
-
-    const merged = {
-      ...DEFAULTS,
-      ...(projectConfig?.worktreeWorkflow ?? {}),
-      ...(projectConfigC?.worktreeWorkflow ?? {}),
-      ...(sidecarConfig ?? {}),
-    };
-
-    return {
-      branchPrefix: normalizeBranchPrefix(merged.branchPrefix ?? DEFAULTS.branchPrefix),
-      remote: merged.remote || DEFAULTS.remote,
-      baseBranch: typeof merged.baseBranch === "string" && merged.baseBranch.trim() ? merged.baseBranch.trim() : null,
-      cleanupMode: merged.cleanupMode === "apply" ? "apply" : DEFAULTS.cleanupMode,
-      protectedBranches: Array.isArray(merged.protectedBranches)
-        ? merged.protectedBranches.filter((value) => typeof value === "string")
-        : [],
-      worktreeRoot: path.resolve(repoRoot, formatRootTemplate(merged.worktreeRoot || DEFAULTS.worktreeRoot, repoRoot)),
-    };
-  }
-
-  async function getDefaultBranch(repoRoot, remote) {
-    const remoteHead = await git(
-      ["symbolic-ref", "--quiet", "--short", `refs/remotes/${remote}/HEAD`],
-      { cwd: repoRoot, allowFailure: true },
-    );
-
-    if (remoteHead.exitCode === 0 && remoteHead.stdout.startsWith(`${remote}/`)) {
-      return remoteHead.stdout.slice(remote.length + 1);
+    const nextArgs = { ...args };
+    if (toolName === "bash" && nextArgs.workdir == null && nextArgs.cwd == null) {
+      nextArgs.workdir = binding.task.worktree_path;
+      nextArgs.cwd = binding.task.worktree_path;
     }
-
-    const remoteShow = await git(["remote", "show", remote], {
-      cwd: repoRoot,
-      allowFailure: true,
-    });
-
-    if (remoteShow.exitCode === 0) {
-      const match = remoteShow.stdout.match(/HEAD branch: (.+)/);
-      if (match?.[1]) {
-        return match[1].trim();
+    if ((toolName === "glob" || toolName === "grep") && nextArgs.path == null) {
+      nextArgs.path = binding.task.worktree_path;
+    }
+    for (const key of rewritePolicy.pathArgKeys) {
+      if (key in nextArgs) {
+        nextArgs[key] = rewriteRepoScopedPathIntoWorktree({
+          value: nextArgs[key],
+          repoRoot: binding.repoRoot,
+          worktreePath: binding.task.worktree_path,
+        });
       }
     }
 
-    for (const candidate of ["main", "master", "trunk", "develop"]) {
-      const hasLocal = await git(["show-ref", "--verify", "--quiet", `refs/heads/${candidate}`], {
-        cwd: repoRoot,
-        allowFailure: true,
-      });
-      if (hasLocal.exitCode === 0) {
-        return candidate;
-      }
+    return { ...input, args: nextArgs };
+  }
 
-      const hasRemote = await git(["show-ref", "--verify", "--quiet", `refs/remotes/${remote}/${candidate}`], {
-        cwd: repoRoot,
-        allowFailure: true,
+  async function onToolExecuteAfter(input) {
+    const toolName = input?.tool?.name ?? input?.toolName;
+    const args = input?.args || {};
+    const sessionID = input?.sessionID ?? input?.context?.sessionID;
+    if (toolName === "worktree_prepare" && sessionID) {
+      const result = input?.metadata?.result ?? input?.result;
+      if (result?.branch && result?.worktree_path) {
+        const repoRoot = await service.getRepoRoot();
+        await service.updateStateForPrepare(repoRoot, sessionID, result, "manual");
+      }
+    }
+    if (toolName === "task" && sessionID) {
+      const repoRoot = await service.getRepoRoot();
+      const handoffPath = resolveSafeHandoffPath({
+        rawPath: extractHandoffArtifactPath(args.prompt),
+        repoRoot,
+        directory,
       });
-      if (hasRemote.exitCode === 0) {
-        return candidate;
+      if (handoffPath) {
+        try {
+          const lifecycle = await resolveTaskResultLifecycleSignal(handoffPath);
+          if (lifecycle?.signal) {
+            const persisted = await service.recordTaskLifecycleSignal({
+              repoRoot,
+              sessionID,
+              taskID: lifecycle.handoff?.payload?.task_id,
+              worktreePath: lifecycle.handoff?.payload?.worktree_path,
+              signal: lifecycle.signal,
+            });
+            if (persisted && lifecycle.signal === "complete") {
+              try {
+                const advisory = await service.buildCleanupAdvisoryPreview({ repoRoot, activeWorktree: input?.context?.worktree ?? input?.worktree ?? directory });
+                const parts = Array.isArray(input?.output?.parts) ? [...input.output.parts] : [];
+                parts.push({ type: "text", text: advisory.message });
+                await service.recordToolUsage({ sessionID });
+                return {
+                  ...input,
+                  output: {
+                    ...(input?.output && typeof input.output === "object" ? input.output : {}),
+                    parts,
+                  },
+                  metadata: {
+                    ...(input?.metadata && typeof input.metadata === "object" ? input.metadata : {}),
+                    advisory_cleanup_preview: advisory,
+                  },
+                };
+              } catch {
+                // Advisory preview is non-fatal.
+              }
+            }
+          }
+        } catch {
+          // Artifact correlation/lifecycle inference is non-fatal.
+        }
       }
     }
+    if (sessionID) await service.recordToolUsage({ sessionID });
+    return input;
+  }
 
-    const currentBranch = await git(["branch", "--show-current"], {
-      cwd: repoRoot,
-      allowFailure: true,
-    });
+  async function onCommandExecuteBefore(input) {
+    const commandName = input?.command?.name ?? input?.name;
+    const normalizedName = typeof commandName === "string" ? commandName.replace(/^\//, "") : "";
+    if (normalizedName !== "wt-new" && normalizedName !== "wt-clean") return input;
 
-    if (currentBranch.stdout) {
-      return currentBranch.stdout;
-    }
-
-    throw new Error("Could not determine the default branch for this repository.");
-  }
+    const argsText = typeof input?.arguments === "string" ? input.arguments : typeof input?.args === "string" ? input.args : "";
+    const parts = normalizedName === "wt-new" ? buildWtNewCommandPromptParts(argsText) : buildWtCleanCommandPromptParts(argsText);
 
-  async function resolveBaseBranch(repoRoot, remote, configuredBaseBranch) {
-    return configuredBaseBranch || getDefaultBranch(repoRoot, remote);
+    return {
+      ...input,
+      output: {
+        ...(input?.output && typeof input.output === "object" ? input.output : {}),
+        parts,
+      },
+    };
   }
 
-  async function getBaseRef(repoRoot, remote, baseBranch) {
-    try {
-      await git(["fetch", "--prune", remote, baseBranch], { cwd: repoRoot });
-    } catch (error) {
-      if (isMissingRemoteError(error.message || "", remote)) {
-        throw new Error(
-          `Could not fetch base branch information from remote \"${remote}\". Configure the expected remote in .opencode/worktree-workflow.json or add that remote to this repository.`,
-        );
-      }
+  async function onExperimentalChatSystemTransform(input) {
+    const sessionID = input?.sessionID ?? input?.context?.sessionID;
+    const existingSystem = typeof input?.system === "string" ? input.system : "";
+    if (!sessionID || existingSystem.includes(WORKSPACE_SYSTEM_CONTEXT_MARKER)) return input;
 
-      throw error;
-    }
+    const repoRoot = await service.getRepoRoot();
+    const { activeTask } = await service.getSessionBinding({ repoRoot, sessionID });
+    if (!activeTask?.worktree_path) return input;
 
-    const remoteRef = `refs/remotes/${remote}/${baseBranch}`;
-    const remoteExists = await git(["show-ref", "--verify", "--quiet", remoteRef], {
-      cwd: repoRoot,
-      allowFailure: true,
+    const workspaceContext = buildWorkspaceContext({
+      task: activeTask,
+      workspaceRole: activeTask.workspace_role,
     });
-
-    return remoteExists.exitCode === 0 ? `${remote}/${baseBranch}` : baseBranch;
-  }
-
-  async function resolveBaseTarget(repoRoot, config) {
-    const defaultBranch = await getDefaultBranch(repoRoot, config.remote);
-    const baseBranch = await resolveBaseBranch(repoRoot, config.remote, config.baseBranch);
-    const baseRef = await getBaseRef(repoRoot, config.remote, baseBranch);
-
+    const injected = formatWorkspaceSystemContext(workspaceContext);
     return {
-      defaultBranch,
-      baseBranch,
-      baseRef,
+      ...input,
+      system: existingSystem ? `${existingSystem}\n\n${injected}` : injected,
     };
   }
 
-  async function ensureBranchDoesNotExist(repoRoot, branchName) {
-    const exists = await git(["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], {
-      cwd: repoRoot,
-      allowFailure: true,
-    });
-
-    if (exists.exitCode === 0) {
-      throw new Error(`Local branch already exists: ${branchName}`);
-    }
-  }
-
   return {
+    hooks: {
+      "command.execute.before": onCommandExecuteBefore,
+      "experimental.chat.system.transform": onExperimentalChatSystemTransform,
+      "tool.execute.before": onToolExecuteBefore,
+      "tool.execute.after": onToolExecuteAfter,
+    },
     tool: {
       worktree_prepare: tool({
         description: "Create a synced git worktree from a descriptive title",
@@ -640,50 +354,8 @@ export const WorktreeWorkflowPlugin = async ({ $, directory }) => {
         },
         async execute(args, context) {
           context.metadata({ title: `Create worktree: ${args.title}` });
-
-          const repoRoot = await getRepoRoot();
-          const config = await loadWorkflowConfig(repoRoot);
-          const { defaultBranch, baseBranch, baseRef } = await resolveBaseTarget(repoRoot, config);
-          const baseCommit = (await git(["rev-parse", baseRef], { cwd: repoRoot })).stdout;
-          const slug = slugifyTitle(args.title);
-
-          if (!slug) {
-            throw new Error("Could not derive a branch name from the provided title.");
-          }
-
-          const branchName = `${config.branchPrefix}${slug}`;
-          const worktreePath = path.join(config.worktreeRoot, slug);
-
-          await ensureBranchDoesNotExist(repoRoot, branchName);
-
-          if (await pathExists(worktreePath)) {
-            throw new Error(`Worktree path already exists: ${worktreePath}`);
-          }
-
-          await fs.mkdir(config.worktreeRoot, { recursive: true });
-          await git(["worktree", "add", "-b", branchName, worktreePath, baseRef], {
-            cwd: repoRoot,
-          });
-
-          const branchCommit = (await git(["rev-parse", branchName], { cwd: repoRoot })).stdout;
-          if (branchCommit !== baseCommit) {
-            throw new Error(
-              `New branch ${branchName} does not match ${baseBranch} at ${baseCommit}. Found ${branchCommit} instead.`,
-            );
-          }
-
-          return publishStructuredResult(
-            context,
-            buildPrepareResult({
-              title: args.title,
-              branch: branchName,
-              worktreePath,
-              defaultBranch,
-              baseBranch,
-              baseRef,
-              baseCommit,
-            }),
-          );
+          const result = await service.prepare({ title: args.title, sessionID: context.sessionID });
+          return publishStructuredResult(context, result);
         },
       }),
       worktree_cleanup: tool({
@@ -691,160 +363,18 @@ export const WorktreeWorkflowPlugin = async ({ $, directory }) => {
         args: {
           mode: tool.schema.string().optional().describe("Preview cleanup candidates or remove them"),
           raw: tool.schema.string().optional().describe("Raw cleanup arguments from slash commands"),
-          selectors: tool.schema
-            .array(tool.schema.string())
-            .default([])
-            .describe("Optional branch names or worktree paths to remove explicitly"),
+          selectors: tool.schema.array(tool.schema.string()).default([]).describe("Optional branch names or worktree paths to remove explicitly"),
         },
         async execute(args, context) {
-          const repoRoot = await getRepoRoot();
-          const config = await loadWorkflowConfig(repoRoot);
-          const normalizedArgs = normalizeCleanupArgs(args, config);
-
-          context.metadata({ title: `Clean worktrees (${normalizedArgs.mode})` });
-
-          const { defaultBranch, baseBranch, baseRef } = await resolveBaseTarget(repoRoot, config);
-          const activeWorktree = path.resolve(context.worktree || repoRoot);
-          const worktreeList = await git(["worktree", "list", "--porcelain"], { cwd: repoRoot });
-          const entries = parseWorktreeList(worktreeList.stdout);
-          const protectedBranches = new Set([defaultBranch, baseBranch, ...config.protectedBranches]);
-          const grouped = {
-            safe: [],
-            review: [],
-            blocked: [],
-          };
-
-          for (const entry of entries) {
-            const branchName = entry.branch;
-            let mergedIntoBase = false;
-
-            if (branchName && !entry.detached) {
-              const merged = await git(["merge-base", "--is-ancestor", branchName, baseRef], {
-                cwd: repoRoot,
-                allowFailure: true,
-              });
-
-              mergedIntoBase = merged.exitCode === 0;
-            }
-
-            const classified = classifyEntry(
-              entry,
-              repoRoot,
-              activeWorktree,
-              protectedBranches,
-              mergedIntoBase,
-            );
-
-            grouped[classified.status].push(classified);
-          }
-
-          if (normalizedArgs.mode !== "apply") {
-            return publishStructuredResult(
-              context,
-              buildCleanupPreviewResult({
-                defaultBranch,
-                baseBranch,
-                baseRef,
-                grouped,
-              }),
-            );
-          }
-
-          const requestedSelectors = [...new Set(normalizedArgs.selectors || [])];
-          const selected = [];
-          const failed = [];
-
-          for (const selector of requestedSelectors) {
-            const match = [...grouped.safe, ...grouped.review, ...grouped.blocked].find((item) =>
-              selectorMatches(item, selector),
-            );
-
-            if (!match) {
-              failed.push({
-                selector,
-                reason: "selector did not match any connected worktree",
-              });
-              continue;
-            }
-
-            if (!match.selectable) {
-              failed.push({
-                ...match,
-                selector,
-                reason: `cannot remove via selector: ${match.reason}`,
-              });
-              continue;
-            }
-
-            selected.push({
-              ...match,
-              selector,
-            });
-          }
-
-          const targets = [...grouped.safe];
-
-          for (const item of selected) {
-            if (!targets.some((target) => target.path === item.path)) {
-              targets.push({
-                ...item,
-                selector: item.selector ?? null,
-                selected: true,
-              });
-            }
-          }
-
-          const removed = [];
-
-          for (const candidate of targets) {
-            const removeWorktree = await git(["worktree", "remove", candidate.path], {
-              cwd: repoRoot,
-              allowFailure: true,
-            });
-
-            if (removeWorktree.exitCode !== 0) {
-              failed.push({
-                ...candidate,
-                reason: removeWorktree.stderr || removeWorktree.stdout || "worktree remove failed",
-              });
-              continue;
-            }
-
-            const deleteBranch = await git(
-              ["branch", candidate.status === "safe" ? "-d" : "-D", candidate.branch],
-              {
-                cwd: repoRoot,
-                allowFailure: true,
-              },
-            );
-
-            if (deleteBranch.exitCode !== 0) {
-              failed.push({
-                ...candidate,
-                reason: deleteBranch.stderr || deleteBranch.stdout || "branch delete failed",
-              });
-              continue;
-            }
-
-            removed.push(candidate);
-          }
-
-          await git(["worktree", "prune"], {
-            cwd: repoRoot,
-            allowFailure: true,
+          const result = await service.cleanup({
+            mode: args.mode,
+            raw: args.raw,
+            selectors: args.selectors,
+            worktree: context.worktree,
+            sessionID: context.sessionID,
           });
-
-          return publishStructuredResult(
-            context,
-            buildCleanupApplyResult({
-              defaultBranch,
-              baseBranch,
-              baseRef,
-              removed,
-              failed,
-              requestedSelectors,
-            }),
-          );
+          context.metadata({ title: `Clean worktrees (${result.mode})` });
+          return publishStructuredResult(context, result);
         },
       }),
     },