@fastagent-sh/fastagent 0.17.1 → 0.19.0

package/dist/channels/{state.js → kit/state.js}

@@ -12,9 +12,9 @@
  * is an ENVIRONMENT error the operator must fix: it throws, and construction fails loudly — booting
  * with silently-empty state would hide real data behind a config mistake.
  */
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { log } from "../log.js";
+import { mkdirSync, readFileSync } from "node:fs";
+import { writeFileAtomic } from "../../atomic-write.js";
+import { log } from "../../log.js";
 /** Create the channel's state home — the one shared spelling of it, so no channel invents its own. */
 export function ensureStateHome(dir) {
     mkdirSync(dir, { recursive: true });
@@ -43,25 +43,5 @@ export function loadStateFile(path) {
     }
 }
 export function saveStateFile(path, value) {
-    mkdirSync(dirname(path), { recursive: true });
-    const tmp = `${path}.tmp`;
-    writeFileSync(tmp, JSON.stringify(value));
-    renameSync(tmp, path);
-}
-/**
- * Drop a state file a redesign retired. Best-effort by design: a leftover file is untidy, not fatal,
- * so a failure is debug-level and never blocks a boot. Only for files that are pure CACHE — anything
- * whose loss changes behaviour needs a migration, not a delete.
- *
- * Shared because a retired file is usually retired in every channel at once: one best-effort
- * semantic, one log shape, one place to check what "retired" means here. (The removal DEADLINE is not
- * here — it lives in test/migration-deadline.test.ts, which names every call site to delete.)
- */
-export function removeRetiredStateFile(stateHome, name, label) {
-    try {
-        rmSync(join(stateHome, name), { force: true });
-    }
-    catch (error) {
-        log.debug(`${label} could not remove the obsolete ${name}: ${String(error)}`);
-    }
+    writeFileAtomic(path, JSON.stringify(value));
 }

package/dist/channels/{stop-command.d.ts → kit/stop-command.d.ts}

@@ -1,4 +1,4 @@
-import { type SessionControl } from "../session.ts";
+import { type SessionControl } from "../../session.ts";
 /** Bare stop word for summon-body matching (Slack/Feishu); Telegram uses its native `/stop` command. */
 export declare function isStopText(text: string): boolean;
 /** Dispatch `abort` for the session and map the outcome to the customer-facing line. Never throws;

package/dist/channels/{stop-command.js → kit/stop-command.js}

@@ -6,8 +6,8 @@
  * at-least-once floor; and the hub stays gated by `config.sessionControl`, so without it the command
  * degrades to a visible "not enabled" notice, never a silent ignore.
  */
-import { log } from "../log.js";
-import { NO_ACTIVE_RUN_CODE } from "../session.js";
+import { log } from "../../log.js";
+import { NO_ACTIVE_RUN_CODE } from "../../session.js";
 /** Bare stop word for summon-body matching (Slack/Feishu); Telegram uses its native `/stop` command. */
 export function isStopText(text) {
     return /^(stop|cancel)[.!]?$/i.test(text.trim());

package/dist/channels/{tasks.js → kit/tasks.js}

@@ -4,7 +4,7 @@
  * (`turnsIdle`) — otherwise a reply in flight when the process exits is silently dropped. Error
  * handling stays with the caller: track() only guarantees the drain sees the task settle.
  */
-import { beginWork } from "./busy.js";
+import { beginWork } from "../busy.js";
 export function createTaskTracker() {
     const tasks = new Set();
     return {

package/dist/channels/{thread-participants.d.ts → kit/thread-participants.d.ts}

@@ -6,6 +6,13 @@ export interface ThreadParticipants {
      * get wrong twice, and "a second human restores the mention requirement" must have one place to change.
      */
     admitsBareMessage(key: string): boolean;
+    /**
+     * Has the agent answered into this thread before — the "first answered turn" fact
+     * (participant-model.md §8), unlike {@link ThreadParticipants.admitsBareMessage} which also weighs
+     * the second-human rule. An evicted record answers false (this store is a cache — see the header),
+     * so gate a repeatable read on it, never a durable claim.
+     */
+    agentSpokeIn(key: string): boolean;
     /**
      * Merge in what was just heard. Idempotent; a failed write is a warning, never a failed delivery.
      *

package/dist/channels/{thread-participants.js → kit/thread-participants.js}

@@ -19,7 +19,7 @@
  * - Keyed by `thread_id`, never a reply-chain root: Feishu's `root_id` moves with the chain, so it
  *   cannot identify a side conversation at all.
  */
-import { log } from "../log.js";
+import { log } from "../../log.js";
 import { loadStateFile, saveStateFile } from "./state.js";
 /** Cap on remembered threads. Losing one costs a mention to re-enter that thread, so an unbounded file
  *  buys little — and a merge that carries new information rewrites the whole map synchronously, so the
@@ -68,6 +68,9 @@ export function createThreadParticipants(path, label) {
             const heard = records.get(key);
             return heard?.agentSpoke === true && heard.humans.length <= 1;
         },
+        agentSpokeIn(key) {
+            return records.get(key)?.agentSpoke === true;
+        },
         merge(key, heard) {
             const previous = records.get(key);
             const humans = new Set(previous?.humans ?? []);

package/dist/channels/{turn-queue.js → kit/turn-queue.js}

@@ -10,8 +10,8 @@
  * process-crash recovery, at-least-once). Exactly-once / deterministic step-replay (L2) is the K-axis
  * backend — an external queue with distributed locking (SPEC §11) — not this in-memory queue.
  */
-import { log } from "../log.js";
-import { beginWork } from "./busy.js";
+import { log } from "../../log.js";
+import { beginWork } from "../busy.js";
 export function createTurnQueue(opts) {
     const { label, run, onQueuedBehind } = opts;
     // Per-session serial chains: a second turn for the same session waits its turn (FIFO) instead of

package/dist/channels/{turn-store.js → kit/turn-store.js}

@@ -49,7 +49,7 @@
  * Single-process, single-writer: same durability model as state.ts (crash-safe via atomic rename;
  * power-loss is best-effort — no fsync, consistent with the rest of the channel's state).
  */
-import { log } from "../log.js";
+import { log } from "../../log.js";
 import { loadStateFile, saveStateFile } from "./state.js";
 export function createTurnStore(path, opts) {
     const { label, isRecord, order } = opts;

package/dist/channels/lark/lark.d.ts

@@ -3,7 +3,7 @@
  * this module binds it to Lark's cloud profile and exposes natural Lark-branded public names. Lark's
  * weaker control-plane capabilities live in onboarding/registration, not in a fork of the turn engine.
  */
-import type { ChannelModule, LongConnectionChannelModule } from "../../host/node.ts";
+import type { ChannelModule, LongConnectionChannelModule } from "../../channel.ts";
 import { type FeishuChannelOptions, type FeishuFailure, type FeishuMessage, type FeishuMessageEvent, type FeishuRoute, type FeishuWebSocketChannelOptions, defaultFeishuRoute } from "../feishu/feishu.ts";
 export type LarkChannelOptions = FeishuChannelOptions;
 export type LarkWebSocketChannelOptions = FeishuWebSocketChannelOptions;

package/dist/channels/serve.d.ts

@@ -0,0 +1,73 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ChannelHandler, Routes } from "../channel.ts";
+/** Parse a route key: `"METHOD /path"` → `{ method, path }`, or `"/path"` → `{ path }` (any method).
+ *  An empty method (`" /x"`) parses as `""`, which {@link assertRouteKey} refuses — see there. */
+export declare function parseRouteKey(key: string): {
+    method?: string;
+    path: string;
+};
+/**
+ * A route key is `"METHOD /path"` or `"/path"`, with a literal path.
+ *
+ * Every rule here exists because breaking it costs SOMEONE ELSE. Two keys naming one route, a route
+ * under a mount, a path a URL rewrites (`/a/../x` and `/x` are one route spelled two ways, while
+ * the conflict check compares strings) — in each case a channel goes dark and its author did
+ * nothing wrong.
+ *
+ * Mistakes that only cost their own author a debugging session are NOT policed: `:id` and `*` are
+ * literal path characters here, so such a key simply never matches, and an unusual method is the
+ * same. Refusing those would trade a working capability for a lecture.
+ */
+export declare function assertRouteKey(key: string, describe: (problem: string) => string): void;
+/** Do these two keys fight over the same request? Equal paths, and a method each answers; a key
+ *  with no method answers all of them. */
+export declare function routeKeysConflict(a: string, b: string): boolean;
+/** A handler owning a path prefix and everything beneath it — the session control plane is the one
+ *  user. Kept out of {@link Routes} so a key is always a literal path and collision checks stay
+ *  comparisons. */
+export interface PrefixMount {
+    /** Absolute, no trailing slash, and not `/` (`/control`). Owns `/control` and everything below it.
+     *  The root is excluded deliberately: a handler owning every path is that handler, and routing to
+     *  it through here would only add a table nothing can reach. */
+    prefix: string;
+    handler: ChannelHandler;
+}
+/** Same status and headers, no content (RFC 9110's HEAD). The discarded body is cancelled, or a
+ *  streaming producer keeps running with no reader. Shared with the control plane, which answers
+ *  HEAD too. */
+export declare function withoutBody(res: Response): Response;
+/** Is `path` inside `prefix`? Segment-wise, so `/controlled` is not inside `/control`. */
+export declare function pathUnderPrefix(path: string, prefix: string): boolean;
+/**
+ * Compose a {@link Routes} table and its {@link PrefixMount}s into one handler.
+ *
+ * Refuses at assembly anything that could not receive a request: a key naming the same route as
+ * another (`"/x"` and `"GET /x"`), a route inside a mount, two mounts claiming the same ground. A
+ * channel must never go dark unannounced.
+ *
+ * 404 and 405 stay distinct: a remote client reads 404 as "this serve predates the route" (version
+ * skew) rather than as a fault.
+ */
+export declare function router(routes: Routes, mounts?: readonly PrefixMount[]): ChannelHandler;
+/** The node:http adapter for a Fetch handler — the embedded server uses it, and an embedder mounting
+ *  fastagent on its OWN node:http server can too.
+ *
+ *  Takes the same {@link ChannelHandler} `serveNode` does, so both doors accept the same thing: a
+ *  handler may answer synchronously, and `router()` returns exactly that. Requiring a Promise here
+ *  made the most natural mount — `nodeListener(router(routes))`, the whole agent on the app's own
+ *  server — a type error. */
+export declare function nodeListener(handler: ChannelHandler): (req: IncomingMessage, res: ServerResponse) => void;
+/**
+ * Serve `handler` on a Node HTTP server. Thin mechanism: bind, report the port, let the caller stop
+ * accepting or force-close active connections — no logging/signals/exit (the CLI owns those).
+ * `listening` resolves with the bound port (useful for port 0) or rejects on a bind error.
+ * `host` is the bind address; unset means all interfaces (what containers need).
+ */
+export declare function serveNode(handler: ChannelHandler, options: {
+    port: number;
+    host?: string;
+}): {
+    listening: Promise<number>;
+    close: () => Promise<void>;
+    closeAllConnections: () => void;
+};

package/dist/channels/serve.js

@@ -0,0 +1,243 @@
+/**
+ * How a {@link Routes} table becomes a running server: the path rule, dispatch, the totality
+ * boundary, and the node:http binding.
+ *
+ * Shared ground, not a deployment target — every host in `src/deploy/` runs this same process; what
+ * differs between them is process, storage, credentials and deployment (core.md §1), none of it
+ * here.
+ *
+ * Dispatch is a Map lookup rather than a router because a deployment mounts a handful of LITERAL
+ * paths. A routing library would answer through a pattern language we do not use, and its extra
+ * semantics (decode-before-match, HEAD fallback, wildcard precedence) would have to be predicted by
+ * every collision check.
+ *
+ * The types a channel author or an embedder writes stay pure Fetch — SPEC §11 fixes the gateway
+ * contract as `(Request) => Response`, and an embedding app may already run its own framework.
+ * `overrideGlobalObjects: false` is part of that: the adapter otherwise swaps
+ * `globalThis.Request`/`Response` process-wide, which breaks a channel holding a `Response`
+ * captured before mount (it fails `instanceof` in {@link totalFetch} and is answered 500).
+ *
+ * Post-ACK work (a webhook channel's fire-and-forget turns) runs on this event loop and is lost on
+ * shutdown — the accepted tradeoff until durable execution (the K axis) exists.
+ */
+import { serve, getRequestListener } from "@hono/node-server";
+import { log } from "../log.js";
+import { text } from "./respond.js";
+/** Parse a route key: `"METHOD /path"` → `{ method, path }`, or `"/path"` → `{ path }` (any method).
+ *  An empty method (`" /x"`) parses as `""`, which {@link assertRouteKey} refuses — see there. */
+export function parseRouteKey(key) {
+    const sp = key.indexOf(" ");
+    return sp === -1 ? { path: key } : { method: key.slice(0, sp).toUpperCase(), path: key.slice(sp + 1) };
+}
+/**
+ * A route key is `"METHOD /path"` or `"/path"`, with a literal path.
+ *
+ * Every rule here exists because breaking it costs SOMEONE ELSE. Two keys naming one route, a route
+ * under a mount, a path a URL rewrites (`/a/../x` and `/x` are one route spelled two ways, while
+ * the conflict check compares strings) — in each case a channel goes dark and its author did
+ * nothing wrong.
+ *
+ * Mistakes that only cost their own author a debugging session are NOT policed: `:id` and `*` are
+ * literal path characters here, so such a key simply never matches, and an unusual method is the
+ * same. Refusing those would trade a working capability for a lecture.
+ */
+export function assertRouteKey(key, describe) {
+    const { method, path } = parseRouteKey(key);
+    if (method === "")
+        throw new Error(describe('a leading space is not a method — write "/path" for any method'));
+    if (!path.startsWith("/"))
+        throw new Error(describe('must start with "/"'));
+    // Asked of `URL` rather than by listing what it rewrites (`?`/`#`, `.`/`..`, `\`, `%2e`). A key it
+    // rewrites is unreachable AND compares as a different string, hiding that `/a/../x` and `/x` are
+    // one route.
+    const arrives = new URL(path, "http://x").pathname;
+    if (arrives !== path) {
+        throw new Error(describe(`is not the path a request would carry — that request arrives as "${arrives}"`));
+    }
+}
+/** Do these two keys fight over the same request? Equal paths, and a method each answers; a key
+ *  with no method answers all of them. */
+export function routeKeysConflict(a, b) {
+    const ka = parseRouteKey(a);
+    const kb = parseRouteKey(b);
+    if (ka.path !== kb.path)
+        return false;
+    return ka.method === undefined || kb.method === undefined || ka.method === kb.method;
+}
+/** Same status and headers, no content (RFC 9110's HEAD). The discarded body is cancelled, or a
+ *  streaming producer keeps running with no reader. Shared with the control plane, which answers
+ *  HEAD too. */
+export function withoutBody(res) {
+    void res.body?.cancel().catch(() => { });
+    return new Response(null, { status: res.status, statusText: res.statusText, headers: res.headers });
+}
+/** Is `path` inside `prefix`? Segment-wise, so `/controlled` is not inside `/control`. */
+export function pathUnderPrefix(path, prefix) {
+    return path === prefix || path.startsWith(`${prefix}/`);
+}
+/**
+ * Compose a {@link Routes} table and its {@link PrefixMount}s into one handler.
+ *
+ * Refuses at assembly anything that could not receive a request: a key naming the same route as
+ * another (`"/x"` and `"GET /x"`), a route inside a mount, two mounts claiming the same ground. A
+ * channel must never go dark unannounced.
+ *
+ * 404 and 405 stay distinct: a remote client reads 404 as "this serve predates the route" (version
+ * skew) rather than as a fault.
+ */
+export function router(routes, mounts = []) {
+    for (const [i, mount] of mounts.entries()) {
+        assertRouteKey(mount.prefix, (problem) => `mount prefix "${mount.prefix}" is invalid — ${problem}`);
+        if (mount.prefix === "/") {
+            throw new Error(`mount prefix "/" is invalid — a handler owning every path IS that handler; serve it directly`);
+        }
+        if (mount.prefix.endsWith("/")) {
+            throw new Error(`mount prefix "${mount.prefix}" is invalid — no trailing slash (write "/control")`);
+        }
+        const clash = mounts
+            .slice(0, i)
+            .find((other) => pathUnderPrefix(mount.prefix, other.prefix) || pathUnderPrefix(other.prefix, mount.prefix));
+        if (clash) {
+            throw new Error(`mount "${mount.prefix}" overlaps "${clash.prefix}" — one of them would never receive a request`);
+        }
+    }
+    const byKey = new Map();
+    const paths = new Set();
+    for (const [key, handler] of Object.entries(routes)) {
+        assertRouteKey(key, (problem) => `route "${key}" is not a valid route key — ${problem}`);
+        const { path } = parseRouteKey(key);
+        for (const mount of mounts) {
+            if (pathUnderPrefix(path, mount.prefix)) {
+                throw new Error(`route "${key}" is inside the mount "${mount.prefix}" — it would never receive a request`);
+            }
+        }
+        const shadowed = [...byKey.keys()].find((other) => routeKeysConflict(other, key));
+        if (shadowed) {
+            throw new Error(`route "${key}" conflicts with "${shadowed}" — one of them would never receive a request`);
+        }
+        // Stored normalised: `parseRouteKey` upper-cases the method, so `"get /x"` validates under
+        // `GET` and would otherwise be looked up under a name nothing stores.
+        const { method } = parseRouteKey(key);
+        byKey.set(method ? `${method} ${path}` : path, handler);
+        paths.add(path);
+    }
+    return (req) => {
+        // `URL` normalises the path (`/a/../x` → `/x`) and drops query/fragment.
+        const path = new URL(req.url).pathname;
+        const answer = () => {
+            for (const mount of mounts)
+                if (pathUnderPrefix(path, mount.prefix))
+                    return mount.handler(req);
+            const exact = byKey.get(`${req.method} ${path}`) ?? byKey.get(path);
+            if (exact)
+                return exact(req);
+            if (req.method === "HEAD") {
+                const get = byKey.get(`GET ${path}`);
+                if (get)
+                    return get(req);
+            }
+            return paths.has(path) ? text("method not allowed\n", 405) : text("not found\n", 404);
+        };
+        // ONE exit, so the HEAD rule holds for every reply — a mount's, a route's, the GET fallback's,
+        // and the 404/405 this router writes itself. RFC 9110: HEAD is GET without the content.
+        const res = answer();
+        if (req.method !== "HEAD")
+            return res;
+        return res instanceof Promise ? res.then(withoutBody) : withoutBody(res);
+    };
+}
+/**
+ * The totality boundary every serving path shares. `loadChannels` imports arbitrary author code, so
+ * a channel that throws — or forgets to return — must become a logged 500 rather than escape as an
+ * unhandled rejection. Both `nodeListener` and `serveNode` route through it.
+ *
+ * The message stays internal: an adapter's default error page would echo exception text (a stack, a
+ * path, a key inside an error string) to whoever made the request. Visibility is the LOG's job.
+ */
+function totalFetch(handler) {
+    return async (req) => {
+        try {
+            const response = await handler(req);
+            if (!(response instanceof Response))
+                throw new TypeError("handler did not return a Response");
+            return response;
+        }
+        catch (error) {
+            log.error(`[serve] request failed: ${String(error)}`);
+            return text("internal error\n", 500);
+        }
+    };
+}
+/**
+ * Has upstream middleware already drained the request body?
+ *
+ * Node's `req` is one-shot, so a body parser mounted ahead of this route consumes it — a property of
+ * the Node/Fetch seam, not of this adapter. What is avoidable is the diagnosis: undici answers
+ * `TypeError: Body is unusable`, naming neither the cause nor the fix, and for a webhook channel
+ * that reads as "the integration is broken and the platform keeps retrying".
+ *
+ * Answers only when CERTAIN — a positive `content-length`. `readableEnded` alone is true for any
+ * request something upstream merely touched, and an empty chunked body is legal, arrives drained,
+ * and is indistinguishable from an eaten one. Guessing there rejects valid requests, making this
+ * guard the outage it explains.
+ */
+function bodyAlreadyRead(req) {
+    const length = Number(req.headers["content-length"]);
+    return Number.isFinite(length) && length > 0 && req.readableEnded;
+}
+/** The node:http adapter for a Fetch handler — the embedded server uses it, and an embedder mounting
+ *  fastagent on its OWN node:http server can too.
+ *
+ *  Takes the same {@link ChannelHandler} `serveNode` does, so both doors accept the same thing: a
+ *  handler may answer synchronously, and `router()` returns exactly that. Requiring a Promise here
+ *  made the most natural mount — `nodeListener(router(routes))`, the whole agent on the app's own
+ *  server — a type error. */
+export function nodeListener(handler) {
+    const listener = getRequestListener(totalFetch(handler), { overrideGlobalObjects: false });
+    return (req, res) => {
+        if (bodyAlreadyRead(req)) {
+            log.error(`[serve] ${req.method} ${req.url}: the request body was already read by upstream middleware ` +
+                `(e.g. express.json()) — mount fastagent BEFORE the body parser, or scope the parser away ` +
+                `from this route. Channels that verify webhook signatures need the RAW body.`);
+            res.writeHead(500, { "content-type": "text/plain" });
+            res.end("internal error\n");
+            return;
+        }
+        listener(req, res);
+    };
+}
+/**
+ * Serve `handler` on a Node HTTP server. Thin mechanism: bind, report the port, let the caller stop
+ * accepting or force-close active connections — no logging/signals/exit (the CLI owns those).
+ * `listening` resolves with the bound port (useful for port 0) or rejects on a bind error.
+ * `host` is the bind address; unset means all interfaces (what containers need).
+ */
+export function serveNode(handler, options) {
+    let onListening;
+    let onBindError;
+    const listening = new Promise((resolve, reject) => {
+        onListening = resolve;
+        onBindError = reject;
+    });
+    // serve() types its return as the union of every server it CAN build (incl. http2). We never pass
+    // a createServer/http2 option, so it is always node:http's Server — the one carrying
+    // closeAllConnections, which the caller-owned force-close depends on.
+    const server = serve({
+        fetch: totalFetch(handler),
+        overrideGlobalObjects: false,
+        port: options.port,
+        ...(options.host !== undefined ? { hostname: options.host } : {}),
+    }, (info) => {
+        // Detach before resolving: this listener answers the BIND, and leaving it attached would let
+        // a later runtime error call reject() on a settled promise — swallowed, with nothing raised
+        // anywhere. Detached, an error after bind is an unhandled 'error' event, which is loud.
+        // (Not reachable from a test without forging an event on a server this function does not
+        // expose; the bind-failure half below is covered.)
+        server.off("error", onBindError);
+        onListening(info.port);
+    });
+    server.once("error", onBindError); // a bind failure surfaces here, before "listening"
+    const close = () => new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())));
+    const closeAllConnections = () => server.closeAllConnections();
+    return { listening, close, closeAllConnections };
+}

package/dist/channels/slack/bot-auth.js

@@ -1,6 +1,6 @@
 /** Rotating Slack bot-token provider backed by owner-only channel state. */
-import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { readFileSync } from "node:fs";
+import { writeFileAtomic } from "../../atomic-write.js";
 const REFRESH_EARLY_MS = 5 * 60_000;
 const REQUEST_TIMEOUT_MS = 30_000;
 function isState(value) {
@@ -35,18 +35,7 @@ function load(path) {
     }
 }
 function save(path, state) {
-    mkdirSync(dirname(path), { recursive: true });
-    const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
-    try {
-        writeFileSync(temp, JSON.stringify(state), { mode: 0o600 });
-        chmodSync(temp, 0o600);
-        renameSync(temp, path);
-        chmodSync(path, 0o600);
-    }
-    catch (error) {
-        rmSync(temp, { force: true });
-        throw error;
-    }
+    writeFileAtomic(path, JSON.stringify(state), 0o600);
 }
 async function refreshSlackBotToken(input) {
     const authorization = Buffer.from(`${input.clientId}:${input.clientSecret}`, "utf8").toString("base64");

package/dist/channels/slack/context-buffer.d.ts

@@ -1,9 +1,9 @@
 /**
- * Slack's half of the shared context buffer (mechanics + consume protocol: ../context-buffer.ts):
+ * Slack's half of the shared context buffer (mechanics + consume protocol: ../kit/context-buffer.ts):
  * the entry shape, its fold-line rendering, and buffered-file selection. Durable, bounded
  * unsummoned Slack discussion folded into the next answered turn in the same place.
  */
-import { type ContextBuffer } from "../context-buffer.ts";
+import { type ContextBuffer } from "../kit/context-buffer.ts";
 export interface SlackBufferEntry {
     sender: string;
     body: string;

package/dist/channels/slack/context-buffer.js

@@ -1,9 +1,9 @@
 /**
- * Slack's half of the shared context buffer (mechanics + consume protocol: ../context-buffer.ts):
+ * Slack's half of the shared context buffer (mechanics + consume protocol: ../kit/context-buffer.ts):
  * the entry shape, its fold-line rendering, and buffered-file selection. Durable, bounded
  * unsummoned Slack discussion folded into the next answered turn in the same place.
  */
-import { BUFFER_ATTACH_MAX, createContextBuffer as createGenericContextBuffer, } from "../context-buffer.js";
+import { BUFFER_ATTACH_MAX, createContextBuffer as createGenericContextBuffer, } from "../kit/context-buffer.js";
 function bufferLine(entry) {
     const meta = [`msg ${entry.messageId}`, entry.replyTo ? `thread root ${entry.replyTo}` : undefined]
         .filter(Boolean)

package/dist/channels/slack/invoke-turn.d.ts

@@ -1,6 +1,6 @@
 /** Resolve Slack file IDs at dequeue, then stream one engine-neutral Agent turn. */
 import type { Agent, AgentEvent } from "../../agent.ts";
-import { type BusyRetry } from "../invoke-turn-kit.ts";
+import { type BusyRetry } from "../kit/invoke-turn-kit.ts";
 import type { SlackBufferedFileRef } from "./context-buffer.ts";
 import type { SlackApi } from "./slack-api.ts";
 export interface SlackTurnTransport {

package/dist/channels/slack/invoke-turn.js

@@ -1,11 +1,11 @@
 import { log } from "../../log.js";
-import { DEFAULT_BUSY_RETRY, attachedFilesManifest, attributedFileName, backgroundImagesManifest, missingAttachmentsNote, streamTurnWithBusyRetry, } from "../invoke-turn-kit.js";
+import { DEFAULT_BUSY_RETRY, attachedFilesManifest, attributedFileName, backgroundImagesManifest, missingAttachmentsNote, streamTurnWithBusyRetry, } from "../kit/invoke-turn-kit.js";
 const MARKDOWN_INSTRUCTION = "\n\n(Format your reply as standard Markdown. Slack renders it natively. Do not use HTML or Slack control-mention syntax such as <!here>, <!channel>, or <!everyone>.)";
 async function resolveFile(transport, fileId) {
     const info = await transport.api.fileInfo(fileId);
-    return info.mimetype?.toLowerCase().startsWith("image/")
-        ? { image: await transport.api.fetchImage(info) }
-        : { file: await transport.api.fetchFile(info, transport.channelId, transport.filesDir) };
+    if (info.mimetype?.toLowerCase().startsWith("image/"))
+        return { image: await transport.api.fetchImage(info) };
+    return { file: await transport.api.fetchFile(info, transport.channelId, transport.filesDir) };
 }
 async function resolveInputs(transport, attachments) {
     const images = [];
@@ -20,7 +20,10 @@ async function resolveInputs(transport, attachments) {
     const backgroundImages = [];
     const backgroundFiles = [];
     let lost = 0;
-    const results = await Promise.allSettled(attachments.buffered.files.map(async (ref) => ({ ref, resolved: await resolveFile(transport, ref.id) })));
+    const results = await Promise.allSettled(attachments.buffered.files.map(async (ref) => ({
+        ref,
+        resolved: await resolveFile(transport, ref.id),
+    })));
     for (const result of results) {
         if (result.status === "fulfilled") {
             const { ref, resolved } = result.value;
@@ -59,5 +62,5 @@ export async function* invokeSlackTurn(agent, session, text, transport, attachme
         return;
     }
     const prompt = { text: `${text}${resolved.promptSuffix}${MARKDOWN_INSTRUCTION}`, images: resolved.images };
-    yield* streamTurnWithBusyRetry(agent, session, prompt, { label: transport.label, onCompleted, busyRetry });
+    yield* streamTurnWithBusyRetry(agent, { session }, prompt, { label: transport.label, onCompleted, busyRetry });
 }

package/dist/channels/slack/parse.js

@@ -1,5 +1,5 @@
-import { BUFFER_LINE_MAX_CHARS } from "../context-buffer.js";
-import { codePointPrefix, truncateCodePointPrefix } from "../text.js";
+import { BUFFER_LINE_MAX_CHARS } from "../kit/context-buffer.js";
+import { codePointPrefix, truncateCodePointPrefix } from "../kit/text.js";
 const HUMAN_MESSAGE_SUBTYPES = new Set(["file_share", "thread_broadcast"]);
 /**
  * Both forms Slack writes a mention in: `<@U123>` and the labelled `<@U123|name>`. ONE definition,

package/dist/channels/slack/preview.d.ts

@@ -1,6 +1,6 @@
 /** Slack reply rendering: native Agent streams first, rate-safe edited-message compatibility second. */
 import type { AgentEvent } from "../../agent.ts";
-import { type ChannelFailure, defaultErrorMessage } from "../preview-kit.ts";
+import { type ChannelFailure, defaultErrorMessage } from "../kit/preview-kit.ts";
 import { type SlackApi, type SlackTarget } from "./slack-api.ts";
 export type SlackFailure = ChannelFailure;
 export type SlackRendering = "native" | "classic";

package/dist/channels/slack/preview.js

@@ -1,5 +1,5 @@
 import { log } from "../../log.js";
-import { RETRY_NOTICE, THINKING_PLACEHOLDER, applyTurnEvent, composeTurnBody, createTurnView, defaultErrorMessage, humanizeToolName, revealedAnswer, summarizeToolArgs, toolLines, } from "../preview-kit.js";
+import { RETRY_NOTICE, THINKING_PLACEHOLDER, applyTurnEvent, composeTurnBody, createTurnView, defaultErrorMessage, humanizeToolName, revealedAnswer, summarizeToolArgs, toolLines, } from "../kit/preview-kit.js";
 import { chunkSlackMarkdown, chunkSlackText, isSlackNativeUnavailable, } from "./slack-api.js";
 export { defaultErrorMessage };
 const CLASSIC_UPDATE_INTERVAL_MS = 3_000;
@@ -175,7 +175,11 @@ async function streamClassicSlackReply(events, api, target, formatError, initial
             if (event.type === "failed") {
                 await finishPump();
                 finalized = true;
-                const notice = formatError({ details: event.details, retryable: event.retryable }) ?? "";
+                const notice = formatError({
+                    details: event.details,
+                    retryable: event.retryable,
+                    ...(event.code !== undefined ? { code: event.code } : {}),
+                }) ?? "";
                 await finalize(notice).catch((error) => log.error(`${label} failed to deliver the agent-failure notice: ${String(error)}`));
                 throw new Error(`agent failed: ${event.details} (retryable=${event.retryable})`);
             }
@@ -367,7 +371,11 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
             }
             else if (event.type === "failed") {
                 finalized = true;
-                const notice = formatError({ details: event.details, retryable: event.retryable }) ?? "";
+                const notice = formatError({
+                    details: event.details,
+                    retryable: event.retryable,
+                    ...(event.code !== undefined ? { code: event.code } : {}),
+                }) ?? "";
                 if (notice) {
                     pendingText += `${fullAnswer.trim() ? "\n\n" : ""}${notice}`;
                     fullAnswer += `${fullAnswer.trim() ? "\n\n" : ""}${notice}`;

package/dist/channels/slack/slack-api.js

@@ -1,7 +1,7 @@
 /** Slack Web API transport: one JSON pipeline plus authenticated, capped private-file downloads. */
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { codePointPrefix } from "../text.js";
+import { codePointPrefix } from "../kit/text.js";
 const API_TIMEOUT_MS = 30_000;
 const DOWNLOAD_TIMEOUT_MS = 120_000;
 const MAX_DOWNLOAD_BYTES = 20 * 1024 * 1024;

package/dist/channels/slack/slack.d.ts

@@ -1,4 +1,4 @@
-import type { ChannelModule } from "../../host/node.ts";
+import type { ChannelModule } from "../../channel.ts";
 import { type SlackEventEnvelope, type SlackFile, type SlackMessageEvent, type SlackRoute, defaultSlackRoute, slackEnvelope } from "./parse.ts";
 import { type SlackFailure, type SlackRendering } from "./preview.ts";
 export { defaultSlackRoute, slackEnvelope };