@@ -2,7 +2,7 @@
 description: Delegate investigation, an explicit fix request, or follow-up rescue work to the OpenCode rescue subagent
 argument-hint: "[--background|--wait] [--worktree] [--resume|--fresh] [--model <provider/model>] [--agent <build|plan>] [what OpenCode should investigate, solve, or continue]"
 context: fork
-allowed-tools: Bash(node:*)
+allowed-tools: Bash(node:*), AskUserQuestion
 ---
 
 Route this request to the `opencode:opencode-rescue` subagent.
 
@@ -7,7 +7,7 @@ allowed-tools: Bash(node:*), Bash(npm:*), Bash(brew:*), Bash(curl:*), AskUserQue
 Run:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/opencode-companion.mjs" setup --json $ARGUMENTS
+node "${CLAUDE_PLUGIN_ROOT}/scripts/opencode-companion.mjs" setup --json "$ARGUMENTS"
 ```
 
 If the result says OpenCode is unavailable:
@@ -25,7 +25,7 @@ npm install -g opencode-ai
 - Then rerun:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/opencode-companion.mjs" setup --json $ARGUMENTS
+node "${CLAUDE_PLUGIN_ROOT}/scripts/opencode-companion.mjs" setup --json "$ARGUMENTS"
 ```
 
 If OpenCode is already installed:
 
@@ -16,17 +16,24 @@ import {
   getPrDiff,
 } from "./git.mjs";
 
-// Inline-diff thresholds. When a review exceeds either, we fall back to a
-// "self-collect" context that omits the full diff and asks OpenCode to
-// inspect the change itself via read-only git commands. See issue #40 and
-// openai/codex-plugin-cc#179.
+// Inline-diff thresholds. When a review exceeds either, we keep the prompt
+// bounded by including a diff excerpt instead of the full diff. The review
+// agent is intentionally shell-disabled, so the prompt must contain the
+// evidence the model is allowed to use.
 const DEFAULT_INLINE_DIFF_MAX_FILES = 5;
 const DEFAULT_INLINE_DIFF_MAX_BYTES = 256 * 1024;
 
-function buildCollectionGuidance(includeDiff) {
-  return includeDiff
+function buildCollectionGuidance(diffIsComplete) {
+  return diffIsComplete
     ? "Use the repository context below as primary evidence."
-    : "The repository context below is a lightweight summary. The full diff is intentionally omitted — inspect the target yourself with read-only git commands (git diff, git log, git show) before finalizing findings.";
+    : "The repository context below contains a bounded diff excerpt, not the complete diff. Only report findings supported by the provided excerpt, metadata, status, and changed-file list; explicitly say when omitted diff content prevents a conclusion.";
+}
+
+function truncateUtf8(text, maxBytes) {
+  if (!text) return text;
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return text;
+  return buf.subarray(0, maxBytes).toString("utf8").replace(/\uFFFD$/, "");
 }
 
 /**
@@ -57,28 +64,31 @@ export async function buildReviewPrompt(cwd, opts, pluginRoot) {
     diffStat = await getDiffStat(cwd, { base: opts.base });
   }
 
-  // Classify the review scope. Large reviews fall back to a lightweight
-  // context (stat + changed-files list + status) so the prompt doesn't blow
-  // past model/provider input limits. OpenCode is then instructed to
-  // inspect the diff itself via read-only git commands.
   const diffBytes = Buffer.byteLength(diff || "", "utf8");
   const maxFiles = Number.isFinite(opts.maxInlineDiffFiles)
     ? opts.maxInlineDiffFiles
     : DEFAULT_INLINE_DIFF_MAX_FILES;
   const maxBytes = Number.isFinite(opts.maxInlineDiffBytes)
     ? opts.maxInlineDiffBytes
     : DEFAULT_INLINE_DIFF_MAX_BYTES;
-  const includeDiff = changedFiles.length <= maxFiles && diffBytes <= maxBytes;
-  const collectionGuidance = buildCollectionGuidance(includeDiff);
+  const overFileLimit = changedFiles.length > maxFiles;
+  const overByteLimit = diffBytes > maxBytes;
+  const diffIsComplete = !overByteLimit;
+  const diffForPrompt = overByteLimit ? truncateUtf8(diff, maxBytes) : diff;
+  const collectionGuidance = buildCollectionGuidance(diffIsComplete);
 
   const targetLabel = prInfo
     ? `Pull request #${prInfo.number} "${prInfo.title}" (${prInfo.headRefName} -> ${prInfo.baseRefName})`
     : opts.base
       ? `Branch diff against ${opts.base}`
       : "Working tree changes";
 
-  const reviewContext = buildReviewContext(diff, status, changedFiles, prInfo, {
-    includeDiff,
+  const reviewContext = buildReviewContext(diffForPrompt, status, changedFiles, prInfo, {
+    diffIsComplete,
+    originalDiffBytes: diffBytes,
+    maxInlineDiffBytes: maxBytes,
+    overFileLimit,
+    overByteLimit,
     diffStat,
   });
 
@@ -112,7 +122,7 @@ function buildStandardReviewPrompt(diff, status, changedFiles, opts) {
 
   const reviewContext =
     opts.reviewContext
-    ?? buildReviewContext(diff, status, changedFiles, opts.prInfo, { includeDiff: true });
+    ?? buildReviewContext(diff, status, changedFiles, opts.prInfo, { diffIsComplete: true });
   const collectionGuidance = opts.collectionGuidance ?? buildCollectionGuidance(true);
 
   return `You are performing a code review of ${targetLabel}.
@@ -136,13 +146,11 @@ ${reviewContext}`;
 /**
  * Build the repository context block for review prompts.
  *
- * When `opts.includeDiff` is false (large-review fallback), the full `<diff>`
- * block is omitted and a `<diff_stat>` summary is emitted instead. OpenCode
- * is expected to inspect the diff itself via read-only git commands — the
- * collection-guidance line above the context makes this explicit.
+ * When `opts.diffIsComplete` is false, the `<diff>` block is a bounded
+ * excerpt. The surrounding note tells the model not to invent findings from
+ * omitted content.
  */
 function buildReviewContext(diff, status, changedFiles, prInfo, opts = {}) {
-  const includeDiff = opts.includeDiff !== false;
   const sections = [];
 
   if (prInfo) {
@@ -166,16 +174,31 @@ function buildReviewContext(diff, status, changedFiles, prInfo, opts = {}) {
     sections.push(`<changed_files>\n${changedFiles.join("\n")}\n</changed_files>`);
   }
 
-  if (includeDiff) {
-    if (diff) {
-      sections.push(`<diff>\n${diff}\n</diff>`);
+  if (opts.overFileLimit || opts.overByteLimit) {
+    const reasons = [];
+    if (opts.overFileLimit) reasons.push(`file count ${changedFiles.length}`);
+    if (opts.overByteLimit) {
+      reasons.push(`diff size ${opts.originalDiffBytes} bytes`);
     }
-  } else {
-    const statBody =
-      opts.diffStat && opts.diffStat.length > 0
-        ? opts.diffStat
-        : `(diff too large to inline: ${changedFiles.length} file(s))`;
-    sections.push(`<diff_stat>\n${statBody}\n</diff_stat>`);
+    const budget = opts.overByteLimit && opts.maxInlineDiffBytes
+      ? `; excerpt budget ${opts.maxInlineDiffBytes} bytes`
+      : "";
+    const note = opts.diffIsComplete === false
+      ? "Diff context is bounded"
+      : "Review spans a broad changed-file set, but the diff below is complete";
+    sections.push(
+      `<diff_note>\n` +
+      `${note} (${reasons.join(", ")}${budget}). ` +
+      `Findings must be supported by the diff evidence below.\n` +
+      `</diff_note>`
+    );
+    if (opts.diffStat) {
+      sections.push(`<diff_stat>\n${opts.diffStat}\n</diff_stat>`);
+    }
+  }
+
+  if (diff) {
+    sections.push(`<diff>\n${diff}\n</diff>`);
   }
 
   return sections.join("\n\n");
 
@@ -46,7 +46,14 @@ import { isOpencodeInstalled, getOpencodeVersion, spawnDetached, getConfiguredPr
 import { isServerRunning, ensureServer, createClient, connect } from "./lib/opencode-server.mjs";
 import { resolveWorkspace } from "./lib/workspace.mjs";
 import { loadState, updateState, upsertJob, generateJobId, jobDataPath } from "./lib/state.mjs";
-import { buildStatusSnapshot, resolveResultJob, resolveCancelableJob, enrichJob, reconcileAllJobs } from "./lib/job-control.mjs";
+import {
+  buildStatusSnapshot,
+  resolveResultJob,
+  resolveCancelableJob,
+  enrichJob,
+  reconcileAllJobs,
+  matchJobReference,
+} from "./lib/job-control.mjs";
 import { createJobRecord, runTrackedJob, getClaudeSessionId } from "./lib/tracked-jobs.mjs";
 import {
   renderStatus,
@@ -589,7 +596,11 @@ async function handleWorktreeCleanup(argv) {
 
   const workspace = await resolveWorkspace();
   const state = loadState(workspace);
-  const job = state.jobs?.find((j) => j.id === jobId || j.id.startsWith(jobId));
+  const { job, ambiguous } = matchJobReference(state.jobs ?? [], jobId);
+  if (ambiguous) {
+    console.error("Ambiguous job reference. Please provide a more specific ID prefix.");
+    process.exit(1);
+  }
   if (!job) {
     console.error(`No job found for ${jobId}.`);
     process.exit(1);
@@ -631,24 +642,53 @@ async function handleWorktreeCleanup(argv) {
 async function handleTaskWorker(argv) {
   const { options } = parseArgs(argv, {
     valueOptions: ["job-id", "workspace", "task-text", "agent", "model", "resume-session"],
-    booleanOptions: ["write"],
+    booleanOptions: ["write", "worktree"],
   });
 
   const workspace = options.workspace;
   const jobId = options["job-id"];
   const taskText = options["task-text"];
   const agentName = options.agent ?? "build";
   const isWrite = !!options.write;
+  const useWorktree = Boolean(options.worktree);
   const resumeSessionId = options["resume-session"];
 
   if (!workspace || !jobId || !taskText) {
     process.exit(1);
   }
 
+  let worktreeSession = null;
+  let effectiveCwd = workspace;
+  if (useWorktree) {
+    try {
+      worktreeSession = await createWorktreeSession(workspace);
+      effectiveCwd = worktreeSession.worktreePath;
+      upsertJob(workspace, {
+        id: jobId,
+        worktreeSession: {
+          worktreePath: worktreeSession.worktreePath,
+          branch: worktreeSession.branch,
+          repoRoot: worktreeSession.repoRoot,
+          baseCommit: worktreeSession.baseCommit,
+          timestamp: worktreeSession.timestamp,
+        },
+      });
+    } catch (err) {
+      upsertJob(workspace, {
+        id: jobId,
+        status: "failed",
+        phase: "failed",
+        completedAt: new Date().toISOString(),
+        errorMessage: `Failed to create worktree: ${err.message}`,
+      });
+      process.exit(1);
+    }
+  }
+
   try {
     await runTrackedJob(workspace, { id: jobId }, async ({ report, log }) => {
       report("starting", "Background worker connecting to OpenCode...");
-      const client = await connect({ cwd: workspace });
+      const client = await connect({ cwd: effectiveCwd });
 
       let sessionId;
       if (resumeSessionId) {
@@ -663,17 +703,48 @@ async function handleTaskWorker(argv) {
 
       const prompt = buildTaskPrompt(taskText, { write: isWrite });
       report("investigating", "Running task...");
+      log(`Agent: ${agentName}, Write: ${isWrite}, Worktree: ${worktreeSession?.branch ?? "no"}`);
 
       const response = await client.sendPrompt(sessionId, prompt, {
         agent: agentName,
       });
 
       const text = extractResponseText(response);
+
+      let worktreeDiff = null;
+      if (worktreeSession) {
+        try {
+          worktreeDiff = await diffWorktreeSession(worktreeSession);
+        } catch (err) {
+          log(`Failed to compute worktree diff: ${err.message}`);
+        }
+      }
+
       report("finalizing", "Done");
 
-      return { rendered: text, summary: text.slice(0, 500) };
+      return {
+        rendered: worktreeSession
+          ? renderWorktreeTaskOutput(text, worktreeSession, worktreeDiff, jobId)
+          : text,
+        summary: text.slice(0, 500),
+        worktreeSession: worktreeSession
+          ? {
+              worktreePath: worktreeSession.worktreePath,
+              branch: worktreeSession.branch,
+              repoRoot: worktreeSession.repoRoot,
+              baseCommit: worktreeSession.baseCommit,
+            }
+          : null,
+      };
     });
   } catch (err) {
+    if (worktreeSession) {
+      try {
+        await cleanupWorktreeSession(worktreeSession, { keep: false });
+      } catch {
+        // best-effort
+      }
+    }
     // Error is already logged by runTrackedJob
     process.exit(1);
   }
 
@@ -0,0 +1,63 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createTmpDir, cleanupTmpDir, setupTestEnv } from "./helpers.mjs";
+import { runCommand } from "../plugins/opencode/scripts/lib/process.mjs";
+import { saveState } from "../plugins/opencode/scripts/lib/state.mjs";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const companionScript = path.join(repoRoot, "plugins", "opencode", "scripts", "opencode-companion.mjs");
+
+let tmpDir;
+let workspace;
+
+beforeEach(() => {
+  tmpDir = createTmpDir("companion-cli");
+  workspace = path.join(tmpDir, "workspace");
+  fs.mkdirSync(workspace);
+  setupTestEnv(tmpDir);
+});
+
+afterEach(() => {
+  cleanupTmpDir(tmpDir);
+});
+
+describe("opencode-companion CLI", () => {
+  it("worktree-cleanup rejects ambiguous job ID prefixes", async () => {
+    saveState(workspace, {
+      config: {},
+      jobs: [
+        {
+          id: "task-abc",
+          type: "task",
+          worktreeSession: {
+            worktreePath: path.join(tmpDir, "wt-a"),
+            branch: "opencode/a",
+            repoRoot: workspace,
+          },
+        },
+        {
+          id: "task-abd",
+          type: "task",
+          worktreeSession: {
+            worktreePath: path.join(tmpDir, "wt-b"),
+            branch: "opencode/b",
+            repoRoot: workspace,
+          },
+        },
+      ],
+    });
+
+    const result = await runCommand(
+      "node",
+      [companionScript, "worktree-cleanup", "task-a", "--action", "discard"],
+      { cwd: workspace, env: { CLAUDE_PLUGIN_DATA: tmpDir } }
+    );
+
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stderr, /Ambiguous job reference/);
+    assert.equal(result.stdout, "");
+  });
+});