atom-agent 1.1.0 → 1.3.0

package/dist/context-manager.js

@@ -2,7 +2,6 @@
 //   - How much context is available?      (budget())
 //   - How much is currently used?         (usage())
 //   - Should we compact?                  (needsCompaction())
-//   - What messages should be sent?       (trimForSend())
 //
 // Budget derivation (no fixed-200K assumption): the history allowance comes
 // from the model's ACTUAL verified context window:
@@ -12,20 +11,18 @@
 //
 // measured in tokens via the shared 4ch/token estimator. A model with a 1M
 // window therefore gets ~1M of usable history instead of ~50K tokens.
+// Models with NO verified window report no allowance (a window is never
+// invented; auto-compact stays off for them).
 //
-// Hard safety ceiling (configurable, never primary): env ATOM_MAX_HISTORY_*
-// and atom.json maxHistory* still resolve through historyCharSource /
-// historyMessageSource. The ceiling only ever CAPS the derived budget — with
-// nothing configured it never binds for known-window models. Models with NO
-// verified window keep the legacy 200K-char / 100-message behavior exactly
-// (a window is never invented; auto-compact stays off for them).
+// History itself is NEVER truncated: there are no message/char caps.
+// Compaction (manual /compact, auto at ~83% of the verified window) is the
+// only pressure valve — Pi-style.
 //
 // Layering: this module owns measurement + budget math. It imports
-// context-windows (metadata) and config (file fallback) at runtime, and
-// zen.js types ONLY (no runtime cycle — zen.ts imports this module for its
-// loop trim). The agent loop, compaction mechanics, and providers are
-// untouched: truncateHistory/shouldAutoCompact/compactPct keep working via
-// re-exports from their original modules.
+// context-windows (metadata) and config (file fallback for compactPct) at
+// runtime, and zen.js types ONLY (no runtime cycle — zen.ts imports this
+// module for context math). The agent loop, compaction mechanics, and
+// providers are untouched.
 //
 // Prompt-caching foundation (NOT implemented): all inputs here are explicit
 // values (system/tools/history split, measured sizes, stable options), so a
@@ -72,8 +69,10 @@ export function historyChars(history) {
         total += messageChars(m);
     return total;
 }
-// Load = last POST's reported prompt_tokens when available, else the
-// 4ch/token estimate of the sent history chars.
+// Load = last POST's reported input-side tokens (prompt_tokens, normalized at
+// parse time to include exclusive prefix-cache counters like Anthropic's
+// cache_read/_creation) when available, else the 4ch/token estimate of the
+// sent history chars.
 export function computeContextLoad(lastPromptTokens, sentHistoryChars) {
     if (typeof lastPromptTokens === "number" &&
         Number.isFinite(lastPromptTokens) &&
@@ -82,51 +81,6 @@ export function computeContextLoad(lastPromptTokens, sentHistoryChars) {
     }
     return estimateTokensForChars(sentHistoryChars);
 }
-// ---- Safety-ceiling sources (env > atom.json > compiled default) ----
-export const MAX_HISTORY_MESSAGES = 100;
-export const MAX_HISTORY_CHARS = 200_000;
-function clampInt(n, min, max) {
-    return Math.min(Math.max(Math.floor(n), min), max);
-}
-function envInt(raw) {
-    if (raw === undefined)
-        return undefined;
-    const text = raw.trim();
-    if (!/^\d+$/.test(text))
-        return undefined;
-    const n = Number(text);
-    return Number.isFinite(n) ? Math.floor(n) : undefined;
-}
-// Message-count ceiling source. `explicit` tells whether a human configured
-// it (env or file) as opposed to the compiled default.
-export function historyMessageSource() {
-    const env = envInt(process.env.ATOM_MAX_HISTORY_MESSAGES);
-    if (env !== undefined)
-        return { value: clampInt(env, 10, 1000), explicit: true };
-    const file = loadAtomConfig().config.maxHistoryMessages;
-    if (file !== undefined)
-        return { value: file, explicit: true };
-    return { value: MAX_HISTORY_MESSAGES, explicit: false };
-}
-// Char-count safety ceiling source. Same explicit contract.
-export function historyCharSource() {
-    const env = envInt(process.env.ATOM_MAX_HISTORY_CHARS);
-    if (env !== undefined)
-        return { value: clampInt(env, 10_000, 2_000_000), explicit: true };
-    const file = loadAtomConfig().config.maxHistoryChars;
-    if (file !== undefined)
-        return { value: file, explicit: true };
-    return { value: MAX_HISTORY_CHARS, explicit: false };
-}
-// Legacy accessors (env → file → default). Kept for the loop's legacy path
-// and existing callers; the manager uses the sources above so it can tell
-// configured ceilings apart from defaults.
-export function historyMessageBudget() {
-    return historyMessageSource().value;
-}
-export function historyCharBudget() {
-    return historyCharSource().value;
-}
 // ---- Compaction threshold (moved here: the manager owns "should compact") ----
 export const COMPACT_PCT_DEFAULT = 0.83;
 function clampPctPercent(n) {
@@ -159,135 +113,20 @@ export function shouldAutoCompact(load, model, pctOverride) {
         : compactPct();
     return load / window >= pct;
 }
-// Searchable text for todo matching: message content plus the assistant's
-// tool_calls payload (todowrite CALLS carry the list, tool RESULTS echo it).
-// Tool call ids are NOT searched — they are pairing keys, not goal text, so
-// a todo that reads like an id can never false-pin a turn.
-function todoHaystack(m) {
-    let hay = "";
-    const content = m.content;
-    if (typeof content === "string")
-        hay += content;
-    if (m.role === "assistant" && m.tool_calls !== undefined) {
-        try {
-            hay += JSON.stringify(m.tool_calls);
-        }
-        catch {
-            // unstringifiable payload pins nothing
-        }
-    }
-    return hay;
-}
-function turnMentionsTodo(history, start, end, needles) {
-    for (let i = start; i < end; i++) {
-        const hay = todoHaystack(history[i]);
-        if (hay.length === 0)
-            continue;
-        for (const n of needles) {
-            if (n.length > 0 && hay.includes(n))
-                return true;
-        }
-    }
-    return false;
-}
-// Drop oldest user-turns until history fits BOTH caps (message count AND
-// total chars, each plus the caller's `reserve` headroom for a message it is
-// about to push). A user turn = the `user` message plus all following
-// messages up to (excluding) the next `user` message, so assistant
-// tool_calls always stay paired with their tool results across all three
-// wire formats. NEVER drops history[0] (system prompt), the first user turn
-// (the task prompt — the goal a long run must never forget), any turn that
-// still quotes a CURRENT open todo, or the latest turn (the one being
-// sent/built). Budget-aware edge: when the pinned content alone (first turn
-// + todo turns + latest) already exceeds a cap, there is nothing left to
-// drop — stop and still send (same never-drop-the-live-turn principle).
-// Mutates `history` in place via splice (so caller indices captured after
-// this call stay valid) and, when at least one turn dropped, fires ONE
-// `notify` (the caller surfaces it dim in the TUI); silence otherwise.
-// Returns what was dropped.
-export function truncateHistoryWithCaps(history, caps, opts) {
-    const result = { droppedTurns: 0, droppedMessages: 0 };
-    if (history.length <= 1)
-        return result;
-    const maxMessages = caps.maxMessages;
-    const maxChars = caps.maxChars;
-    const reserve = opts?.reserve;
-    const needles = opts?.todoNeedles ?? [];
-    const roomMessages = reserve?.messages !== undefined && Number.isFinite(reserve.messages)
-        ? Math.max(0, Math.floor(reserve.messages))
-        : 0;
-    const roomChars = reserve?.chars !== undefined && Number.isFinite(reserve.chars)
-        ? Math.max(0, reserve.chars)
-        : 0;
-    for (;;) {
-        const over = history.length + roomMessages > maxMessages ||
-            historyChars(history) + roomChars > maxChars;
-        if (!over)
-            break;
-        // Turn boundaries over history[1..]: each turn starts at a `user`
-        // message (the oldest slice starts at 1 even when it isn't one, matching
-        // the pre-pin drop unit). Whole-turn drops keep assistant/tool pairing.
-        const starts = [1];
-        for (let i = 2; i < history.length; i++) {
-            if (history[i]?.role === "user")
-                starts.push(i);
-        }
-        // Oldest NON-pinned, non-latest turn goes first: the first turn (task
-        // prompt) and any turn still quoting a current open todo stay, and the
-        // latest turn is never dropped. No candidate means pinned content alone
-        // is over budget — stop and send it as-is (see edge above).
-        let drop = -1;
-        for (let t = 0; t < starts.length; t++) {
-            if (t === starts.length - 1)
-                continue; // latest turn
-            if (t === 0)
-                continue; // task prompt
-            const end = t + 1 < starts.length ? starts[t + 1] : history.length;
-            if (needles.length > 0 && turnMentionsTodo(history, starts[t], end, needles))
-                continue;
-            drop = t;
-            break;
-        }
-        if (drop === -1)
-            break;
-        const end = drop + 1 < starts.length ? starts[drop + 1] : history.length;
-        const removed = history.splice(starts[drop], end - starts[drop]);
-        result.droppedTurns += 1;
-        result.droppedMessages += removed.length;
-    }
-    if (result.droppedTurns > 0) {
-        try {
-            opts?.notify?.(`(history truncated: dropped ${result.droppedTurns} oldest turn(s))`);
-        }
-        catch {
-            // observer errors never break the loop
-        }
-    }
-    return result;
-}
 // ---- Budget derivation ----
 // Expected completion/output reserve: one full summary-sized generation must
 // always fit alongside history (mirrors the compaction output cap).
 export const OUTPUT_RESERVE_TOKENS = 4096;
-// Safety headroom below the raw window: the trim cap never plans to use the
+// Safety headroom below the raw window: the budget never plans to use the
 // last 5% (auto-compact at ~83% fires long before this matters — the margin
-// is the last defense, not the trigger).
+// is informational, not a trigger).
 export const SAFETY_MARGIN_PCT = 0.05;
-// Default safety ceiling when nothing is configured AND no window is known
-// (the legacy 200K-char budget, preserved byte-for-byte as fallback).
-export const HARD_CEILING_FLOOR_CHARS = 200_000;
 export function createContextManager(opts) {
     const model = opts.model;
     const toolsChars = opts.toolsChars ?? 0;
     const reserveTokens = opts.outputReserveTokens ?? OUTPUT_RESERVE_TOKENS;
     const marginPct = opts.safetyMarginPct ?? SAFETY_MARGIN_PCT;
     const pct = opts.compactPct ?? compactPct();
-    function ceilingChars() {
-        if (opts.hardCeilingChars !== undefined) {
-            return { value: opts.hardCeilingChars, explicit: opts.hardCeilingExplicit ?? true };
-        }
-        return historyCharSource();
-    }
     function budget(history) {
         const window = contextWindowFor(model);
         const stats = ledgerStats(history);
@@ -298,18 +137,6 @@ export function createContextManager(opts) {
             ? Math.max(0, window - systemTokens - toolsTokens - reserveTokens - margin)
             : undefined;
         const historyCharsCap = historyTokens !== undefined ? historyTokens * CHARS_PER_TOKEN : undefined;
-        const ceil = ceilingChars();
-        const ceilMsgs = opts.hardCeilingMessages ?? historyMessageSource().value;
-        // The ceiling only ever CAPS: with nothing configured the derived budget
-        // rules (large windows stay usable); an explicit ceiling still binds as
-        // the safety net it is. Unknown windows fall back to the legacy floor.
-        const effectiveMaxChars = historyCharsCap !== undefined
-            ? ceil.explicit
-                ? Math.min(historyCharsCap, ceil.value)
-                : historyCharsCap
-            : ceil.explicit
-                ? ceil.value
-                : HARD_CEILING_FLOOR_CHARS;
         return {
             windowTokens: window,
             systemTokens,
@@ -318,11 +145,6 @@ export function createContextManager(opts) {
             safetyMarginTokens: margin,
             historyTokens,
             historyChars: historyCharsCap,
-            hardCeilingChars: ceil.value,
-            hardCeilingExplicit: ceil.explicit,
-            hardCeilingMessages: ceilMsgs,
-            effectiveMaxChars,
-            effectiveMaxMessages: ceilMsgs,
         };
     }
     function usage(history, lastPromptTokens) {
@@ -340,11 +162,7 @@ export function createContextManager(opts) {
     function needsCompaction(loadTokens) {
         return shouldAutoCompact(loadTokens, model, pct);
     }
-    function trimForSend(history, notify, reserve, todoNeedles = []) {
-        const b = budget(history);
-        return truncateHistoryWithCaps(history, { maxMessages: b.effectiveMaxMessages, maxChars: b.effectiveMaxChars }, { notify, reserve, todoNeedles });
-    }
-    return { model, budget, usage, needsCompaction, trimForSend };
+    return { model, budget, usage, needsCompaction };
 }
 const ledgerByRaw = new WeakMap();
 const ledgerByProxy = new WeakMap();

package/dist/context-windows.js

@@ -77,7 +77,9 @@ export function contextWindowFor(model) {
     return CONTEXT_WINDOWS[model];
 }
 // Total session tokens: prefer usage.total_tokens when present, else
-// prompt_tokens + completion_tokens (missing keys count as 0).
+// prompt_tokens + completion_tokens (missing keys count as 0). prompt_tokens
+// is normalized at parse time to total input-side tokens (exclusive
+// prefix-cache counters folded in), so both paths count cached context.
 export function totalTokens(usage) {
     if (typeof usage.total_tokens === "number") {
         return Math.max(0, Math.floor(usage.total_tokens));
@@ -90,7 +92,7 @@ export function totalTokens(usage) {
 // - no usage reported yet: `token: n/a` (never estimated)
 // - known window: `token: (P%) NK` (NK = round(total/1024) + "K" from the
 //   CUMULATIVE session spend; P = round(100*load/window) from the CURRENT
-//   context load — prompt_tokens of the last POST, else the 4ch/token
+//   context load — input-side tokens of the last POST, else the 4ch/token
 //   estimate. Cumulative spend keeps growing after compaction, so it must
 //   NOT drive P; load does. Pass load explicitly; when omitted it falls
 //   back to the cumulative total for backward compat.)

package/dist/env-block.js

@@ -3,17 +3,18 @@
 // timestamp.
 //
 // Placement: pinned to the SYSTEM message only (suffix to history[0]'s
-// content via withEnvBlock), NEVER into user content. history[0] is the only
-// slot truncateHistory never drops, so the block survives budget trimming.
-// Caching: the App refreshes history[0] once per turn in submit() (before the
-// budget check, so truncation accounts for it) — the loop's up-to-30 POSTs
-// reuse the same history[0], so git is shelled at most once per turn.
+// content via withEnvBlock), NEVER into user content. history[0] is the
+// system prompt, so the block survives every turn.
+// Caching: the App refreshes history[0] once per turn in submit() — the
+// loop's POSTs reuse the same history[0], so git is shelled at most once
+// per turn.
 // Failure-silent: missing git / non-repo cwd / timeout → the block shrinks
 // (cwd + node + time only), never throws, never blocks the turn. No new
 // dependencies; one cheap `git status` invocation with a short timeout, and
 // zero shell-outs when `.git` is absent.
 import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 // Cap for the block itself (~500 chars per the task). The base system prompt
 // (SYSTEM_PROMPT + AGENTS.md overlay) is untouched by this cap.
@@ -30,8 +31,9 @@ function shortCwd(cwd) {
     return `…${cwd.slice(cwd.length - (CWD_DISPLAY_CAP - 1))}`;
 }
 // Pure formatter (no I/O): always `cwd + node + time`, plus
-// `branch + status` only when git reported them. Capped to
-// ENV_BLOCK_CHAR_CAP (cwd is pre-truncated so time/node survive the cap).
+// `branch + status` only when git reported them, plus the operating context
+// (`os + shell + user`) when provided. Capped to ENV_BLOCK_CHAR_CAP (cwd is
+// pre-truncated so time/node survive the cap).
 export function buildEnvBlock(parts) {
     const cwd = shortCwd(parts.cwd);
     const git = parts.branch !== undefined &&
@@ -39,7 +41,10 @@ export function buildEnvBlock(parts) {
         parts.branch.length > 0
         ? ` branch=${parts.branch} status=${parts.status ?? "unknown"}`
         : "";
-    const block = `[env cwd=${cwd}${git} node=${parts.nodeVersion} time=${parts.timestamp}]`;
+    const machine = parts.os !== undefined && parts.os !== null && parts.os.length > 0
+        ? ` os=${parts.os} shell=${parts.shell ?? "unknown"} user=${parts.user ?? "unknown"}`
+        : "";
+    const block = `[env cwd=${cwd}${git}${machine} node=${parts.nodeVersion} time=${parts.timestamp}]`;
     return block.length > ENV_BLOCK_CHAR_CAP
         ? `${block.slice(0, ENV_BLOCK_CHAR_CAP - 1)}]`
         : block;
@@ -117,12 +122,45 @@ export function getEnvBlock(cwd = process.cwd()) {
         catch {
             git = null;
         }
+        // Operating context (best-effort, never throws): tells the model which
+        // shell runs its commands and who/where it is, so it stops probing with
+        // whoami/hostname and guessing `ls` vs `dir` (measured: 2–4 wasted bash
+        // calls per task before this existed).
+        let osName = "unknown";
+        try {
+            if (typeof process.platform === "string" && process.platform.length > 0) {
+                osName = process.platform;
+            }
+        }
+        catch {
+            // keep fallback
+        }
+        let shell = "unknown";
+        try {
+            shell = process.platform === "win32" ? "cmd.exe" : "sh";
+        }
+        catch {
+            // keep fallback
+        }
+        let user = "unknown";
+        try {
+            const name = os.userInfo?.().username;
+            if (typeof name === "string" && name.length > 0) {
+                user = name;
+            }
+        }
+        catch {
+            // keep fallback (sandboxed runtimes may forbid userInfo)
+        }
         return buildEnvBlock({
             cwd: dir,
             branch: git?.branch ?? null,
             status: git?.status ?? null,
             nodeVersion,
             timestamp,
+            os: osName,
+            shell,
+            user,
         });
     }
     catch {

package/dist/extension-commands.js

@@ -0,0 +1,196 @@
+// Extension slash commands (ticket 04): the runtime store behind
+// ExtensionAPI.registerCommand. Dependency-free (no imports) like
+// tools/custom.ts and tools/intercept.ts, so the extension host and the App
+// slash dispatch share it with no cycle: extensions register here, the App
+// lists/parses/runs here, nobody imports the other.
+//
+// A command is a real slash command (`/name args...`): it appears in the
+// command palette and the "/" menu, takes typed free-text arguments, and
+// runs extension code OUTSIDE the model turn loop with a generation-bound
+// context (prompt the user, read a session snapshot, post messages).
+//
+// Semantics:
+// - Names are bare in the definition ("deploy") and slash-prefixed at the
+//   seam ("/deploy"). Lowercase [a-z0-9_-] only, mirroring builtin style so
+//   menu/palette matching stays exact and case-free.
+// - Collision decision: builtins always win. The host rejects a colliding
+//   name at activation (loud error, nothing commits) and App dispatch
+//   routes builtins first as backstop — a builtin is never shadowed, and
+//   there is no renamed form to discover. Duplicate extension names throw
+//   the same way (first registration wins, deterministically by load order).
+// - Handlers never touch model history: say() stages messages and the
+//   runner commits them only on success. A throwing handler drops the
+//   stage and surfaces a clean `Error:` string — the session is untouched.
+// - The context is generation-bound: every ctx call runs checkStale first,
+//   so use after a session replacement throws loudly instead of acting on
+//   the wrong session (same rule as the event API).
+const NAME_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const store = new Map();
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorText(e) {
+    return e instanceof Error ? e.message : String(e ?? "unknown error");
+}
+/**
+ * Validate a registration shape. Throws Error on any problem (bad name,
+ * empty description, non-function handler). Duplicate and builtin-
+ * collision checks live with the callers that own those names (the store
+ * owns extension names; the host owns the builtin set).
+ */
+export function validateExtensionCommandDef(def) {
+    if (!isRecord(def))
+        throw new Error("extension command definition must be an object");
+    if (typeof def.name !== "string" || !NAME_RE.test(def.name)) {
+        throw new Error(`extension command has an invalid name ${JSON.stringify(def.name)} (want a bare 1-64 char a-z0-9_- name, no leading slash)`);
+    }
+    if (typeof def.description !== "string" || def.description.trim().length === 0) {
+        throw new Error(`extension command "/${def.name}" needs a non-empty description`);
+    }
+    if (typeof def.handler !== "function") {
+        throw new Error(`extension command "/${def.name}" needs a handler function`);
+    }
+}
+/** Register a validated command. Throws on duplicate names. Returns an unregister function. */
+export function registerExtensionCommand(def, owner = "(unknown)") {
+    validateExtensionCommandDef(def);
+    if (store.has(def.name)) {
+        throw new Error(`extension command "/${def.name}" is already registered`);
+    }
+    const rec = {
+        name: def.name,
+        description: def.description,
+        handler: def.handler,
+        owner,
+    };
+    store.set(def.name, rec);
+    let live = true;
+    return () => {
+        if (!live)
+            return;
+        live = false;
+        if (store.get(def.name) === rec)
+            store.delete(def.name);
+    };
+}
+export function unregisterExtensionCommand(name) {
+    return store.delete(name);
+}
+export function getExtensionCommand(name) {
+    return store.get(name);
+}
+/** Live commands in registration order (deterministic menu/palette order). */
+export function listExtensionCommands() {
+    return [...store.values()];
+}
+/** Test seam: drop every extension command. */
+export function clearExtensionCommands() {
+    store.clear();
+}
+// Split "/name args..." into its bare name and raw args. Returns null for
+// anything that is not a single-line slash invocation (plain text, a bare
+// "/", multiline, namespaced skill forms like "/skill:dep" — the name must
+// be followed by whitespace or end, so skill routing is never disturbed).
+export function parseExtensionCommandInput(text) {
+    if (!text.startsWith("/") || text.length < 2)
+        return null;
+    if (/[\r\n]/.test(text))
+        return null;
+    const match = /^\/([A-Za-z0-9_-]+)(?:[ \t]+([\s\S]*))?$/.exec(text);
+    if (!match)
+        return null;
+    return { name: match[1], args: (match[2] ?? "").trim() };
+}
+// Whitespace tokenizer for ctx.argv: double/single quotes group words, the
+// quotes are stripped, no escape processing (documented, not shell).
+export function splitCommandArgs(args) {
+    const out = [];
+    let cur = "";
+    let quote = null;
+    let has = false;
+    for (let i = 0; i < args.length; i++) {
+        const ch = args[i];
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                cur += ch;
+            }
+            has = true;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            has = true;
+            continue;
+        }
+        if (ch === " " || ch === "\t") {
+            if (has) {
+                out.push(cur);
+                cur = "";
+                has = false;
+            }
+            continue;
+        }
+        cur += ch;
+        has = true;
+    }
+    if (has)
+        out.push(cur);
+    return out;
+}
+// Run a registered command outside the model turn loop. Never throws for
+// handler failures: unknown names and throwing handlers return a clean
+// `Error:` result. say() output stages in a buffer and commits through
+// deps.say only on success, so a throwing handler leaves the session
+// untouched. Every context call runs checkStale first — stale use throws
+// into the same clean-error path instead of acting on the wrong session.
+export async function runExtensionCommand(name, rawArgs, deps) {
+    const rec = store.get(name);
+    if (!rec) {
+        return { ok: false, error: `Error: unknown extension command "/${name}" (not registered)` };
+    }
+    const stale = deps.checkStale ?? (() => undefined);
+    const staged = [];
+    const ctx = {
+        name,
+        args: rawArgs,
+        argv: splitCommandArgs(rawArgs),
+        cwd: deps.cwd ?? process.cwd(),
+        askUser: async (question, options, allowCustom) => {
+            stale();
+            return deps.askUser(question, options, allowCustom);
+        },
+        getSession: () => {
+            stale();
+            return deps.getSession();
+        },
+        say: (message) => {
+            stale();
+            if (typeof message !== "string") {
+                throw new Error(`extension command "/${name}" say() needs a string`);
+            }
+            if (message.length === 0)
+                return;
+            staged.push(message);
+        },
+    };
+    let returned;
+    try {
+        returned = await rec.handler(ctx);
+    }
+    catch (e) {
+        return { ok: false, error: `Error: extension command "/${name}" failed: ${errorText(e)}` };
+    }
+    if (typeof returned === "string" && returned.length > 0)
+        staged.push(returned);
+    try {
+        for (const message of staged)
+            deps.say(message);
+    }
+    catch (e) {
+        return { ok: false, error: `Error: extension command "/${name}" failed: ${errorText(e)}` };
+    }
+    return { ok: true, posted: staged.length };
+}