@songsid/agend 2.3.2-beta.1 → 2.3.2-beta.10

package/dist/instance-lifecycle.d.ts

@@ -18,7 +18,15 @@ import type { DeliveryOutbox } from "./delivery-outbox.js";
 export { isFleetStartCommandLine } from "./fleet-lock.js";
 export interface BackendInstallationInfo {
     binary: string;
+    /** The install command shown to a person (to copy and run themselves). */
     install: string;
+    /**
+     * The same install when AgEnD runs it with nobody at the terminal (`/login`'s install window). Codex's
+     * install.sh asks "Start Codex now? [y/N]" (and, on a conflict, whether to uninstall) on /dev/tty, so a
+     * window nobody types into waits until the install times out; CODEX_NON_INTERACTIVE=1 skips both questions.
+     * Omitted: `install` runs as it is.
+     */
+    unattended?: string;
     /**
      * #1092: where this backend's own installer puts the binary, read from the
      * installer script itself. `/login`'s install verifies on a fresh login shell
@@ -193,6 +201,8 @@ export interface IncidentEventSource {
     isCodexLivePane?(): Promise<boolean>;
     /** Existing occurrence count used to preserve Codex capacity history on restart. */
     getErrorPatternOccurrenceCount?(type: "model_error", pattern: RegExp): number;
+    /** #2648: kiro only — what a model error on its current launch should do (restart once, say once, or nothing). */
+    kiroModelError?(): import("./backend/kiro-retired-model.js").KiroModelErrorVerdict | null;
     /** Present on real daemons; hang buttons attach only when it returns one. */
     getHangDetector?(): {
         on(event: string, handler: (...args: any[]) => void): unknown;
@@ -435,6 +445,15 @@ export declare class InstanceLifecycle {
      * up, and the operator needs to know which conversation each instance is in.
      */
     attachLaunchWarningHandler(name: string, daemon: IncidentEventSource): void;
+    /**
+     * The daemon gave up resuming after repeated startup failures and started a
+     * fresh conversation (#737, #749). Without this the only trace was an error
+     * line in daemon.log. Attached before start, because the startup spawn is
+     * where it happens; and never suppressed for a planned restart, which is
+     * exactly when the user expects the conversation to carry on. A ClassicBot's
+     * channel is the end user's chat, so its notice goes to General only.
+     */
+    attachContextLostHandler(name: string, daemon: IncidentEventSource): void;
     /**
      * Daemon delivery events → the status reaction on the inbound message. The
      * emoji for each status comes from config (#1005); this only names it.

package/dist/instance-lifecycle.js

@@ -8,7 +8,7 @@ import { execFileSync } from "node:child_process";
 import { join, basename, dirname, resolve, sep as pathSep } from "node:path";
 import { access } from "node:fs/promises";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
-import { DEFAULT_INSTANCE_CONFIG, getEffectiveInstanceDefaults, getTmuxSession } from "./config.js";
+import { DEFAULT_INSTANCE_CONFIG, getEffectiveInstanceDefaults, getTmuxSession, newInstanceKiroUi } from "./config.js";
 import { readStatuslineModel, uniqueInstanceName } from "./topic-commands.js";
 import { isModelCompatible } from "./backend/types.js";
 import { safeHandler } from "./safe-async.js";
@@ -39,6 +39,7 @@ export const BACKEND_INSTALLATION_INFO = {
     // a symlink into ~/.codex/packages/standalone/current/bin (#1092).
     codex: {
         binary: "codex", install: "curl -fsSL https://chatgpt.com/codex/install.sh | sh",
+        unattended: "curl -fsSL https://chatgpt.com/codex/install.sh | CODEX_NON_INTERACTIVE=1 sh",
         binDirs: (env, home) => [env.CODEX_INSTALL_DIR, localBin(home)].filter((d) => !!d),
     },
     opencode: { binary: "opencode", install: "curl -fsSL https://opencode.ai/install | bash", binDirs: (_env, home) => [join(home, ".opencode", "bin")] },
@@ -554,6 +555,27 @@ export class InstanceLifecycle {
                 this.ctx.notifyInstanceTopic(name, t("inst.backend_launch_warning", name, data.message));
         }, this.ctx.logger, `daemon.backend_launch_warning[${name}]`));
     }
+    /**
+     * The daemon gave up resuming after repeated startup failures and started a
+     * fresh conversation (#737, #749). Without this the only trace was an error
+     * line in daemon.log. Attached before start, because the startup spawn is
+     * where it happens; and never suppressed for a planned restart, which is
+     * exactly when the user expects the conversation to carry on. A ClassicBot's
+     * channel is the end user's chat, so its notice goes to General only.
+     */
+    attachContextLostHandler(name, daemon) {
+        daemon.on("context_lost", safeHandler((_name, reason, attempts) => {
+            this.ctx.eventLog?.insert(name, "context_lost", { reason, ...(attempts != null ? { attempts } : {}) });
+            this.ctx.logger.warn({ name, reason, attempts }, "Instance started a fresh conversation — previous context lost");
+            const tries = attempts != null ? String(attempts) : "?";
+            if (!this.ctx.isClassicInstance?.(name))
+                this.ctx.notifyInstanceTopic(name, t("inst.context_lost", name, tries));
+            const general = this.findGeneralInstance();
+            if (general && general !== name)
+                this.ctx.notifyInstanceTopic(general, t("inst.context_lost_general", name, tries));
+            this.ctx.webhookEmit("context_lost", name, { reason, ...(attempts != null ? { attempts } : {}) });
+        }, this.ctx.logger, `daemon.context_lost[${name}]`));
+    }
     /**
      * Daemon delivery events → the status reaction on the inbound message. The
      * emoji for each status comes from config (#1005); this only names it.
@@ -787,9 +809,8 @@ export class InstanceLifecycle {
                 recovered: data.recovered,
                 ...(data.recoveryStarted ? { recoveryStarted: true } : {}),
             });
-            // The reply guard posts its own immediate, exact-target status before
-            // asking for one recovery turn. Do not duplicate that with the older
-            // instance-topic malformed-call notice.
+            // The reply guard owns recovery and log-only detection. Do not duplicate
+            // a possible false alarm with the older instance-topic malformed-call notice.
             if (data.recoveryStarted)
                 return;
             const notificationTarget = this.ptyErrorNotificationTarget(name);
@@ -803,6 +824,7 @@ export class InstanceLifecycle {
                 generation: data.generation,
                 reason: data.reason,
                 recoveryStarted: data.recoveryStarted,
+                ...(data.message ? { message: data.message } : {}),
             });
             this.ctx.logger.warn(data, "Turn ended without an adapter-confirmed reply");
         }, this.ctx.logger, `daemon.reply_drop_detected[${name}]`));
@@ -818,6 +840,7 @@ export class InstanceLifecycle {
                 correlationId: data.correlationId,
                 generation: data.generation,
                 reason: data.reason,
+                ...(data.message ? { message: data.message } : {}),
             });
             this.ctx.logger.error(data, "Reply-drop recovery ended without a delivered reply");
         }, this.ctx.logger, `daemon.reply_drop_unrecovered[${name}]`));
@@ -989,15 +1012,30 @@ export class InstanceLifecycle {
                     return;
                 }
             }
+            // #2648: a kiro model error — the resumed conversation's saved model retired, or the instance's own model
+            // unavailable. Restart once on kiro's default (no model of its own), else say it once; never on every start.
+            const kiroVerdict = data.type === "model_error" && this.backendOf(name) === "kiro-cli" ? daemon.kiroModelError?.() ?? null : null;
+            if (kiroVerdict?.kind === "restart") {
+                this.ctx.logger.warn({ name, model: kiroVerdict.model }, "kiro model unavailable on a resumed conversation — restarting once on kiro's default model");
+                this.ctx.clearCancelButton(name);
+                this.ctx.restartSingleInstance(name).catch(err => this.ctx.logger.error({ err, name }, "kiro model-switch restart failed"));
+                return;
+            }
+            if (kiroVerdict?.kind === "quiet") {
+                this.ctx.logger.info({ name }, "kiro model unavailable — already said for this conversation and model");
+                return;
+            }
             const emoji = data.type === "rate_limit" || data.type === "timeout" ? "⏳" : data.type === "auth_error" ? "🔑" : "⚠️";
-            const incidentMessage = data.type === "model_error" && this.backendOf(name) === "claude-code"
-                ? (() => {
-                    const liveModel = readStatuslineModel(this.ctx.dataDir, name);
-                    return liveModel
-                        ? t("inst.claude_model_fallback", liveModel)
-                        : t("inst.claude_model_unavailable");
-                })()
-                : data.message;
+            const incidentMessage = kiroVerdict?.kind === "notify"
+                ? (kiroVerdict.configured ? t("kiro.model_unavailable_configured", name, kiroVerdict.configured) : t("kiro.model_unavailable_once", name))
+                : data.type === "model_error" && this.backendOf(name) === "claude-code"
+                    ? (() => {
+                        const liveModel = readStatuslineModel(this.ctx.dataDir, name);
+                        return liveModel
+                            ? t("inst.claude_model_fallback", liveModel)
+                            : t("inst.claude_model_unavailable");
+                    })()
+                    : data.message;
             const notificationTarget = this.ptyErrorNotificationTarget(name);
             // Auth failures are a property of the BACKEND's shared credentials, not of
             // one instance: every instance on that CLI fails at once, and one re-login
@@ -1363,6 +1401,7 @@ export class InstanceLifecycle {
         // warning synchronously inside Daemon.start, long before
         // attachIncidentHandlers runs (#984).
         this.attachLaunchWarningHandler(name, daemon);
+        this.attachContextLostHandler(name, daemon);
         daemon.on("durable_delivery_deferred", (data) => {
             // A daemon without its outbox port cannot update the row directly. The
             // lifecycle owns the same-process store and records a bounded pre-write
@@ -2110,6 +2149,10 @@ export class InstanceLifecycle {
                 && !isModelCompatible(instanceConfig.backend, instanceConfig.model)) {
                 delete instanceConfig.model;
             }
+            // #2598: a new kiro instance is written with the TUI engine, explicitly (an unset one is classic).
+            const newKiroUi = newInstanceKiroUi(instanceConfig.backend, this.ctx.fleetConfig?.defaults);
+            if (newKiroUi)
+                instanceConfig.kiro_ui = newKiroUi;
             createdConfig = instanceConfig;
             const beforeCreate = structuredClone(this.ctx.fleetConfig);
             const persist = () => {