volute 0.48.0 → 0.50.0

package/templates/pi/src/lib/event-handler.ts

@@ -137,15 +137,28 @@ export function createEventHandler(session: EventSession, options: EventHandlerO
 
       if (event.type === "agent_end") {
         flushBuffers();
-        if (session.currentMessageId) {
-          session.messageChannels.delete(session.currentMessageId);
+        // Capture the turn's message context before clearing it: the ordered error/done
+        // emits below run asynchronously, but currentMessageId must be reset synchronously
+        // so the next turn shifts a fresh id (see the currentMessageId guard above).
+        const messageId = session.currentMessageId;
+        if (messageId) {
+          session.messageChannels.delete(messageId);
         }
+        const channel = messageId ? session.messageChannels.get(messageId)?.channel : undefined;
         log("mind", `session "${session.name}": turn done`);
-        // Log any error messages from the agent
+        // Collect any agent-level errors (e.g. a provider 401 reported inside agent_end).
+        // Warn-logging alone left the failure invisible at every host surface (#619);
+        // we emit a turn_error to the daemon too — mirroring the dispatch-rejection path in
+        // agent.ts — so classify() tags it and chat status + lastError surface it. Dedupe
+        // identical messages so a turn with several failed messages records one notice.
+        const errorMessages: string[] = [];
         if (event.messages) {
+          const seen = new Set<string>();
           for (const msg of event.messages as AgentEndMessage[]) {
-            if (msg.errorMessage) {
+            if (msg.errorMessage && !seen.has(msg.errorMessage)) {
+              seen.add(msg.errorMessage);
               warn("mind", `session "${session.name}": agent error: ${msg.errorMessage}`);
+              errorMessages.push(msg.errorMessage);
             }
           }
         }
@@ -175,14 +188,42 @@ export function createEventHandler(session: EventSession, options: EventHandlerO
           }
         }
         options.broadcast({ type: "done" });
-        emit(session, { type: "done" });
         session.currentMessageId = undefined;
+        // Emit any errors BEFORE done, awaiting each in turn. daemonEmit is fire-and-forget,
+        // so without ordered awaits the daemon could process `done` before `error`:
+        // markErrored would land after done consumed the errored flag, leaking it into the
+        // next turn (whose clean done then wrongly skips clearing delivered notices). This
+        // mirrors agent.ts's awaited error-then-done ordering. Message context is captured
+        // above rather than read from the (now-cleared) session.
+        void (async () => {
+          for (const content of errorMessages) {
+            const ev = filterEvent(preset, {
+              type: "error",
+              session: session.name,
+              channel,
+              messageId,
+              content,
+            });
+            if (ev) await daemonEmit(ev);
+          }
+          const doneEv = filterEvent(preset, {
+            type: "done",
+            session: session.name,
+            channel,
+            messageId,
+          });
+          if (doneEv) await daemonEmit(doneEv);
+        })().catch((err) =>
+          warn("mind", `session "${session.name}": error/done emit failed:`, err),
+        );
         flushFileChanges(options.cwd)
           .then(() => options.onTurnEnd?.())
           .catch((err) => log("mind", `session "${session.name}": flush/turn-end error:`, err));
       }
     } catch (err) {
-      log("mind", `session "${session.name}": event handler error (${event?.type}):`, err);
+      // warn-level: this block now drives turn-completion (error/done emission), so a throw
+      // here can hang a turn — it must not be buried at debug level.
+      warn("mind", `session "${session.name}": event handler error (${event?.type}):`, err);
     }
   };
 }

package/templates/pi/src/lib/reply-instructions-extension.ts

@@ -1,5 +1,6 @@
 import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import type { EventSession } from "./event-handler.js";
+import { firstReplyableEntry, isEventTurn } from "./event-turn.js";
 import { log } from "./logger.js";
 import { loadPrompts } from "./startup.js";
 
@@ -14,11 +15,37 @@ export function createReplyInstructionsExtension(
   const prompts = loadPrompts();
   return (pi) => {
     let fired = false;
+    let eventNoteFired = false;
     pi.on("before_agent_start", () => {
       try {
+        const entries = [...messageChannels.values()];
+
+        // System-event turn: ambient, from the environment, with no channel to reply to.
+        // The note fires once per session (see event-turn.ts for why).
+        if (isEventTurn(entries)) {
+          if (eventNoteFired) return {};
+          eventNoteFired = true;
+          const content = prompts.event_instructions;
+          if (emitContext && session) {
+            emitContext(session, {
+              type: "context",
+              content,
+              metadata: { source: "event-instructions" },
+            });
+          }
+          return {
+            message: {
+              customType: "event-instructions",
+              content,
+              display: true,
+            },
+          };
+        }
+
         if (fired) return {};
 
-        const entry = messageChannels.values().next().value;
+        // Reply instructions must name a channel the mind can actually send to.
+        const entry = firstReplyableEntry(entries);
         if (!entry) return {};
 
         fired = true;

package/dist/chunk-5KXCM5AW.js

@@ -1,169 +0,0 @@
-#!/usr/bin/env node
-import {
-  voluteSystemDir
-} from "./chunk-WW6C3PLV.js";
-
-// packages/daemon/src/lib/config/setup.ts
-import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
-import { resolve } from "path";
-function configPath() {
-  return resolve(voluteSystemDir(), "config.json");
-}
-function secretsPath() {
-  return resolve(voluteSystemDir(), "secrets.json");
-}
-function hasEntries(obj) {
-  return !!obj && Object.keys(obj).length > 0;
-}
-function splitConfig(config) {
-  const publicConfig = { ...config };
-  const secrets = {};
-  if (config.ai) {
-    const { providers, ...rest } = config.ai;
-    publicConfig.ai = { ...rest, providers: {} };
-    if (hasEntries(providers)) secrets.ai = { providers };
-  }
-  if (config.imagegen) {
-    const { providers, ...rest } = config.imagegen;
-    publicConfig.imagegen = { ...rest };
-    if (providers && Object.keys(providers).length > 0) secrets.imagegen = { providers };
-  }
-  if (config.backup) {
-    const { password, env, ...rest } = config.backup;
-    publicConfig.backup = { ...rest };
-    if (password || hasEntries(env)) {
-      secrets.backup = {};
-      if (password) secrets.backup.password = password;
-      if (hasEntries(env)) secrets.backup.env = env;
-    }
-  }
-  return { publicConfig, secrets };
-}
-function mergeSecrets(publicConfig, secrets) {
-  const merged = { ...publicConfig };
-  if (secrets.ai?.providers) {
-    merged.ai = { ...merged.ai ?? { providers: {} }, providers: secrets.ai.providers };
-  }
-  if (secrets.imagegen?.providers) {
-    merged.imagegen = { ...merged.imagegen ?? {}, providers: secrets.imagegen.providers };
-  }
-  if (secrets.backup) {
-    merged.backup = { ...merged.backup ?? {}, ...secrets.backup };
-  }
-  return merged;
-}
-function readSecrets() {
-  const path = secretsPath();
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-var _cachedConfig = null;
-var CONFIG_CACHE_TTL = 2e3;
-function _resetConfigCache() {
-  _cachedConfig = null;
-}
-function readGlobalConfig() {
-  if (_cachedConfig && Date.now() - _cachedConfig.ts < CONFIG_CACHE_TTL) {
-    return { ..._cachedConfig.config };
-  }
-  const path = configPath();
-  if (!existsSync(path)) {
-    _cachedConfig = null;
-    return {};
-  }
-  let publicConfig;
-  try {
-    publicConfig = JSON.parse(readFileSync(path, "utf-8"));
-  } catch (err) {
-    console.error(`Failed to parse ${path}: ${err instanceof Error ? err.message : err}`);
-    return {};
-  }
-  const config = mergeSecrets(publicConfig, readSecrets());
-  _cachedConfig = { config, ts: Date.now() };
-  return config;
-}
-function writeGlobalConfig(config) {
-  mkdirSync(voluteSystemDir(), { recursive: true });
-  const { publicConfig, secrets } = splitConfig(config);
-  const cfgPath = configPath();
-  writeFileSync(cfgPath, `${JSON.stringify(publicConfig, null, 2)}
-`, { mode: 420 });
-  chmodSync(cfgPath, 420);
-  const secPath = secretsPath();
-  writeFileSync(secPath, `${JSON.stringify(secrets, null, 2)}
-`, { mode: 384 });
-  chmodSync(secPath, 384);
-  _cachedConfig = { config, ts: Date.now() };
-}
-function migrateConfigSecrets() {
-  const path = configPath();
-  if (!existsSync(path)) return;
-  let raw;
-  try {
-    raw = readFileSync(path, "utf-8");
-  } catch {
-    return;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return;
-  }
-  const embedsSecrets = hasEntries(parsed.ai?.providers) || hasEntries(parsed.imagegen?.providers) || !!parsed.backup?.password || hasEntries(parsed.backup?.env);
-  const mode = statSync(path).mode & 511;
-  if (!embedsSecrets && mode === 420) return;
-  _resetConfigCache();
-  writeGlobalConfig(readGlobalConfig());
-}
-function setupStatus() {
-  const config = readGlobalConfig();
-  if (config.setupCompleted === true) return "complete";
-  if (config.setup != null && config.setupCompleted == null) return "complete";
-  if (config.setup != null) return "in-progress";
-  return "none";
-}
-function isSetupComplete() {
-  return setupStatus() === "complete";
-}
-function setupUrl() {
-  const config = readGlobalConfig();
-  const port = config.port || 1618;
-  let host = config.hostname || "127.0.0.1";
-  if (host === "0.0.0.0" || host === "::") host = "localhost";
-  if (host.includes(":") && !host.startsWith("[")) host = `[${host}]`;
-  return `http://${host}:${port}`;
-}
-function isImagegenEnabled() {
-  const config = readGlobalConfig();
-  const ig = config.imagegen;
-  if (!ig) return false;
-  if (ig.enabled === true) return true;
-  if (ig.providers && Object.keys(ig.providers).length > 0) return true;
-  return false;
-}
-function migrateSetupCompleted() {
-  const config = readGlobalConfig();
-  if (config.setup != null && config.setupCompleted == null) {
-    config.setupCompleted = true;
-    writeGlobalConfig(config);
-  }
-}
-
-export {
-  configPath,
-  secretsPath,
-  _resetConfigCache,
-  readGlobalConfig,
-  writeGlobalConfig,
-  migrateConfigSecrets,
-  setupStatus,
-  isSetupComplete,
-  setupUrl,
-  isImagegenEnabled,
-  migrateSetupCompleted
-};

package/dist/chunk-IYCV34IU.js

@@ -1,158 +0,0 @@
-#!/usr/bin/env node
-import {
-  logger_default
-} from "./chunk-T2TP6ZC6.js";
-import {
-  getDb
-} from "./chunk-WW6C3PLV.js";
-import {
-  mindNotices,
-  turns
-} from "./chunk-2MJ7EOMT.js";
-
-// packages/daemon/src/lib/daemon/notices.ts
-import { and, asc, desc, eq, gt, inArray, lte, or, sql } from "drizzle-orm";
-var nlog = logger_default.child("notices");
-var MIND_LEVEL_SESSION = "";
-var MAX_NOTICES_PER_SESSION = 100;
-async function recordNotice(input) {
-  try {
-    const db = await getDb();
-    await db.insert(mindNotices).values({
-      mind: input.mind,
-      session: input.session,
-      kind: input.kind,
-      reason: input.reason,
-      detail: input.detail,
-      raw: input.raw ?? null
-    });
-    await db.run(
-      sql`DELETE FROM mind_notices WHERE mind = ${input.mind} AND session = ${input.session} AND id NOT IN (SELECT id FROM mind_notices WHERE mind = ${input.mind} AND session = ${input.session} ORDER BY id DESC LIMIT ${MAX_NOTICES_PER_SESSION})`
-    );
-  } catch (err) {
-    nlog.error(`failed to record notice for ${input.mind}:${input.session}`, logger_default.errorData(err));
-  }
-}
-async function drainNotices(mind, session, limit = MAX_NOTICES_PER_SESSION) {
-  const db = await getDb();
-  return db.select().from(mindNotices).where(
-    and(
-      eq(mindNotices.mind, mind),
-      or(eq(mindNotices.session, session), eq(mindNotices.session, MIND_LEVEL_SESSION))
-    )
-  ).orderBy(asc(mindNotices.id)).limit(limit);
-}
-var FAILURE_KINDS = ["turn_error", "crash", "startup"];
-var failureReadErrorLogged = false;
-async function latestFailureNotice(mind) {
-  try {
-    const db = await getDb();
-    const rows = await db.select().from(mindNotices).where(and(eq(mindNotices.mind, mind), inArray(mindNotices.kind, [...FAILURE_KINDS]))).orderBy(desc(mindNotices.id)).limit(1);
-    const n = rows[0];
-    if (!n) return null;
-    const recovered = await db.select({ id: turns.id }).from(turns).where(
-      and(eq(turns.mind, mind), eq(turns.status, "complete"), gt(turns.created_at, n.created_at))
-    ).limit(1);
-    if (recovered.length > 0) return null;
-    return {
-      kind: n.kind,
-      reason: n.reason,
-      detail: n.detail,
-      at: n.created_at
-    };
-  } catch (err) {
-    if (!failureReadErrorLogged) {
-      failureReadErrorLogged = true;
-      nlog.error(`failed to read latest failure notice for ${mind}`, logger_default.errorData(err));
-    }
-    return null;
-  }
-}
-async function latestNotice(mind) {
-  const db = await getDb();
-  const row = await db.select().from(mindNotices).where(eq(mindNotices.mind, mind)).orderBy(desc(mindNotices.id)).limit(1).get();
-  return row ?? null;
-}
-async function hasUndeliveredNotice(mind, reason) {
-  const db = await getDb();
-  const row = await db.select({ id: mindNotices.id }).from(mindNotices).where(and(eq(mindNotices.mind, mind), eq(mindNotices.reason, reason))).limit(1).get();
-  return row != null;
-}
-async function clearDeliveredNotices(mind, session, uptoId) {
-  try {
-    const db = await getDb();
-    await db.delete(mindNotices).where(
-      and(
-        eq(mindNotices.mind, mind),
-        or(eq(mindNotices.session, session), eq(mindNotices.session, MIND_LEVEL_SESSION)),
-        lte(mindNotices.id, uptoId)
-      )
-    );
-  } catch (err) {
-    nlog.warn(`failed to clear delivered notices for ${mind}:${session}`, logger_default.errorData(err));
-  }
-}
-var NOTICE_HEADER = "[Notices] While you were unavailable, one or more turns failed. You're back now:";
-function formatNotices(notices) {
-  if (notices.length === 0) return null;
-  const failures = notices.filter((n) => n.kind !== "extension" && n.kind !== "budget");
-  const budgets = notices.filter((n) => n.kind === "budget");
-  const extensions = notices.filter((n) => n.kind === "extension");
-  const blocks = [];
-  if (failures.length > 0) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const n of failures) {
-      const time = localHM(n.created_at);
-      const g = groups.get(n.reason);
-      if (g) {
-        g.count += 1;
-        g.detail = n.detail;
-        g.last = time;
-      } else {
-        groups.set(n.reason, { count: 1, detail: n.detail, first: time, last: time });
-      }
-    }
-    const lines = [...groups.values()].map((g) => {
-      const span = g.first === g.last ? g.first : `${g.first}\u2013${g.last}`;
-      const plural = g.count === 1 ? "turn" : "turns";
-      return `- ${g.count} ${plural} failed (${span}): ${g.detail}`;
-    });
-    blocks.push(`${NOTICE_HEADER}
-${lines.join("\n")}`);
-  }
-  if (budgets.length > 0) {
-    const lines = budgets.map((n) => `- ${localHM(n.created_at)} ${n.detail}`);
-    blocks.push(`[Budget]
-${lines.join("\n")}`);
-  }
-  if (extensions.length > 0) {
-    const byExt = /* @__PURE__ */ new Map();
-    for (const n of extensions) {
-      const arr = byExt.get(n.reason);
-      if (arr) arr.push(n);
-      else byExt.set(n.reason, [n]);
-    }
-    for (const [ext, items] of byExt) {
-      const header = `[${ext.charAt(0).toUpperCase()}${ext.slice(1)}]`;
-      const lines = items.map((n) => `- ${localHM(n.created_at)} ${n.detail}`);
-      blocks.push(`${header}
-${lines.join("\n")}`);
-    }
-  }
-  return blocks.join("\n\n");
-}
-function localHM(createdAt) {
-  const iso = createdAt.endsWith("Z") ? createdAt : `${createdAt.replace(" ", "T")}Z`;
-  return new Date(iso).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
-}
-
-export {
-  MIND_LEVEL_SESSION,
-  recordNotice,
-  drainNotices,
-  latestFailureNotice,
-  latestNotice,
-  hasUndeliveredNotice,
-  clearDeliveredNotices,
-  formatNotices
-};