@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-7wadkhey.js

@@ -0,0 +1,175 @@
+import {
+  exports_instructions
+} from "./permission-b3hvtezn.js";
+import {
+  exports_read_filesystem
+} from "./permission-2g1pqmbp.js";
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  exports_location_mutation
+} from "./permission-a2yyszsy.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/plugin/read.ts
+var exports_read = {};
+__export(exports_read, {
+  toModelContent: () => toModelContent,
+  name: () => name,
+  ReadTool: () => exports_read,
+  Plugin: () => Plugin,
+  Input: () => Input
+});
+import { basename, dirname, join } from "path";
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var name = "read";
+var FILENAME = "AGENTS.md";
+var SUPPORTED_MEDIA_MIMES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp", "application/pdf"]);
+var LocationInput = Schema.Struct({
+  path: Schema.String.annotate({ description: "File or directory to read" }),
+  offset: exports_read_filesystem.PageInput.fields.offset.annotate({
+    description: "The line or directory entry to start reading from (1-based)"
+  }),
+  limit: exports_read_filesystem.PageInput.fields.limit.annotate({
+    description: "The maximum number of lines or directory entries to read (defaults to 2000)"
+  })
+});
+var Input = LocationInput;
+var Output = Schema.Union([exports_read_filesystem.FileContent, exports_read_filesystem.TextPage, exports_read_filesystem.ListPage]);
+var Plugin = {
+  id: "opencode.tool.read",
+  effect: Effect.fn("ReadTool.Plugin")(function* (ctx) {
+    const reader = yield* exports_read_filesystem.Service;
+    const mutation = yield* exports_location_mutation.Service;
+    const permission = yield* exports_permission.Service;
+    const sessionInstructions = yield* exports_instructions.Service;
+    const fs = yield* FSUtil.Service;
+    const location = yield* exports_location.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description: "Read the contents of a file or directory. Supports text files, images, and PDFs. Images and PDFs are presented directly to the model. Each text line is prefixed by its 1-based line number as <line>: <content>. The prefix is for reference and is not part of the file content. Directory entries are returned one per line. Use offset and limit to read large files or directories in sections. Prefer one larger read over many small slices, and use grep to find specific content in large files.",
+      input: Input,
+      output: Output,
+      execute: (input, context) => {
+        return Effect.gen(function* () {
+          const source = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          const target = yield* mutation.resolve({ path: input.path });
+          const external = target.externalDirectory;
+          if (external)
+            yield* permission.assert({
+              ...exports_location_mutation.externalDirectoryPermission(external),
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source
+            });
+          const resource = target.resource;
+          const absolute = AbsolutePath.make(target.absolute);
+          yield* permission.assert({
+            action: name,
+            resources: [resource],
+            save: ["*"],
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+          const content = yield* reader.read(absolute, resource, { offset: input.offset, limit: input.limit }).pipe(Effect.catchIf((error) => error instanceof exports_environment.NotFound, () => missing(input.path, target.absolute)));
+          yield* Effect.gen(function* () {
+            if (target.externalDirectory !== undefined)
+              return;
+            const resolved = yield* fs.resolve(target.absolute);
+            const root = yield* fs.resolve(location.directory);
+            const discovered = yield* fs.up({
+              targets: [FILENAME],
+              start: content.type === "list-page" ? resolved : dirname(resolved),
+              stop: root
+            });
+            const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter((file) => dirname(file) !== root);
+            if (candidates.length === 0)
+              return;
+            yield* sessionInstructions.load({ sessionID: context.sessionID, paths: candidates });
+          }).pipe(Effect.catch(() => Effect.void), Effect.catchDefect(() => Effect.void));
+          if (content.type === "file" && content.encoding === "base64" && !SUPPORTED_MEDIA_MIMES.has(content.mime))
+            return yield* Effect.fail(new exports_read_filesystem.BinaryFileError({ resource }));
+          return content;
+        }).pipe(Effect.map((output) => ({
+          output,
+          content: toModelContent(input.path, input.offset, output),
+          metadata: { truncated: output.type === "file" ? false : output.truncated }
+        })), Effect.mapError((error) => {
+          if (error instanceof ToolFailure)
+            return error;
+          const message = error instanceof exports_read_filesystem.BinaryFileError || error instanceof exports_read_filesystem.MediaIngestLimitError || error instanceof exports_read_filesystem.OffsetOutOfRangeError || error instanceof exports_read_filesystem.PathKindError ? error.message : `Unable to read ${input.path}`;
+          return new ToolFailure({ message, error });
+        }));
+      }
+    })).pipe(Effect.orDie);
+    const missing = Effect.fn("ReadTool.missing")(function* (input, absolute) {
+      const base = basename(input).toLowerCase();
+      const suggestions = yield* fs.readDirectory(dirname(absolute)).pipe(Effect.map((entries) => entries.filter((entry) => {
+        const candidate = entry.toLowerCase();
+        return candidate.includes(base) || base.includes(candidate);
+      }).map((entry) => join(dirname(input), entry)).slice(0, 3)), Effect.catch(() => Effect.succeed([])));
+      const message = suggestions.length === 0 ? `File not found: ${input}` : `File not found: ${input}
+
+Did you mean one of these?
+${suggestions.join(`
+`)}`;
+      return yield* new ToolFailure({ message });
+    });
+  })
+};
+var toModelContent = (path, offset, output) => {
+  if (output.type === "file" && output.encoding === "base64")
+    return [
+      { type: "text", text: output.mime === "application/pdf" ? "PDF read successfully" : "Image read successfully" },
+      {
+        type: "file",
+        uri: `data:${output.mime};base64,${output.content}`,
+        mime: output.mime,
+        name: path
+      }
+    ];
+  if (output.type === "list-page") {
+    const start2 = offset ?? 1;
+    const content2 = [
+      output.entries.length === 0 ? `Read directory ${path}, 0 entries` : `Read directory ${path}, entries ${start2}-${start2 + output.entries.length - 1}`
+    ];
+    output.entries.forEach((entry) => content2.push(entry.path));
+    if (output.truncated && output.next !== undefined)
+      content2.push(`[Output truncated. Continue reading with offset: ${output.next}]`);
+    return content2.join(`
+`);
+  }
+  const start = output.type === "text-page" ? output.offset : 1;
+  const lines = output.content === "" ? [] : output.content.replace(/\n$/, "").split(`
+`);
+  const content = [
+    lines.length === 0 ? `Read file ${path}, 0 lines` : `Read file ${path}, lines ${start}-${start + lines.length - 1}`
+  ];
+  lines.forEach((line, index) => content.push(`${start + index}: ${line}`));
+  if (output.type === "text-page" && output.truncated && output.next !== undefined)
+    content.push(`[Output truncated. Continue reading with offset: ${output.next}]`);
+  return content.join(`
+`);
+};
+
+export { name, Input, Plugin, toModelContent, exports_read };

package/dist/chunks/permission-7wcmqxrc.js

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/config/markdown.ts
+var exports_markdown = {};
+__export(exports_markdown, {
+  sanitize: () => sanitize,
+  parseOption: () => parseOption,
+  parse: () => parse,
+  ConfigMarkdown: () => exports_markdown
+});
+import matter from "gray-matter";
+function parse(content) {
+  try {
+    return matter(content);
+  } catch {
+    return matter(sanitize(content));
+  }
+}
+function parseOption(content) {
+  try {
+    return parse(content);
+  } catch {
+    return;
+  }
+}
+function sanitize(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match)
+    return content;
+  const frontmatter = match[1];
+  const result = frontmatter.split(/\r?\n/).flatMap((line) => {
+    if (line.trim().startsWith("#") || line.trim() === "" || /^\s+/.test(line))
+      return [line];
+    const entry = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)$/);
+    if (!entry)
+      return [line];
+    const value = entry[2].trim();
+    if (value === "" || value === ">" || value === "|" || value.startsWith('"') || value.startsWith("'"))
+      return [line];
+    if (!value.includes(":"))
+      return [line];
+    return [`${entry[1]}: |-`, `  ${value}`];
+  });
+  return content.replace(frontmatter, () => result.join(`
+`));
+}
+
+export { parse, parseOption, sanitize, exports_markdown };

package/dist/chunks/permission-7wee78f9.js

@@ -0,0 +1,408 @@
+import {
+  createLLMEventPublisher
+} from "./permission-9q1hedyj.js";
+import {
+  exports_retry
+} from "./permission-szjq6xea.js";
+import {
+  exports_compaction
+} from "./permission-zt25ybqs.js";
+import {
+  exports_model_request
+} from "./permission-ans8s2g6.js";
+import {
+  exports_context
+} from "./permission-n59ptmzm.js";
+import {
+  exports_title
+} from "./permission-a6ndeaxw.js";
+import {
+  exports_usage
+} from "./permission-8ywqk2j9.js";
+import {
+  llmClient
+} from "./permission-m01ryvbe.js";
+import {
+  exports_tool_output
+} from "./permission-6xc82ex6.js";
+import {
+  Service
+} from "./permission-cz3dkvcz.js";
+import {
+  toSessionError
+} from "./permission-42xz94rv.js";
+import {
+  exports_pending
+} from "./permission-vz49gck1.js";
+import {
+  exports_snapshot
+} from "./permission-vh4z0rtm.js";
+import {
+  exports_store
+} from "./permission-2zyawa45.js";
+import {
+  StepFailedError
+} from "./permission-s6by3cc4.js";
+import {
+  exports_instruction_state
+} from "./permission-bha9y19b.js";
+import {
+  exports_message
+} from "./permission-25pxtba7.js";
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/runner/llm.ts
+var exports_llm = {};
+__export(exports_llm, {
+  node: () => node,
+  SessionRunnerLLM: () => exports_llm
+});
+import {
+  LLMClient,
+  AIError,
+  LLMEvent,
+  isContextOverflowFailure
+} from "@opencode-ai/ai";
+import { Cause, Data, Effect, Exit, Fiber, FiberSet, Layer, Option, Pull, Schedule, Stream } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var CallOutcome = Data.taggedEnum();
+var isDecline = (error) => error._tag === "Permission.DeclinedError" || error._tag === "QuestionTool.CancelledError";
+var classifyToolExits = (settled, calls) => {
+  const exits = settled._tag === "Success" ? settled.value : [];
+  const declines = exits.flatMap((exit, index) => exit._tag === "Failure" ? exit.cause.reasons.flatMap((reason) => Cause.isFailReason(reason) && isDecline(reason.error) ? [{ call: calls[index], reason: reason.error }] : []) : []);
+  const causes = settled._tag === "Failure" ? [settled.cause] : exits.flatMap((exit) => exit._tag === "Failure" ? [exit.cause] : []);
+  const failure = causes.flatMap((cause) => {
+    if (Cause.hasInterrupts(cause))
+      return [];
+    const reasons = cause.reasons.flatMap((reason) => Cause.isFailReason(reason) ? [] : [reason]);
+    return reasons.length > 0 ? [Cause.fromReasons(reasons)] : [];
+  }).at(0);
+  return {
+    interrupted: causes.some(Cause.hasInterrupts),
+    declines,
+    failure
+  };
+};
+var TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" };
+var STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" };
+var RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" };
+var CONTINUE_AFTER_INCOMPLETE_STREAM = "The previous response was interrupted. Continue from where you left off without repeating completed content.";
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const llm = yield* LLMClient.Service;
+  const store = yield* exports_store.Service;
+  const context = yield* exports_context.Service;
+  const modelRequests = yield* exports_model_request.Service;
+  const snapshots = yield* exports_snapshot.Service;
+  const db = (yield* exports_database.Service).db;
+  const compaction = yield* exports_compaction.Service;
+  const title = yield* exports_title.Service;
+  const toolOutput = yield* exports_tool_output.Service;
+  const titlesRunning = new Set;
+  const forkTitle = yield* FiberSet.makeRuntime();
+  const drain = Effect.fn("SessionRunner.drain")(function* (input) {
+    if (!input.force && !(yield* exports_pending.has(db, input.sessionID, "any")))
+      return;
+    yield* settleStaleToolCalls(input.sessionID);
+    yield* runPendingCompaction(input.sessionID);
+    if (!input.force && !(yield* exports_pending.has(db, input.sessionID, "input")))
+      return;
+    do {
+      yield* runSteps(input.sessionID);
+    } while (yield* exports_pending.has(db, input.sessionID, "input"));
+  });
+  const runSteps = Effect.fn("SessionRunner.runSteps")(function* (sessionID) {
+    let promotable = "input";
+    let step = 1;
+    while (true) {
+      const result = yield* runStep(sessionID, promotable, step);
+      if (step === 1)
+        yield* startTitle(sessionID);
+      yield* runPendingCompaction(sessionID);
+      if (!result.needsContinuation && !(yield* exports_pending.has(db, sessionID, "steer")))
+        return;
+      promotable = "steer";
+      step = result.step + 1;
+    }
+  });
+  const runStep = Effect.fnUntraced(function* (sessionID, promotable, step) {
+    let assistantMessageID = exports_message.ID.create();
+    const retry = yield* Schedule.toStepWithSleep(exports_retry.schedule(bus, sessionID, () => assistantMessageID));
+    const waitForRetry = (failure) => retry(failure).pipe(Effect.as(CallOutcome.Retry({ step: failure.step })), Pull.catchDone(() => bus.publish(SessionEvent.Step.Failed, {
+      sessionID,
+      assistantMessageID,
+      error: failure.error
+    }).pipe(Effect.andThen(Effect.fail(failure.cause)))));
+    let currentPromotable = promotable;
+    let currentStep = step;
+    let recoverOverflow = true;
+    while (true) {
+      const outcome = yield* callModel(sessionID, currentPromotable, currentStep, recoverOverflow, assistantMessageID).pipe(Effect.catchTag("SessionRunner.RetryableFailure", waitForRetry));
+      if (outcome._tag === "Completed")
+        return { needsContinuation: outcome.needsContinuation, step: outcome.step };
+      if (outcome._tag === "Continue") {
+        yield* retry(new exports_retry.RetryableFailure({
+          cause: outcome.cause,
+          error: outcome.error,
+          step: outcome.step
+        })).pipe(Pull.catchDone(() => Effect.fail(outcome.cause)));
+        yield* bus.publish(SessionEvent.Synthetic, {
+          sessionID,
+          text: CONTINUE_AFTER_INCOMPLETE_STREAM
+        });
+        assistantMessageID = exports_message.ID.create();
+      }
+      if (outcome._tag === "Restart") {
+        if (outcome.recoveredOverflow)
+          recoverOverflow = false;
+        assistantMessageID = exports_message.ID.create();
+      }
+      currentPromotable = undefined;
+      currentStep = outcome.step;
+    }
+  });
+  const callModel = Effect.fn("SessionRunner.callModel")(function* (sessionID, promotable, step, recoverOverflow, assistantMessageID) {
+    const selected = yield* context.select(sessionID);
+    yield* exports_instruction_state.prepare(db, bus, selected.instructions, selected.session.id);
+    const promoted = promotable ? yield* exports_pending.promote(db, bus, selected.session.id, promotable) : 0;
+    const currentStep = promoted > 0 ? 1 : step;
+    const loaded = yield* context.load(selected);
+    const { session, agent } = loaded;
+    const resolved = loaded.model;
+    const model = resolved.model;
+    const compactionInput = { session, messages: loaded.messages, model, ref: resolved.ref, cost: resolved.cost };
+    if (compaction.required(compactionInput) && !(yield* exports_pending.compaction(db, session.id))) {
+      const compacted = yield* compaction.compact(compactionInput);
+      if (compacted.status === "completed")
+        return CallOutcome.Restart({ step: currentStep, recoveredOverflow: false });
+      return yield* new StepFailedError({ error: compacted.error });
+    }
+    const prepared = yield* modelRequests.prepare({
+      context: loaded,
+      step: currentStep
+    });
+    const toolRuns = [];
+    const interruptTools = Effect.suspend(() => Fiber.interruptAll(toolRuns.map((run) => run.fiber)));
+    const startSnapshot = yield* snapshots.capture();
+    const publisher = createLLMEventPublisher(bus, {
+      sessionID: session.id,
+      agent: agent.id,
+      model: resolved.ref,
+      providerMetadataKey: model.route.providerMetadataKey ?? model.provider,
+      snapshot: startSnapshot,
+      assistantMessageID
+    });
+    const stepUsage = (finish) => ({
+      cost: exports_usage.calculateCost(resolved.cost, finish.tokens),
+      tokens: finish.tokens
+    });
+    const captureStepEnd = Effect.fnUntraced(function* () {
+      const snapshot = yield* snapshots.capture();
+      const files = startSnapshot && snapshot ? yield* snapshots.files({ from: startSnapshot, to: snapshot }).pipe(Effect.catch(() => Effect.succeed(undefined))) : undefined;
+      return { snapshot, files };
+    });
+    const publishStepEnd = (finish) => Effect.gen(function* () {
+      const end = yield* captureStepEnd();
+      yield* bus.publish(SessionEvent.Step.Ended, {
+        sessionID: session.id,
+        assistantMessageID: yield* publisher.startAssistant(),
+        finish: finish.finish,
+        ...stepUsage(finish),
+        ...end
+      });
+    });
+    let overflowFailure;
+    const providerStream = llm.stream(prepared.request, prepared.options).pipe(Stream.runForEach((event) => Effect.gen(function* () {
+      if (overflowFailure || publisher.hasProviderError())
+        return;
+      if (LLMEvent.is.providerError(event)) {
+        if (isContextOverflowFailure(event) && !publisher.record().outputStarted) {
+          overflowFailure = event;
+          return;
+        }
+      }
+      yield* publisher.publish(event);
+      if (event.type !== "tool-call" || event.providerExecuted)
+        return;
+      const assistantMessageID2 = yield* publisher.assistantMessageID(event.id);
+      toolRuns.push({
+        call: event,
+        fiber: yield* Effect.uninterruptibleMask((restore) => restore(prepared.executeTool({
+          sessionID: session.id,
+          agent: agent.id,
+          messageID: assistantMessageID2,
+          call: event,
+          progress: (update) => publisher.progress(event.id, update)
+        })).pipe(Effect.flatMap(toolOutput.truncate), Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)), Effect.catchTag("Tool.Error", (error) => publisher.failTool(event.id, toSessionError(error), error.metadata).pipe(Effect.asVoid)))).pipe(Effect.forkScoped)
+      });
+    })), Effect.ensuring(publisher.flush()));
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const stream = yield* restore(providerStream).pipe(Effect.exit);
+      const streamFailure = Option.getOrUndefined(Exit.findErrorOption(stream));
+      const streamInterrupted = stream._tag === "Failure" && Cause.hasInterrupts(stream.cause);
+      if (streamInterrupted)
+        yield* interruptTools;
+      const joined = yield* restore(Effect.forEach(toolRuns, (run) => Fiber.await(run.fiber), { concurrency: "unbounded" })).pipe(Effect.exit);
+      if (joined._tag === "Failure")
+        yield* interruptTools;
+      const tools = classifyToolExits(joined, toolRuns.map((run) => run.call));
+      if (recoverOverflow && !publisher.record().outputStarted && isContextOverflowFailure(overflowFailure ?? streamFailure) && (yield* restore(compaction.compact(compactionInput))).status === "completed")
+        return CallOutcome.Restart({ step: currentStep, recoveredOverflow: true });
+      if (overflowFailure)
+        yield* publisher.publish(overflowFailure);
+      const llmFailure = streamFailure instanceof AIError ? streamFailure : undefined;
+      const llmError = llmFailure && !publisher.record().providerFailed ? toSessionError(llmFailure) : undefined;
+      if (llmFailure && llmError && exports_retry.isRetryable(llmFailure) && !publisher.record().outputStarted) {
+        yield* publisher.startAssistant();
+        return yield* new exports_retry.RetryableFailure({
+          cause: llmFailure,
+          error: llmError,
+          step: currentStep
+        });
+      }
+      if (llmError)
+        yield* publisher.failAssistant(llmError);
+      for (const decline of tools.declines)
+        yield* publisher.failTool(decline.call.id, {
+          type: "aborted",
+          message: decline.reason._tag === "QuestionTool.CancelledError" ? decline.reason.message : "The user declined this tool call"
+        });
+      if (tools.declines.length > 0 || streamInterrupted || tools.interrupted) {
+        yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED);
+        yield* publisher.failAssistant(STEP_INTERRUPTED);
+      }
+      if (tools.failure !== undefined) {
+        const error = toSessionError(Cause.squash(tools.failure));
+        yield* publisher.failUnsettledTools(error);
+      }
+      if (publisher.record().providerFailed)
+        yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED);
+      if (llmError)
+        yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted");
+      if (stream._tag === "Success" && !publisher.record().providerFailed) {
+        const hostedResultMissing = yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted");
+        if (hostedResultMissing && !publisher.record().finish)
+          yield* publisher.failAssistant(RESULT_MISSING);
+      }
+      const record = publisher.record();
+      if (record.finish && !record.failure)
+        yield* publishStepEnd(record.finish);
+      if (record.failure) {
+        const end = yield* captureStepEnd();
+        yield* publisher.publishStepFailure({
+          ...record.finish ? stepUsage(record.finish) : {},
+          ...end
+        });
+      }
+      const incompleteStream = llmFailure?.reason._tag === "InvalidProviderOutput" && llmFailure.reason.classification === "incomplete-stream";
+      const toolsAllowContinuation = tools.declines.length === 0 && !tools.interrupted;
+      if (llmError && incompleteStream && record.outputStarted && toolsAllowContinuation)
+        return CallOutcome.Continue({
+          cause: llmFailure,
+          error: llmError,
+          step: currentStep
+        });
+      if (stream._tag === "Failure")
+        return yield* Effect.failCause(stream.cause);
+      if (tools.declines.length > 0)
+        return yield* Effect.interrupt;
+      if (tools.interrupted && tools.failure)
+        return yield* Effect.failCause(tools.failure);
+      if (tools.interrupted && joined._tag === "Failure")
+        return yield* Effect.failCause(joined.cause);
+      if (record.failure)
+        return yield* new StepFailedError({ error: record.failure });
+      return CallOutcome.Completed({
+        needsContinuation: !prepared.stepLimitReached && record.calls.some((call) => !call.providerExecuted && (call.called || call.settled)),
+        step: currentStep
+      });
+    }));
+  }, Effect.scoped);
+  const runPendingCompaction = Effect.fn("SessionRunner.runPendingCompaction")(function* (sessionID) {
+    const pending = yield* exports_pending.compaction(db, sessionID);
+    if (!pending)
+      return;
+    const session = yield* getSession(sessionID);
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const compacted = yield* restore(Effect.gen(function* () {
+        return yield* compaction.compactManual({
+          session,
+          messages: yield* store.context(sessionID),
+          inputID: pending.id
+        });
+      })).pipe(Effect.exit);
+      if (Exit.isSuccess(compacted))
+        return;
+      const unsettled = yield* exports_pending.compaction(db, sessionID);
+      if (unsettled)
+        yield* bus.publish(SessionEvent.Compaction.Failed, {
+          sessionID,
+          reason: "manual",
+          error: Cause.hasInterruptsOnly(compacted.cause) ? { type: "aborted", message: "Compaction cancelled" } : { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
+          inputID: unsettled.id
+        });
+      return yield* Effect.failCause(compacted.cause);
+    }));
+  });
+  const settleStaleToolCalls = Effect.fn("SessionRunner.settleStaleToolCalls")(function* (sessionID) {
+    for (const message of yield* store.context(sessionID)) {
+      if (message.type !== "assistant")
+        continue;
+      for (const tool of message.content) {
+        if (tool.type !== "tool" || tool.state.status !== "streaming" && tool.state.status !== "running")
+          continue;
+        yield* bus.publish(SessionEvent.Tool.Failed, {
+          sessionID,
+          assistantMessageID: message.id,
+          id: tool.id,
+          error: { type: "aborted", message: `Tool execution interrupted: ${tool.name}` },
+          executed: tool.executed === true
+        });
+      }
+    }
+  });
+  const startTitle = Effect.fnUntraced(function* (sessionID) {
+    if (titlesRunning.has(sessionID))
+      return;
+    titlesRunning.add(sessionID);
+    forkTitle(title.generateForFirstPrompt(sessionID).pipe(Effect.ignore, Effect.ensuring(Effect.sync(() => {
+      titlesRunning.delete(sessionID);
+    }))));
+  });
+  const getSession = Effect.fn("SessionRunner.getSession")(function* (sessionID) {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
+    return session;
+  });
+  return Service.of({ drain });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [
+    exports_bus.node,
+    llmClient,
+    exports_context.node,
+    exports_model_request.node,
+    exports_store.node,
+    exports_compaction.node,
+    exports_title.node,
+    exports_snapshot.node,
+    exports_tool_output.node,
+    exports_database.node
+  ]
+});
+
+export { node, exports_llm };