@ai-ecoverse/slicc-agent 2.1.0 → 2.2.0

package/README.md

@@ -31,6 +31,32 @@ await agent.prompt('What is in /home?');
 - `hostAgent(agent)` serves the agent with pi's protocol: a pi-server with one session, `agent`, whose Chord services are `slicc.agent.control` (send with `whenBusy` `steer`, `followUp` or `reject`, wait, withdraw, abort, compact) and `slicc.agent.transcript` (the conversation's durable view as replicated state). `serveConnections(self, host)` hands it every `MessagePort` the page sends.
 - `startAgent({ worker })` takes the Web Lock `slicc-agent`, so one tab at a time owns the agent worker, and waits while another tab holds it. `connect()` returns an `AgentConnection` (`control`, `transcript`, `prompt()`), `restart()` replaces the worker (durable resumes from SQLite), and `release()` stops it and lets the next tab take over.
 
+### Bash and files on slicc-kernel
+
+The page owns the one kernel (plan decision D3), and the agent worker attaches to it as a second client ([slicc-kernel#66](https://github.com/ai-ecoverse/slicc-kernel/issues/66)), so a terminal's `ps` and `kill` reach whatever the agent started.
+
+```js
+const owner = await startAgent({ worker, kernel: { connect: () => kernel.connect() } });
+```
+
+```js
+import { attachKernel } from '@ai-ecoverse/slicc-kernel';
+import { CodingTools } from '@earendil-works/pi-durable/tools';
+import { kernelEnvironment, kernelPort } from '@ai-ecoverse/slicc-agent';
+
+const client = await attachKernel(await kernelPort(self));
+registry.install(CodingTools);
+const agent = await openAgent({ models, model, storage, registry, env: kernelEnvironment(client) });
+```
+
+`SliccKernelEnv` implements pi durable's `ExecutionEnv` on the kernel client and passes pi's environment conformance suite:
+- string commands run as `bash -c`, each in its own process group; timeouts and aborts kill the group;
+- output past the spill limits goes to `/tmp/slicc-agent-output-*.log`;
+- files and directories go through the kernel's OPFS view and metadata sidecar;
+- `watch()` polls until the kernel offers file watching.
+
+A conversation without a `cwd` works in `/home`.
+
 ### In slicc-spectrum
 
 `@ai-ecoverse/slicc-agent/spectrum` turns an `AgentConnection` into slicc-spectrum's `AgentPort`, so `<slicc-app>` shows the real agent:

package/dist/agent.js

@@ -25,7 +25,8 @@ async function openAgent(options) {
     {
       models: options.models,
       registry: options.registry ?? createRegistry(),
-      ...options.settings ? { settings: options.settings } : {}
+      ...options.settings ? { settings: options.settings } : {},
+      ...options.env ? { env: options.env } : {}
     },
     context
   );

package/dist/agent.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/agent.ts"],
-  "sourcesContent": ["import type { Context } from '@earendil-works/chord';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport type { Models } from '@earendil-works/pi-ai/models';\nimport {\n  AssistantEntry,\n  type Conversation,\n  createRegistry,\n  type EntryId,\n  Harness,\n  type HarnessOptions,\n  MemoryStorage,\n  type ModelRef,\n  type Registry,\n  type Storage,\n} from '@earendil-works/pi-durable';\n\nexport interface AgentOptions {\n  models: Models;\n  model: ModelRef;\n  storage?: Storage;\n  registry?: Registry;\n  settings?: HarnessOptions['settings'];\n  context?: Context;\n}\n\nexport interface Agent {\n  readonly harness: Harness;\n  readonly root: Conversation;\n  prompt(text: string): Promise<string>;\n  close(): Promise<void>;\n}\n\ninterface Block {\n  type: string;\n  text?: string;\n}\n\nexport function answerText(content: unknown): string {\n  if (typeof content === 'string') return content;\n  if (!Array.isArray(content)) return '';\n  return (content as Block[])\n    .filter((block) => block.type === 'text')\n    .map((block) => block.text ?? '')\n    .join('');\n}\n\nasync function prompt(root: Conversation, text: string, context: Context): Promise<string> {\n  const submission = await root.submit({ type: 'input', content: text }, context);\n  const settled = await submission.wait(context);\n  const { answer, reason } = settled as { answer?: EntryId; reason?: string };\n  if (answer === undefined) throw new Error(`unanswered: ${reason}`);\n  const entry = await root.commit((tx) => tx.entry(AssistantEntry, answer), context);\n  return answerText(entry?.model?.[0]?.content);\n}\n\nexport async function openAgent(options: AgentOptions): Promise<Agent> {\n  const context = options.context ?? BACKGROUND_CONTEXT;\n  const harness = await Harness.open(\n    options.storage ?? new MemoryStorage(),\n    {\n      models: options.models,\n      registry: options.registry ?? createRegistry(),\n      ...(options.settings ? { settings: options.settings } : {}),\n    },\n    context\n  );\n  const root = await harness.root(context, { agent: { model: options.model } });\n  harness.resume();\n  return {\n    harness,\n    root,\n    prompt: (text) => prompt(root, text, context),\n    close: () => harness.close(context),\n  };\n}\n"],
-  "mappings": "AACA,SAAS,0BAA0B;AAEnC;AAAA,EACE;AAAA,EAEA;AAAA,EAEA;AAAA,EAEA;AAAA,OAIK;AAuBA,SAAS,WAAW,SAA0B;AACnD,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,MAAI,CAAC,MAAM,QAAQ,OAAO,EAAG,QAAO;AACpC,SAAQ,QACL,OAAO,CAAC,UAAU,MAAM,SAAS,MAAM,EACvC,IAAI,CAAC,UAAU,MAAM,QAAQ,EAAE,EAC/B,KAAK,EAAE;AACZ;AAEA,eAAe,OAAO,MAAoB,MAAc,SAAmC;AACzF,QAAM,aAAa,MAAM,KAAK,OAAO,EAAE,MAAM,SAAS,SAAS,KAAK,GAAG,OAAO;AAC9E,QAAM,UAAU,MAAM,WAAW,KAAK,OAAO;AAC7C,QAAM,EAAE,QAAQ,OAAO,IAAI;AAC3B,MAAI,WAAW,OAAW,OAAM,IAAI,MAAM,eAAe,MAAM,EAAE;AACjE,QAAM,QAAQ,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,MAAM,gBAAgB,MAAM,GAAG,OAAO;AACjF,SAAO,WAAW,OAAO,QAAQ,CAAC,GAAG,OAAO;AAC9C;AAEA,eAAsB,UAAU,SAAuC;AACrE,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,UAAU,MAAM,QAAQ;AAAA,IAC5B,QAAQ,WAAW,IAAI,cAAc;AAAA,IACrC;AAAA,MACE,QAAQ,QAAQ;AAAA,MAChB,UAAU,QAAQ,YAAY,eAAe;AAAA,MAC7C,GAAI,QAAQ,WAAW,EAAE,UAAU,QAAQ,SAAS,IAAI,CAAC;AAAA,IAC3D;AAAA,IACA;AAAA,EACF;AACA,QAAM,OAAO,MAAM,QAAQ,KAAK,SAAS,EAAE,OAAO,EAAE,OAAO,QAAQ,MAAM,EAAE,CAAC;AAC5E,UAAQ,OAAO;AACf,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,QAAQ,CAAC,SAAS,OAAO,MAAM,MAAM,OAAO;AAAA,IAC5C,OAAO,MAAM,QAAQ,MAAM,OAAO;AAAA,EACpC;AACF;",
+  "sourcesContent": ["import type { Context } from '@earendil-works/chord';\nimport { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';\nimport type { Models } from '@earendil-works/pi-ai/models';\nimport {\n  AssistantEntry,\n  type Conversation,\n  createRegistry,\n  type EntryId,\n  Harness,\n  type HarnessOptions,\n  MemoryStorage,\n  type ModelRef,\n  type Registry,\n  type Storage,\n} from '@earendil-works/pi-durable';\n\nexport interface AgentOptions {\n  models: Models;\n  model: ModelRef;\n  storage?: Storage;\n  registry?: Registry;\n  settings?: HarnessOptions['settings'];\n  env?: HarnessOptions['env'];\n  context?: Context;\n}\n\nexport interface Agent {\n  readonly harness: Harness;\n  readonly root: Conversation;\n  prompt(text: string): Promise<string>;\n  close(): Promise<void>;\n}\n\ninterface Block {\n  type: string;\n  text?: string;\n}\n\nexport function answerText(content: unknown): string {\n  if (typeof content === 'string') return content;\n  if (!Array.isArray(content)) return '';\n  return (content as Block[])\n    .filter((block) => block.type === 'text')\n    .map((block) => block.text ?? '')\n    .join('');\n}\n\nasync function prompt(root: Conversation, text: string, context: Context): Promise<string> {\n  const submission = await root.submit({ type: 'input', content: text }, context);\n  const settled = await submission.wait(context);\n  const { answer, reason } = settled as { answer?: EntryId; reason?: string };\n  if (answer === undefined) throw new Error(`unanswered: ${reason}`);\n  const entry = await root.commit((tx) => tx.entry(AssistantEntry, answer), context);\n  return answerText(entry?.model?.[0]?.content);\n}\n\nexport async function openAgent(options: AgentOptions): Promise<Agent> {\n  const context = options.context ?? BACKGROUND_CONTEXT;\n  const harness = await Harness.open(\n    options.storage ?? new MemoryStorage(),\n    {\n      models: options.models,\n      registry: options.registry ?? createRegistry(),\n      ...(options.settings ? { settings: options.settings } : {}),\n      ...(options.env ? { env: options.env } : {}),\n    },\n    context\n  );\n  const root = await harness.root(context, { agent: { model: options.model } });\n  harness.resume();\n  return {\n    harness,\n    root,\n    prompt: (text) => prompt(root, text, context),\n    close: () => harness.close(context),\n  };\n}\n"],
+  "mappings": "AACA,SAAS,0BAA0B;AAEnC;AAAA,EACE;AAAA,EAEA;AAAA,EAEA;AAAA,EAEA;AAAA,OAIK;AAwBA,SAAS,WAAW,SAA0B;AACnD,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,MAAI,CAAC,MAAM,QAAQ,OAAO,EAAG,QAAO;AACpC,SAAQ,QACL,OAAO,CAAC,UAAU,MAAM,SAAS,MAAM,EACvC,IAAI,CAAC,UAAU,MAAM,QAAQ,EAAE,EAC/B,KAAK,EAAE;AACZ;AAEA,eAAe,OAAO,MAAoB,MAAc,SAAmC;AACzF,QAAM,aAAa,MAAM,KAAK,OAAO,EAAE,MAAM,SAAS,SAAS,KAAK,GAAG,OAAO;AAC9E,QAAM,UAAU,MAAM,WAAW,KAAK,OAAO;AAC7C,QAAM,EAAE,QAAQ,OAAO,IAAI;AAC3B,MAAI,WAAW,OAAW,OAAM,IAAI,MAAM,eAAe,MAAM,EAAE;AACjE,QAAM,QAAQ,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,MAAM,gBAAgB,MAAM,GAAG,OAAO;AACjF,SAAO,WAAW,OAAO,QAAQ,CAAC,GAAG,OAAO;AAC9C;AAEA,eAAsB,UAAU,SAAuC;AACrE,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,UAAU,MAAM,QAAQ;AAAA,IAC5B,QAAQ,WAAW,IAAI,cAAc;AAAA,IACrC;AAAA,MACE,QAAQ,QAAQ;AAAA,MAChB,UAAU,QAAQ,YAAY,eAAe;AAAA,MAC7C,GAAI,QAAQ,WAAW,EAAE,UAAU,QAAQ,SAAS,IAAI,CAAC;AAAA,MACzD,GAAI,QAAQ,MAAM,EAAE,KAAK,QAAQ,IAAI,IAAI,CAAC;AAAA,IAC5C;AAAA,IACA;AAAA,EACF;AACA,QAAM,OAAO,MAAM,QAAQ,KAAK,SAAS,EAAE,OAAO,EAAE,OAAO,QAAQ,MAAM,EAAE,CAAC;AAC5E,UAAQ,OAAO;AACf,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,QAAQ,CAAC,SAAS,OAAO,MAAM,MAAM,OAAO;AAAA,IAC5C,OAAO,MAAM,QAAQ,MAAM,OAAO;AAAA,EACpC;AACF;",
   "names": []
 }

package/dist/index.js

@@ -2,6 +2,7 @@ import { answerText, openAgent } from "./agent.js";
 import { connectAgent } from "./client.js";
 import { createAgentControl } from "./control.js";
 import { hostAgent } from "./host.js";
+import { HOME, kernelEnvironment, SliccKernelEnv } from "./kernel/env.js";
 import {
   AGENT_LOCK,
   startAgent
@@ -19,7 +20,7 @@ import {
   WasmSqliteDatabase
 } from "./sqlite.js";
 import { PortChannel, PortListener, withUnrefTimers } from "./wire.js";
-import { serveConnections } from "./worker.js";
+import { kernelPort, serveConnections } from "./worker.js";
 export {
   AGENT_DIRECTORY,
   AGENT_LOCK,
@@ -27,13 +28,17 @@ export {
   AgentControl,
   AgentSessions,
   AgentTranscript,
+  HOME,
   PortChannel,
   PortListener,
+  SliccKernelEnv,
   WasmSqliteDatabase,
   answerText,
   connectAgent,
   createAgentControl,
   hostAgent,
+  kernelEnvironment,
+  kernelPort,
   openAgent,
   openMemorySqliteStorage,
   openOpfsSqliteStorage,

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "sourcesContent": ["export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';\nexport { type AgentConnection, connectAgent } from './client.ts';\nexport { createAgentControl } from './control.ts';\nexport { type AgentHost, hostAgent } from './host.ts';\nexport {\n  AGENT_LOCK,\n  type AgentOwner,\n  type AgentWorker,\n  type OwnerOptions,\n  startAgent,\n} from './owner.ts';\nexport {\n  AGENT_SESSION,\n  AgentControl,\n  AgentSessions,\n  type AgentSettingsChange,\n  AgentTranscript,\n  type OperationError,\n  type PromptResult,\n  type SendMode,\n  type SendRequest,\n  type SendResponse,\n} from './services.ts';\nexport {\n  AGENT_DIRECTORY,\n  type OpfsSqliteOptions,\n  openMemorySqliteStorage,\n  openOpfsSqliteStorage,\n  WasmSqliteDatabase,\n} from './sqlite.ts';\nexport { PortChannel, type PortEndpoint, PortListener, withUnrefTimers } from './wire.ts';\nexport { serveConnections, type WorkerScope } from './worker.ts';\n"],
-  "mappings": "AAAA,SAAwC,YAAY,iBAAiB;AACrE,SAA+B,oBAAoB;AACnD,SAAS,0BAA0B;AACnC,SAAyB,iBAAiB;AAC1C;AAAA,EACE;AAAA,EAIA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,OAMK;AACP;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,aAAgC,cAAc,uBAAuB;AAC9E,SAAS,wBAA0C;",
+  "sourcesContent": ["export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts';\nexport { type AgentConnection, connectAgent } from './client.ts';\nexport { createAgentControl } from './control.ts';\nexport { type AgentHost, hostAgent } from './host.ts';\nexport type {\n  KernelClient,\n  KernelFs,\n  KernelProcess,\n  KernelStat,\n  SpawnOptions,\n} from './kernel/client.ts';\nexport { HOME, type KernelEnvOptions, kernelEnvironment, SliccKernelEnv } from './kernel/env.ts';\nexport {\n  AGENT_LOCK,\n  type AgentOwner,\n  type AgentWorker,\n  type OwnerOptions,\n  startAgent,\n} from './owner.ts';\nexport {\n  AGENT_SESSION,\n  AgentControl,\n  AgentSessions,\n  type AgentSettingsChange,\n  AgentTranscript,\n  type OperationError,\n  type PromptResult,\n  type SendMode,\n  type SendRequest,\n  type SendResponse,\n} from './services.ts';\nexport {\n  AGENT_DIRECTORY,\n  type OpfsSqliteOptions,\n  openMemorySqliteStorage,\n  openOpfsSqliteStorage,\n  WasmSqliteDatabase,\n} from './sqlite.ts';\nexport { PortChannel, type PortEndpoint, PortListener, withUnrefTimers } from './wire.ts';\nexport { kernelPort, serveConnections, type WorkerScope } from './worker.ts';\n"],
+  "mappings": "AAAA,SAAwC,YAAY,iBAAiB;AACrE,SAA+B,oBAAoB;AACnD,SAAS,0BAA0B;AACnC,SAAyB,iBAAiB;AAQ1C,SAAS,MAA6B,mBAAmB,sBAAsB;AAC/E;AAAA,EACE;AAAA,EAIA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,OAMK;AACP;AAAA,EACE;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,aAAgC,cAAc,uBAAuB;AAC9E,SAAS,YAAY,wBAA0C;",
   "names": []
 }

package/dist/kernel/client.js

@@ -0,0 +1 @@
+//# sourceMappingURL=client.js.map

package/dist/kernel/client.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/kernel/env.js

@@ -0,0 +1,204 @@
+import {
+  err,
+  FileError,
+  ok
+} from "@earendil-works/pi-durable/env";
+import { execute } from "./exec.js";
+import { attempt, info, KernelDirReader, SnapshotLines, SnapshotReader } from "./files.js";
+import { dirname, normalize, resolve } from "./paths.js";
+import { pollWatch } from "./watch.js";
+class SliccKernelEnv {
+  id;
+  cwd;
+  #client;
+  #watchers = /* @__PURE__ */ new Set();
+  #poll;
+  constructor(client, options) {
+    this.#client = client;
+    this.cwd = options.cwd;
+    this.id = options.id ?? "slicc-kernel";
+    this.#poll = options.watch ?? {};
+  }
+  #path(path) {
+    return resolve(this.cwd, path);
+  }
+  get #fs() {
+    return this.#client.fs;
+  }
+  async absolutePath(path) {
+    return ok(this.#path(path));
+  }
+  async joinPath(parts) {
+    return ok(normalize(parts.join("/")));
+  }
+  readTextFile(path, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, () => this.#fs.readText(resolved));
+  }
+  readBinaryFile(path, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, () => this.#fs.readFile(resolved));
+  }
+  async openTextLineReader(path, context) {
+    const text = await this.readTextFile(path, context);
+    return text.ok ? ok(new SnapshotLines(text.value)) : text;
+  }
+  async readTextLines(path, options, context) {
+    if (options?.maxLines !== void 0 && options.maxLines <= 0) return ok([]);
+    const text = await this.readTextFile(path, context);
+    if (!text.ok) return text;
+    const reader = new SnapshotLines(text.value);
+    const lines = [];
+    for (let line = await reader.readLine(); line.ok && line.value; line = await reader.readLine()) {
+      if (options?.maxLines !== void 0 && lines.length >= options.maxLines) break;
+      lines.push(line.value.text);
+    }
+    return ok(lines);
+  }
+  openBinaryReader(path, options, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, async () => {
+      if (options?.noFollow && (await this.#fs.lstat(resolved)).isSymbolicLink) {
+        throw new FileError("invalid", "Refusing to follow a symbolic link", resolved);
+      }
+      const stat = await this.#fs.stat(resolved);
+      if (stat.isDirectory) throw new FileError("is_directory", "Is a directory", resolved);
+      if (!stat.isFile) throw new FileError("invalid", "Not a regular file", resolved);
+      return new SnapshotReader(await this.#fs.readFile(resolved), info(resolved, stat));
+    });
+  }
+  writeFile(path, content, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, async () => {
+      await this.#fs.mkdir(dirname(resolved));
+      await this.#fs.writeFile(resolved, content);
+    });
+  }
+  appendFile(path, content, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, async () => {
+      const before = await this.#fs.exists(resolved) ? await this.#fs.readFile(resolved) : new Uint8Array();
+      const added = typeof content === "string" ? new TextEncoder().encode(content) : content;
+      const all = new Uint8Array(before.length + added.length);
+      all.set(before);
+      all.set(added, before.length);
+      await this.#fs.mkdir(dirname(resolved));
+      await this.#fs.writeFile(resolved, all);
+    });
+  }
+  truncateFile(path, size, context) {
+    const resolved = this.#path(path);
+    if (!Number.isSafeInteger(size) || size < 0) {
+      return Promise.resolve(
+        err(new FileError("invalid", "File size must be a non-negative integer", resolved))
+      );
+    }
+    return attempt(context, resolved, async () => {
+      const before = await this.#fs.readFile(resolved);
+      const after = new Uint8Array(size);
+      after.set(before.subarray(0, size));
+      await this.#fs.writeFile(resolved, after);
+    });
+  }
+  flushFile(path, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, async () => {
+      if ((await this.#fs.stat(resolved)).isDirectory)
+        throw Object.assign(new Error("Is a directory"), { code: "EISDIR" });
+    });
+  }
+  renameFile(sourcePath, destinationPath, context) {
+    const source = this.#path(sourcePath);
+    return attempt(context, source, () => this.#fs.rename(source, this.#path(destinationPath)));
+  }
+  fileInfo(path, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, async () => info(resolved, await this.#fs.lstat(resolved)));
+  }
+  async listDir(path, context) {
+    const reader = await this.openDirReader(path, context);
+    if (!reader.ok) return reader;
+    return ok(await reader.value.rest());
+  }
+  openDirReader(path, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, async () => {
+      if (!(await this.#fs.stat(resolved)).isDirectory) {
+        throw Object.assign(new Error("Not a directory"), { code: "ENOTDIR" });
+      }
+      return new KernelDirReader(this.#fs, resolved, await this.#fs.readdir(resolved));
+    });
+  }
+  watch(targets, onChange, context) {
+    return attempt(context, this.cwd, async () => {
+      const watcher = await pollWatch(this.#fs, this.cwd, targets, onChange, this.#poll);
+      this.#watchers.add(watcher);
+      return {
+        mode: watcher.mode,
+        close: async (closing) => {
+          this.#watchers.delete(watcher);
+          await watcher.close(closing);
+        }
+      };
+    });
+  }
+  canonicalPath(path, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, () => this.#fs.realpath(resolved));
+  }
+  async exists(path, context) {
+    const found = await this.fileInfo(path, context);
+    if (found.ok) return ok(true);
+    return found.error.code === "not_found" ? ok(false) : found;
+  }
+  createDir(path, _options, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, () => this.#fs.mkdir(resolved));
+  }
+  remove(path, options, context) {
+    const resolved = this.#path(path);
+    return attempt(context, resolved, async () => {
+      if (!options?.recursive) {
+        const stat = await this.#fs.lstat(resolved).catch((error) => {
+          if (options?.force) return void 0;
+          throw error;
+        });
+        if (stat?.isDirectory) throw Object.assign(new Error("Is a directory"), { code: "EISDIR" });
+      }
+      await this.#fs.rm(resolved, { force: options?.force ?? false });
+    });
+  }
+  async createTempDir(prefix, context) {
+    const path = `/tmp/${prefix ?? "tmp-"}${crypto.randomUUID()}`;
+    return attempt(context, path, async () => {
+      await this.#fs.mkdir(path);
+      return path;
+    });
+  }
+  async createTempFile(options, context) {
+    const dir = await this.createTempDir("tmp-", context);
+    if (!dir.ok) return dir;
+    const path = `${dir.value}/${options?.prefix ?? ""}${crypto.randomUUID()}${options?.suffix ?? ""}`;
+    return attempt(context, path, async () => {
+      await this.#fs.writeFile(path, "");
+      return path;
+    });
+  }
+  exec(command, options, context) {
+    return execute(this.#client, this.cwd, command, options, context);
+  }
+  async cleanup(context) {
+    for (const watcher of [...this.#watchers]) await watcher.close(context);
+    this.#watchers.clear();
+  }
+}
+const HOME = "/home";
+function kernelEnvironment(client, options = {}) {
+  return (target) => new SliccKernelEnv(client, { ...options, cwd: target.cwd ?? HOME });
+}
+export {
+  HOME,
+  SliccKernelEnv,
+  kernelEnvironment
+};
+//# sourceMappingURL=env.js.map

package/dist/kernel/env.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/env.ts"],
+  "sourcesContent": ["import type { Context } from '@earendil-works/chord';\nimport {\n  type BinaryReader,\n  type DirReader,\n  type ExecutionEnv,\n  type ExecutionError,\n  err,\n  FileError,\n  type FileInfo,\n  type FileWatcher,\n  ok,\n  type Result,\n  type ShellExecOptions,\n  type ShellExecResult,\n  type TextLineReader,\n  type WatchChange,\n  type WatchTarget,\n} from '@earendil-works/pi-durable/env';\nimport type { KernelClient } from './client.ts';\nimport { execute } from './exec.ts';\nimport { attempt, info, KernelDirReader, SnapshotLines, SnapshotReader } from './files.ts';\nimport { dirname, normalize, resolve } from './paths.ts';\nimport { type PollOptions, pollWatch } from './watch.ts';\n\nexport interface KernelEnvOptions {\n  cwd: string;\n  id?: string;\n  watch?: PollOptions;\n}\n\ntype FileResult<T> = Promise<Result<T, FileError>>;\n\nexport class SliccKernelEnv implements ExecutionEnv {\n  readonly id: string;\n  cwd: string;\n  readonly #client: KernelClient;\n  readonly #watchers = new Set<FileWatcher>();\n  readonly #poll: PollOptions;\n\n  constructor(client: KernelClient, options: KernelEnvOptions) {\n    this.#client = client;\n    this.cwd = options.cwd;\n    this.id = options.id ?? 'slicc-kernel';\n    this.#poll = options.watch ?? {};\n  }\n\n  #path(path: string): string {\n    return resolve(this.cwd, path);\n  }\n\n  get #fs() {\n    return this.#client.fs;\n  }\n\n  async absolutePath(path: string): FileResult<string> {\n    return ok(this.#path(path));\n  }\n\n  async joinPath(parts: string[]): FileResult<string> {\n    return ok(normalize(parts.join('/')));\n  }\n\n  readTextFile(path: string, context: Context): FileResult<string> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, () => this.#fs.readText(resolved));\n  }\n\n  readBinaryFile(path: string, context: Context): FileResult<Uint8Array> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, () => this.#fs.readFile(resolved));\n  }\n\n  async openTextLineReader(path: string, context: Context): FileResult<TextLineReader> {\n    const text = await this.readTextFile(path, context);\n    return text.ok ? ok(new SnapshotLines(text.value)) : text;\n  }\n\n  async readTextLines(\n    path: string,\n    options: { maxLines?: number } | undefined,\n    context: Context\n  ): FileResult<string[]> {\n    if (options?.maxLines !== undefined && options.maxLines <= 0) return ok([]);\n    const text = await this.readTextFile(path, context);\n    if (!text.ok) return text;\n    const reader = new SnapshotLines(text.value);\n    const lines: string[] = [];\n    for (\n      let line = await reader.readLine();\n      line.ok && line.value;\n      line = await reader.readLine()\n    ) {\n      if (options?.maxLines !== undefined && lines.length >= options.maxLines) break;\n      lines.push(line.value.text);\n    }\n    return ok(lines);\n  }\n\n  openBinaryReader(\n    path: string,\n    options: { noFollow?: boolean } | undefined,\n    context: Context\n  ): FileResult<BinaryReader> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, async () => {\n      if (options?.noFollow && (await this.#fs.lstat(resolved)).isSymbolicLink) {\n        throw new FileError('invalid', 'Refusing to follow a symbolic link', resolved);\n      }\n      const stat = await this.#fs.stat(resolved);\n      if (stat.isDirectory) throw new FileError('is_directory', 'Is a directory', resolved);\n      if (!stat.isFile) throw new FileError('invalid', 'Not a regular file', resolved);\n      return new SnapshotReader(await this.#fs.readFile(resolved), info(resolved, stat));\n    });\n  }\n\n  writeFile(path: string, content: string | Uint8Array, context: Context): FileResult<void> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, async () => {\n      await this.#fs.mkdir(dirname(resolved));\n      await this.#fs.writeFile(resolved, content);\n    });\n  }\n\n  appendFile(path: string, content: string | Uint8Array, context: Context): FileResult<void> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, async () => {\n      const before = (await this.#fs.exists(resolved))\n        ? await this.#fs.readFile(resolved)\n        : new Uint8Array();\n      const added = typeof content === 'string' ? new TextEncoder().encode(content) : content;\n      const all = new Uint8Array(before.length + added.length);\n      all.set(before);\n      all.set(added, before.length);\n      await this.#fs.mkdir(dirname(resolved));\n      await this.#fs.writeFile(resolved, all);\n    });\n  }\n\n  truncateFile(path: string, size: number, context: Context): FileResult<void> {\n    const resolved = this.#path(path);\n    if (!Number.isSafeInteger(size) || size < 0) {\n      return Promise.resolve(\n        err(new FileError('invalid', 'File size must be a non-negative integer', resolved))\n      );\n    }\n    return attempt(context, resolved, async () => {\n      const before = await this.#fs.readFile(resolved);\n      const after = new Uint8Array(size);\n      after.set(before.subarray(0, size));\n      await this.#fs.writeFile(resolved, after);\n    });\n  }\n\n  flushFile(path: string, context: Context): FileResult<void> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, async () => {\n      if ((await this.#fs.stat(resolved)).isDirectory)\n        throw Object.assign(new Error('Is a directory'), { code: 'EISDIR' });\n    });\n  }\n\n  renameFile(sourcePath: string, destinationPath: string, context: Context): FileResult<void> {\n    const source = this.#path(sourcePath);\n    return attempt(context, source, () => this.#fs.rename(source, this.#path(destinationPath)));\n  }\n\n  fileInfo(path: string, context: Context): FileResult<FileInfo> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, async () => info(resolved, await this.#fs.lstat(resolved)));\n  }\n\n  async listDir(path: string, context: Context): FileResult<FileInfo[]> {\n    const reader = await this.openDirReader(path, context);\n    if (!reader.ok) return reader;\n    return ok(await (reader.value as KernelDirReader).rest());\n  }\n\n  openDirReader(path: string, context: Context): FileResult<DirReader> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, async () => {\n      if (!(await this.#fs.stat(resolved)).isDirectory) {\n        throw Object.assign(new Error('Not a directory'), { code: 'ENOTDIR' });\n      }\n      return new KernelDirReader(this.#fs, resolved, await this.#fs.readdir(resolved));\n    });\n  }\n\n  watch(\n    targets: readonly WatchTarget[],\n    onChange: (change: WatchChange) => void,\n    context: Context\n  ): FileResult<FileWatcher> {\n    return attempt(context, this.cwd, async () => {\n      const watcher = await pollWatch(this.#fs, this.cwd, targets, onChange, this.#poll);\n      this.#watchers.add(watcher);\n      return {\n        mode: watcher.mode,\n        close: async (closing: Context) => {\n          this.#watchers.delete(watcher);\n          await watcher.close(closing);\n        },\n      };\n    });\n  }\n\n  canonicalPath(path: string, context: Context): FileResult<string> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, () => this.#fs.realpath(resolved));\n  }\n\n  async exists(path: string, context: Context): FileResult<boolean> {\n    const found = await this.fileInfo(path, context);\n    if (found.ok) return ok(true);\n    return found.error.code === 'not_found' ? ok(false) : found;\n  }\n\n  createDir(\n    path: string,\n    _options: { recursive?: boolean } | undefined,\n    context: Context\n  ): FileResult<void> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, () => this.#fs.mkdir(resolved));\n  }\n\n  remove(\n    path: string,\n    options: { recursive?: boolean; force?: boolean } | undefined,\n    context: Context\n  ): FileResult<void> {\n    const resolved = this.#path(path);\n    return attempt(context, resolved, async () => {\n      if (!options?.recursive) {\n        const stat = await this.#fs.lstat(resolved).catch((error: unknown) => {\n          if (options?.force) return undefined;\n          throw error;\n        });\n        if (stat?.isDirectory) throw Object.assign(new Error('Is a directory'), { code: 'EISDIR' });\n      }\n      await this.#fs.rm(resolved, { force: options?.force ?? false });\n    });\n  }\n\n  async createTempDir(prefix: string | undefined, context: Context): FileResult<string> {\n    const path = `/tmp/${prefix ?? 'tmp-'}${crypto.randomUUID()}`;\n    return attempt(context, path, async () => {\n      await this.#fs.mkdir(path);\n      return path;\n    });\n  }\n\n  async createTempFile(\n    options: { prefix?: string; suffix?: string } | undefined,\n    context: Context\n  ): FileResult<string> {\n    const dir = await this.createTempDir('tmp-', context);\n    if (!dir.ok) return dir;\n    const path = `${dir.value}/${options?.prefix ?? ''}${crypto.randomUUID()}${options?.suffix ?? ''}`;\n    return attempt(context, path, async () => {\n      await this.#fs.writeFile(path, '');\n      return path;\n    });\n  }\n\n  exec(\n    command: string | readonly string[],\n    options: ShellExecOptions | undefined,\n    context: Context\n  ): Promise<Result<ShellExecResult, ExecutionError>> {\n    return execute(this.#client, this.cwd, command, options, context);\n  }\n\n  async cleanup(context: Context): Promise<void> {\n    for (const watcher of [...this.#watchers]) await watcher.close(context);\n    this.#watchers.clear();\n  }\n}\n\nexport const HOME = '/home';\n\nexport function kernelEnvironment(\n  client: KernelClient,\n  options: Omit<KernelEnvOptions, 'cwd'> = {}\n): (target: { cwd?: string }) => SliccKernelEnv {\n  return (target) => new SliccKernelEnv(client, { ...options, cwd: target.cwd ?? HOME });\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/kernel/exec.js

@@ -0,0 +1,115 @@
+import {
+  ExecutionError,
+  err,
+  ok,
+  StreamDecoder
+} from "@earendil-works/pi-durable/env";
+import { resolve } from "./paths.js";
+const SHELL = ["bash", "-c"];
+class Spill {
+  #chunks = [];
+  #limit;
+  #bytes = 0;
+  #lines = 0;
+  constructor(limit) {
+    this.#limit = limit;
+  }
+  add(chunk) {
+    if (!this.#limit) return;
+    this.#chunks.push(chunk);
+    this.#bytes += chunk.length;
+    for (const byte of chunk) if (byte === 10) this.#lines++;
+  }
+  get over() {
+    const limit = this.#limit;
+    return limit !== void 0 && (this.#bytes > limit.afterBytes || this.#lines > limit.afterLines);
+  }
+  async write(client) {
+    if (!this.over) return void 0;
+    const path = `/tmp/slicc-agent-output-${crypto.randomUUID()}.log`;
+    const all = new Uint8Array(this.#bytes);
+    let offset = 0;
+    for (const chunk of this.#chunks) {
+      all.set(chunk, offset);
+      offset += chunk.length;
+    }
+    await client.fs.mkdir("/tmp");
+    await client.fs.writeFile(path, all);
+    return path;
+  }
+}
+function sink(stream, spill, options, context) {
+  const decoder = new StreamDecoder();
+  return {
+    push(bytes) {
+      spill.add(bytes);
+      const text = decoder.decode(bytes);
+      if (text) options?.onOutput?.(text, context, { stream });
+    },
+    end() {
+      const text = decoder.decode();
+      if (text) options?.onOutput?.(text, context, { stream });
+    }
+  };
+}
+function guard(process, options, context) {
+  let ending;
+  const stop = (why) => {
+    ending ??= why;
+    process.signal("SIGKILL");
+  };
+  const timer = options?.timeout === void 0 ? void 0 : setTimeout(() => stop("timeout"), options.timeout * 1e3);
+  const onAbort = () => stop("aborted");
+  context.abortSignal?.addEventListener("abort", onAbort, { once: true });
+  if (context.abortSignal?.aborted) onAbort();
+  return {
+    get ending() {
+      return ending;
+    },
+    release() {
+      clearTimeout(timer);
+      context.abortSignal?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+async function execute(client, cwd, command, options, context) {
+  const argv = typeof command === "string" ? [...SHELL, command] : [...command];
+  if (argv.length === 0) return err(new ExecutionError("spawn_error", "No program to run"));
+  if (context.abortSignal?.aborted)
+    return err(new ExecutionError("aborted", "The command was aborted"));
+  const spill = new Spill(options?.spill);
+  const out = sink("stdout", spill, options, context);
+  const errors = sink("stderr", spill, options, context);
+  let process;
+  try {
+    process = await client.spawn(argv, {
+      cwd: resolve(cwd, options?.cwd ?? "."),
+      ...options?.env ? { env: options.env } : {},
+      onStdout: (bytes) => out.push(bytes),
+      onStderr: (bytes) => errors.push(bytes)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return err(new ExecutionError("spawn_error", message));
+  }
+  const watch = guard(process, options, context);
+  const exitCode = await process.exited.finally(() => watch.release());
+  out.end();
+  errors.end();
+  const spillPath = await spill.write(client);
+  const ending = watch.ending;
+  if (ending) {
+    const error = new ExecutionError(
+      ending,
+      `The command was ${ending === "timeout" ? "timed out" : "aborted"}`
+    );
+    if (spillPath) error.spillPath = spillPath;
+    return err(error);
+  }
+  return ok(spillPath ? { exitCode, spillPath } : { exitCode });
+}
+export {
+  SHELL,
+  execute
+};
+//# sourceMappingURL=exec.js.map

package/dist/kernel/exec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/exec.ts"],
+  "sourcesContent": ["import type { Context } from '@earendil-works/chord';\nimport {\n  ExecutionError,\n  err,\n  ok,\n  type Result,\n  type ShellExecOptions,\n  type ShellExecResult,\n  StreamDecoder,\n} from '@earendil-works/pi-durable/env';\nimport type { KernelClient, KernelProcess } from './client.ts';\nimport { resolve } from './paths.ts';\n\nexport const SHELL = ['bash', '-c'] as const;\n\nclass Spill {\n  readonly #chunks: Uint8Array[] = [];\n  readonly #limit: { afterBytes: number; afterLines: number } | undefined;\n  #bytes = 0;\n  #lines = 0;\n\n  constructor(limit: ShellExecOptions['spill']) {\n    this.#limit = limit;\n  }\n\n  add(chunk: Uint8Array): void {\n    if (!this.#limit) return;\n    this.#chunks.push(chunk);\n    this.#bytes += chunk.length;\n    for (const byte of chunk) if (byte === 10) this.#lines++;\n  }\n\n  get over(): boolean {\n    const limit = this.#limit;\n    return (\n      limit !== undefined && (this.#bytes > limit.afterBytes || this.#lines > limit.afterLines)\n    );\n  }\n\n  async write(client: KernelClient): Promise<string | undefined> {\n    if (!this.over) return undefined;\n    const path = `/tmp/slicc-agent-output-${crypto.randomUUID()}.log`;\n    const all = new Uint8Array(this.#bytes);\n    let offset = 0;\n    for (const chunk of this.#chunks) {\n      all.set(chunk, offset);\n      offset += chunk.length;\n    }\n    await client.fs.mkdir('/tmp');\n    await client.fs.writeFile(path, all);\n    return path;\n  }\n}\n\nfunction sink(\n  stream: 'stdout' | 'stderr',\n  spill: Spill,\n  options: ShellExecOptions | undefined,\n  context: Context\n) {\n  const decoder = new StreamDecoder();\n  return {\n    push(bytes: Uint8Array) {\n      spill.add(bytes);\n      const text = decoder.decode(bytes);\n      if (text) options?.onOutput?.(text, context, { stream });\n    },\n    end() {\n      const text = decoder.decode();\n      if (text) options?.onOutput?.(text, context, { stream });\n    },\n  };\n}\n\ntype Ending = 'timeout' | 'aborted' | undefined;\n\nfunction guard(process: KernelProcess, options: ShellExecOptions | undefined, context: Context) {\n  let ending: Ending;\n  const stop = (why: Ending) => {\n    ending ??= why;\n    process.signal('SIGKILL');\n  };\n  const timer =\n    options?.timeout === undefined\n      ? undefined\n      : setTimeout(() => stop('timeout'), options.timeout * 1000);\n  const onAbort = () => stop('aborted');\n  context.abortSignal?.addEventListener('abort', onAbort, { once: true });\n  if (context.abortSignal?.aborted) onAbort();\n  return {\n    get ending() {\n      return ending;\n    },\n    release() {\n      clearTimeout(timer);\n      context.abortSignal?.removeEventListener('abort', onAbort);\n    },\n  };\n}\n\nexport async function execute(\n  client: KernelClient,\n  cwd: string,\n  command: string | readonly string[],\n  options: ShellExecOptions | undefined,\n  context: Context\n): Promise<Result<ShellExecResult, ExecutionError>> {\n  const argv = typeof command === 'string' ? [...SHELL, command] : [...command];\n  if (argv.length === 0) return err(new ExecutionError('spawn_error', 'No program to run'));\n  if (context.abortSignal?.aborted)\n    return err(new ExecutionError('aborted', 'The command was aborted'));\n  const spill = new Spill(options?.spill);\n  const out = sink('stdout', spill, options, context);\n  const errors = sink('stderr', spill, options, context);\n  let process: KernelProcess;\n  try {\n    process = await client.spawn(argv, {\n      cwd: resolve(cwd, options?.cwd ?? '.'),\n      ...(options?.env ? { env: options.env } : {}),\n      onStdout: (bytes) => out.push(bytes),\n      onStderr: (bytes) => errors.push(bytes),\n    });\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    return err(new ExecutionError('spawn_error', message));\n  }\n  const watch = guard(process, options, context);\n  const exitCode = await process.exited.finally(() => watch.release());\n  out.end();\n  errors.end();\n  const spillPath = await spill.write(client);\n  const ending = watch.ending;\n  if (ending) {\n    const error = new ExecutionError(\n      ending,\n      `The command was ${ending === 'timeout' ? 'timed out' : 'aborted'}`\n    );\n    if (spillPath) error.spillPath = spillPath;\n    return err(error);\n  }\n  return ok(spillPath ? { exitCode, spillPath } : { exitCode });\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/kernel/files.js

@@ -0,0 +1,153 @@
+import {
+  err,
+  FileError,
+  LineScanner,
+  ok
+} from "@earendil-works/pi-durable/env";
+import { basename } from "./paths.js";
+const codes = {
+  ENOENT: "not_found",
+  EACCES: "permission_denied",
+  EPERM: "permission_denied",
+  ENOTDIR: "not_directory",
+  EISDIR: "is_directory",
+  EINVAL: "invalid",
+  ELOOP: "invalid",
+  ENOSYS: "not_supported",
+  ENOTSUP: "not_supported"
+};
+function fileError(error, path) {
+  if (error instanceof FileError) return error;
+  const code = error?.code;
+  const message = error instanceof Error ? error.message : String(error);
+  const cause = error instanceof Error ? error : void 0;
+  return new FileError(code && codes[code] || "unknown", message, path, cause);
+}
+function aborted(context, path) {
+  if (!context.abortSignal?.aborted) return void 0;
+  return err(new FileError("aborted", "The operation was aborted", path));
+}
+async function attempt(context, path, run) {
+  const before = aborted(context, path);
+  if (before) return before;
+  try {
+    const value = await run();
+    return aborted(context, path) ?? ok(value);
+  } catch (error) {
+    return err(fileError(error, path));
+  }
+}
+function info(path, stat) {
+  const kind = stat.isSymbolicLink ? "symlink" : stat.isDirectory ? "directory" : "file";
+  return {
+    name: basename(path),
+    path,
+    kind,
+    size: stat.size,
+    mtimeMs: new Date(stat.mtime).getTime()
+  };
+}
+function closed(what, path) {
+  return err(new FileError("invalid", `${what} is closed`, path));
+}
+class SnapshotReader {
+  #bytes;
+  #info;
+  #closed = false;
+  constructor(bytes, fileInfo) {
+    this.#bytes = bytes;
+    this.#info = fileInfo;
+  }
+  async info() {
+    return this.#closed ? closed("Binary reader", this.#info.path) : ok(this.#info);
+  }
+  async read(offset, length, context) {
+    const path = this.#info.path;
+    const stop = aborted(context, path);
+    if (stop) return stop;
+    if (this.#closed) return closed("Binary reader", path);
+    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(length) || length < 0) {
+      return err(new FileError("invalid", "Offset and length must be non-negative integers", path));
+    }
+    return ok(this.#bytes.slice(offset, offset + length));
+  }
+  async scanLines(options, context) {
+    const path = this.#info.path;
+    const stop = aborted(context, path);
+    if (stop) return stop;
+    if (this.#closed) return closed("Binary reader", path);
+    let scanner;
+    try {
+      scanner = new LineScanner(options.startLine, options.endLine);
+    } catch {
+      return err(new FileError("invalid", "Invalid line range", path));
+    }
+    scanner.push(this.#bytes);
+    return ok(scanner.finish());
+  }
+  async close() {
+    this.#closed = true;
+  }
+}
+class SnapshotLines {
+  #lines;
+  #next = 0;
+  constructor(text) {
+    const parts = text.split("\n");
+    const last = parts.pop();
+    this.#lines = parts.map((part) => ({ text: part, terminated: true }));
+    if (last !== "") this.#lines.push({ text: last, terminated: false });
+  }
+  async readLine() {
+    return ok(this.#lines[this.#next++]);
+  }
+  async close() {
+    this.#next = this.#lines.length;
+  }
+}
+class KernelDirReader {
+  #fs;
+  #path;
+  #names;
+  #closed = false;
+  constructor(fs, path, names) {
+    this.#fs = fs;
+    this.#path = path;
+    this.#names = names;
+  }
+  async next(maxEntries, context) {
+    if (this.#closed) return closed("Directory reader", this.#path);
+    if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) {
+      return err(new FileError("invalid", "maxEntries must be a positive integer", this.#path));
+    }
+    const stop = aborted(context, this.#path);
+    if (stop) return stop;
+    const entries = await this.#take(maxEntries);
+    return ok({ entries, done: this.#names.length === 0 });
+  }
+  rest() {
+    return this.#take(Number.MAX_SAFE_INTEGER);
+  }
+  async #take(max) {
+    const entries = [];
+    while (entries.length < max && this.#names.length > 0) {
+      const path = `${this.#path === "/" ? "" : this.#path}/${this.#names.shift()}`;
+      const stat = await this.#fs.lstat(path).catch(() => void 0);
+      if (stat) entries.push(info(path, stat));
+    }
+    return entries;
+  }
+  async close() {
+    this.#closed = true;
+  }
+}
+export {
+  KernelDirReader,
+  SnapshotLines,
+  SnapshotReader,
+  aborted,
+  attempt,
+  fileError,
+  info
+};
+//# sourceMappingURL=files.js.map

package/dist/kernel/files.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/files.ts"],
+  "sourcesContent": ["import type { Context } from '@earendil-works/chord';\nimport {\n  type BinaryReader,\n  type DirReader,\n  err,\n  FileError,\n  type FileErrorCode,\n  type FileInfo,\n  type LineScan,\n  LineScanner,\n  ok,\n  type Result,\n  type TextLine,\n  type TextLineReader,\n} from '@earendil-works/pi-durable/env';\nimport type { KernelFs, KernelStat } from './client.ts';\nimport { basename } from './paths.ts';\n\nconst codes: Record<string, FileErrorCode> = {\n  ENOENT: 'not_found',\n  EACCES: 'permission_denied',\n  EPERM: 'permission_denied',\n  ENOTDIR: 'not_directory',\n  EISDIR: 'is_directory',\n  EINVAL: 'invalid',\n  ELOOP: 'invalid',\n  ENOSYS: 'not_supported',\n  ENOTSUP: 'not_supported',\n};\n\nexport function fileError(error: unknown, path?: string): FileError {\n  if (error instanceof FileError) return error;\n  const code = (error as { code?: string } | null)?.code;\n  const message = error instanceof Error ? error.message : String(error);\n  const cause = error instanceof Error ? error : undefined;\n  return new FileError((code && codes[code]) || 'unknown', message, path, cause);\n}\n\nexport function aborted(context: Context, path?: string): Result<never, FileError> | undefined {\n  if (!context.abortSignal?.aborted) return undefined;\n  return err(new FileError('aborted', 'The operation was aborted', path));\n}\n\nexport async function attempt<T>(\n  context: Context,\n  path: string,\n  run: () => Promise<T>\n): Promise<Result<T, FileError>> {\n  const before = aborted(context, path);\n  if (before) return before;\n  try {\n    const value = await run();\n    return aborted(context, path) ?? ok(value);\n  } catch (error) {\n    return err(fileError(error, path));\n  }\n}\n\nexport function info(path: string, stat: KernelStat): FileInfo {\n  const kind = stat.isSymbolicLink ? 'symlink' : stat.isDirectory ? 'directory' : 'file';\n  return {\n    name: basename(path),\n    path,\n    kind,\n    size: stat.size,\n    mtimeMs: new Date(stat.mtime).getTime(),\n  };\n}\n\nfunction closed<T>(what: string, path: string): Result<T, FileError> {\n  return err(new FileError('invalid', `${what} is closed`, path));\n}\n\nexport class SnapshotReader implements BinaryReader {\n  readonly #bytes: Uint8Array;\n  readonly #info: FileInfo;\n  #closed = false;\n\n  constructor(bytes: Uint8Array, fileInfo: FileInfo) {\n    this.#bytes = bytes;\n    this.#info = fileInfo;\n  }\n\n  async info(): Promise<Result<FileInfo, FileError>> {\n    return this.#closed ? closed('Binary reader', this.#info.path) : ok(this.#info);\n  }\n\n  async read(\n    offset: number,\n    length: number,\n    context: Context\n  ): Promise<Result<Uint8Array, FileError>> {\n    const path = this.#info.path;\n    const stop = aborted(context, path);\n    if (stop) return stop;\n    if (this.#closed) return closed('Binary reader', path);\n    if (\n      !Number.isSafeInteger(offset) ||\n      offset < 0 ||\n      !Number.isSafeInteger(length) ||\n      length < 0\n    ) {\n      return err(new FileError('invalid', 'Offset and length must be non-negative integers', path));\n    }\n    return ok(this.#bytes.slice(offset, offset + length));\n  }\n\n  async scanLines(\n    options: { startLine: number; endLine?: number },\n    context: Context\n  ): Promise<Result<LineScan, FileError>> {\n    const path = this.#info.path;\n    const stop = aborted(context, path);\n    if (stop) return stop;\n    if (this.#closed) return closed('Binary reader', path);\n    let scanner: LineScanner;\n    try {\n      scanner = new LineScanner(options.startLine, options.endLine);\n    } catch {\n      return err(new FileError('invalid', 'Invalid line range', path));\n    }\n    scanner.push(this.#bytes);\n    return ok(scanner.finish());\n  }\n\n  async close(): Promise<void> {\n    this.#closed = true;\n  }\n}\n\nexport class SnapshotLines implements TextLineReader {\n  readonly #lines: TextLine[];\n  #next = 0;\n\n  constructor(text: string) {\n    const parts = text.split('\\n');\n    const last = parts.pop() as string;\n    this.#lines = parts.map((part) => ({ text: part, terminated: true }));\n    if (last !== '') this.#lines.push({ text: last, terminated: false });\n  }\n\n  async readLine(): Promise<Result<TextLine | undefined, FileError>> {\n    return ok(this.#lines[this.#next++]);\n  }\n\n  async close(): Promise<void> {\n    this.#next = this.#lines.length;\n  }\n}\n\nexport class KernelDirReader implements DirReader {\n  readonly #fs: KernelFs;\n  readonly #path: string;\n  readonly #names: string[];\n  #closed = false;\n\n  constructor(fs: KernelFs, path: string, names: string[]) {\n    this.#fs = fs;\n    this.#path = path;\n    this.#names = names;\n  }\n\n  async next(\n    maxEntries: number,\n    context: Context\n  ): Promise<Result<{ entries: FileInfo[]; done: boolean }, FileError>> {\n    if (this.#closed) return closed('Directory reader', this.#path);\n    if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) {\n      return err(new FileError('invalid', 'maxEntries must be a positive integer', this.#path));\n    }\n    const stop = aborted(context, this.#path);\n    if (stop) return stop;\n    const entries = await this.#take(maxEntries);\n    return ok({ entries, done: this.#names.length === 0 });\n  }\n\n  rest(): Promise<FileInfo[]> {\n    return this.#take(Number.MAX_SAFE_INTEGER);\n  }\n\n  async #take(max: number): Promise<FileInfo[]> {\n    const entries: FileInfo[] = [];\n    while (entries.length < max && this.#names.length > 0) {\n      const path = `${this.#path === '/' ? '' : this.#path}/${this.#names.shift()}`;\n      const stat = await this.#fs.lstat(path).catch(() => undefined);\n      if (stat) entries.push(info(path, stat));\n    }\n    return entries;\n  }\n\n  async close(): Promise<void> {\n    this.#closed = true;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/kernel/paths.js

@@ -0,0 +1,31 @@
+function normalize(path) {
+  const absolute = path.startsWith("/");
+  const parts = [];
+  for (const part of path.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (parts.length > 0 && parts.at(-1) !== "..") parts.pop();
+      else if (!absolute) parts.push(part);
+    } else parts.push(part);
+  }
+  const joined = parts.join("/");
+  if (absolute) return `/${joined}`;
+  return joined || ".";
+}
+function resolve(cwd, path) {
+  return normalize(path.startsWith("/") ? path : `${cwd}/${path}`);
+}
+function dirname(path) {
+  const index = path.lastIndexOf("/");
+  return index <= 0 ? "/" : path.slice(0, index);
+}
+function basename(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+export {
+  basename,
+  dirname,
+  normalize,
+  resolve
+};
+//# sourceMappingURL=paths.js.map

package/dist/kernel/paths.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/paths.ts"],
+  "sourcesContent": ["export function normalize(path: string): string {\n  const absolute = path.startsWith('/');\n  const parts: string[] = [];\n  for (const part of path.split('/')) {\n    if (part === '' || part === '.') continue;\n    if (part === '..') {\n      if (parts.length > 0 && parts.at(-1) !== '..') parts.pop();\n      else if (!absolute) parts.push(part);\n    } else parts.push(part);\n  }\n  const joined = parts.join('/');\n  if (absolute) return `/${joined}`;\n  return joined || '.';\n}\n\nexport function resolve(cwd: string, path: string): string {\n  return normalize(path.startsWith('/') ? path : `${cwd}/${path}`);\n}\n\nexport function dirname(path: string): string {\n  const index = path.lastIndexOf('/');\n  return index <= 0 ? '/' : path.slice(0, index);\n}\n\nexport function basename(path: string): string {\n  return path.slice(path.lastIndexOf('/') + 1);\n}\n"],
+  "mappings": "AAAO,SAAS,UAAU,MAAsB;AAC9C,QAAM,WAAW,KAAK,WAAW,GAAG;AACpC,QAAM,QAAkB,CAAC;AACzB,aAAW,QAAQ,KAAK,MAAM,GAAG,GAAG;AAClC,QAAI,SAAS,MAAM,SAAS,IAAK;AACjC,QAAI,SAAS,MAAM;AACjB,UAAI,MAAM,SAAS,KAAK,MAAM,GAAG,EAAE,MAAM,KAAM,OAAM,IAAI;AAAA,eAChD,CAAC,SAAU,OAAM,KAAK,IAAI;AAAA,IACrC,MAAO,OAAM,KAAK,IAAI;AAAA,EACxB;AACA,QAAM,SAAS,MAAM,KAAK,GAAG;AAC7B,MAAI,SAAU,QAAO,IAAI,MAAM;AAC/B,SAAO,UAAU;AACnB;AAEO,SAAS,QAAQ,KAAa,MAAsB;AACzD,SAAO,UAAU,KAAK,WAAW,GAAG,IAAI,OAAO,GAAG,GAAG,IAAI,IAAI,EAAE;AACjE;AAEO,SAAS,QAAQ,MAAsB;AAC5C,QAAM,QAAQ,KAAK,YAAY,GAAG;AAClC,SAAO,SAAS,IAAI,MAAM,KAAK,MAAM,GAAG,KAAK;AAC/C;AAEO,SAAS,SAAS,MAAsB;AAC7C,SAAO,KAAK,MAAM,KAAK,YAAY,GAAG,IAAI,CAAC;AAC7C;",
+  "names": []
+}

package/dist/kernel/watch.js

@@ -0,0 +1,71 @@
+import { dirname, resolve } from "./paths.js";
+function excluded(name, target) {
+  const rule = target.exclude;
+  if (!rule) return false;
+  return rule.hidden === true && name.startsWith(".") || (rule.names?.includes(name) ?? false);
+}
+async function record(fs, path, into) {
+  const stat = await fs.stat(path).catch(() => void 0);
+  if (!stat) return false;
+  into.set(
+    path,
+    `${stat.isDirectory ? "d" : "f"}:${stat.ino}:${stat.size}:${new Date(stat.mtime).getTime()}`
+  );
+  return stat.isDirectory;
+}
+async function scan(fs, path, target, deep, into) {
+  const directory = await record(fs, path, into);
+  if (!directory || !deep) return;
+  const names = await fs.readdir(path).catch(() => []);
+  for (const name of names) {
+    if (excluded(name, target)) continue;
+    const child = `${path === "/" ? "" : path}/${name}`;
+    await scan(fs, child, target, target.recursive === true, into);
+  }
+}
+async function snapshot(fs, cwd, targets) {
+  const all = /* @__PURE__ */ new Map();
+  for (const target of targets) await scan(fs, resolve(cwd, target.path), target, true, all);
+  return all;
+}
+function differences(before, after) {
+  const changed = /* @__PURE__ */ new Set();
+  const moved = (path) => {
+    changed.add(path);
+    changed.add(dirname(path));
+  };
+  for (const [path, value] of after) {
+    if (!before.has(path)) moved(path);
+    else if (before.get(path) !== value) changed.add(path);
+  }
+  for (const path of before.keys()) if (!after.has(path)) moved(path);
+  return [...changed];
+}
+async function pollWatch(fs, cwd, targets, onChange, options = {}) {
+  let current = await snapshot(fs, cwd, targets);
+  let open = true;
+  let running = Promise.resolve();
+  const tick = async () => {
+    const next = await snapshot(fs, cwd, targets);
+    const paths = differences(current, next);
+    current = next;
+    if (open && paths.length > 0) onChange({ paths });
+  };
+  const timer = setInterval(() => {
+    running = running.then(tick);
+  }, options.intervalMs ?? 100);
+  return {
+    mode: "polling",
+    async close(_context) {
+      open = false;
+      clearInterval(timer);
+      await running;
+    }
+  };
+}
+export {
+  differences,
+  pollWatch,
+  snapshot
+};
+//# sourceMappingURL=watch.js.map

package/dist/kernel/watch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/watch.ts"],
+  "sourcesContent": ["import type { Context } from '@earendil-works/chord';\nimport type { FileWatcher, WatchChange, WatchTarget } from '@earendil-works/pi-durable/env';\nimport type { KernelFs } from './client.ts';\nimport { dirname, resolve } from './paths.ts';\n\ntype Snapshot = Map<string, string>;\n\nfunction excluded(name: string, target: WatchTarget): boolean {\n  const rule = target.exclude;\n  if (!rule) return false;\n  return (rule.hidden === true && name.startsWith('.')) || (rule.names?.includes(name) ?? false);\n}\n\nasync function record(fs: KernelFs, path: string, into: Snapshot): Promise<boolean> {\n  const stat = await fs.stat(path).catch(() => undefined);\n  if (!stat) return false;\n  into.set(\n    path,\n    `${stat.isDirectory ? 'd' : 'f'}:${stat.ino}:${stat.size}:${new Date(stat.mtime).getTime()}`\n  );\n  return stat.isDirectory;\n}\n\nasync function scan(\n  fs: KernelFs,\n  path: string,\n  target: WatchTarget,\n  deep: boolean,\n  into: Snapshot\n) {\n  const directory = await record(fs, path, into);\n  if (!directory || !deep) return;\n  const names = await fs.readdir(path).catch(() => [] as string[]);\n  for (const name of names) {\n    if (excluded(name, target)) continue;\n    const child = `${path === '/' ? '' : path}/${name}`;\n    await scan(fs, child, target, target.recursive === true, into);\n  }\n}\n\nexport async function snapshot(\n  fs: KernelFs,\n  cwd: string,\n  targets: readonly WatchTarget[]\n): Promise<Snapshot> {\n  const all: Snapshot = new Map();\n  for (const target of targets) await scan(fs, resolve(cwd, target.path), target, true, all);\n  return all;\n}\n\nexport function differences(before: Snapshot, after: Snapshot): string[] {\n  const changed = new Set<string>();\n  const moved = (path: string) => {\n    changed.add(path);\n    changed.add(dirname(path));\n  };\n  for (const [path, value] of after) {\n    if (!before.has(path)) moved(path);\n    else if (before.get(path) !== value) changed.add(path);\n  }\n  for (const path of before.keys()) if (!after.has(path)) moved(path);\n  return [...changed];\n}\n\nexport interface PollOptions {\n  intervalMs?: number;\n}\n\nexport async function pollWatch(\n  fs: KernelFs,\n  cwd: string,\n  targets: readonly WatchTarget[],\n  onChange: (change: WatchChange) => void,\n  options: PollOptions = {}\n): Promise<FileWatcher> {\n  let current = await snapshot(fs, cwd, targets);\n  let open = true;\n  let running = Promise.resolve();\n  const tick = async () => {\n    const next = await snapshot(fs, cwd, targets);\n    const paths = differences(current, next);\n    current = next;\n    if (open && paths.length > 0) onChange({ paths });\n  };\n  const timer = setInterval(() => {\n    running = running.then(tick);\n  }, options.intervalMs ?? 100);\n  return {\n    mode: 'polling',\n    async close(_context: Context) {\n      open = false;\n      clearInterval(timer);\n      await running;\n    },\n  };\n}\n"],
+  "mappings": "AAGA,SAAS,SAAS,eAAe;AAIjC,SAAS,SAAS,MAAc,QAA8B;AAC5D,QAAM,OAAO,OAAO;AACpB,MAAI,CAAC,KAAM,QAAO;AAClB,SAAQ,KAAK,WAAW,QAAQ,KAAK,WAAW,GAAG,MAAO,KAAK,OAAO,SAAS,IAAI,KAAK;AAC1F;AAEA,eAAe,OAAO,IAAc,MAAc,MAAkC;AAClF,QAAM,OAAO,MAAM,GAAG,KAAK,IAAI,EAAE,MAAM,MAAM,MAAS;AACtD,MAAI,CAAC,KAAM,QAAO;AAClB,OAAK;AAAA,IACH;AAAA,IACA,GAAG,KAAK,cAAc,MAAM,GAAG,IAAI,KAAK,GAAG,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,EAAE,QAAQ,CAAC;AAAA,EAC5F;AACA,SAAO,KAAK;AACd;AAEA,eAAe,KACb,IACA,MACA,QACA,MACA,MACA;AACA,QAAM,YAAY,MAAM,OAAO,IAAI,MAAM,IAAI;AAC7C,MAAI,CAAC,aAAa,CAAC,KAAM;AACzB,QAAM,QAAQ,MAAM,GAAG,QAAQ,IAAI,EAAE,MAAM,MAAM,CAAC,CAAa;AAC/D,aAAW,QAAQ,OAAO;AACxB,QAAI,SAAS,MAAM,MAAM,EAAG;AAC5B,UAAM,QAAQ,GAAG,SAAS,MAAM,KAAK,IAAI,IAAI,IAAI;AACjD,UAAM,KAAK,IAAI,OAAO,QAAQ,OAAO,cAAc,MAAM,IAAI;AAAA,EAC/D;AACF;AAEA,eAAsB,SACpB,IACA,KACA,SACmB;AACnB,QAAM,MAAgB,oBAAI,IAAI;AAC9B,aAAW,UAAU,QAAS,OAAM,KAAK,IAAI,QAAQ,KAAK,OAAO,IAAI,GAAG,QAAQ,MAAM,GAAG;AACzF,SAAO;AACT;AAEO,SAAS,YAAY,QAAkB,OAA2B;AACvE,QAAM,UAAU,oBAAI,IAAY;AAChC,QAAM,QAAQ,CAAC,SAAiB;AAC9B,YAAQ,IAAI,IAAI;AAChB,YAAQ,IAAI,QAAQ,IAAI,CAAC;AAAA,EAC3B;AACA,aAAW,CAAC,MAAM,KAAK,KAAK,OAAO;AACjC,QAAI,CAAC,OAAO,IAAI,IAAI,EAAG,OAAM,IAAI;AAAA,aACxB,OAAO,IAAI,IAAI,MAAM,MAAO,SAAQ,IAAI,IAAI;AAAA,EACvD;AACA,aAAW,QAAQ,OAAO,KAAK,EAAG,KAAI,CAAC,MAAM,IAAI,IAAI,EAAG,OAAM,IAAI;AAClE,SAAO,CAAC,GAAG,OAAO;AACpB;AAMA,eAAsB,UACpB,IACA,KACA,SACA,UACA,UAAuB,CAAC,GACF;AACtB,MAAI,UAAU,MAAM,SAAS,IAAI,KAAK,OAAO;AAC7C,MAAI,OAAO;AACX,MAAI,UAAU,QAAQ,QAAQ;AAC9B,QAAM,OAAO,YAAY;AACvB,UAAM,OAAO,MAAM,SAAS,IAAI,KAAK,OAAO;AAC5C,UAAM,QAAQ,YAAY,SAAS,IAAI;AACvC,cAAU;AACV,QAAI,QAAQ,MAAM,SAAS,EAAG,UAAS,EAAE,MAAM,CAAC;AAAA,EAClD;AACA,QAAM,QAAQ,YAAY,MAAM;AAC9B,cAAU,QAAQ,KAAK,IAAI;AAAA,EAC7B,GAAG,QAAQ,cAAc,GAAG;AAC5B,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,MAAM,UAAmB;AAC7B,aAAO;AACP,oBAAc,KAAK;AACnB,YAAM;AAAA,IACR;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/owner.js

@@ -4,26 +4,49 @@ const AGENT_LOCK = "slicc-agent";
 async function startAgent(options) {
   const release = await holdLock(options.locks ?? navigator.locks, AGENT_LOCK);
   const channel = options.channel ?? (() => new MessageChannel());
-  let worker;
+  const spawn = async () => {
+    const created = options.worker();
+    try {
+      if (options.kernel) {
+        const port = await options.kernel.connect();
+        created.postMessage({ kernel: port }, [port]);
+      }
+    } catch (error) {
+      created.terminate();
+      throw error;
+    }
+    return created;
+  };
+  let worker = Promise.resolve().then(spawn);
   try {
-    worker = options.worker();
+    await worker;
   } catch (error) {
     release();
     throw error;
   }
   return {
-    connect() {
+    async connect() {
+      const ready = await worker;
+      if (!ready) throw new Error("the agent was released");
       const { port1, port2 } = channel();
-      worker.postMessage({ connect: port2 }, [port2]);
+      ready.postMessage({ connect: port2 }, [port2]);
       return connectAgent(port1);
     },
     restart() {
-      worker.terminate();
-      worker = options.worker();
+      worker = worker.catch(() => void 0).then((old) => {
+        old?.terminate();
+        return spawn();
+      });
+      return worker.then(() => void 0);
     },
-    release() {
-      worker.terminate();
-      release();
+    async release() {
+      const previous = worker;
+      worker = Promise.resolve(void 0);
+      try {
+        (await previous.catch(() => void 0))?.terminate();
+      } finally {
+        release();
+      }
     }
   };
 }

package/dist/owner.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/owner.ts"],
-  "sourcesContent": ["import { type AgentConnection, connectAgent } from './client.ts';\nimport { holdLock } from './opfs-pool.ts';\nimport type { PortEndpoint } from './wire.ts';\n\nexport const AGENT_LOCK = 'slicc-agent';\n\nexport interface AgentWorker {\n  postMessage(message: unknown, transfer: Transferable[]): void;\n  terminate(): void;\n}\n\nexport interface AgentOwner {\n  connect(): Promise<AgentConnection>;\n  restart(): void;\n  release(): void;\n}\n\nexport interface OwnerOptions {\n  worker: () => AgentWorker;\n  locks?: LockManager;\n  channel?: () => { port1: PortEndpoint; port2: Transferable };\n}\n\nexport async function startAgent(options: OwnerOptions): Promise<AgentOwner> {\n  const release = await holdLock(options.locks ?? navigator.locks, AGENT_LOCK);\n  const channel = options.channel ?? (() => new MessageChannel());\n  let worker: AgentWorker;\n  try {\n    worker = options.worker();\n  } catch (error) {\n    release();\n    throw error;\n  }\n  return {\n    connect() {\n      const { port1, port2 } = channel();\n      worker.postMessage({ connect: port2 }, [port2]);\n      return connectAgent(port1);\n    },\n    restart() {\n      worker.terminate();\n      worker = options.worker();\n    },\n    release() {\n      worker.terminate();\n      release();\n    },\n  };\n}\n"],
-  "mappings": "AAAA,SAA+B,oBAAoB;AACnD,SAAS,gBAAgB;AAGlB,MAAM,aAAa;AAmB1B,eAAsB,WAAW,SAA4C;AAC3E,QAAM,UAAU,MAAM,SAAS,QAAQ,SAAS,UAAU,OAAO,UAAU;AAC3E,QAAM,UAAU,QAAQ,YAAY,MAAM,IAAI,eAAe;AAC7D,MAAI;AACJ,MAAI;AACF,aAAS,QAAQ,OAAO;AAAA,EAC1B,SAAS,OAAO;AACd,YAAQ;AACR,UAAM;AAAA,EACR;AACA,SAAO;AAAA,IACL,UAAU;AACR,YAAM,EAAE,OAAO,MAAM,IAAI,QAAQ;AACjC,aAAO,YAAY,EAAE,SAAS,MAAM,GAAG,CAAC,KAAK,CAAC;AAC9C,aAAO,aAAa,KAAK;AAAA,IAC3B;AAAA,IACA,UAAU;AACR,aAAO,UAAU;AACjB,eAAS,QAAQ,OAAO;AAAA,IAC1B;AAAA,IACA,UAAU;AACR,aAAO,UAAU;AACjB,cAAQ;AAAA,IACV;AAAA,EACF;AACF;",
+  "sourcesContent": ["import { type AgentConnection, connectAgent } from './client.ts';\nimport { holdLock } from './opfs-pool.ts';\nimport type { PortEndpoint } from './wire.ts';\n\nexport const AGENT_LOCK = 'slicc-agent';\n\nexport interface AgentWorker {\n  postMessage(message: unknown, transfer: Transferable[]): void;\n  terminate(): void;\n}\n\nexport interface AgentOwner {\n  connect(): Promise<AgentConnection>;\n  restart(): Promise<void>;\n  release(): Promise<void>;\n}\n\nexport interface KernelSource {\n  connect(): Promise<Transferable>;\n}\n\nexport interface OwnerOptions {\n  worker: () => AgentWorker;\n  kernel?: KernelSource;\n  locks?: LockManager;\n  channel?: () => { port1: PortEndpoint; port2: Transferable };\n}\n\nexport async function startAgent(options: OwnerOptions): Promise<AgentOwner> {\n  const release = await holdLock(options.locks ?? navigator.locks, AGENT_LOCK);\n  const channel = options.channel ?? (() => new MessageChannel());\n  const spawn = async (): Promise<AgentWorker> => {\n    const created = options.worker();\n    try {\n      if (options.kernel) {\n        const port = await options.kernel.connect();\n        created.postMessage({ kernel: port }, [port]);\n      }\n    } catch (error) {\n      created.terminate();\n      throw error;\n    }\n    return created;\n  };\n  let worker: Promise<AgentWorker | undefined> = Promise.resolve().then(spawn);\n  try {\n    await worker;\n  } catch (error) {\n    release();\n    throw error;\n  }\n  return {\n    async connect() {\n      const ready = await worker;\n      if (!ready) throw new Error('the agent was released');\n      const { port1, port2 } = channel();\n      ready.postMessage({ connect: port2 }, [port2]);\n      return connectAgent(port1);\n    },\n    restart() {\n      worker = worker\n        .catch(() => undefined)\n        .then((old) => {\n          old?.terminate();\n          return spawn();\n        });\n      return worker.then(() => undefined);\n    },\n    async release() {\n      const previous = worker;\n      worker = Promise.resolve(undefined);\n      try {\n        (await previous.catch(() => undefined))?.terminate();\n      } finally {\n        release();\n      }\n    },\n  };\n}\n"],
+  "mappings": "AAAA,SAA+B,oBAAoB;AACnD,SAAS,gBAAgB;AAGlB,MAAM,aAAa;AAwB1B,eAAsB,WAAW,SAA4C;AAC3E,QAAM,UAAU,MAAM,SAAS,QAAQ,SAAS,UAAU,OAAO,UAAU;AAC3E,QAAM,UAAU,QAAQ,YAAY,MAAM,IAAI,eAAe;AAC7D,QAAM,QAAQ,YAAkC;AAC9C,UAAM,UAAU,QAAQ,OAAO;AAC/B,QAAI;AACF,UAAI,QAAQ,QAAQ;AAClB,cAAM,OAAO,MAAM,QAAQ,OAAO,QAAQ;AAC1C,gBAAQ,YAAY,EAAE,QAAQ,KAAK,GAAG,CAAC,IAAI,CAAC;AAAA,MAC9C;AAAA,IACF,SAAS,OAAO;AACd,cAAQ,UAAU;AAClB,YAAM;AAAA,IACR;AACA,WAAO;AAAA,EACT;AACA,MAAI,SAA2C,QAAQ,QAAQ,EAAE,KAAK,KAAK;AAC3E,MAAI;AACF,UAAM;AAAA,EACR,SAAS,OAAO;AACd,YAAQ;AACR,UAAM;AAAA,EACR;AACA,SAAO;AAAA,IACL,MAAM,UAAU;AACd,YAAM,QAAQ,MAAM;AACpB,UAAI,CAAC,MAAO,OAAM,IAAI,MAAM,wBAAwB;AACpD,YAAM,EAAE,OAAO,MAAM,IAAI,QAAQ;AACjC,YAAM,YAAY,EAAE,SAAS,MAAM,GAAG,CAAC,KAAK,CAAC;AAC7C,aAAO,aAAa,KAAK;AAAA,IAC3B;AAAA,IACA,UAAU;AACR,eAAS,OACN,MAAM,MAAM,MAAS,EACrB,KAAK,CAAC,QAAQ;AACb,aAAK,UAAU;AACf,eAAO,MAAM;AAAA,MACf,CAAC;AACH,aAAO,OAAO,KAAK,MAAM,MAAS;AAAA,IACpC;AAAA,IACA,MAAM,UAAU;AACd,YAAM,WAAW;AACjB,eAAS,QAAQ,QAAQ,MAAS;AAClC,UAAI;AACF,SAAC,MAAM,SAAS,MAAM,MAAM,MAAS,IAAI,UAAU;AAAA,MACrD,UAAE;AACA,gBAAQ;AAAA,MACV;AAAA,IACF;AAAA,EACF;AACF;",
   "names": []
 }

package/dist/types/agent.d.ts

@@ -7,6 +7,7 @@ export interface AgentOptions {
     storage?: Storage;
     registry?: Registry;
     settings?: HarnessOptions['settings'];
+    env?: HarnessOptions['env'];
     context?: Context;
 }
 export interface Agent {

package/dist/types/index.d.ts

@@ -2,8 +2,10 @@ export { type Agent, type AgentOptions, answerText, openAgent } from './agent.ts
 export { type AgentConnection, connectAgent } from './client.ts';
 export { createAgentControl } from './control.ts';
 export { type AgentHost, hostAgent } from './host.ts';
+export type { KernelClient, KernelFs, KernelProcess, KernelStat, SpawnOptions, } from './kernel/client.ts';
+export { HOME, type KernelEnvOptions, kernelEnvironment, SliccKernelEnv } from './kernel/env.ts';
 export { AGENT_LOCK, type AgentOwner, type AgentWorker, type OwnerOptions, startAgent, } from './owner.ts';
 export { AGENT_SESSION, AgentControl, AgentSessions, type AgentSettingsChange, AgentTranscript, type OperationError, type PromptResult, type SendMode, type SendRequest, type SendResponse, } from './services.ts';
 export { AGENT_DIRECTORY, type OpfsSqliteOptions, openMemorySqliteStorage, openOpfsSqliteStorage, WasmSqliteDatabase, } from './sqlite.ts';
 export { PortChannel, type PortEndpoint, PortListener, withUnrefTimers } from './wire.ts';
-export { serveConnections, type WorkerScope } from './worker.ts';
+export { kernelPort, serveConnections, type WorkerScope } from './worker.ts';

package/dist/types/kernel/client.d.ts

@@ -0,0 +1,39 @@
+export interface KernelStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+    mtime: Date | number;
+    ino?: number;
+}
+export interface KernelFs {
+    readFile(path: string): Promise<Uint8Array>;
+    readText(path: string): Promise<string>;
+    writeFile(path: string, data: string | Uint8Array): Promise<void>;
+    stat(path: string): Promise<KernelStat>;
+    lstat(path: string): Promise<KernelStat>;
+    readdir(path: string): Promise<string[]>;
+    mkdir(path: string): Promise<void>;
+    rm(path: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    realpath(path: string): Promise<string>;
+    exists(path: string): Promise<boolean>;
+}
+export interface KernelProcess {
+    pid: number;
+    pgid: number;
+    exited: Promise<number>;
+    signal(name?: string): unknown;
+}
+export interface SpawnOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    onStdout?(bytes: Uint8Array): void;
+    onStderr?(bytes: Uint8Array): void;
+}
+export interface KernelClient {
+    fs: KernelFs;
+    spawn(argv: readonly string[], options: SpawnOptions): Promise<KernelProcess>;
+}

package/dist/types/kernel/env.d.ts

@@ -0,0 +1,57 @@
+import type { Context } from '@earendil-works/chord';
+import { type BinaryReader, type DirReader, type ExecutionEnv, type ExecutionError, FileError, type FileInfo, type FileWatcher, type Result, type ShellExecOptions, type ShellExecResult, type TextLineReader, type WatchChange, type WatchTarget } from '@earendil-works/pi-durable/env';
+import type { KernelClient } from './client.ts';
+import { type PollOptions } from './watch.ts';
+export interface KernelEnvOptions {
+    cwd: string;
+    id?: string;
+    watch?: PollOptions;
+}
+type FileResult<T> = Promise<Result<T, FileError>>;
+export declare class SliccKernelEnv implements ExecutionEnv {
+    #private;
+    readonly id: string;
+    cwd: string;
+    constructor(client: KernelClient, options: KernelEnvOptions);
+    absolutePath(path: string): FileResult<string>;
+    joinPath(parts: string[]): FileResult<string>;
+    readTextFile(path: string, context: Context): FileResult<string>;
+    readBinaryFile(path: string, context: Context): FileResult<Uint8Array>;
+    openTextLineReader(path: string, context: Context): FileResult<TextLineReader>;
+    readTextLines(path: string, options: {
+        maxLines?: number;
+    } | undefined, context: Context): FileResult<string[]>;
+    openBinaryReader(path: string, options: {
+        noFollow?: boolean;
+    } | undefined, context: Context): FileResult<BinaryReader>;
+    writeFile(path: string, content: string | Uint8Array, context: Context): FileResult<void>;
+    appendFile(path: string, content: string | Uint8Array, context: Context): FileResult<void>;
+    truncateFile(path: string, size: number, context: Context): FileResult<void>;
+    flushFile(path: string, context: Context): FileResult<void>;
+    renameFile(sourcePath: string, destinationPath: string, context: Context): FileResult<void>;
+    fileInfo(path: string, context: Context): FileResult<FileInfo>;
+    listDir(path: string, context: Context): FileResult<FileInfo[]>;
+    openDirReader(path: string, context: Context): FileResult<DirReader>;
+    watch(targets: readonly WatchTarget[], onChange: (change: WatchChange) => void, context: Context): FileResult<FileWatcher>;
+    canonicalPath(path: string, context: Context): FileResult<string>;
+    exists(path: string, context: Context): FileResult<boolean>;
+    createDir(path: string, _options: {
+        recursive?: boolean;
+    } | undefined, context: Context): FileResult<void>;
+    remove(path: string, options: {
+        recursive?: boolean;
+        force?: boolean;
+    } | undefined, context: Context): FileResult<void>;
+    createTempDir(prefix: string | undefined, context: Context): FileResult<string>;
+    createTempFile(options: {
+        prefix?: string;
+        suffix?: string;
+    } | undefined, context: Context): FileResult<string>;
+    exec(command: string | readonly string[], options: ShellExecOptions | undefined, context: Context): Promise<Result<ShellExecResult, ExecutionError>>;
+    cleanup(context: Context): Promise<void>;
+}
+export declare const HOME = "/home";
+export declare function kernelEnvironment(client: KernelClient, options?: Omit<KernelEnvOptions, 'cwd'>): (target: {
+    cwd?: string;
+}) => SliccKernelEnv;
+export {};

package/dist/types/kernel/exec.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@earendil-works/chord';
+import { ExecutionError, type Result, type ShellExecOptions, type ShellExecResult } from '@earendil-works/pi-durable/env';
+import type { KernelClient } from './client.ts';
+export declare const SHELL: readonly ['bash', '-c'];
+export declare function execute(client: KernelClient, cwd: string, command: string | readonly string[], options: ShellExecOptions | undefined, context: Context): Promise<Result<ShellExecResult, ExecutionError>>;

package/dist/types/kernel/files.d.ts

@@ -0,0 +1,34 @@
+import type { Context } from '@earendil-works/chord';
+import { type BinaryReader, type DirReader, FileError, type FileInfo, type LineScan, type Result, type TextLine, type TextLineReader } from '@earendil-works/pi-durable/env';
+import type { KernelFs, KernelStat } from './client.ts';
+export declare function fileError(error: unknown, path?: string): FileError;
+export declare function aborted(context: Context, path?: string): Result<never, FileError> | undefined;
+export declare function attempt<T>(context: Context, path: string, run: () => Promise<T>): Promise<Result<T, FileError>>;
+export declare function info(path: string, stat: KernelStat): FileInfo;
+export declare class SnapshotReader implements BinaryReader {
+    #private;
+    constructor(bytes: Uint8Array, fileInfo: FileInfo);
+    info(): Promise<Result<FileInfo, FileError>>;
+    read(offset: number, length: number, context: Context): Promise<Result<Uint8Array, FileError>>;
+    scanLines(options: {
+        startLine: number;
+        endLine?: number;
+    }, context: Context): Promise<Result<LineScan, FileError>>;
+    close(): Promise<void>;
+}
+export declare class SnapshotLines implements TextLineReader {
+    #private;
+    constructor(text: string);
+    readLine(): Promise<Result<TextLine | undefined, FileError>>;
+    close(): Promise<void>;
+}
+export declare class KernelDirReader implements DirReader {
+    #private;
+    constructor(fs: KernelFs, path: string, names: string[]);
+    next(maxEntries: number, context: Context): Promise<Result<{
+        entries: FileInfo[];
+        done: boolean;
+    }, FileError>>;
+    rest(): Promise<FileInfo[]>;
+    close(): Promise<void>;
+}

package/dist/types/kernel/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function normalize(path: string): string;
+export declare function resolve(cwd: string, path: string): string;
+export declare function dirname(path: string): string;
+export declare function basename(path: string): string;

package/dist/types/kernel/watch.d.ts

@@ -0,0 +1,10 @@
+import type { FileWatcher, WatchChange, WatchTarget } from '@earendil-works/pi-durable/env';
+import type { KernelFs } from './client.ts';
+type Snapshot = Map<string, string>;
+export declare function snapshot(fs: KernelFs, cwd: string, targets: readonly WatchTarget[]): Promise<Snapshot>;
+export declare function differences(before: Snapshot, after: Snapshot): string[];
+export interface PollOptions {
+    intervalMs?: number;
+}
+export declare function pollWatch(fs: KernelFs, cwd: string, targets: readonly WatchTarget[], onChange: (change: WatchChange) => void, options?: PollOptions): Promise<FileWatcher>;
+export {};

package/dist/types/owner.d.ts

@@ -7,11 +7,15 @@ export interface AgentWorker {
 }
 export interface AgentOwner {
     connect(): Promise<AgentConnection>;
-    restart(): void;
-    release(): void;
+    restart(): Promise<void>;
+    release(): Promise<void>;
+}
+export interface KernelSource {
+    connect(): Promise<Transferable>;
 }
 export interface OwnerOptions {
     worker: () => AgentWorker;
+    kernel?: KernelSource;
     locks?: LockManager;
     channel?: () => {
         port1: PortEndpoint;

package/dist/types/worker.d.ts

@@ -3,3 +3,4 @@ export interface WorkerScope {
     addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
 }
 export declare function serveConnections(scope: WorkerScope, host: Promise<AgentHost>): void;
+export declare function kernelPort(scope: WorkerScope): Promise<MessagePort>;

package/dist/worker.js

@@ -8,7 +8,16 @@ function serveConnections(scope, host) {
     );
   });
 }
+function kernelPort(scope) {
+  return new Promise((resolve) => {
+    scope.addEventListener("message", ({ data }) => {
+      const port = data?.kernel;
+      if (port) resolve(port);
+    });
+  });
+}
 export {
+  kernelPort,
   serveConnections
 };
 //# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/worker.ts"],
-  "sourcesContent": ["import type { AgentHost } from './host.ts';\nimport type { PortEndpoint } from './wire.ts';\n\nexport interface WorkerScope {\n  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;\n}\n\nexport function serveConnections(scope: WorkerScope, host: Promise<AgentHost>): void {\n  scope.addEventListener('message', ({ data }) => {\n    const port = (data as { connect?: PortEndpoint } | null)?.connect;\n    if (!port) return;\n    host.then(\n      (ready) => ready.connect(port),\n      () => port.close?.()\n    );\n  });\n}\n"],
-  "mappings": "AAOO,SAAS,iBAAiB,OAAoB,MAAgC;AACnF,QAAM,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AAC9C,UAAM,OAAQ,MAA4C;AAC1D,QAAI,CAAC,KAAM;AACX,SAAK;AAAA,MACH,CAAC,UAAU,MAAM,QAAQ,IAAI;AAAA,MAC7B,MAAM,KAAK,QAAQ;AAAA,IACrB;AAAA,EACF,CAAC;AACH;",
+  "sourcesContent": ["import type { AgentHost } from './host.ts';\nimport type { PortEndpoint } from './wire.ts';\n\nexport interface WorkerScope {\n  addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;\n}\n\nexport function serveConnections(scope: WorkerScope, host: Promise<AgentHost>): void {\n  scope.addEventListener('message', ({ data }) => {\n    const port = (data as { connect?: PortEndpoint } | null)?.connect;\n    if (!port) return;\n    host.then(\n      (ready) => ready.connect(port),\n      () => port.close?.()\n    );\n  });\n}\n\nexport function kernelPort(scope: WorkerScope): Promise<MessagePort> {\n  return new Promise((resolve) => {\n    scope.addEventListener('message', ({ data }) => {\n      const port = (data as { kernel?: MessagePort } | null)?.kernel;\n      if (port) resolve(port);\n    });\n  });\n}\n"],
+  "mappings": "AAOO,SAAS,iBAAiB,OAAoB,MAAgC;AACnF,QAAM,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AAC9C,UAAM,OAAQ,MAA4C;AAC1D,QAAI,CAAC,KAAM;AACX,SAAK;AAAA,MACH,CAAC,UAAU,MAAM,QAAQ,IAAI;AAAA,MAC7B,MAAM,KAAK,QAAQ;AAAA,IACrB;AAAA,EACF,CAAC;AACH;AAEO,SAAS,WAAW,OAA0C;AACnE,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,iBAAiB,WAAW,CAAC,EAAE,KAAK,MAAM;AAC9C,YAAM,OAAQ,MAA0C;AACxD,UAAI,KAAM,SAAQ,IAAI;AAAA,IACxB,CAAC;AAAA,EACH,CAAC;AACH;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/slicc-agent",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "SLICC's agent core on pi durable: an agent worker, session storage, remoting and pi extensions",
   "type": "module",
   "license": "Apache-2.0",
@@ -40,7 +40,7 @@
     "prepack": "npm run build",
     "start": "npm run build && node test/integration/chrome.mjs",
     "pretest": "npm run build && node test/integration/build.mjs && playwright-core install --no-shell chromium",
-    "test": "node --test --test-global-setup=node_modules/@ai-ecoverse/slicc-shared-web/harness/global.mjs 'test/integration/*.test.mjs'",
+    "test": "node --test --test-timeout=120000 --test-global-setup=node_modules/@ai-ecoverse/slicc-shared-web/harness/global.mjs 'test/integration/*.test.mjs'",
     "test:unit": "NODE_NO_WARNINGS=1 mcr -c node_modules/@ai-ecoverse/slicc-shared-web/mcr.config.mjs node --test 'test/unit/**/*.test.mjs'",
     "typecheck": "tsc",
     "lint": "slicc-lint",
@@ -50,8 +50,11 @@
     "release": "semantic-release"
   },
   "devDependencies": {
+    "@ai-ecoverse/slicc-kernel": "1.9.0",
     "@ai-ecoverse/slicc-shared-web": "1.5.0",
     "@ai-ecoverse/slicc-spectrum": "1.7.0",
+    "@ai-ecoverse/wasm-bash": "5.3.0-7",
+    "@ai-ecoverse/wasm-coreutils": "9.7.0-3",
     "@biomejs/biome": "2.5.15",
     "@types/node": "24.19.1",
     "esbuild": "0.28.2",