@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/command-chunks/{chunk-YFSDDFGV.js → chunk-WH627NJL.js}

@@ -12,10 +12,11 @@ import {
 
 // packages/safe-bash-command-llm/src/command.ts
 init_buffer();
-import { createOutputOperation, getCommandArguments, FsError as FsError7 } from "../../safe-bash-contracts/index.js";
-import { inheritYieldCheckpoint, yieldTurn as yieldTurn3 } from "../../safe-bash-contracts/yield.js";
-import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
-import { pathOf as pathOf4 } from "../../safe-bash-contracts/path.js";
+
+// packages/safe-bash-command-llm/src/stored-schema.ts
+init_buffer();
+import { FsError as FsError7 } from "../../safe-bash-contracts/index.js";
+import { pathOf as pathOf2 } from "../../safe-bash-contracts/path.js";
 
 // packages/safe-bash-command-llm/src/configuration.ts
 init_buffer();
@@ -246,10 +247,400 @@ function createLlmConfiguration(context) {
   };
 }
 
-// packages/safe-bash-command-llm/src/templates.ts
+// packages/safe-bash-command-llm/src/sqlite-scan.ts
+init_buffer();
+
+// packages/safe-bash-command-llm/src/sqlite-pages.ts
+init_buffer();
+
+// packages/safe-bash-command-llm/src/sqlite-varint.ts
 init_buffer();
 import { FsError as FsError3 } from "../../safe-bash-contracts/index.js";
-import { pathOf as pathOf2 } from "../../safe-bash-contracts/path.js";
+function readSqliteVarint(bytes, start) {
+  let value = 0n;
+  for (let i = 0; i < 9; i++) {
+    const byte = bytes[start + i];
+    if (byte === void 0) throw new FsError3("EIO", { message: "Invalid SQLite varint" });
+    value = value << BigInt(i === 8 ? 8 : 7) | BigInt(i === 8 ? byte : byte & 127);
+    if (i === 8 || byte < 128) return { value, end: start + i + 1 };
+  }
+  throw new FsError3("EIO", { message: "Invalid SQLite varint" });
+}
+
+// packages/safe-bash-command-llm/src/sqlite-pages.ts
+import { FsError as FsError5 } from "../../safe-bash-contracts/index.js";
+
+// packages/safe-bash-command-llm/src/sqlite-snapshot.ts
+init_buffer();
+import { FsError as FsError4 } from "../../safe-bash-contracts/index.js";
+function verifySqliteSnapshot(actual, expected) {
+  const identity = expected.opaqueIdentity !== void 0 ? actual.opaqueIdentity === expected.opaqueIdentity : expected.dev !== void 0 && expected.ino !== void 0 && actual.dev === expected.dev && actual.ino === expected.ino;
+  if (!identity || expected.identityScope === void 0 || expected.identityScope !== actual.identityScope || actual.type !== "file" || actual.size !== expected.size || actual.revision !== expected.revision || actual.opaqueVersion !== expected.opaqueVersion || actual.mtimeMs !== expected.mtimeMs || actual.ctimeMs !== expected.ctimeMs) {
+    throw new FsError4("EBUSY", { message: "SQLite retained snapshot changed" });
+  }
+}
+
+// packages/safe-bash-command-llm/src/sqlite-pages.ts
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+function corrupt() {
+  throw new FsError5("EIO", { message: "Invalid SQLite table record or page chain" });
+}
+function u16(bytes, offset) {
+  if (offset < 0 || offset + 2 > bytes.length) return corrupt();
+  return bytes[offset] * 256 + bytes[offset + 1];
+}
+function u32(bytes, offset) {
+  return u16(bytes, offset) * 65536 + u16(bytes, offset + 2);
+}
+async function findSqliteRecord(file, rootPage, rowid, signal, match = "exact") {
+  signal.throwIfAborted();
+  if (rowid < -(1n << 63n) || rowid >= 1n << 63n) throw new RangeError("SQLite rowid out of range");
+  const expected = await file.stat({ signal });
+  verifySqliteSnapshot(expected, expected);
+  if (!Number.isSafeInteger(expected.size) || expected.size < 100) return corrupt();
+  const check = async () => {
+    signal.throwIfAborted();
+    verifySqliteSnapshot(await file.stat({ signal }), expected);
+  };
+  const read = async (position, count) => {
+    await check();
+    if (!Number.isSafeInteger(position) || position < 0 || count < 0 || count > 65536 || position + count > expected.size) return corrupt();
+    const bytes = new Uint8Array(count);
+    for (let offset = 0; offset < count; ) {
+      const part = await file.read(position + offset, count - offset, { signal });
+      if (!(part instanceof Uint8Array) || !part.length || part.length > count - offset) return corrupt();
+      bytes.set(part, offset);
+      offset += part.length;
+    }
+    await check();
+    return bytes;
+  };
+  const header = await read(0, 100);
+  const magic = "SQLite format 3\0";
+  if ([...magic].some((character, index) => header[index] !== character.charCodeAt(0))) return corrupt();
+  const encodedSize = u16(header, 16), pageSize = encodedSize === 1 ? 65536 : encodedSize;
+  if (pageSize < 512 || pageSize > 65536 || (pageSize & pageSize - 1) !== 0 || expected.size % pageSize) return corrupt();
+  const usable = pageSize - header[20];
+  if (usable < 480) return corrupt();
+  const pages = expected.size / pageSize;
+  const page = async (number2, length = pageSize) => {
+    if (!Number.isSafeInteger(number2) || number2 < 1 || number2 > pages) return corrupt();
+    await yieldTurn(signal);
+    return (await read((number2 - 1) * pageSize, length)).subarray(0, usable);
+  };
+  let number = rootPage, successor;
+  for (let depth = 0; depth < pages * (match === "exact" ? 1 : 2); depth++) {
+    const data = await page(number), start = number === 1 ? 100 : 0;
+    const kind = data[start];
+    if (kind !== 5 && kind !== 13) return corrupt();
+    const count = u16(data, start + 3), pointers = start + (kind === 5 ? 12 : 8);
+    if (pointers + count * 2 > usable) return corrupt();
+    let child = kind === 5 ? u32(data, start + 8) : 0;
+    for (let i = 0; i < count; i++) {
+      const cell = u16(data, pointers + i * 2);
+      if (cell < pointers + count * 2 || cell >= usable) return corrupt();
+      if (kind === 5) {
+        const key = BigInt.asIntN(64, readSqliteVarint(data, cell + 4).value);
+        if (rowid <= key) {
+          child = u32(data, cell);
+          if (key < (1n << 63n) - 1n && (successor === void 0 || key + 1n < successor)) successor = key + 1n;
+          break;
+        }
+      } else {
+        const payload = readSqliteVarint(data, cell), key = readSqliteVarint(data, payload.end);
+        const foundRowid = BigInt.asIntN(64, key.value);
+        if (match === "exact" ? foundRowid !== rowid : foundRowid < rowid) continue;
+        const size = Number(payload.value);
+        if (!Number.isSafeInteger(size)) return corrupt();
+        const max = usable - 35, min = Math.floor((usable - 12) * 32 / 255) - 23;
+        let local = size <= max ? size : min + (size - min) % (usable - 4);
+        if (local > max) local = min;
+        if (key.end + local + (local < size ? 4 : 0) > usable) return corrupt();
+        const first = data.slice(key.end, key.end + local);
+        const overflow = local < size ? u32(data, key.end + local) : 0;
+        return { size, rowid: foundRowid, async *bytes(offset = 0, length = size - offset) {
+          if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset > size || length > size - offset) throw new RangeError("Invalid SQLite record range");
+          await check();
+          const stop = offset + length;
+          async function* emit(content, position2) {
+            const start2 = Math.max(0, offset - position2), end = Math.min(content.length, stop - position2);
+            for (let index = start2; index < end; index += 16384) {
+              await check();
+              yield content.slice(index, Math.min(end, index + 16384));
+            }
+          }
+          yield* emit(first, 0);
+          let position = local, next = overflow, traversed = 0;
+          while (length && position < stop) {
+            if (++traversed > pages) return corrupt();
+            const available = Math.min(size - position, usable - 4);
+            const skipped = position + available <= offset;
+            const content = await page(next, skipped ? 4 : pageSize);
+            next = u32(content, 0);
+            if (!skipped) yield* emit(content.subarray(4, 4 + available), position);
+            position += available;
+          }
+          if (stop === size && length && next !== 0) return corrupt();
+          await check();
+        } };
+      }
+    }
+    if (kind === 13) {
+      if (match === "exact" || successor === void 0) return void 0;
+      rowid = successor;
+      successor = void 0;
+      number = rootPage;
+      continue;
+    }
+    number = child;
+  }
+  return corrupt();
+}
+
+// packages/safe-bash-command-llm/src/sqlite-scan.ts
+async function* scanSqliteRecords(file, rootPage, signal) {
+  signal.throwIfAborted();
+  const snapshot = await file.stat({ signal });
+  verifySqliteSnapshot(snapshot, snapshot);
+  let next = -(1n << 63n);
+  while (next < 1n << 63n) {
+    signal.throwIfAborted();
+    verifySqliteSnapshot(await file.stat({ signal }), snapshot);
+    const record2 = await findSqliteRecord(file, rootPage, next, signal, "at-or-after");
+    verifySqliteSnapshot(await file.stat({ signal }), snapshot);
+    if (!record2) return;
+    yield record2;
+    next = record2.rowid + 1n;
+  }
+}
+
+// packages/safe-bash-command-llm/src/sqlite-values.ts
+init_buffer();
+import { FsError as FsError6 } from "../../safe-bash-contracts/index.js";
+
+// packages/safe-bash-command-llm/src/sqlite-stream.ts
+init_buffer();
+function interruptible(start, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return start();
+    }).then(
+      (value) => {
+        signal.removeEventListener("abort", abort);
+        if (signal.aborted) reject(signal.reason);
+        else resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(signal.aborted ? signal.reason : error);
+      }
+    );
+  });
+}
+async function* sqliteSourceChunks(source, signal) {
+  const iterator = source[Symbol.asyncIterator]();
+  let done = false;
+  try {
+    while (true) {
+      const result = await interruptible(() => iterator.next(), signal);
+      if (result.done) {
+        done = true;
+        return;
+      }
+      yield result.value;
+    }
+  } finally {
+    if (!done) {
+      const closing = Promise.resolve().then(() => iterator.return?.());
+      if (signal.aborted) void closing.catch(() => void 0);
+      else await interruptible(() => closing, signal);
+    }
+  }
+}
+
+// packages/safe-bash-command-llm/src/sqlite-values.ts
+function corrupt2() {
+  throw new FsError6("EIO", { message: "Invalid SQLite record fields" });
+}
+async function readSqliteValues(record2, columns, signal) {
+  signal.throwIfAborted();
+  if (!Number.isSafeInteger(columns) || columns < 0 || !Number.isSafeInteger(columns * 9 + 9)) {
+    throw new RangeError("Invalid SQLite column count");
+  }
+  if (!Number.isSafeInteger(record2.size) || record2.size < 1) return corrupt2();
+  async function read(offset, length) {
+    const result = new Uint8Array(length);
+    let received = 0;
+    for await (const chunk of sqliteSourceChunks(record2.bytes(offset, length), signal)) {
+      signal.throwIfAborted();
+      if (!(chunk instanceof Uint8Array) || chunk.length > length - received) return corrupt2();
+      result.set(chunk, received);
+      received += chunk.length;
+    }
+    if (received !== length) return corrupt2();
+    return result;
+  }
+  const prefix = readSqliteVarint(await read(0, Math.min(9, record2.size)), 0);
+  const headerSize = Number(prefix.value);
+  if (!Number.isSafeInteger(headerSize) || headerSize < prefix.end || headerSize > record2.size || headerSize > columns * 9 + 9) return corrupt2();
+  const header = await read(prefix.end, headerSize - prefix.end);
+  const fields = [];
+  let cursor = 0, position = headerSize;
+  while (cursor < header.length) {
+    if (fields.length >= columns) return corrupt2();
+    const next = readSqliteVarint(header, cursor);
+    cursor = next.end;
+    const serial2 = Number(next.value);
+    if (!Number.isSafeInteger(serial2) || serial2 === 10 || serial2 === 11) return corrupt2();
+    const size = serial2 >= 12 ? Math.floor((serial2 - 12) / 2) : [0, 1, 2, 3, 4, 6, 8, 8, 0, 0][serial2];
+    if (size > record2.size - position) return corrupt2();
+    fields.push({ serial: serial2, offset: position, size });
+    position += size;
+  }
+  if (fields.length !== columns || position !== record2.size) return corrupt2();
+  const values = [];
+  for (const field of fields) {
+    signal.throwIfAborted();
+    if (field.serial === 0) values.push(null);
+    else if (field.serial === 8 || field.serial === 9) values.push(BigInt(field.serial - 8));
+    else if (field.serial >= 12) {
+      values.push({ type: field.serial % 2 ? "text" : "blob", size: field.size, bytes: {
+        async *[Symbol.asyncIterator]() {
+          let received = 0;
+          for await (const chunk of sqliteSourceChunks(record2.bytes(field.offset, field.size), signal)) {
+            signal.throwIfAborted();
+            if (!(chunk instanceof Uint8Array) || chunk.length > field.size - received) return corrupt2();
+            for (let offset = 0; offset < chunk.length; offset += 16384) {
+              signal.throwIfAborted();
+              yield chunk.slice(offset, offset + 16384);
+            }
+            received += chunk.length;
+          }
+          if (received !== field.size) return corrupt2();
+        }
+      } });
+    } else {
+      const bytes = await read(field.offset, field.size);
+      if (field.serial === 7) values.push(new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0));
+      else {
+        let value = 0n;
+        for (const byte of bytes) value = value * 256n + BigInt(byte);
+        values.push(BigInt.asIntN(field.size * 8, value));
+      }
+    }
+  }
+  return values;
+}
+
+// packages/safe-bash-command-llm/src/stored-schema.ts
+async function loadLlmStoredSchema(context, id, options = {}) {
+  const { fs, signal } = context;
+  signal.throwIfAborted();
+  const maxBytes = options.maxBytes ?? Infinity;
+  if (maxBytes !== Infinity && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) throw new RangeError("Invalid schema byte limit");
+  const path = options.database === void 0 ? `${createLlmConfiguration(context).directory}/logs.db` : pathOf2(context, options.database);
+  let expected;
+  try {
+    expected = await fs.stat(path, { signal });
+  } catch (error) {
+    if (error instanceof FsError7 && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  const checkpointed = async () => {
+    for (const suffix of ["-wal", "-journal"]) {
+      try {
+        if ((await fs.stat(path + suffix, { signal })).size > 0) throw new FsError7("ENOTSUP", { path, message: "LLM history requires a checkpointed SQLite snapshot" });
+      } catch (error) {
+        if (!(error instanceof FsError7) || error.code !== "ENOENT") throw error;
+      }
+    }
+  };
+  await checkpointed();
+  if (expected.type !== "file") throw new FsError7("EINVAL", { path });
+  if (!expected.size) return void 0;
+  const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
+  if (!capabilities.retainedRead || !fs.openReadFile) throw new FsError7("ENOTSUP", { path, message: "LLM history requires retained reads" });
+  const file = await fs.openReadFile(path, { signal });
+  try {
+    verifySqliteSnapshot(await file.stat({ signal }), expected);
+    const header = new Uint8Array(60);
+    for (let position = 0; position < header.length; ) {
+      const bytes = await file.read(position, header.length - position, { signal });
+      if (!bytes.length || bytes.length > header.length - position) throw new FsError7("EIO", { path, message: "Invalid SQLite header" });
+      header.set(bytes, position);
+      position += bytes.length;
+    }
+    verifySqliteSnapshot(await file.stat({ signal }), expected);
+    const encoding = [void 0, "utf-8", "utf-16le", "utf-16be"][new DataView(header.buffer).getUint32(56)];
+    if (!encoding) throw new FsError7("EIO", { path, message: "Invalid SQLite text encoding" });
+    async function matches(value, target) {
+      if (!value || typeof value !== "object" || value.type !== "text") return false;
+      const decoder = new TextDecoder(encoding, { fatal: true, ignoreBOM: true });
+      let position = 0;
+      for await (const bytes of value.bytes) {
+        const text = decoder.decode(bytes, { stream: true });
+        if (text !== target.slice(position, position + text.length)) return false;
+        position += text.length;
+      }
+      const final = decoder.decode();
+      return final === target.slice(position) && position + final.length === target.length;
+    }
+    let root;
+    for await (const record2 of scanSqliteRecords(file, 1, signal)) {
+      const row = await readSqliteValues(record2, 5, signal);
+      if (await matches(row[0], "table") && await matches(row[1], "schemas")) {
+        if (typeof row[3] !== "bigint" || row[3] < 1n || row[3] > BigInt(Number.MAX_SAFE_INTEGER)) throw new FsError7("EIO", { path, message: "Invalid SQLite schema root" });
+        root = Number(row[3]);
+        break;
+      }
+    }
+    let result;
+    if (root !== void 0) for await (const record2 of scanSqliteRecords(file, root, signal)) {
+      const row = await readSqliteValues(record2, 2, signal);
+      if (!await matches(row[0], id)) continue;
+      const content = row[1];
+      if (!content || typeof content !== "object" || content.type !== "text") throw new Error("Invalid schema");
+      if (content.size > maxBytes) throw new FsError7("EFBIG", { path, message: "LLM schema input byte limit exceeded" });
+      const decoder = new TextDecoder(encoding, { fatal: true, ignoreBOM: true });
+      let text = "";
+      for await (const bytes of content.bytes) {
+        options.admitBytes?.(bytes.length);
+        text += decoder.decode(bytes, { stream: true });
+      }
+      text += decoder.decode();
+      let value;
+      try {
+        value = JSON.parse(text);
+      } catch {
+        throw new Error("Invalid schema");
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid schema");
+      result = value;
+      break;
+    }
+    await checkpointed();
+    verifySqliteSnapshot(await file.stat({ signal }), expected);
+    signal.throwIfAborted();
+    return result;
+  } finally {
+    await file.close();
+  }
+}
+
+// packages/safe-bash-command-llm/src/command.ts
+import { createOutputOperation, getCommandArguments, FsError as FsError12 } from "../../safe-bash-contracts/index.js";
+import { inheritYieldCheckpoint, yieldTurn as yieldTurn4 } from "../../safe-bash-contracts/yield.js";
+import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
+import { pathOf as pathOf5 } from "../../safe-bash-contracts/path.js";
+
+// packages/safe-bash-command-llm/src/templates.ts
+init_buffer();
+import { FsError as FsError8 } from "../../safe-bash-contracts/index.js";
+import { pathOf as pathOf3 } from "../../safe-bash-contracts/path.js";
 function unicodeOrder(left, right) {
   let a = 0, b = 0;
   while (a < left.length && b < right.length) {
@@ -437,11 +828,11 @@ For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/St
         }
       }
       const { parse: parse2 } = await import("../bundled-yaml/index.js");
-      let path = pathOf2(context, name);
+      let path = pathOf3(context, name);
       try {
         await context.fs.stat(path, { signal: context.signal });
       } catch (error) {
-        if (!(error instanceof FsError3) || error.code !== "ENOENT") throw error;
+        if (!(error instanceof FsError8) || error.code !== "ENOENT") throw error;
         const colon = name.indexOf(":");
         if (colon > 0) {
           const prefix = name.slice(0, colon);
@@ -470,7 +861,7 @@ For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/St
       const bytes = await context.fs.readFile(path, { signal: context.signal });
       return template(parse2(new TextDecoder("utf-8", { fatal: true }).decode(bytes)), name);
     } catch (error) {
-      if (error instanceof FsError3 && error.code === "ENOENT") throw new Error(`Invalid template: ${name}`);
+      if (error instanceof FsError8 && error.code === "ENOENT") throw new Error(`Invalid template: ${name}`);
       throw error;
     }
   };
@@ -482,7 +873,7 @@ For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/St
     try {
       expected = await context.fs.lstat(path, { signal: context.signal });
     } catch (error) {
-      if (!(error instanceof FsError3) || error.code !== "ENOENT") throw error;
+      if (!(error instanceof FsError8) || error.code !== "ENOENT") throw error;
       expected = null;
     }
     await publishConfiguration(context.fs, directory, path, bytes, parent, expected, context.signal);
@@ -603,7 +994,7 @@ Options:
         try {
           await context.fs.lstat(path, { signal: context.signal });
         } catch (error) {
-          if (!(error instanceof FsError3) || error.code !== "ENOENT") throw error;
+          if (!(error instanceof FsError8) || error.code !== "ENOENT") throw error;
           await publish(name, new TextEncoder().encode("prompt: "));
         }
         const editor = context.env.VISUAL || context.env.EDITOR || "vi";
@@ -626,7 +1017,7 @@ Options:
       try {
         files = await context.fs.readdir(directory, { signal: context.signal });
       } catch (error) {
-        if (error instanceof FsError3 && error.code === "ENOENT") return 0;
+        if (error instanceof FsError8 && error.code === "ENOENT") return 0;
         throw error;
       }
       const values = [];
@@ -663,18 +1054,18 @@ Options:
 
 // packages/safe-bash-command-llm/src/retained-spool.ts
 init_buffer();
-import { FsError as FsError4 } from "../../safe-bash-contracts/index.js";
+import { FsError as FsError9 } from "../../safe-bash-contracts/index.js";
 var serial = 0;
 function verifyRetainedFile(actual, expected) {
   const sameOwner = expected.identityScope !== void 0 && expected.identityScope === actual.identityScope;
   const sameIdentity = expected.opaqueIdentity !== void 0 ? expected.opaqueIdentity === actual.opaqueIdentity : expected.dev !== void 0 && expected.ino !== void 0 && expected.dev === actual.dev && expected.ino === actual.ino;
-  if (!sameOwner || !sameIdentity || actual.type !== "file" || actual.size !== expected.size || actual.revision !== expected.revision || actual.opaqueVersion !== expected.opaqueVersion || actual.mtimeMs !== expected.mtimeMs || actual.ctimeMs !== expected.ctimeMs) throw new FsError4("EBUSY", { message: "LLM spool changed" });
+  if (!sameOwner || !sameIdentity || actual.type !== "file" || actual.size !== expected.size || actual.revision !== expected.revision || actual.opaqueVersion !== expected.opaqueVersion || actual.mtimeMs !== expected.mtimeMs || actual.ctimeMs !== expected.ctimeMs) throw new FsError9("EBUSY", { message: "LLM spool changed" });
 }
 async function createLlmSpool(fs, directory, signal, purpose = "output") {
   const parent = await fs.stat(directory, { signal });
-  if (parent.type !== "directory") throw new FsError4("ENOTDIR", { path: directory });
+  if (parent.type !== "directory") throw new FsError9("ENOTDIR", { path: directory });
   const caps = await fs.capabilitiesFor?.(directory, { signal }) ?? fs.capabilities;
-  if (!caps.retainedStagingCleanup || !caps.retainedStagingWrite || !caps.retainedRead || !fs.createStagedFile || !fs.openReadFile) throw new FsError4("ENOTSUP", { message: "LLM staging requires caller filesystem retained staging and reads" });
+  if (!caps.retainedStagingCleanup || !caps.retainedStagingWrite || !caps.retainedRead || !fs.createStagedFile || !fs.openReadFile) throw new FsError9("ENOTSUP", { message: "LLM staging requires caller filesystem retained staging and reads" });
   let staging;
   for (let attempt = 0; attempt < 16; attempt++) {
     try {
@@ -682,10 +1073,10 @@ async function createLlmSpool(fs, directory, signal, purpose = "output") {
       break;
     } catch (error) {
       signal.throwIfAborted();
-      if (!(error instanceof FsError4) || error.code !== "EEXIST") throw error;
+      if (!(error instanceof FsError9) || error.code !== "EEXIST") throw error;
     }
   }
-  if (!staging) throw new FsError4("EEXIST", { message: "LLM output staging names exhausted" });
+  if (!staging) throw new FsError9("EEXIST", { message: "LLM output staging names exhausted" });
   const owner = staging;
   const cleanup = owner.cleanup;
   const writer = owner.writer;
@@ -695,7 +1086,7 @@ async function createLlmSpool(fs, directory, signal, purpose = "output") {
     } finally {
       await cleanup?.close();
     }
-    throw new FsError4("EIO", { message: "Caller filesystem omitted its retained staging handles" });
+    throw new FsError9("EIO", { message: "Caller filesystem omitted its retained staging handles" });
   }
   let reader;
   let sealed;
@@ -704,7 +1095,7 @@ async function createLlmSpool(fs, directory, signal, purpose = "output") {
   return {
     async write(bytes) {
       signal.throwIfAborted();
-      if (sealed || closing) throw new FsError4("EBADF", { message: "LLM spool is closed" });
+      if (sealed || closing) throw new FsError9("EBADF", { message: "LLM spool is closed" });
       for (let offset = 0; offset < bytes.byteLength; offset += 16384) {
         const chunk = bytes.subarray(offset, offset + 16384);
         await writer.write(chunk, { signal });
@@ -713,32 +1104,32 @@ async function createLlmSpool(fs, directory, signal, purpose = "output") {
     },
     async *replay(select) {
       signal.throwIfAborted();
-      if (sealed || closing) throw new FsError4("EBADF", { message: "LLM spool is closed" });
+      if (sealed || closing) throw new FsError9("EBADF", { message: "LLM spool is closed" });
       sealed = await writer.finish({ signal });
-      if (sealed.size !== written) throw new FsError4("EIO", { message: "LLM spool size mismatch" });
+      if (sealed.size !== written) throw new FsError9("EIO", { message: "LLM spool size mismatch" });
       signal.throwIfAborted();
-      if (closing) throw new FsError4("EBADF", { message: "LLM spool is closed" });
+      if (closing) throw new FsError9("EBADF", { message: "LLM spool is closed" });
       const opened = await fs.openReadFile(owner.file.path, { signal });
       if (closing || signal.aborted) {
         await opened.close();
         signal.throwIfAborted();
-        throw new FsError4("EBADF", { message: "LLM spool is closed" });
+        throw new FsError9("EBADF", { message: "LLM spool is closed" });
       }
       reader = opened;
       verifyRetainedFile(await reader.stat({ signal }), sealed);
       const read = async (position2, maxBytes) => {
         signal.throwIfAborted();
-        if (closing || !reader) throw new FsError4("EBADF", { message: "LLM spool is closed" });
-        if (!Number.isSafeInteger(position2) || position2 < 0 || position2 >= written || !Number.isSafeInteger(maxBytes) || maxBytes <= 0 || maxBytes > 16384) throw new FsError4("EINVAL", { message: "Invalid LLM spool range" });
+        if (closing || !reader) throw new FsError9("EBADF", { message: "LLM spool is closed" });
+        if (!Number.isSafeInteger(position2) || position2 < 0 || position2 >= written || !Number.isSafeInteger(maxBytes) || maxBytes <= 0 || maxBytes > 16384) throw new FsError9("EINVAL", { message: "Invalid LLM spool range" });
         const count = Math.min(maxBytes, written - position2);
         verifyRetainedFile(await reader.stat({ signal }), sealed);
         const bytes = await reader.read(position2, count, { signal });
-        if (!bytes.byteLength || bytes.byteLength > count) throw new FsError4("EIO", { message: "Invalid LLM spool read" });
+        if (!bytes.byteLength || bytes.byteLength > count) throw new FsError9("EIO", { message: "Invalid LLM spool read" });
         verifyRetainedFile(await reader.stat({ signal }), sealed);
         return bytes;
       };
       const range = await select?.({ size: written, read });
-      if (range && (!Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end < range.start || range.end > written)) throw new FsError4("EINVAL", { message: "Invalid LLM spool selection" });
+      if (range && (!Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end < range.start || range.end > written)) throw new FsError9("EINVAL", { message: "Invalid LLM spool selection" });
       let position = range?.start ?? 0;
       const end = range?.end ?? written;
       while (position < end) {
@@ -766,7 +1157,7 @@ async function createLlmSpool(fs, directory, signal, purpose = "output") {
 
 // packages/safe-bash-command-llm/src/extract-range.ts
 init_buffer();
-import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
 
 // packages/safe-bash-command-llm/src/word-ranges.ts
 init_buffer();
@@ -789,7 +1180,7 @@ async function findExtractedRange(reader, last, signal) {
   let cacheStart = -1, work = 0;
   async function byte(position2) {
     signal.throwIfAborted();
-    if (++work % 4096 === 0) await yieldTurn(signal);
+    if (++work % 4096 === 0) await yieldTurn2(signal);
     if (position2 < 0 || position2 >= reader.size) throw new Error("Invalid extraction position");
     if (position2 < cacheStart || position2 >= cacheStart + cache.length) {
       cache = await reader.read(position2, Math.min(16384, reader.size - position2));
@@ -861,19 +1252,19 @@ async function findExtractedRange(reader, last, signal) {
 
 // packages/safe-bash-command-llm/src/file-source.ts
 init_buffer();
-import { FsError as FsError5 } from "../../safe-bash-contracts/index.js";
+import { FsError as FsError10 } from "../../safe-bash-contracts/index.js";
 function sameFile(actual, expected) {
   const identified = expected.opaqueIdentity !== void 0 ? expected.opaqueIdentity === actual.opaqueIdentity : expected.dev !== void 0 && expected.ino !== void 0 && expected.dev === actual.dev && expected.ino === actual.ino;
-  if (!identified || expected.identityScope === void 0 || expected.identityScope !== actual.identityScope || actual.type !== "file" || actual.size !== expected.size || actual.revision !== expected.revision || actual.opaqueVersion !== expected.opaqueVersion || actual.mtimeMs !== expected.mtimeMs || actual.ctimeMs !== expected.ctimeMs) throw new FsError5("EBUSY", { message: "LLM attachment changed" });
+  if (!identified || expected.identityScope === void 0 || expected.identityScope !== actual.identityScope || actual.type !== "file" || actual.size !== expected.size || actual.revision !== expected.revision || actual.opaqueVersion !== expected.opaqueVersion || actual.mtimeMs !== expected.mtimeMs || actual.ctimeMs !== expected.ctimeMs) throw new FsError10("EBUSY", { message: "LLM attachment changed" });
 }
 async function fileSource({ fs, path, signal, maxBytes = Infinity, expectedStat }) {
   signal.throwIfAborted();
   const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
-  if (!capabilities.retainedRead || !fs.openReadFile) throw new FsError5("ENOTSUP", { message: "LLM attachment sources require retained reads" });
+  if (!capabilities.retainedRead || !fs.openReadFile) throw new FsError10("ENOTSUP", { message: "LLM attachment sources require retained reads" });
   const expected = await fs.stat(path, { signal });
   if (expectedStat) sameFile(expected, expectedStat);
-  if (expected.type !== "file") throw new FsError5("EINVAL", { path });
-  if (expected.size > maxBytes) throw new FsError5("EFBIG", { message: "LLM attachment input byte limit exceeded" });
+  if (expected.type !== "file") throw new FsError10("EINVAL", { path });
+  if (expected.size > maxBytes) throw new FsError10("EFBIG", { message: "LLM attachment input byte limit exceeded" });
   const reader = await fs.openReadFile(path, { signal });
   let closing;
   const dispose = () => closing ??= reader.close();
@@ -887,18 +1278,18 @@ async function fileSource({ fs, path, signal, maxBytes = Infinity, expectedStat
   return {
     dispose,
     bytes: { async *[Symbol.asyncIterator]() {
-      if (consumed || closing) throw new FsError5("EBADF", { message: "LLM attachment source is closed" });
+      if (consumed || closing) throw new FsError10("EBADF", { message: "LLM attachment source is closed" });
       consumed = true;
       let position = 0;
       while (position < expected.size) {
         signal.throwIfAborted();
-        if (closing) throw new FsError5("EBADF", { message: "LLM attachment source is closed" });
+        if (closing) throw new FsError10("EBADF", { message: "LLM attachment source is closed" });
         sameFile(await reader.stat({ signal }), expected);
         const length = Math.min(16384, expected.size - position);
         const bytes = await reader.read(position, length, { signal });
-        if (closing) throw new FsError5("EBADF", { message: "LLM attachment source is closed" });
+        if (closing) throw new FsError10("EBADF", { message: "LLM attachment source is closed" });
         signal.throwIfAborted();
-        if (!bytes.byteLength || bytes.byteLength > length) throw new FsError5("EIO", { message: "Invalid LLM attachment read" });
+        if (!bytes.byteLength || bytes.byteLength > length) throw new FsError10("EIO", { message: "Invalid LLM attachment read" });
         sameFile(await reader.stat({ signal }), expected);
         position += bytes.byteLength;
         yield bytes;
@@ -940,8 +1331,8 @@ function parseLlmSchemaDsl(input, multi = false) {
 
 // packages/safe-bash-command-llm/src/schema-input.ts
 init_buffer();
-import { FsError as FsError6 } from "../../safe-bash-contracts/index.js";
-import { pathOf as pathOf3 } from "../../safe-bash-contracts/path.js";
+import { FsError as FsError11 } from "../../safe-bash-contracts/index.js";
+import { pathOf as pathOf4 } from "../../safe-bash-contracts/path.js";
 async function resolveLlmSchemaInput(context, input, options) {
   context.signal.throwIfAborted();
   let schema;
@@ -960,12 +1351,12 @@ async function resolveLlmSchemaInput(context, input, options) {
     }
     if (schema === void 0 && (trimmed.includes(" ") || input.includes(","))) schema = parseLlmSchemaDsl(input);
     if (schema === void 0) {
-      const path = pathOf3(context, input);
+      const path = pathOf4(context, input);
       let stat;
       try {
         stat = await context.fs.stat(path, { signal: context.signal });
       } catch (error) {
-        if (!(error instanceof FsError6) || error.code !== "ENOENT") throw error;
+        if (!(error instanceof FsError11) || error.code !== "ENOENT") throw error;
       }
       if (stat) {
         const source = await fileSource({ fs: context.fs, path, signal: context.signal, maxBytes: options.maxBytes ?? Infinity, expectedStat: stat });
@@ -1175,7 +1566,7 @@ init_buffer();
 
 // packages/safe-bash-command-llm/src/model-selection.ts
 init_buffer();
-import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn3 } from "../../safe-bash-contracts/yield.js";
 function getLlmModelAliases({ provider, model }, configured) {
   const aliases = new Set(model.aliases);
   for (const [alias, target] of Object.entries(configured)) {
@@ -1189,7 +1580,7 @@ async function selectLlmModelByQuery(models, queries, configuredAliases = {}, si
   const normalized = queries.map((query) => query.toLowerCase());
   for (let index = 0; index < models.length; index++) {
     signal?.throwIfAborted();
-    if (signal && index && index % 256 === 0) await yieldTurn2(signal);
+    if (signal && index && index % 256 === 0) await yieldTurn3(signal);
     const entry = models[index];
     const terms = [`${entry.provider.name}: ${entry.model.id}`, ...getLlmModelAliases(entry, configuredAliases)].map((value) => value.toLowerCase());
     if (normalized.every((query) => terms.some((term) => term.includes(query))) && (!selected || [...entry.model.id].length < [...selected.model.id].length)) selected = entry;
@@ -1421,13 +1812,13 @@ async function execute(context, service, limits, templateLoaderOptions) {
     signal.throwIfAborted();
     if (closed) throw new Error("LLM invocation is closed");
     work++;
-    if (work % 256 === 0) await yieldTurn3(signal);
+    if (work % 256 === 0) await yieldTurn4(signal);
   };
   let outputSpool;
   let outputBytes = 0;
   let writing = false;
   const write = async (chunk) => {
-    if (chunk.byteLength > (limits?.maxOutputBytes ?? Infinity) - outputBytes) throw new FsError7("EFBIG", { message: "llm output byte limit exceeded" });
+    if (chunk.byteLength > (limits?.maxOutputBytes ?? Infinity) - outputBytes) throw new FsError12("EFBIG", { message: "llm output byte limit exceeded" });
     outputBytes += chunk.byteLength;
     if (outputSpool) {
       await outputSpool.write(chunk);
@@ -1451,7 +1842,7 @@ async function execute(context, service, limits, templateLoaderOptions) {
   const inputLimit = Math.min(context.inputBudget?.maxBytes ?? Infinity, limits?.maxInputBytes ?? Infinity);
   const checkInput = (size) => {
     context.inputBudget?.check(inputBytes + size);
-    if (size > inputLimit - inputBytes) throw new FsError7("EFBIG", { message: "llm input byte limit exceeded" });
+    if (size > inputLimit - inputBytes) throw new FsError12("EFBIG", { message: "llm input byte limit exceeded" });
   };
   const admitInput = (size) => {
     checkInput(size);
@@ -1543,7 +1934,8 @@ async function execute(context, service, limits, templateLoaderOptions) {
       multi: Boolean(args.schemaMulti),
       maxBytes: inputLimit - inputBytes,
       admitBytes: admitInput,
-      loadTemplate: (name) => templateStore.load(name)
+      loadTemplate: (name) => templateStore.load(name),
+      loadSchema: (id) => loadLlmStoredSchema({ ...context, signal }, id, { maxBytes: inputLimit - inputBytes, admitBytes: admitInput })
     }) : void 0;
     if (args.save && args.template) throw new Error("Error: --save cannot be used with --template");
     let stored;
@@ -1668,7 +2060,7 @@ ${args.prompt}` : evaluated.prompt;
     for (const attachment of args.attachments) {
       await step();
       if (attachment.path.includes("://")) throw new Error("URL attachments are not supported");
-      const path = pathOf4(context, attachment.path);
+      const path = pathOf5(context, attachment.path);
       const stat = await interrupted(() => context.fs.stat(path, { signal }), signal);
       checkInput(stat.size);
       if (streamed) {
@@ -1685,14 +2077,14 @@ ${args.prompt}` : evaluated.prompt;
             await source.dispose();
           },
           bytes: { async *[Symbol.asyncIterator]() {
-            if (closed2 || consumed) throw new FsError7("EBADF", { message: "LLM attachment source is closed" });
+            if (closed2 || consumed) throw new FsError12("EBADF", { message: "LLM attachment source is closed" });
             consumed = true;
             signal.throwIfAborted();
             if (!first.done) yield first.value;
             while (true) {
-              if (closed2) throw new FsError7("EBADF", { message: "LLM attachment source is closed" });
+              if (closed2) throw new FsError12("EBADF", { message: "LLM attachment source is closed" });
               const next = await interrupted(() => input.next(), signal);
-              if (closed2) throw new FsError7("EBADF", { message: "LLM attachment source is closed" });
+              if (closed2) throw new FsError12("EBADF", { message: "LLM attachment source is closed" });
               if (next.done) break;
               yield next.value;
             }
@@ -1816,6 +2208,7 @@ function llmCommands(options = {}) {
 
 export {
   createLlmConfiguration,
+  loadLlmStoredSchema,
   validateLlmTemplateParameters,
   llmTemplateUsesInput,
   evaluateLlmTemplate,