Merge pull request #24 from sendbird/jin/release-1.0.5

Release 1.0.5

Author: sf-jin-ku

.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cc",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Claude Code Plugin for Codex. Delegate code reviews, investigations, and tracked tasks to Claude Code from inside Codex.",
   "author": {
     "name": "Sendbird, Inc.",

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## v1.0.5
+
+- Keep built-in background review jobs attached to the parent Codex session so plain `$cc:status` and `$cc:result` stay intuitive after nested rescue/review flows.
+- Make `$cc:status --all` show the full job history for the current repository workspace instead of staying session-scoped.
+- Harden large-diff review and hook fingerprinting so oversized `git diff` output degrades cleanly instead of failing with `ENOBUFS`.
+- Clarify README guidance around review visibility, large diffs, and the difference between session-scoped status and repository-wide status.
+
 ## v1.0.4
 
 - Make background built-in rescue/review completions steer users to `$cc:result <job-id>` instead of inlining raw child output.

README.md

@@ -114,6 +114,8 @@ Scope `auto` (the default) inspects `git status` and chooses between working-tre
 
 In foreground, review returns the result directly. In background, the plugin uses a Codex built-in subagent, tracks the review as a job, and nudges you to open the result when it completes.
 
+If the diff is too large to inline safely, the review prompt falls back to concise status/stat context and tells Claude to inspect the diff directly with read-only `git diff` commands instead of failing the run.
+
 ### `$cc:adversarial-review`
 
 Same as `$cc:review`, but steers Claude to challenge the implementation — tradeoffs, alternative approaches, hidden assumptions.
@@ -163,10 +165,12 @@ Background rescue runs through a built-in Codex subagent. When the child finishe
 ```text
 $cc:status                          # list active and recent jobs
 $cc:status task-abc123              # detailed status for one job
-$cc:status --all                    # include older jobs
+$cc:status --all                    # show all tracked jobs in this repository workspace
 $cc:status --wait task-abc123       # block until job completes
 ```
 
+By default, `$cc:status` shows jobs owned by the current Codex session. Use `--all` when you want the wider repository view across older or sibling sessions in the same workspace.
+
 ### `$cc:result`
 
 ```text
@@ -205,7 +209,7 @@ All review and rescue commands support `--background`. Background jobs are track
 3. **Completion nudges** — when a background built-in flow finishes, the plugin tries to nudge the parent thread with the right `$cc:result <job-id>`. If that nudge cannot surface cleanly, unread-result hooks are the backstop.
    The nudge is intentionally just a pointer. The actual stored result still opens through `$cc:result`.
 4. **Unread-result fallback** — when you submit your next prompt after a finished unread job, Codex can remind you that a result is waiting and point you to `$cc:status` / `$cc:result`.
-5. **Session ownership** — jobs are scoped to the Codex session that created them. Nested sessions do not steal ownership of parent jobs.
+5. **Session ownership** — jobs stay attached to the user-facing parent Codex session even when a built-in rescue/review child does the actual work, so plain `$cc:status` still shows the job you just launched.
 6. **Cleanup on exit** — when your Codex session ends, any still-running detached jobs are terminated via PID identity validation, and stale reserved job markers are cleaned up over time.
 
 **Typical background flow:**
@@ -317,6 +321,18 @@ $cc:result
 ```
 The built-in notify path is best-effort. The tracked job store and unread hook remain the reliable fallback.
 
+If you think the job may belong to an older session in the same repository, use:
+```text
+$cc:status --all
+```
+
+**Large review diff caused a failure or was omitted**
+That is expected on very large diffs. The plugin now degrades to a compact review context and points Claude toward read-only `git diff` commands instead of trying to inline everything. If you want the full picture, run a narrower review such as:
+```text
+$cc:review --base main
+$cc:review --scope working-tree
+```
+
 **Review gate draining tokens**
 Disable it: `$cc:setup --disable-review-gate`. The gate fires on every Ctrl+C, which adds up.
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-plugin-codex",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Claude Code Plugin for Codex by Sendbird",
   "type": "module",
   "author": {

package.json

@@ -176,6 +176,12 @@ function resolveExplicitJobId(value, workspaceRoot) {
   return explicitJobId;
 }
 
+function resolveOwnerSessionId(value) {
+  const trimmed = value == null ? "" : String(value).trim();
+  if (!trimmed) return null;
+  return sanitizeId(trimmed, "session ID");
+}
+
 async function withReleasedReservation(workspaceRoot, explicitJobId, fn) {
   try {
     return await fn();
@@ -1099,7 +1105,7 @@ async function resolveLatestResumableSession(cwd, options = {}) {
 
 async function handleReviewCommand(argv, config) {
   const { options, positionals } = parseCommandInput(argv, {
-    valueOptions: ["base", "scope", "model", "cwd", "view-state", "job-id"],
+    valueOptions: ["base", "scope", "model", "cwd", "view-state", "job-id", "owner-session-id"],
     booleanOptions: ["json", "background", "wait"],
     aliasMap: {
       m: "model"
@@ -1115,6 +1121,7 @@ async function handleReviewCommand(argv, config) {
     scope: options.scope
   });
   const explicitJobId = resolveExplicitJobId(options["job-id"], workspaceRoot);
+  const ownerSessionId = resolveOwnerSessionId(options["owner-session-id"]);
   const markViewedOnSuccess = resolveMarkViewedOnSuccess(
     options["view-state"],
     Boolean(options.background)
@@ -1132,6 +1139,7 @@ async function handleReviewCommand(argv, config) {
       workspaceRoot,
       jobClass: "review",
       summary: metadata.summary,
+      sessionId: ownerSessionId,
       explicitJobId
     });
 
@@ -1234,7 +1242,7 @@ async function handleTask(argv) {
   ensureClaudeReady(cwd);
 
   const write = Boolean(options.write);
-  const ownerSessionId = options["owner-session-id"] || null;
+  const ownerSessionId = resolveOwnerSessionId(options["owner-session-id"]);
   const explicitJobId = resolveExplicitJobId(options["job-id"], workspaceRoot);
   await withReleasedReservation(workspaceRoot, explicitJobId, async () => {
     const taskMetadata = buildTaskRunMetadata({

scripts/claude-companion.mjs

@@ -7,10 +7,12 @@ import { createHash } from "node:crypto";
 import path from "node:path";
 
 import { isProbablyText } from "./fs.mjs";
-import { runCommand, runCommandChecked } from "./process.mjs";
+import { formatCommandFailure, runCommand, runCommandChecked } from "./process.mjs";
 
 const MAX_UNTRACKED_BYTES = 24 * 1024;
 const MAX_INLINE_REVIEW_DIFF_BYTES = 64 * 1024;
+const REVIEW_DIFF_READ_MAX_BUFFER = MAX_INLINE_REVIEW_DIFF_BYTES + 8 * 1024;
+const HASH_OBJECT_BATCH_SIZE = 128;
 
 function git(cwd, args, options = {}) {
   return runCommand("git", args, { cwd, ...options });
@@ -109,17 +111,16 @@ function buildUntrackedMetadataFingerprint(repoRoot, relativePaths) {
 
 export function getWorkingTreeFingerprint(cwd) {
   const repoRoot = getRepoRoot(cwd);
-  const stagedDiff = gitChecked(repoRoot, [
+  const stagedDiffHash = gitChecked(repoRoot, ["write-tree"]).stdout.trim();
+  const unstaged = gitChecked(repoRoot, [
     "diff",
-    "--cached",
+    "--name-only",
     "--no-ext-diff",
-    "--submodule=diff",
-  ]).stdout;
-  const unstagedDiff = gitChecked(repoRoot, [
-    "diff",
-    "--no-ext-diff",
-    "--submodule=diff",
-  ]).stdout;
+    "-z",
+  ]).stdout
+    .split("\0")
+    .filter(Boolean)
+    .sort();
   const untracked = gitChecked(repoRoot, [
     "ls-files",
     "--others",
@@ -130,8 +131,7 @@ export function getWorkingTreeFingerprint(cwd) {
     .filter(Boolean)
     .sort();
 
-  const stagedDiffHash = hashText(stagedDiff);
-  const unstagedDiffHash = hashText(unstagedDiff);
+  const unstagedDiffHash = hashWorkingTreePaths(repoRoot, unstaged);
   const untrackedFingerprintHash = buildUntrackedMetadataFingerprint(
     repoRoot,
     untracked
@@ -155,6 +155,75 @@ export function getWorkingTreeFingerprint(cwd) {
   };
 }
 
+function hashWorkingTreePaths(repoRoot, relativePaths) {
+  const hash = createHash("sha256");
+  const regularPaths = [];
+
+  for (const relativePath of relativePaths) {
+    hash.update(relativePath, "utf8");
+    hash.update("\0", "utf8");
+
+    const absolutePath = path.join(repoRoot, relativePath);
+    try {
+      const stat = fs.lstatSync(absolutePath);
+      if (stat.isDirectory()) {
+        hash.update("directory", "utf8");
+        hash.update("\0", "utf8");
+        hash.update(String(Math.trunc(stat.mtimeMs)), "utf8");
+        hash.update("\0", "utf8");
+        continue;
+      }
+
+      if (stat.isSymbolicLink()) {
+        hash.update("symlink", "utf8");
+        hash.update("\0", "utf8");
+        hash.update(fs.readlinkSync(absolutePath), "utf8");
+        hash.update("\0", "utf8");
+        continue;
+      }
+
+      regularPaths.push(relativePath);
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        hash.update("deleted", "utf8");
+      } else {
+        throw error;
+      }
+    }
+    hash.update("\0", "utf8");
+  }
+
+  const blobHashes = readBlobHashes(repoRoot, regularPaths);
+  for (const relativePath of regularPaths) {
+    hash.update(blobHashes.get(relativePath), "utf8");
+    hash.update("\0", "utf8");
+  }
+
+  return hash.digest("hex");
+}
+
+function readBlobHashes(repoRoot, relativePaths) {
+  const hashes = new Map();
+  for (let index = 0; index < relativePaths.length; index += HASH_OBJECT_BATCH_SIZE) {
+    const batch = relativePaths.slice(index, index + HASH_OBJECT_BATCH_SIZE);
+    const stdout = gitChecked(repoRoot, ["hash-object", "--no-filters", "--", ...batch]).stdout;
+    const digestLines = stdout
+      .trim()
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean);
+    if (digestLines.length !== batch.length) {
+      throw new Error(
+        `git hash-object returned ${digestLines.length} hashes for ${batch.length} path(s).`
+      );
+    }
+    batch.forEach((relativePath, batchIndex) => {
+      hashes.set(relativePath, digestLines[batchIndex]);
+    });
+  }
+  return hashes;
+}
+
 export function resolveReviewTarget(cwd, options = {}) {
   ensureGitRepository(cwd);
 
@@ -259,25 +328,44 @@ function shouldInlineReviewDiff(...sections) {
   return true;
 }
 
+function readBoundedGitDiff(cwd, args) {
+  const result = git(cwd, args, { maxBuffer: REVIEW_DIFF_READ_MAX_BUFFER });
+  if (result.error) {
+    if (result.error.code === "ENOBUFS") {
+      return { text: "", tooLarge: true };
+    }
+    throw new Error(
+      `${result.command} ${result.args.join(" ")}: ${result.error.message}`
+    );
+  }
+  if (result.status !== 0) {
+    throw new Error(formatCommandFailure(result));
+  }
+  return { text: result.stdout, tooLarge: false };
+}
+
 function collectWorkingTreeContext(cwd, state) {
   const status = gitChecked(cwd, ["status", "--short"]).stdout.trim();
-  const stagedDiff = gitChecked(cwd, ["diff", "--cached", "--no-ext-diff", "--submodule=diff"]).stdout;
-  const unstagedDiff = gitChecked(cwd, ["diff", "--no-ext-diff", "--submodule=diff"]).stdout;
   const untrackedBody = state.untracked.map((file) => formatUntrackedFile(cwd, file)).join("\n\n");
-  const inlineDiffs = shouldInlineReviewDiff(status, stagedDiff, unstagedDiff, untrackedBody);
+  const stagedDiff = readBoundedGitDiff(cwd, ["diff", "--cached", "--no-ext-diff", "--submodule=diff"]);
+  const unstagedDiff = readBoundedGitDiff(cwd, ["diff", "--no-ext-diff", "--submodule=diff"]);
+  const inlineDiffs =
+    !stagedDiff.tooLarge &&
+    !unstagedDiff.tooLarge &&
+    shouldInlineReviewDiff(status, stagedDiff.text, unstagedDiff.text, untrackedBody);
 
   const parts = [
     formatSection("Git Status", status),
     formatSection(
       "Staged Diff",
       inlineDiffs
-        ? stagedDiff
+        ? stagedDiff.text
         : "Large diff omitted. Inspect staged changes directly with read-only git commands such as `git diff --cached --no-ext-diff --submodule=diff`."
     ),
     formatSection(
       "Unstaged Diff",
       inlineDiffs
-        ? unstagedDiff
+        ? unstagedDiff.text
         : "Large diff omitted. Inspect unstaged changes directly with read-only git commands such as `git diff --no-ext-diff --submodule=diff`."
     ),
     formatSection("Untracked Files", untrackedBody)
@@ -296,8 +384,10 @@ function collectBranchContext(cwd, baseRef) {
   const currentBranch = getCurrentBranch(cwd);
   const logOutput = gitChecked(cwd, ["log", "--oneline", "--decorate", commitRange]).stdout.trim();
   const diffStat = gitChecked(cwd, ["diff", "--stat", commitRange]).stdout.trim();
-  const diff = gitChecked(cwd, ["diff", "--no-ext-diff", "--submodule=diff", commitRange]).stdout;
-  const inlineDiff = shouldInlineReviewDiff(logOutput, diffStat, diff);
+  const diff = readBoundedGitDiff(cwd, ["diff", "--no-ext-diff", "--submodule=diff", commitRange]);
+  const inlineDiff =
+    !diff.tooLarge &&
+    shouldInlineReviewDiff(logOutput, diffStat, diff.text);
 
   return {
     mode: "branch",
@@ -308,7 +398,7 @@ function collectBranchContext(cwd, baseRef) {
       formatSection(
         "Branch Diff",
         inlineDiff
-          ? diff
+          ? diff.text
           : `Large diff omitted. Inspect the branch diff directly with read-only git commands such as \`git diff --no-ext-diff --submodule=diff ${commitRange}\`.`
       )
     ].join("\n")

scripts/lib/git.mjs

@@ -156,10 +156,12 @@ export function buildStatusSnapshot(cwd, options = {}) {
   const workspaceRoot = resolveWorkspaceRoot(cwd);
   const config = getConfig(workspaceRoot);
   const jobs = sortJobsNewestFirst(
-    filterJobsForCurrentSession(listJobs(workspaceRoot), {
-      ...options,
-      cwd: workspaceRoot,
-    })
+    options.all
+      ? listJobs(workspaceRoot)
+      : filterJobsForCurrentSession(listJobs(workspaceRoot), {
+          ...options,
+          cwd: workspaceRoot,
+        })
   );
   const maxJobs = options.maxJobs ?? DEFAULT_MAX_STATUS_JOBS;
   const maxProgressLines = options.maxProgressLines ?? DEFAULT_MAX_PROGRESS_LINES;

scripts/lib/job-control.mjs

@@ -13,6 +13,7 @@ export function runCommand(command, args = [], options = {}) {
     env: options.env,
     encoding: "utf8",
     input: options.input,
+    maxBuffer: options.maxBuffer,
     stdio: options.stdio ?? "pipe",
     shell: false
   });

scripts/lib/process.mjs

@@ -58,6 +58,7 @@ Background flow:
 - Before spawning the built-in child, reserve a review job id by running:
   `node "<plugin-root>/scripts/claude-companion.mjs" review-reserve-job --json`
 - If that helper returns a non-empty `jobId`, pass it into the companion command as an internal `--job-id <reserved-job-id>` routing flag.
+- Add an internal `--owner-session-id <parent-session-id>` routing flag when spawning the built-in child so the tracked review job stays visible in the parent Codex session's plain `$cc:status`.
 - If the built-in review is running in background, the parent should first capture its own thread id by running:
   `node -e "process.stdout.write(process.env.CODEX_THREAD_ID || '')"`
 - If that command returns a non-empty thread id, pass it into the child prompt as the parent thread id for one-shot completion notification.
@@ -76,6 +77,7 @@ Background flow:
   - run exactly one shell command
   - execute:
     `node "<plugin-root>/scripts/claude-companion.mjs" adversarial-review --view-state defer <arguments with --wait/--background removed>`
+  - include `--owner-session-id <parent-session-id>` so background review jobs stay attached to the parent session
   - include `--job-id <reserved-job-id>` when the parent reserved one
   - return only that command's stdout exactly, with no added commentary
   - ignore stderr progress chatter such as `[cc] ...` lines and preserve only the final stdout-equivalent result text