@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-ed4jjjcc.js

@@ -0,0 +1,171 @@
+import {
+  Failed,
+  NotFound,
+  WrongKind
+} from "./location-mutation-zthe9zqc.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/environment/memory.ts
+var exports_memory = {};
+__export(exports_memory, {
+  makeMemoryDriver: () => makeMemoryDriver,
+  EnvironmentMemory: () => exports_memory
+});
+import path from "node:path";
+import { Effect, PlatformError } from "effect";
+import { make } from "effect/unstable/process/ChildProcessSpawner";
+var makeMemoryDriver = () => {
+  const nodes = new Map([["/", { type: "directory", mtimeMs: Date.now() }]]);
+  const key = (value) => path.posix.resolve("/", value);
+  const info = (node) => ({
+    type: node.type,
+    size: node.type === "file" ? node.bytes.length : node.type === "symlink" ? new TextEncoder().encode(node.target).length : 0,
+    mtimeMs: node.mtimeMs
+  });
+  const resolveKey = (value, followFinal, seen = new Set) => {
+    const normalized = key(value);
+    const parts = normalized.split("/").filter(Boolean);
+    const base = "/";
+    const walk = (current, index) => {
+      if (index === parts.length)
+        return current;
+      const part = parts[index];
+      const candidate = path.posix.join(current, part);
+      const node = nodes.get(candidate);
+      if (node?.type !== "symlink" || !followFinal && index === parts.length - 1)
+        return walk(candidate, index + 1);
+      if (seen.has(candidate))
+        return;
+      seen.add(candidate);
+      const target = path.posix.resolve(path.posix.dirname(candidate), node.target);
+      return resolveKey(path.posix.join(target, ...parts.slice(index + 1)), followFinal, seen);
+    };
+    return walk(base, 0);
+  };
+  const lookup = (value) => nodes.get(resolveKey(value, false) ?? key(value));
+  const requireParent = (value) => {
+    const parentPath = path.posix.dirname(key(value));
+    const parent = nodes.get(resolveKey(parentPath, true) ?? parentPath);
+    if (!parent)
+      throw new Error(`Parent directory does not exist: ${path.posix.dirname(value)}`);
+    if (parent.type !== "directory")
+      throw new Error(`Parent is not a directory: ${path.posix.dirname(value)}`);
+  };
+  const mkdirSync = (value) => {
+    const target = resolveKey(value, false) ?? key(value);
+    const existing = nodes.get(target);
+    if (existing?.type === "directory")
+      return;
+    if (existing)
+      throw new Error(`Path is not a directory: ${value}`);
+    const parent = path.posix.dirname(target);
+    if (parent !== target)
+      mkdirSync(parent);
+    nodes.set(target, { type: "directory", mtimeMs: Date.now() });
+  };
+  const failed = (value, cause) => new Failed({ path: value, cause });
+  const overrides = {
+    stat: (value) => {
+      const node = lookup(value);
+      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }));
+    },
+    read: (value, range) => {
+      const original = lookup(value);
+      if (!original)
+        return Effect.fail(new NotFound({ path: value }));
+      if (original.type === "directory")
+        return Effect.fail(new WrongKind({ path: value, actual: "directory" }));
+      const resolved = resolveKey(value, true);
+      const node = resolved === undefined ? undefined : nodes.get(resolved);
+      if (!node)
+        return Effect.fail(new NotFound({ path: value }));
+      if (node.type !== "file")
+        return Effect.fail(new WrongKind({ path: value, actual: node.type }));
+      const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length);
+      return Effect.succeed({ info: info(node), bytes: bytes.slice() });
+    },
+    write: (value, bytes) => Effect.try({
+      try: () => {
+        mkdirSync(path.posix.dirname(key(value)));
+        const existing = lookup(value);
+        if (existing?.type === "directory")
+          throw new Error(`Path is a directory: ${value}`);
+        const target = existing?.type === "symlink" ? resolveKey(value, true) : resolveKey(value, false);
+        if (!target)
+          throw new Error(`Cannot resolve symlink: ${value}`);
+        requireParent(target);
+        nodes.set(target, { type: "file", bytes: bytes.slice(), mtimeMs: Date.now() });
+      },
+      catch: (cause) => failed(value, cause)
+    }),
+    list: (value) => {
+      const target = resolveKey(value, true) ?? key(value);
+      const node = nodes.get(target);
+      if (!node)
+        return Effect.fail(new NotFound({ path: value }));
+      if (node.type !== "directory")
+        return Effect.fail(new WrongKind({ path: value, actual: node.type }));
+      const entries = [...nodes.entries()].filter(([entry]) => entry !== target && path.posix.dirname(entry) === target).map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type })).sort((a, b) => a.name.localeCompare(b.name));
+      return Effect.succeed(entries);
+    },
+    remove: (value) => Effect.sync(() => {
+      const target = resolveKey(value, false) ?? key(value);
+      for (const entry of nodes.keys()) {
+        if (entry === target || entry.startsWith(`${target}/`))
+          nodes.delete(entry);
+      }
+    }),
+    move: (from, to) => {
+      const source = resolveKey(from, false) ?? key(from);
+      const node = nodes.get(source);
+      if (!node)
+        return Effect.fail(new NotFound({ path: from }));
+      return Effect.try({
+        try: () => {
+          const requested = resolveKey(to, false) ?? key(to);
+          const destination = nodes.get(requested)?.type === "directory" ? path.posix.join(requested, path.posix.basename(source)) : requested;
+          if (node.type === "directory" && destination.startsWith(`${source}/`)) {
+            throw new Error(`Cannot move a directory into itself: ${from}`);
+          }
+          const existing = nodes.get(destination);
+          if (node.type === "directory" && existing && existing.type !== "directory") {
+            throw new Error(`Cannot overwrite a non-directory with a directory: ${to}`);
+          }
+          requireParent(destination);
+          const moved = [...nodes.entries()].filter(([entry]) => entry === source || entry.startsWith(`${source}/`));
+          for (const [entry] of moved)
+            nodes.delete(entry);
+          for (const [entry, child] of moved)
+            nodes.set(`${destination}${entry.slice(source.length)}`, child);
+        },
+        catch: (cause) => failed(from, cause)
+      });
+    },
+    mkdir: (value) => Effect.try({ try: () => mkdirSync(value), catch: (cause) => failed(value, cause) })
+  };
+  const spawner = make((command) => Effect.suspend(() => {
+    const description = command._tag === "StandardCommand" ? command.command : "pipeline";
+    return Effect.fail(PlatformError.systemError({
+      _tag: "Unknown",
+      module: "EnvironmentMemory",
+      method: "spawn",
+      pathOrDescriptor: description,
+      cause: failed(description, new Error("The memory driver cannot spawn processes"))
+    }));
+  }));
+  return {
+    spawner,
+    overrides,
+    symlink: (target, value) => Effect.try({
+      try: () => {
+        requireParent(value);
+        nodes.set(resolveKey(value, false) ?? key(value), { type: "symlink", target, mtimeMs: Date.now() });
+      },
+      catch: (cause) => failed(value, cause)
+    })
+  };
+};
+
+export { makeMemoryDriver, exports_memory };

package/dist/chunks/location-mutation-ehj9csmv.js

@@ -0,0 +1,6 @@
+// src/util/iife.ts
+function iife(fn) {
+  return fn();
+}
+
+export { iife };

package/dist/chunks/location-mutation-em6xpscd.js

@@ -0,0 +1,35 @@
+// src/database/migration/20260812213948_worktree.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260812213948_worktree",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`worktree\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`strategy\` text,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`worktree_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_worktree_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`
+        INSERT INTO \`worktree\` (\`project_id\`, \`directory\`, \`strategy\`, \`time_created\`)
+        SELECT
+          \`project_id\`,
+          \`directory\`,
+          CASE
+            WHEN \`strategy\` = 'git_worktree' THEN 'git'
+            WHEN \`strategy\` IS NOT NULL THEN \`strategy\`
+            WHEN \`type\` = 'git_worktree' THEN 'git'
+          END,
+          \`time_created\`
+        FROM \`project_directory\`;
+      `);
+    });
+  }
+};
+var _20260812213948_worktree_default = migration;
+
+export { _20260812213948_worktree_default };

package/dist/chunks/location-mutation-emmqknsm.js

@@ -0,0 +1,26 @@
+// src/database/migration/20260812181746_session_inbox.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260812181746_session_inbox",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`session_inbox\` (
+          \`id\` text PRIMARY KEY,
+          \`session_id\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`payload\` text NOT NULL,
+          \`delivery\` text NOT NULL,
+          \`enqueued_seq\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`fk_session_inbox_session_id_session_v2_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session_v2\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE INDEX \`session_inbox_session_delivery_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`delivery\`,\`enqueued_seq\`);`);
+      yield* tx.run(`CREATE UNIQUE INDEX \`session_inbox_session_enqueued_seq_idx\` ON \`session_inbox\` (\`session_id\`,\`enqueued_seq\`);`);
+    });
+  }
+};
+var _20260812181746_session_inbox_default = migration;
+
+export { _20260812181746_session_inbox_default };

package/dist/chunks/location-mutation-erj4j75s.js

@@ -0,0 +1,129 @@
+import {
+  getTableColumnsRuntime,
+  mapUpdateSet,
+  orderSelectedFields
+} from "./location-mutation-ma07p6tt.js";
+
+// src/database/drizzle/sqlite-core/effect/insert.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind, is } from "drizzle-orm/entity";
+import { Param, SQL, sql } from "drizzle-orm/sql/sql";
+import { extractUsedTable } from "drizzle-orm/sqlite-core/utils";
+import { haveSameKeys } from "drizzle-orm/utils";
+import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
+class SQLiteEffectInsertBuilder {
+  table;
+  session;
+  dialect;
+  withList;
+  static [entityKind] = "SQLiteEffectInsertBuilder";
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  values(values) {
+    values = Array.isArray(values) ? values : [values];
+    if (values.length === 0) {
+      throw new Error("values() must be called with at least one value");
+    }
+    const mappedValues = values.map((entry) => {
+      const result = {};
+      const cols = getTableColumnsRuntime(this.table);
+      for (const colKey of Object.keys(entry)) {
+        const colValue = entry[colKey];
+        result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+      }
+      return result;
+    });
+    return new SQLiteEffectInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
+  }
+  select(selectQuery) {
+    const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder) : selectQuery;
+    if (!is(select, SQL) && !haveSameKeys(getTableColumnsRuntime(this.table), select._.selectedFields)) {
+      throw new Error("Insert select error: selected fields are not the same or are in a different order compared to the table definition");
+    }
+    return new SQLiteEffectInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+  }
+}
+
+class SQLiteEffectInsertBase {
+  table;
+  effectSession;
+  effectDialect;
+  static [entityKind] = "SQLiteEffectInsert";
+  config;
+  constructor(table, values, effectSession, effectDialect, withList, select) {
+    this.table = table;
+    this.effectSession = effectSession;
+    this.effectDialect = effectDialect;
+    this.config = { table, values, withList, select };
+  }
+  returning(fields = getTableColumnsRuntime(this.config.table)) {
+    this.config.returning = orderSelectedFields(fields);
+    return this;
+  }
+  onConflictDoNothing(config = {}) {
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    if (config.target === undefined) {
+      this.config.onConflict.push(sql` on conflict do nothing`);
+      return this;
+    }
+    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
+    const whereSql = config.where ? sql` where ${config.where}` : sql``;
+    this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);
+    return this;
+  }
+  onConflictDoUpdate(config) {
+    if (config.where && (config.targetWhere || config.setWhere)) {
+      throw new Error('You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.');
+    }
+    if (!this.config.onConflict)
+      this.config.onConflict = [];
+    const whereSql = config.where ? sql` where ${config.where}` : undefined;
+    const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : undefined;
+    const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : undefined;
+    const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
+    const setSql = this.effectDialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
+    this.config.onConflict.push(sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`);
+    return this;
+  }
+  getSQL() {
+    return this.effectDialect.buildInsertQuery(this.config);
+  }
+  toSQL() {
+    return this.effectDialect.sqlToQuery(this.getSQL());
+  }
+  _prepare(isOneTimeQuery = true) {
+    return this.effectSession[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](this.effectDialect.sqlToQuery(this.getSQL()), this.config.returning, this.config.returning ? "all" : "run", undefined, {
+      type: "insert",
+      tables: extractUsedTable(this.config.table)
+    });
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  run = (placeholderValues) => {
+    return this._prepare().run(placeholderValues);
+  };
+  all = (placeholderValues) => {
+    return this._prepare().all(placeholderValues);
+  };
+  get = (placeholderValues) => {
+    return this._prepare().get(placeholderValues);
+  };
+  values = (placeholderValues) => {
+    return this._prepare().values(placeholderValues);
+  };
+  execute = (placeholderValues) => {
+    return this._prepare().execute(placeholderValues);
+  };
+  $dynamic() {
+    return this;
+  }
+}
+applyEffectWrapper(SQLiteEffectInsertBase);
+
+export { SQLiteEffectInsertBuilder, SQLiteEffectInsertBase };

package/dist/chunks/location-mutation-ex1a6s0j.js

@@ -0,0 +1,286 @@
+import {
+  exports_parse
+} from "./location-mutation-0zs4qnv1.js";
+import {
+  exports_runtime
+} from "./location-mutation-jm193w7g.js";
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_location_mutation
+} from "./location-mutation-z17t3kn2.js";
+import {
+  exports_tool_output
+} from "./location-mutation-6d38mye6.js";
+import {
+  exports_shell
+} from "./location-mutation-087amx3w.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_environment1 as exports_environment
+} from "./location-mutation-pysc8t9c.js";
+import {
+  NonNegativeInt
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/tool/plugin/shell.ts
+var exports_shell2 = {};
+__export(exports_shell2, {
+  name: () => name,
+  ShellTool: () => exports_shell2,
+  Plugin: () => Plugin,
+  Input: () => Input,
+  DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS
+});
+import path from "path";
+import { ToolFailure } from "@opencode-ai/ai";
+import { Deferred, Effect, Schema, Scope } from "effect";
+var name = "shell";
+var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
+var BACKGROUND_STARTED = "The command was moved to the background.";
+var BACKGROUND_INSTRUCTION = "You will be notified automatically when the command finishes. DO NOT sleep, poll, or proactively check on its progress.";
+var OS = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : process.platform === "linux" ? "Linux" : process.platform;
+var description = (shell) => [
+  "Execute a shell command and return its output.",
+  ...shell ? [`Commands run on ${OS} using ${shell}.`] : [],
+  "Quote file paths containing spaces or special characters.",
+  "Prefer dedicated tools over shell commands when possible.",
+  "When output is large, the full result is saved to a file and a truncated preview is returned.",
+  "Rely on automatic truncation unless filtering the output is more useful.",
+  "Commands accept an optional timeout, background commands have no timeout by default.",
+  "Background commands return immediately, and you will be notified when they complete."
+].join(" ");
+var Input = Schema.Struct({
+  command: Schema.String.annotate({ description: "Shell command string to execute" }),
+  workdir: Schema.optionalKey(Schema.String).annotate({
+    description: "Working directory to execute the command in. Defaults to the current working directory. When possible, avoid changing directories in the command and set the working directory here instead."
+  }),
+  timeout: Schema.optionalKey(NonNegativeInt).annotate({
+    description: `Timeout in milliseconds. Set to 0 to disable the timeout. Defaults to ${DEFAULT_TIMEOUT_MS} for foreground commands. Background commands have no timeout by default.`
+  }),
+  background: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Run the command in the background and return immediately. You will be notified when it completes. DO NOT poll its progress."
+  })
+});
+var StructuredOutput = Schema.Struct({
+  exit: Schema.optionalKey(Schema.Number),
+  shellID: Schema.optionalKey(Schema.String),
+  truncated: Schema.Boolean,
+  timeout: Schema.optionalKey(Schema.Boolean)
+});
+var Output = Schema.Struct({
+  ...StructuredOutput.fields,
+  output: Schema.String,
+  status: Schema.optionalKey(Schema.Literals(["completed", "running"]))
+});
+var modelOutput = (output) => {
+  if (output.status === "running")
+    return BACKGROUND_INSTRUCTION;
+  if (output.timeout)
+    return "Command timed out before completion.";
+  return `Command exited with code ${output.exit}.`;
+};
+var Plugin = {
+  id: "opencode.tool.shell",
+  effect: Effect.fn("ShellTool.Plugin")(function* (ctx) {
+    const runtime = yield* exports_runtime.Service;
+    const scope = yield* Scope.Scope;
+    const environment = yield* exports_environment.Service;
+    const mutation = yield* exports_location_mutation.Service;
+    const shell = yield* exports_shell.Service;
+    const permission = yield* exports_permission.Service;
+    const config = yield* exports_config.Service;
+    const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (sessionID, id, command) {
+      yield* runtime.job.wait({ id }).pipe(Effect.flatMap((result) => {
+        const state = result.info?.status === "completed" ? "completed" : result.info?.status === "error" ? "error" : result.info?.status === "cancelled" ? "cancelled" : undefined;
+        if (state === undefined)
+          return Effect.void;
+        const text = state === "completed" ? result.info.output ?? "" : state === "error" ? result.info.error ?? "Command failed" : "Command cancelled";
+        return runtime.session.synthetic({
+          sessionID,
+          text: `<shell id="${id}" state="${state}" command="${command}">
+${text}
+</shell>`,
+          description: command,
+          metadata: { source: "shell", jobID: id, state }
+        });
+      }), Effect.forkIn(scope, { startImmediately: true }));
+    });
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description: description(),
+      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({
+          command: input.command,
+          cwd: input.workdir,
+          timeout,
+          metadata: { sessionID: context.sessionID }
+        }, (invocation) => Effect.gen(function* () {
+          const target = yield* mutation.resolve({ path: invocation.cwd, kind: "directory" });
+          const unrestricted = (yield* permission.allowsAll({
+            sessionID: context.sessionID,
+            action: name,
+            agent: context.agent
+          })) && (yield* permission.allowsAll({
+            sessionID: context.sessionID,
+            action: "external_directory",
+            agent: context.agent
+          }));
+          invocation.cwd = target.absolute;
+          finalTimeout = invocation.timeout;
+          if (!unrestricted) {
+            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: path.resolve(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}`));
+        }));
+        yield* context.progress({ shellID: info.id });
+        const captureShell = Effect.fn("ShellTool.captureShell")(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}]` : "";
+          return {
+            output: `${output || "(no output)"}${notice}`,
+            truncated
+          };
+        });
+        const settleShell = Effect.fn("ShellTool.settleShell")(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}
+
+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,
+            status: "completed"
+          };
+        });
+        const settled = yield* Deferred.make();
+        const run = settleShell().pipe(Effect.tap((output) => Deferred.succeed(settled, output)), Effect.map((output) => output.output), Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)));
+        const job = yield* runtime.job.start({
+          id: context.id,
+          type: name,
+          title: info.command,
+          metadata: { sessionID: context.sessionID, shellID: info.id },
+          run
+        });
+        if (input.background === true) {
+          yield* runtime.job.background(job.id);
+          yield* notifyWhenDone(context.sessionID, context.id, info.command);
+          return {
+            output: BACKGROUND_STARTED,
+            shellID: info.id,
+            truncated: false,
+            status: "running"
+          };
+        }
+        const result = yield* runtime.job.block({ id: job.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)));
+        if (result?.type === "backgrounded") {
+          yield* shell.timeout(info.id, 0);
+          yield* notifyWhenDone(context.sessionID, context.id, info.command);
+          return {
+            output: BACKGROUND_STARTED,
+            shellID: info.id,
+            truncated: false,
+            status: "running"
+          };
+        }
+        if (result?.info.status === "error")
+          return yield* Effect.fail(new Error(result.info.error ?? "Command failed"));
+        if (result?.info.status === "cancelled")
+          return yield* Effect.fail(new Error("Command cancelled"));
+        return yield* Deferred.await(settled);
+      }).pipe(Effect.map((output) => {
+        const content = [{ type: "text", text: output.output }];
+        const model = modelOutput(output);
+        if (model)
+          content.push({ type: "text", text: model });
+        return {
+          output,
+          content,
+          metadata: {
+            status: output.status,
+            truncated: output.truncated,
+            ..."exit" in output && output.exit !== undefined ? { exit: output.exit } : {},
+            ..."shellID" in output && output.shellID !== undefined ? { shellID: output.shellID } : {},
+            ..."timeout" in output && output.timeout !== undefined ? { timeout: output.timeout } : {}
+          }
+        };
+      }), Effect.mapError((error) => new ToolFailure({ message: `Unable to execute command: ${input.command}`, error })))
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const tool = event.tools[name];
+      if (!tool)
+        return;
+      tool.description = description(yield* shell.name());
+    }));
+  })
+};
+
+export { name, DEFAULT_TIMEOUT_MS, Input, Plugin, exports_shell2 as exports_shell };