@opencode-ai/core 0.0.0-beta-18600 → 0.0.0-beta-18707

package/dist/chunks/{project-8ptyzv8c.js → model-a2dvn4yw.js}

@@ -1,36 +1,36 @@
 import {
   exports_parse
-} from "./project-zn8r3q6e.js";
+} from "./model-x8ejds6g.js";
 import {
-  exports_tool_output
-} from "./project-f7q7a28y.js";
+  exports_location_mutation
+} from "./model-zyaamr6c.js";
 import {
   exports_runtime
-} from "./project-g2nsgnf7.js";
-import {
-  exports_permission
-} from "./project-12r08axk.js";
+} from "./model-51jc707v.js";
 import {
   exports_shell
-} from "./project-r9pv5d9a.js";
+} from "./model-6cxkhhme.js";
+import {
+  exports_result
+} from "./model-etvrgfqj.js";
+import {
+  exports_permission
+} from "./model-955f6cmy.js";
 import {
   exports_environment1 as exports_environment
-} from "./project-0xzcm754.js";
+} from "./model-bach7bae.js";
 import {
   exports_config
-} from "./project-6kmefejb.js";
+} from "./model-qmpdqet2.js";
 import {
-  exports_location_mutation
-} from "./project-sg39537v.js";
+  NonNegativeInt
+} from "./model-j07kk359.js";
 import {
   exports_select
-} from "./project-bbhffenw.js";
-import {
-  NonNegativeInt
-} from "./project-j07kk359.js";
+} from "./model-bbhffenw.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/tool/plugin/shell.ts
 var exports_shell2 = {};
@@ -81,14 +81,7 @@ var Output = Schema.Struct({
   status: Schema.optionalKey(Schema.Literals(["completed", "running"]))
 });
 var resultMessages = (output) => {
-  const notice = (() => {
-    if (output.status === "running")
-      return BACKGROUND_INSTRUCTION;
-    if (output.timeout)
-      return "Command timed out before completion.";
-    if (output.exit !== undefined)
-      return `Command exited with code ${output.exit}.`;
-  })();
+  const notice = output.status === "running" ? BACKGROUND_INSTRUCTION : exports_result.notice(output);
   return [output.output, ...notice ? [notice] : []];
 };
 var toolResult = (output) => {
@@ -97,10 +90,8 @@ var toolResult = (output) => {
     content: resultMessages(output).map((text) => ({ type: "text", text })),
     metadata: {
       status: output.status,
-      truncated: output.truncated,
-      ...output.exit !== undefined ? { exit: output.exit } : {},
-      ...output.shellID !== undefined ? { shellID: output.shellID } : {},
-      ...output.timeout !== undefined ? { timeout: output.timeout } : {}
+      ...exports_result.metadata(output),
+      ...output.shellID !== undefined ? { shellID: output.shellID } : {}
     }
   };
 };
@@ -123,6 +114,45 @@ var Plugin = {
     const compatibleShell = shellSelect.resolve({ priority: "compat" });
     const permission = yield* exports_permission.Service;
     const config = yield* exports_config.Service;
+    const prepare = Effect.fn("ShellTool.prepare")(function* (invocation, context) {
+      const source = {
+        type: "tool",
+        messageID: context.messageID,
+        id: context.id
+      };
+      const target = yield* mutation.resolve({ path: invocation.cwd, kind: "directory" });
+      invocation.cwd = target.absolute;
+      const timeout = invocation.timeout;
+      const portable = exports_config.latest(yield* config.entries(), "experimental")?.portable_shell_scanner === true;
+      const parsed = yield* exports_parse.scan(invocation.command, invocation.shell, target.absolute, { portable });
+      const directories = yield* Effect.forEach(parsed.directories, (directory) => mutation.resolve({
+        path: exports_location_mutation.resolvePath(target.absolute, directory),
+        kind: "directory"
+      }));
+      const external = [target, ...directories].map((item) => item.externalDirectory).filter((item) => item !== undefined).filter((item, index, items) => items.findIndex((other) => other.resource === item.resource) === index);
+      if (external.length > 0)
+        yield* permission.assert({
+          action: "external_directory",
+          resources: external.map((item) => item.resource),
+          save: external.map((item) => item.save),
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+      if (parsed.commands.length > 0)
+        yield* permission.assert({
+          action: name,
+          resources: parsed.commands.map((command) => command.resource),
+          save: parsed.commands.map((command) => command.save),
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+      const workdir = yield* exports_environment.typeFollowing(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new Error(`Working directory does not exist: ${target.absolute}`))));
+      if (workdir !== "directory")
+        return yield* Effect.fail(new Error(`Working directory is not a directory: ${target.absolute}`));
+      return timeout;
+    });
     const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (sessionID, id, shellID, command, settled) {
       const info = (yield* runtime.job.wait({ id })).info;
       if (!info || info.status === "running")
@@ -134,21 +164,15 @@ var Plugin = {
       yield* runtime.session.synthetic({
         ...info.notificationID ? { id: info.notificationID } : {},
         sessionID,
-        text: `<shell id="${id}" state="${info.status}" command="${command}">
-${text}
-</shell>`,
         description: command,
-        metadata: {
-          source: "shell",
+        ...exports_result.notification({
           jobID: id,
           shellID,
+          command,
           state: info.status,
-          ...output ? {
-            truncated: output.truncated,
-            ...output.exit !== undefined ? { exit: output.exit } : {},
-            ...output.timeout !== undefined ? { timeout: output.timeout } : {}
-          } : {}
-        }
+          text,
+          output
+        })
       });
       if (info.notificationID)
         yield* runtime.job.completeBackground(info.notificationID);
@@ -160,11 +184,6 @@ ${text}
       input: Input,
       output: Output,
       execute: (input, context) => Effect.gen(function* () {
-        const source = {
-          type: "tool",
-          messageID: context.messageID,
-          id: context.id
-        };
         const timeout = input.background === true ? input.timeout ?? 0 : input.timeout ?? DEFAULT_TIMEOUT_MS;
         let finalTimeout = timeout;
         const info = yield* shell.create({
@@ -174,89 +193,23 @@ ${text}
           shell: yield* compatibleShell,
           metadata: { sessionID: context.sessionID }
         }, (invocation) => Effect.gen(function* () {
-          const target = yield* mutation.resolve({ path: invocation.cwd, kind: "directory" });
-          invocation.cwd = target.absolute;
-          finalTimeout = invocation.timeout;
-          const portable = exports_config.latest(yield* config.entries(), "experimental")?.portable_shell_scanner === true;
-          const parsed = yield* exports_parse.scan(invocation.command, invocation.shell, target.absolute, {
-            portable
-          });
-          const directories = yield* Effect.forEach(parsed.directories, (directory) => mutation.resolve({
-            path: exports_location_mutation.resolvePath(target.absolute, directory),
-            kind: "directory"
-          }));
-          const external = [target, ...directories].map((item) => item.externalDirectory).filter((item) => item !== undefined).filter((item, index, items) => items.findIndex((other) => other.resource === item.resource) === index);
-          if (external.length > 0)
-            yield* permission.assert({
-              action: "external_directory",
-              resources: external.map((item) => item.resource),
-              save: external.map((item) => item.save),
-              sessionID: context.sessionID,
-              agent: context.agent,
-              source
-            });
-          if (parsed.commands.length > 0)
-            yield* permission.assert({
-              action: name,
-              resources: parsed.commands.map((command) => command.resource),
-              save: parsed.commands.map((command) => command.save),
-              sessionID: context.sessionID,
-              agent: context.agent,
-              source
-            });
-          const workdir = yield* exports_environment.typeFollowing(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new Error(`Working directory does not exist: ${target.absolute}`))));
-          if (workdir !== "directory")
-            return yield* Effect.fail(new Error(`Working directory is not a directory: ${target.absolute}`));
+          finalTimeout = yield* prepare(invocation, context);
         }));
         yield* context.progress({ shellID: info.id });
-        const captureShell = Effect.fnUntraced(function* () {
-          const configured = exports_config.latest(yield* config.entries(), "tool_output");
-          const maxLines = configured?.max_lines ?? exports_tool_output.MAX_LINES;
-          const maxBytes = configured?.max_bytes ?? exports_tool_output.MAX_BYTES;
-          const latest = yield* shell.output(info.id, { cursor: Number.MAX_SAFE_INTEGER });
-          const page = yield* shell.output(info.id, {
-            cursor: Math.max(0, latest.size - maxBytes),
-            limit: maxBytes
-          });
-          const lines = page.output.split(`
-`);
-          if (page.output.endsWith(`
-`))
-            lines.pop();
-          const truncated = latest.size > maxBytes || lines.length > maxLines;
-          const output = lines.length > maxLines ? lines.slice(-maxLines).join(`
-`) : page.output;
-          const notice = truncated ? `
-
-[output truncated; full output saved to: ${info.file}]` : "";
+        const settled = yield* Deferred.make();
+        const run = Effect.gen(function* () {
+          const result2 = yield* shell.result(info);
+          if (!result2.capture)
+            return yield* new exports_shell.NotFoundError({ id: info.id });
+          const output = exports_result.output(result2);
           return {
-            output: `${output || "(no output)"}${notice}`,
-            truncated
-          };
-        });
-        const settleShell = Effect.fnUntraced(function* () {
-          const final = yield* shell.wait(info.id);
-          const capture = yield* captureShell();
-          if (final.status === "timeout") {
-            return {
-              ...final.exit !== undefined ? { exit: final.exit } : {},
-              output: `${capture.output}
+            ...output,
+            output: output.timeout ? `${output.output}
 
-Command exceeded timeout of ${finalTimeout} ms. Retry with a larger timeout if the command is expected to take longer.`,
-              truncated: capture.truncated,
-              timeout: true,
-              status: "completed"
-            };
-          }
-          return {
-            ...final.exit !== undefined ? { exit: final.exit } : {},
-            output: capture.output,
-            truncated: capture.truncated,
+Command exceeded timeout of ${finalTimeout} ms. Retry with a larger timeout if the command is expected to take longer.` : output.output,
             status: "completed"
           };
-        });
-        const settled = yield* Deferred.make();
-        const run = settleShell().pipe(Effect.tap((output) => Deferred.succeed(settled, output)), Effect.map((output) => resultMessages(output).join(`
+        }).pipe(Effect.tap((output) => Deferred.succeed(settled, output)), Effect.map((output) => resultMessages(output).join(`
 
 `)), Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)));
         const job = yield* runtime.job.start({

package/dist/chunks/{project-d0ahwm86.js → model-a3jfkbbw.js}

@@ -1,46 +1,46 @@
-import {
-  exports_formatter
-} from "./project-2nmyybe0.js";
-import {
-  exports_lsp
-} from "./project-15hpbjb6.js";
-import {
-  exports_command
-} from "./project-thstd87d.js";
 import {
   exports_provider
-} from "./project-18pv8fg3.js";
+} from "./model-18pv8fg3.js";
 import {
-  exports_plugin
-} from "./project-9f0rnpkn.js";
+  exports_skills
+} from "./model-nzrjycs5.js";
 import {
-  exports_layout
-} from "./project-gcay93cp.js";
+  exports_server
+} from "./model-pq4b4pqk.js";
 import {
   exports_agent
-} from "./project-4s2xwh5d.js";
+} from "./model-h5wnyjzw.js";
 import {
-  exports_permission
-} from "./project-v9bfv94f.js";
+  exports_layout
+} from "./model-gcay93cp.js";
 import {
-  exports_attachment
-} from "./project-r3k9abhd.js";
+  exports_command
+} from "./model-thstd87d.js";
 import {
   exports_mcp
-} from "./project-e1z9a0ts.js";
+} from "./model-e1z9a0ts.js";
 import {
-  exports_server
-} from "./project-pq4b4pqk.js";
+  exports_formatter
+} from "./model-2nmyybe0.js";
 import {
-  exports_skills
-} from "./project-nzrjycs5.js";
+  exports_permission
+} from "./model-v9bfv94f.js";
+import {
+  exports_lsp
+} from "./model-15hpbjb6.js";
+import {
+  exports_attachment
+} from "./model-r3k9abhd.js";
+import {
+  exports_plugin
+} from "./model-9f0rnpkn.js";
 import {
   NonNegativeInt,
   PositiveInt
-} from "./project-j07kk359.js";
+} from "./model-j07kk359.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/v1/config/config.ts
 var exports_config = {};

package/dist/chunks/model-a7zp47hx.js

@@ -0,0 +1,31 @@
+import {
+  __export
+} from "./model-rvfvac9x.js";
+
+// src/session/subagent-completion.ts
+var exports_subagent_completion = {};
+__export(exports_subagent_completion, {
+  deliver: () => deliver,
+  SubagentCompletion: () => exports_subagent_completion
+});
+import { Effect } from "effect";
+var deliver = Effect.fnUntraced(function* (sessions, jobs, input) {
+  if (input.status === "running")
+    return;
+  const recovery = input.recovery;
+  const text = input.status === "completed" ? input.output ?? "Subagent completed without a text response." : input.status === "error" ? input.error ?? "Subagent failed" : "Subagent cancelled";
+  yield* sessions.synthetic({
+    ...input.notificationID ? { id: input.notificationID } : {},
+    sessionID: recovery.parentSessionID,
+    ...input.resume === false ? { resume: false } : {},
+    description: recovery.description,
+    text: `<subagent sessionID="${recovery.childSessionID}" state="${input.status}" description="${recovery.description}">
+${text}
+</subagent>`,
+    metadata: { source: "subagent", childID: recovery.childSessionID, agent: recovery.agent, state: input.status }
+  });
+  if (input.notificationID)
+    yield* jobs.completeBackground(input.notificationID);
+});
+
+export { deliver, exports_subagent_completion };

package/dist/chunks/{project-1mvr5yep.js → model-aykc9wsc.js}

@@ -1,16 +1,19 @@
+import {
+  DiffError
+} from "./model-x4akg8r5.js";
 import {
   MAX_PATCH_BYTES,
   MAX_TOTAL_PATCH_BYTES,
   PATCH_CONTEXT_LINES,
   chunksByFile,
   emptyPatch
-} from "./project-vz89hfgr.js";
+} from "./model-vz89hfgr.js";
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./model-xy3y21dp.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/plugin/vcs/git.ts
 var exports_git = {};
@@ -39,9 +42,10 @@ var Plugin = define({
         id: "git",
         name: "Git",
         info: () => adapter.info(),
+        base: () => adapter.base(),
         branches: (input) => adapter.branches({ search: input.search, limit: input.limit }),
         status: () => adapter.status(),
-        diff: (input) => adapter.diff(input.mode, { context: input.context })
+        diff: (input) => adapter.diff(input.mode, { context: input.context, base: input.base })
       });
     });
   })
@@ -55,6 +59,7 @@ function make(proc, input) {
       });
       return { branch: { current, default: root?.name } };
     }),
+    base: () => ctx.git.base(ctx.directory),
     branches: Effect.fn("VcsGit.branches")(function* (options) {
       return yield* ctx.git.branches(ctx.directory, options);
     }),
@@ -78,17 +83,17 @@ function make(proc, input) {
       if (mode === "working") {
         return yield* track(ctx, (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined, options);
       }
-      const [current, root] = yield* Effect.all([git.branch(ctx.directory), git.defaultBranch(ctx.directory)], {
-        concurrency: 2
-      });
-      if (!root)
-        return [];
-      if (current && current === root.name)
-        return [];
-      const ref = yield* git.mergeBase(ctx.directory, root.ref);
-      if (!ref)
-        return [];
-      return yield* diffAgainstRef(ctx, ref, options);
+      if (!(yield* git.hasHead(ctx.directory))) {
+        return mode === "committed" ? [] : yield* track(ctx, undefined, options);
+      }
+      const base = options?.base ?? (yield* git.defaultBranch(ctx.directory))?.ref;
+      const ref = base ? yield* git.mergeBase(ctx.directory, base) : undefined;
+      if (!ref) {
+        return yield* new DiffError({
+          message: base ? `No merge base available for ${base}` : "No review base available"
+        });
+      }
+      return yield* diffAgainstRef(ctx, ref, { ...options, target: mode === "committed" ? "HEAD" : undefined });
     })
   };
 }
@@ -191,12 +196,65 @@ function makeGit(proc) {
     if (list.includes("master"))
       return { name: "master", ref: "master" };
   });
+  const resolve = Effect.fnUntraced(function* (cwd, ref) {
+    const result = yield* run(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const ancestor = Effect.fnUntraced(function* (cwd, commit, ref) {
+    if (!/^[a-f0-9]{40,64}$/.test(commit))
+      return false;
+    return (yield* run(["merge-base", "--is-ancestor", commit, ref], { cwd })).exitCode === 0;
+  });
+  const namedRef = Effect.fnUntraced(function* (cwd, input) {
+    if (input === "HEAD" || input.endsWith("/HEAD") || /[~^:@{}\s]/.test(input))
+      return;
+    const ref = (yield* text(["rev-parse", "--symbolic-full-name", "--verify", "--end-of-options", input], {
+      cwd
+    })).trim();
+    if (!/^refs\/(heads|remotes)\/.+/.test(ref) || ref.endsWith("/HEAD") || !(yield* resolve(cwd, ref)))
+      return;
+    return { name: ref.replace(/^refs\/heads\//, "").replace(/^refs\/remotes\/[^/]+\//, ""), ref };
+  });
+  const base = Effect.fn("VcsGit.base")(function* (cwd) {
+    if (!(yield* hasHead(cwd)))
+      return null;
+    const current = yield* branch(cwd);
+    if (!current)
+      return yield* new DiffError({ message: "Choose a review base" });
+    const history = (yield* lines(["reflog", "show", "--max-count=256", "--format=%H%x00%gs", `refs/heads/${current}`], {
+      cwd
+    })).flatMap((line) => {
+      const match = /^([a-f0-9]+)\0(.+)$/.exec(line);
+      return match ? [{ commit: match[1], message: match[2] }] : [];
+    });
+    const renamed = history.some((entry) => entry.message.startsWith("Branch: renamed "));
+    const creation = renamed ? undefined : history.find((entry) => entry.message.startsWith("branch: Created from "));
+    const origin = creation?.message.slice("branch: Created from ".length);
+    if (creation && origin) {
+      const candidate2 = yield* namedRef(cwd, origin);
+      if (candidate2 && candidate2.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate2.ref))) {
+        return { ...candidate2, source: "reflog" };
+      }
+    }
+    const root = yield* defaultBranch(cwd);
+    if (!root || current !== root.name)
+      return yield* new DiffError({ message: "Choose a review base" });
+    const candidate = yield* namedRef(cwd, root.ref);
+    if (!candidate)
+      return yield* new DiffError({ message: "The default review base is unavailable" });
+    return { name: root.name, ref: candidate.ref, source: "default" };
+  });
   const hasHead = Effect.fn("VcsGit.hasHead")(function* (cwd) {
     const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd });
     return result.exitCode === 0;
   });
-  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base) {
-    const result = yield* run(["merge-base", base, "HEAD"], { cwd });
+  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base2) {
+    const ref = yield* resolve(cwd, base2);
+    if (!ref)
+      return;
+    const result = yield* run(["merge-base", ref, "HEAD"], { cwd });
     if (result.exitCode !== 0)
       return;
     return result.text().trim() || undefined;
@@ -210,8 +268,11 @@ function makeGit(proc) {
       return [{ file, code, status: kind(code) }];
     });
   });
-  const diff = Effect.fn("VcsGit.diffNames")(function* (cwd, ref) {
-    const list = nuls(yield* text(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, "--", "."], { cwd }));
+  const diff = Effect.fn("VcsGit.diffNames")(function* (cwd, ref, target) {
+    const result = yield* run(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, ...target ? [target] : [], "--", "."], { cwd });
+    if (result.exitCode !== 0)
+      return yield* new DiffError({ message: "Unable to list Git changes" });
+    const list = nuls(result.text());
     return list.flatMap((code, idx) => {
       if (idx % 2 !== 0)
         return [];
@@ -221,8 +282,8 @@ function makeGit(proc) {
       return [{ file, code, status: kind(code) }];
     });
   });
-  const stats = Effect.fn("VcsGit.stats")(function* (cwd, ref) {
-    return nuls(yield* text(["diff", "--no-ext-diff", "--no-renames", "--numstat", "-z", ref, "--", "."], { cwd })).flatMap((item) => {
+  const stats = Effect.fn("VcsGit.stats")(function* (cwd, ref, target) {
+    return nuls(yield* text(["diff", "--no-ext-diff", "--no-renames", "--numstat", "-z", ref, ...target ? [target] : [], "--", "."], { cwd })).flatMap((item) => {
       const a = item.indexOf("\t");
       const b = item.indexOf("\t", a + 1);
       if (a === -1 || b === -1)
@@ -244,11 +305,31 @@ function makeGit(proc) {
     });
   });
   const patch = Effect.fn("VcsGit.patch")(function* (cwd, ref, file, options) {
-    const result = yield* run(["diff", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "--", file], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    const result = yield* run([
+      "diff",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      ref,
+      ...options?.target ? [options.target] : [],
+      "--",
+      file
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
     return { text: result.truncated ? "" : result.text(), truncated: result.truncated };
   });
   const patchAll = Effect.fn("VcsGit.patchAll")(function* (cwd, ref, options) {
-    const result = yield* run(["diff", "--patch", "--no-ext-diff", "--no-renames", `--unified=${options?.context ?? 3}`, ref, "--", "."], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    const result = yield* run([
+      "diff",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      ref,
+      ...options?.target ? [options.target] : [],
+      "--",
+      "."
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
     return { text: result.text(), truncated: result.truncated };
   });
   const patchUntracked = Effect.fn("VcsGit.patchUntracked")(function* (cwd, file, options) {
@@ -286,6 +367,7 @@ function makeGit(proc) {
   return {
     branch,
     branches,
+    base,
     defaultBranch,
     hasHead,
     mergeBase,
@@ -312,6 +394,7 @@ var batchPatches = Effect.fnUntraced(function* (ctx, ref, list, options) {
   if (list.length === 0)
     return emptyBatch();
   const result = yield* ctx.git.patchAll(ctx.directory, ref, {
+    target: options?.target,
     context: options?.context ?? PATCH_CONTEXT_LINES,
     maxOutputBytes: MAX_TOTAL_PATCH_BYTES
   });
@@ -325,6 +408,7 @@ var nativePatch = Effect.fnUntraced(function* (ctx, ref, item, options) {
     context: options?.context ?? PATCH_CONTEXT_LINES,
     maxOutputBytes: MAX_PATCH_BYTES
   }) : yield* ctx.git.patch(ctx.worktree, ref, item.file, {
+    target: options?.target,
     context: options?.context ?? PATCH_CONTEXT_LINES,
     maxOutputBytes: MAX_PATCH_BYTES
   });
@@ -352,7 +436,7 @@ var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
   let total = 0;
   let capped = false;
   for (const item of list.toSorted((a, b) => a.file.localeCompare(b.file))) {
-    const stat = map.get(item.file) ?? (item.status === "added" ? yield* ctx.git.statUntracked(ctx.worktree, item.file) : undefined);
+    const stat = map.get(item.file) ?? (!options?.target && item.status === "added" ? yield* ctx.git.statUntracked(ctx.worktree, item.file) : undefined);
     const patch = yield* patchForItem(ctx, ref, item, batch, capped, options);
     const result = capped ? { patch, capped: true } : totalPatch(item.file, patch, total);
     capped = capped || result.capped;
@@ -371,7 +455,11 @@ var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
   return next;
 });
 var diffAgainstRef = Effect.fnUntraced(function* (ctx, ref, options) {
-  const [list, stats, extra] = yield* Effect.all([ctx.git.diff(ctx.directory, ref), ctx.git.stats(ctx.directory, ref), ctx.git.status(ctx.directory)], { concurrency: 3 });
+  const [list, stats, extra] = yield* Effect.all([
+    ctx.git.diff(ctx.directory, ref, options?.target),
+    ctx.git.stats(ctx.directory, ref, options?.target),
+    options?.target ? Effect.succeed([]) : ctx.git.status(ctx.directory)
+  ], { concurrency: 3 });
   return yield* files(ctx, ref, merge(list, extra.filter((item) => item.code === "??")), nums(stats), yield* batchPatches(ctx, ref, list, options), options);
 });
 var track = Effect.fnUntraced(function* (ctx, ref, options) {

package/dist/chunks/{project-c6yz00sq.js → model-azpmwmnh.js}

@@ -1,24 +1,24 @@
 import {
   exports_supervisor
-} from "./project-4rg3anhc.js";
+} from "./model-z8cvg98n.js";
 import {
   exports_location_watcher_policy
-} from "./project-6wkzvma0.js";
+} from "./model-6wkzvma0.js";
 import {
   exports_watcher
-} from "./project-ns0sdez7.js";
+} from "./model-ns0sdez7.js";
 import {
   exports_location
-} from "./project-pm12wdxj.js";
+} from "./model-xy3y21dp.js";
 import {
   exports_git
-} from "./project-kt491qp2.js";
+} from "./model-dyj7wa6j.js";
 import {
   exports_bus
-} from "./project-gy9zm4ck.js";
+} from "./model-vwkfg4n5.js";
 import {
   __export
-} from "./project-rvfvac9x.js";
+} from "./model-rvfvac9x.js";
 
 // src/filesystem/location-watcher.ts
 var exports_location_watcher = {};