@opencode-ai/core 0.0.0-beta-19234 → 0.0.0-beta-19271

package/dist/chunks/{worktree-tqmakht3.js → file-retention-1q1y40j8.js}

@@ -1,50 +1,65 @@
 import {
-  Service79,
-  node84
-} from "./worktree-dng5ka12.js";
+  Service80,
+  node85
+} from "./file-retention-h6h8wc8c.js";
+import {
+  Service77,
+  node82
+} from "./file-retention-tmm76dnc.js";
 import {
   llmClient2
-} from "./worktree-0e0xafbb.js";
+} from "./file-retention-0e0xafbb.js";
 import {
   SessionEvent2
-} from "./worktree-mntxs535.js";
+} from "./file-retention-mntxs535.js";
+import {
+  provenance2,
+  compatible2,
+  isCheckpoint2,
+  encode2
+} from "./file-retention-bx5n9ey0.js";
+import {
+  load3
+} from "./file-retention-tvgknxm1.js";
 import {
   create3
-} from "./worktree-kg06axw8.js";
+} from "./file-retention-kg06axw8.js";
 import {
   toLLMMessages2
-} from "./worktree-zbjnn3ac.js";
+} from "./file-retention-34jntwha.js";
 import {
   baseTranscript2,
-  unsupportedParts2
-} from "./worktree-nhfc898y.js";
-import {
-  isRetryable2,
-  policy2
-} from "./worktree-hnyf01b0.js";
+  unsupportedParts2,
+  boundImages2
+} from "./file-retention-xtbhkgqd.js";
 import {
   toSessionError2
-} from "./worktree-b3kfkjj6.js";
+} from "./file-retention-btht280w.js";
+import {
+  policy2,
+  transient2
+} from "./file-retention-1r60bktf.js";
 import {
   estimate2
-} from "./worktree-h6vf3j39.js";
+} from "./file-retention-h6vf3j39.js";
 import {
   record2,
   add2
-} from "./worktree-tjykrgmx.js";
+} from "./file-retention-tjykrgmx.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./file-retention-9rqn6x4v.js";
 
 // src/session/compaction.ts
 var exports_compaction2 = {};
 __export(exports_compaction2, {
-  Service: () => Service9,
+  Service: () => Service6,
   SessionCompaction: () => exports_compaction2,
   buildPrompt: () => buildPrompt2,
   estimateTokens: () => estimateTokens2,
-  layer: () => layer7,
-  node: () => node12,
+  layer: () => layer6,
+  node: () => node9,
+  retainUsers: () => retainUsers2,
   serializeToolContent: () => serializeToolContent2,
   truncateToolOutput: () => truncateToolOutput2
 });
@@ -108,10 +123,11 @@ var SUMMARY_RULES = `Rules:
 var SUMMARY_HEADINGS = SUMMARY_TEMPLATE.split(`
 `).filter((line) => line.startsWith("##"));
 
-class Service9 extends Context.Service()("@opencode/SessionCompaction") {
+class Service6 extends Context.Service()("@opencode/SessionCompaction") {
 }
+var hasInputUsage = (message) => message.type === "assistant" && !message.error && message.tokens !== undefined && message.tokens.input + message.tokens.cache.read + message.tokens.cache.write > 0;
 var estimateTokens2 = (input) => {
-  const index = input.messages.findLastIndex((message) => message.type === "assistant" && !message.error && message.tokens !== undefined && message.tokens.input + message.tokens.cache.read + message.tokens.cache.write > 0);
+  const index = input.messages.findLastIndex(hasInputUsage);
   const last = input.messages[index];
   const added = unsupportedParts2(toLLMMessages2(input.messages.slice(Math.max(0, index)), input.resolved.ref), input.resolved.capabilities).filter((message) => message.role !== "assistant" || message.id !== last?.id).reduce((sum, message) => sum + message.content.reduce((sum, part) => sum + estimatePart(part), 0), 0);
   if (last?.type === "assistant" && last.tokens)
@@ -142,6 +158,19 @@ var estimatePart = (part) => {
     return part.result.value.reduce((sum, content) => sum + (content.type === "text" ? estimate2(content.text) : estimateMedia(content.mime)), 0);
   return estimate2(typeof part.result.value === "string" ? part.result.value : JSON.stringify(part.result.value) ?? "");
 };
+var retainUsers2 = (messages, model, keepTokens) => {
+  const users = boundImages2(unsupportedParts2(toLLMMessages2(messages.filter((message) => message.type === "user").map((message) => ({ ...message, skills: undefined })), model.ref), model.capabilities));
+  let tokens = 0;
+  let start = users.length;
+  for (let index = users.length - 1;index >= 0; index--) {
+    const size = users[index].content.reduce((sum, part) => sum + estimatePart(part), 0);
+    if (tokens + size > keepTokens)
+      break;
+    tokens += size;
+    start = index;
+  }
+  return users.slice(start);
+};
 var truncateToolOutput2 = (value) => {
   if (value.length <= TOOL_OUTPUT_MAX_CHARS)
     return value;
@@ -262,9 +291,10 @@ var buildPrompt2 = (update) => {
 };
 var hasSummarySection = (summary) => summary.split(`
 `).some((line) => SUMMARY_HEADINGS.includes(line.trim()));
-var layer7 = Layer.effect(Service9, Effect.gen(function* () {
-  const bus = yield* Service79;
+var layer6 = Layer.effect(Service6, Effect.gen(function* () {
+  const bus = yield* Service77;
   const llm = yield* LLMClient.Service;
+  const db = (yield* Service80).db;
   const state = create3({
     name: "session-compaction",
     initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS }),
@@ -283,40 +313,28 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
     yield* bus.publish(SessionEvent2.Compaction.Failed, input);
     return { status: "failed", error: input.error };
   });
-  const execute = Effect.fn("SessionCompaction.execute")(function* (input) {
+  const started = (input, recent) => input.started ? Effect.void : bus.publish(SessionEvent2.Compaction.Started, {
+    sessionID: input.context.session.id,
+    reason: input.reason,
+    recent,
+    inputID: input.inputID
+  });
+  const interrupted = (input) => input.reason === "auto" ? failed({
+    sessionID: input.context.session.id,
+    reason: input.reason,
+    inputID: input.inputID,
+    error: { type: "compaction.interrupted", message: "Compaction was interrupted" }
+  }).pipe(Effect.asVoid) : Effect.void;
+  const compactionRequest = (input, messages, prompt, webSocket) => {
     const context = input.context;
-    const history = splitHistory(context.messages, state.get().tokens);
-    if (!history)
-      return yield* failed({
-        sessionID: context.session.id,
-        reason: input.reason,
-        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-        inputID: input.inputID
-      });
-    if (!input.started)
-      yield* bus.publish(SessionEvent2.Compaction.Started, {
-        sessionID: context.session.id,
-        reason: input.reason,
-        recent: history.recent,
-        inputID: input.inputID
-      });
-    const chunks = [];
-    let failure;
-    let usage;
-    let providerState;
-    const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent2.UsageRecorded, {
-      sessionID: context.session.id,
-      source: "compaction",
-      ...usage
-    }) : Effect.void);
     const transcript = baseTranscript2({
       agent: context.agent.info,
       model: context.model,
       tools: context.tools,
       initial: context.initial,
-      messages: history.messages
+      messages
     });
-    const prepared = yield* input.prepare({
+    return input.prepare({
       kind: "compaction",
       scope: {
         session: context.session,
@@ -330,11 +348,96 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
         messages: [
           ...transcript.messages,
           ...input.instructionUpdate ? [Message.system(input.instructionUpdate)] : [],
-          Message.user(buildPrompt2(history.messages.some((message) => message.type === "compaction" && message.status === "completed")))
+          ...prompt
         ]
-      }
+      },
+      webSocket
+    });
+  };
+  const original = (sessionID) => load3(db, sessionID, "local").pipe(Effect.orDie);
+  const recoverLocally = (input) => original(input.context.session.id).pipe(Effect.flatMap((messages) => execute({ ...input, context: { ...input.context, messages } })));
+  const executeProvider = Effect.fn("SessionCompaction.executeProvider")(function* (input) {
+    const context = input.context;
+    const reject = (message) => failed({
+      sessionID: context.session.id,
+      reason: input.reason,
+      inputID: input.inputID,
+      error: { type: "provider.unsupported-operation", message }
+    });
+    const prepared = yield* compactionRequest(input, context.messages, [], "session");
+    const request = prepared.request;
+    const provenance = provenance2(context.model);
+    if (!provenance)
+      return yield* reject("Provider compaction requires a stable, configured endpoint");
+    if (!compatible2(provenance, provenance2({ model: request.model, ref: context.model.ref })))
+      return yield* reject("Provider compaction requires the endpoint in provider/model settings, not a model.request rewrite");
+    const transient = transient2(yield* policy2(context.session.id), {
+      agent: Agent.ID.make("compaction"),
+      model: context.model.ref,
+      hook: prepared.retry
+    });
+    yield* started(input, "");
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const result = yield* restore(Effect.gen(function* () {
+        if (LLMClient.canCompact(request, { mechanism: "trigger" })) {
+          const retained = retainUsers2(yield* original(context.session.id), context.model, state.get().tokens);
+          const result = yield* llm.compact(request, { ...prepared.options, mechanism: "trigger" }).pipe(transient);
+          return { replacement: [...retained, Message.assistant(result.checkpoint)], usage: result.usage };
+        }
+        if (LLMClient.canCompact(request))
+          return yield* llm.compact(request, { mechanism: "endpoint", http: prepared.options.http }).pipe(transient);
+        return yield* Effect.die(new Error(`${request.model.provider}/${request.model.route.id} has no compaction operation`));
+      }));
+      if (result.usage)
+        yield* bus.publish(SessionEvent2.UsageRecorded, {
+          sessionID: context.session.id,
+          source: "compaction",
+          ...record2(result.usage, context.model.cost)
+        });
+      yield* bus.publish(SessionEvent2.Compaction.Ended, {
+        sessionID: context.session.id,
+        reason: input.reason,
+        model: context.model.ref,
+        text: "",
+        recent: "",
+        providerContext: encode2(provenance, result.replacement)
+      });
+      return { status: "completed" };
+    })).pipe(Effect.onInterrupt(() => interrupted(input)), Effect.catchTag("AI.Error", (cause) => input.reason === "auto" && isContextOverflowFailure(cause) ? recoverLocally({ ...input, started: true }).pipe(Effect.map((result) => result.status === "completed" ? { ...result, recoveredOverflow: true } : result)) : failed({
+      sessionID: context.session.id,
+      reason: input.reason,
+      inputID: input.inputID,
+      error: toSessionError2(cause)
+    })));
+  });
+  const execute = Effect.fn("SessionCompaction.execute")(function* (input) {
+    const context = input.context;
+    const history = splitHistory(context.messages, state.get().tokens);
+    if (!history)
+      return yield* failed({
+        sessionID: context.session.id,
+        reason: input.reason,
+        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
+        inputID: input.inputID
+      });
+    yield* started(input, history.recent);
+    const chunks = [];
+    let failure;
+    let usage;
+    let providerState;
+    const recordUsage = Effect.suspend(() => usage ? bus.publish(SessionEvent2.UsageRecorded, {
+      sessionID: context.session.id,
+      source: "compaction",
+      ...usage
+    }) : Effect.void);
+    const prepared = yield* compactionRequest(input, history.messages, [
+      Message.user(buildPrompt2(history.messages.some((message) => message.type === "compaction" && message.status === "completed")))
+    ]);
+    const transient = transient2(yield* policy2(context.session.id), {
+      agent: Agent.ID.make("compaction"),
+      model: context.model.ref,
+      hook: prepared.retry
     });
-    const retry = yield* policy2(context.session.id);
     for (const request of [
       prepared.request,
       LLMRequest.update(prepared.request, {
@@ -386,31 +489,9 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
             return Effect.fail(new AIError({ reason: new UnknownProviderError({ message: "Compaction generation failed" }) }));
         }
         return Effect.void;
-      }), Effect.retry({
-        while: (cause) => Effect.gen(function* () {
-          if (isContextOverflowFailure(cause))
-            return false;
-          const decision = yield* retry({
-            cause,
-            error: toSessionError2(cause),
-            agent: Agent.ID.make("compaction"),
-            model: context.model.ref,
-            hook: prepared.retry,
-            retry: isRetryable2(cause)
-          });
-          if (!decision.retry)
-            return false;
-          yield* Effect.sleep(decision.delay);
-          return true;
-        })
-      }), Effect.catchTag("AI.Error", (error) => Effect.sync(() => {
+      }), transient, Effect.catchTag("AI.Error", (error) => Effect.sync(() => {
         failure = toSessionError2(error);
-      })), Effect.onInterrupt(() => recordUsage.pipe(Effect.andThen(input.reason === "auto" ? failed({
-        sessionID: context.session.id,
-        reason: input.reason,
-        error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
-        inputID: input.inputID
-      }).pipe(Effect.asVoid) : Effect.void))));
+      })), Effect.onInterrupt(() => recordUsage.pipe(Effect.andThen(interrupted(input)))));
       if (failure || hasSummarySection(chunks.join("")))
         break;
     }
@@ -438,7 +519,14 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
     });
     return { status: "completed" };
   });
-  const compact = (input) => execute({ ...input, reason: "auto" });
+  const compact = Effect.fn("SessionCompaction.compact")(function* (input) {
+    const request = { ...input, reason: "auto" };
+    if (input.overflow)
+      return yield* recoverLocally(request);
+    if (input.context.model.compaction?.mode !== "provider")
+      return yield* execute(request);
+    return yield* executeProvider(request);
+  });
   const required = (input) => {
     const config = state.get();
     if (!config.auto)
@@ -446,13 +534,17 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
     const last = input.messages.at(-1);
     if (last?.type === "compaction" && last.status === "completed")
       return false;
+    if (input.messages.findLastIndex(hasInputUsage) < input.messages.findLastIndex(isCheckpoint2))
+      return false;
     const limit = input.resolved.limit;
     const context = limit.context;
     if (context <= 0)
       return false;
     const output = Math.min(limit.output, OUTPUT_TOKEN_MAX);
     const promptCeiling = Math.min(limit.input === undefined ? Number.POSITIVE_INFINITY : limit.input - config.buffer, context - Math.max(output, config.buffer));
-    return estimateTokens2(input) >= promptCeiling;
+    const policy = input.resolved.compaction;
+    const threshold = policy?.mode === "provider" && policy.threshold !== undefined ? Math.min(policy.threshold, promptCeiling) : promptCeiling;
+    return estimateTokens2(input) >= threshold;
   };
   const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input) {
     if (findTailStart(input.messages, state.get().tokens) === undefined)
@@ -469,17 +561,20 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
         error: toSessionError2(cause),
         inputID: input.inputID
       }),
-      onSuccess: (context) => execute({
-        context,
-        instructionUpdate: context.instructionUpdate,
-        prepare: input.prepare,
-        reason: "manual",
-        inputID: input.inputID,
-        started: input.started
-      })
+      onSuccess: (context) => {
+        const request = {
+          context,
+          instructionUpdate: context.instructionUpdate,
+          prepare: input.prepare,
+          reason: "manual",
+          inputID: input.inputID,
+          started: input.started
+        };
+        return context.model.compaction?.mode === "provider" ? executeProvider(request) : execute(request);
+      }
     }));
   });
-  return Service9.of({
+  return Service6.of({
     transform: state.transform,
     reload: state.reload,
     enabled: () => state.get().auto,
@@ -488,10 +583,10 @@ var layer7 = Layer.effect(Service9, Effect.gen(function* () {
     compactManual
   });
 }));
-var node12 = makeLocationNode({
-  service: Service9,
-  layer: layer7,
-  deps: [node84, llmClient2]
+var node9 = makeLocationNode({
+  service: Service6,
+  layer: layer6,
+  deps: [node82, node85, llmClient2]
 });
 
-export { Service9, estimateTokens2, truncateToolOutput2, serializeToolContent2, buildPrompt2, layer7, node12, exports_compaction2 };
+export { Service6, estimateTokens2, retainUsers2, truncateToolOutput2, serializeToolContent2, buildPrompt2, layer6, node9, exports_compaction2 };

package/dist/chunks/{worktree-hnyf01b0.js → file-retention-1r60bktf.js}

@@ -1,9 +1,12 @@
 import {
   SessionEvent2
-} from "./worktree-mntxs535.js";
+} from "./file-retention-mntxs535.js";
+import {
+  toSessionError2
+} from "./file-retention-btht280w.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./file-retention-9rqn6x4v.js";
 
 // src/session/runner/retry.ts
 var exports_retry = {};
@@ -11,8 +14,10 @@ __export(exports_retry, {
   SessionRunnerRetry: () => exports_retry,
   isRetryable: () => isRetryable2,
   make: () => make5,
-  policy: () => policy2
+  policy: () => policy2,
+  transient: () => transient2
 });
+import { isContextOverflowFailure } from "@opencode-ai/ai";
 import { Clock, Duration, Effect, Pull, Schedule } from "effect";
 function isRetryable2(error) {
   const override = error.reason.http?.headers["x-should-retry"];
@@ -80,6 +85,17 @@ var policy2 = (sessionID) => Effect.gen(function* () {
     return { retry: true, attempt, delay: normalized };
   });
 });
+var transient2 = (decide, input) => (effect) => Effect.retry(effect, {
+  while: (cause) => Effect.gen(function* () {
+    if (isContextOverflowFailure(cause))
+      return false;
+    const decision = yield* decide({ ...input, cause, error: toSessionError2(cause), retry: isRetryable2(cause) });
+    if (!decision.retry)
+      return false;
+    yield* Effect.sleep(decision.delay);
+    return true;
+  })
+});
 var make5 = (bus, sessionID) => Effect.gen(function* () {
   const decide = yield* policy2(sessionID);
   const wait = (input) => Effect.gen(function* () {
@@ -97,4 +113,4 @@ var make5 = (bus, sessionID) => Effect.gen(function* () {
   return { decide, wait };
 });
 
-export { isRetryable2, policy2, make5, exports_retry };
+export { isRetryable2, policy2, transient2, make5, exports_retry };

package/dist/chunks/{worktree-410zfba8.js → file-retention-1wcfs5an.js}

@@ -1,10 +1,10 @@
 import {
   resolveNullableObjectPaths2,
   mapResultRow2
-} from "./worktree-emrn6kk6.js";
+} from "./file-retention-emrn6kk6.js";
 import {
   SQLiteEffectDatabase2
-} from "./worktree-mfpdf0ta.js";
+} from "./file-retention-3jyr1z4v.js";
 
 // src/database/drizzle/sqlite-core/effect/session.ts
 import * as Cause from "effect/Cause";

package/dist/chunks/{worktree-3883t5g1.js → file-retention-1ydgq2r4.js}

@@ -1,16 +1,16 @@
 import {
   PositiveInt2
-} from "./worktree-p8qxwesx.js";
+} from "./file-retention-p8qxwesx.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./file-retention-9rqn6x4v.js";
 
 // src/v1/config/attachment.ts
 var exports_attachment = {};
 __export(exports_attachment, {
   ConfigAttachmentV1: () => exports_attachment,
   Image: () => Image2,
-  Info: () => Info21
+  Info: () => Info18
 });
 import { Schema } from "effect";
 var Image2 = Schema.Struct({
@@ -27,8 +27,8 @@ var Image2 = Schema.Struct({
     description: "Maximum base64 payload bytes for an image attachment (default: 5242880)"
   })
 }).annotate({ identifier: "ImageAttachmentConfig" });
-var Info21 = Schema.Struct({
+var Info18 = Schema.Struct({
   image: Schema.optional(Image2).annotate({ description: "Image attachment configuration" })
 }).annotate({ identifier: "AttachmentConfig" });
 
-export { Image2, Info21, exports_attachment };
+export { Image2, Info18, exports_attachment };

package/dist/chunks/{worktree-h08w630h.js → file-retention-1z25nwdj.js}

@@ -1,57 +1,57 @@
 import {
   NonNegativeInt2
-} from "./worktree-p8qxwesx.js";
+} from "./file-retention-p8qxwesx.js";
 import {
   latest2,
-  Service62
-} from "./worktree-xpxmebhh.js";
+  Service53
+} from "./file-retention-gztfqjt6.js";
 import {
   typeFollowing2
-} from "./worktree-2a5m3afh.js";
+} from "./file-retention-2a5m3afh.js";
 import {
-  Service57
-} from "./worktree-kk0awzkj.js";
+  Service40
+} from "./file-retention-wh6fxssz.js";
 import {
-  Service72
-} from "./worktree-cjrs1hef.js";
+  Service62
+} from "./file-retention-tebfwd6f.js";
 import {
-  resolvePath2,
-  Service22
-} from "./worktree-ynqmrvb3.js";
+  Service69
+} from "./file-retention-7bz1waha.js";
 import {
-  Service48
-} from "./worktree-471a560f.js";
+  Service17,
+  resolvePath2
+} from "./file-retention-f268p0jz.js";
 import {
   output2,
   notice2,
   metadata2,
   notification2
-} from "./worktree-fxbjtjnd.js";
+} from "./file-retention-fxbjtjnd.js";
 import {
-  Service60,
+  Service50,
   name15
-} from "./worktree-acbvwaxg.js";
+} from "./file-retention-sr82n7vz.js";
 import {
-  NotFoundError8,
-  Service55
-} from "./worktree-tgz6nsmd.js";
+  NotFoundError5,
+  Service37
+} from "./file-retention-fy8y407q.js";
 import {
-  Service24
-} from "./worktree-35bk7ths.js";
+  Service21
+} from "./file-retention-cavx7z03.js";
 import {
   scan2
-} from "./worktree-cs4zqdxc.js";
+} from "./file-retention-mwbry6nn.js";
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./file-retention-9rqn6x4v.js";
 
 // src/tool/plugin/shell.ts
-var exports_shell = {};
-__export(exports_shell, {
+var exports_shell2 = {};
+__export(exports_shell2, {
   DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS2,
   Input: () => Input8,
-  Plugin: () => Plugin9,
-  ShellTool: () => exports_shell,
+  Plugin: () => Plugin25,
+  ShellTool: () => exports_shell2,
   name: () => name8
 });
 import { ToolFailure } from "@opencode-ai/ai";
@@ -115,44 +115,35 @@ Output is streaming to: ${file}`,
   truncated: false,
   status: "running"
 });
-var Plugin9 = {
+var Plugin25 = {
   id: "opencode.tool.shell",
   effect: Effect.fn("ShellTool.Plugin")(function* (ctx) {
-    const sessions = yield* Service24;
-    const jobs = yield* Service72;
+    const sessions = yield* Service21;
+    const jobs = yield* Service62;
     const scope = yield* Scope.Scope;
-    const environment = yield* Service57;
-    const mutation = yield* Service22;
-    const shell = yield* Service55;
-    const shellSelect = yield* Service60;
+    const environment = yield* Service40;
+    const access = yield* Service17;
+    const shell = yield* Service37;
+    const shellSelect = yield* Service50;
     const compatibleShell = shellSelect.resolve({ priority: "compat" });
-    const permission = yield* Service48;
-    const config = yield* Service62;
+    const permission = yield* Service69;
+    const config = yield* Service53;
     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" });
+      const target = yield* access.resolve({ path: invocation.cwd, kind: "directory" });
       invocation.cwd = target.absolute;
       const timeout = invocation.timeout;
       const portable = latest2(yield* config.entries(), "experimental")?.portable_shell_scanner === true;
       const parsed = yield* scan2(invocation.command, invocation.shell, target.absolute, { portable });
-      const directories = yield* Effect.forEach(parsed.directories, (directory) => mutation.resolve({
+      const directories = yield* Effect.forEach(parsed.directories, (directory) => access.resolve({
         path: resolvePath2(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
-        });
+      yield* access.authorizeExternal([target, ...directories], context);
       if (parsed.commands.length > 0)
         yield* permission.assert({
           action: name8,
@@ -214,7 +205,7 @@ var Plugin9 = {
         const run = Effect.gen(function* () {
           const result = yield* shell.result(info);
           if (!result.capture)
-            return yield* new NotFoundError8({ id: info.id });
+            return yield* new NotFoundError5({ id: info.id });
           const output = output2(result);
           return {
             ...output,
@@ -266,4 +257,4 @@ Command exceeded timeout of ${finalTimeout} ms. Retry with a larger timeout if t
   })
 };
 
-export { name8, DEFAULT_TIMEOUT_MS2, Input8, Plugin9, exports_shell };
+export { name8, DEFAULT_TIMEOUT_MS2, Input8, Plugin25, exports_shell2 };

package/dist/chunks/{worktree-21r38tys.js → file-retention-21r38tys.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./file-retention-9rqn6x4v.js";
 
 // src/v1/config/layout.ts
 var exports_layout = {};

package/dist/chunks/{worktree-2402vzrj.js → file-retention-2402vzrj.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./worktree-9rqn6x4v.js";
+} from "./file-retention-9rqn6x4v.js";
 
 // src/repository.ts
 var exports_repository = {};