@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/commands/agent.js

@@ -1,38 +1,123 @@
-import { listAgentIds, resolveAgentDir, resolveAgentModelFallbacksOverride, resolveAgentModelPrimary, resolveAgentWorkspaceDir, } from "../agents/agent-scope.js";
+import path from "node:path";
+import { listAgentIds, resolveAgentDir, resolveEffectiveModelFallbacks, resolveAgentModelPrimary, resolveAgentSkillsFilter, resolveAgentWorkspaceDir, } from "../agents/agent-scope.js";
 import { ensureAuthProfileStore } from "../agents/auth-profiles.js";
+import { clearSessionAuthProfileOverride } from "../agents/auth-profiles/session-override.js";
 import { runCliAgent } from "../agents/cli-runner.js";
 import { getCliSessionId } from "../agents/cli-session.js";
 import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../agents/defaults.js";
+import { AGENT_LANE_SUBAGENT } from "../agents/lanes.js";
 import { loadModelCatalog } from "../agents/model-catalog.js";
 import { runWithModelFallback } from "../agents/model-fallback.js";
-import { buildAllowedModelSet, isCliProvider, modelKey, resolveConfiguredModelRef, resolveThinkingDefault, } from "../agents/model-selection.js";
+import { buildAllowedModelSet, isCliProvider, modelKey, normalizeModelRef, resolveConfiguredModelRef, resolveThinkingDefault, } from "../agents/model-selection.js";
 import { runEmbeddedPiAgent } from "../agents/pi-embedded.js";
 import { buildWorkspaceSkillSnapshot } from "../agents/skills.js";
 import { getSkillsSnapshotVersion } from "../agents/skills/refresh.js";
 import { resolveAgentTimeoutMs } from "../agents/timeout.js";
 import { ensureAgentWorkspace } from "../agents/workspace.js";
 import { formatThinkingLevels, formatXHighModelHint, normalizeThinkLevel, normalizeVerboseLevel, supportsXHighThinking, } from "../auto-reply/thinking.js";
+import { formatCliCommand } from "../cli/command-format.js";
 import { createDefaultDeps } from "../cli/deps.js";
 import { loadConfig } from "../config/config.js";
-import { resolveAgentIdFromSessionKey, resolveSessionFilePath, updateSessionStore, } from "../config/sessions.js";
+import { parseSessionThreadInfo, resolveAndPersistSessionFile, resolveAgentIdFromSessionKey, resolveSessionFilePath, resolveSessionTranscriptPath, updateSessionStore, } from "../config/sessions.js";
 import { clearAgentRunContext, emitAgentEvent, registerAgentRunContext, } from "../infra/agent-events.js";
 import { getRemoteSkillEligibility } from "../infra/skills-remote.js";
+import { normalizeAgentId } from "../routing/session-key.js";
 import { defaultRuntime } from "../runtime.js";
-import { formatCliCommand } from "../cli/command-format.js";
 import { applyVerboseOverride } from "../sessions/level-overrides.js";
-import { resolveSendPolicy } from "../sessions/send-policy.js";
 import { applyModelOverrideToSessionEntry } from "../sessions/model-overrides.js";
-import { clearSessionAuthProfileOverride } from "../agents/auth-profiles/session-override.js";
+import { resolveSendPolicy } from "../sessions/send-policy.js";
 import { resolveMessageChannel } from "../utils/message-channel.js";
 import { deliverAgentCommandResult } from "./agent/delivery.js";
 import { resolveAgentRunContext } from "./agent/run-context.js";
-import { resolveSession } from "./agent/session.js";
 import { updateSessionStoreAfterAgentRun } from "./agent/session-store.js";
-import { normalizeAgentId } from "../routing/session-key.js";
+import { resolveSession } from "./agent/session.js";
+async function persistSessionEntry(params) {
+    params.sessionStore[params.sessionKey] = params.entry;
+    await updateSessionStore(params.storePath, (store) => {
+        store[params.sessionKey] = params.entry;
+    });
+}
+function resolveFallbackRetryPrompt(params) {
+    if (!params.isFallbackRetry) {
+        return params.body;
+    }
+    return "Continue where you left off. The previous model attempt failed or timed out.";
+}
+function runAgentAttempt(params) {
+    const effectivePrompt = resolveFallbackRetryPrompt({
+        body: params.body,
+        isFallbackRetry: params.isFallbackRetry,
+    });
+    if (isCliProvider(params.providerOverride, params.cfg)) {
+        const cliSessionId = getCliSessionId(params.sessionEntry, params.providerOverride);
+        return runCliAgent({
+            sessionId: params.sessionId,
+            sessionKey: params.sessionKey,
+            agentId: params.sessionAgentId,
+            sessionFile: params.sessionFile,
+            workspaceDir: params.workspaceDir,
+            config: params.cfg,
+            prompt: effectivePrompt,
+            provider: params.providerOverride,
+            model: params.modelOverride,
+            thinkLevel: params.resolvedThinkLevel,
+            timeoutMs: params.timeoutMs,
+            runId: params.runId,
+            extraSystemPrompt: params.opts.extraSystemPrompt,
+            cliSessionId,
+            images: params.isFallbackRetry ? undefined : params.opts.images,
+            streamParams: params.opts.streamParams,
+        });
+    }
+    const authProfileId = params.providerOverride === params.primaryProvider
+        ? params.sessionEntry?.authProfileOverride
+        : undefined;
+    return runEmbeddedPiAgent({
+        sessionId: params.sessionId,
+        sessionKey: params.sessionKey,
+        agentId: params.sessionAgentId,
+        messageChannel: params.messageChannel,
+        agentAccountId: params.runContext.accountId,
+        messageTo: params.opts.replyTo ?? params.opts.to,
+        messageThreadId: params.opts.threadId,
+        groupId: params.runContext.groupId,
+        groupChannel: params.runContext.groupChannel,
+        groupSpace: params.runContext.groupSpace,
+        spawnedBy: params.spawnedBy,
+        currentChannelId: params.runContext.currentChannelId,
+        currentThreadTs: params.runContext.currentThreadTs,
+        replyToMode: params.runContext.replyToMode,
+        hasRepliedRef: params.runContext.hasRepliedRef,
+        senderIsOwner: true,
+        sessionFile: params.sessionFile,
+        workspaceDir: params.workspaceDir,
+        config: params.cfg,
+        skillsSnapshot: params.skillsSnapshot,
+        prompt: effectivePrompt,
+        images: params.isFallbackRetry ? undefined : params.opts.images,
+        clientTools: params.opts.clientTools,
+        provider: params.providerOverride,
+        model: params.modelOverride,
+        authProfileId,
+        authProfileIdSource: authProfileId ? params.sessionEntry?.authProfileOverrideSource : undefined,
+        thinkLevel: params.resolvedThinkLevel,
+        verboseLevel: params.resolvedVerboseLevel,
+        timeoutMs: params.timeoutMs,
+        runId: params.runId,
+        lane: params.opts.lane,
+        abortSignal: params.opts.abortSignal,
+        extraSystemPrompt: params.opts.extraSystemPrompt,
+        inputProvenance: params.opts.inputProvenance,
+        streamParams: params.opts.streamParams,
+        agentDir: params.agentDir,
+        onAgentEvent: params.onAgentEvent,
+    });
+}
 export async function agentCommand(opts, runtime = defaultRuntime, deps = createDefaultDeps()) {
     const body = (opts.message ?? "").trim();
-    if (!body)
+    if (!body) {
         throw new Error("Message (--message) is required");
+    }
     if (!opts.to && !opts.sessionId && !opts.sessionKey && !opts.agentId) {
         throw new Error("Pass --to <E.164>, --session-id, or --agent to choose a session");
     }
@@ -78,10 +163,16 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
     if (opts.verbose && !verboseOverride) {
         throw new Error('Invalid verbose level. Use "on", "full", or "off".');
     }
-    const timeoutSecondsRaw = opts.timeout !== undefined ? Number.parseInt(String(opts.timeout), 10) : undefined;
+    const laneRaw = typeof opts.lane === "string" ? opts.lane.trim() : "";
+    const isSubagentLane = laneRaw === String(AGENT_LANE_SUBAGENT);
+    const timeoutSecondsRaw = opts.timeout !== undefined
+        ? Number.parseInt(String(opts.timeout), 10)
+        : isSubagentLane
+            ? 0
+            : undefined;
     if (timeoutSecondsRaw !== undefined &&
-        (Number.isNaN(timeoutSecondsRaw) || timeoutSecondsRaw <= 0)) {
-        throw new Error("--timeout must be a positive integer (seconds)");
+        (Number.isNaN(timeoutSecondsRaw) || timeoutSecondsRaw < 0)) {
+        throw new Error("--timeout must be a non-negative integer (seconds; 0 means no timeout)");
     }
     const timeoutMs = resolveAgentTimeoutMs({
         cfg,
@@ -123,11 +214,13 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
         }
         const needsSkillsSnapshot = isNewSession || !sessionEntry?.skillsSnapshot;
         const skillsSnapshotVersion = getSkillsSnapshotVersion(workspaceDir);
+        const skillFilter = resolveAgentSkillsFilter(cfg, sessionAgentId);
         const skillsSnapshot = needsSkillsSnapshot
             ? buildWorkspaceSkillSnapshot(workspaceDir, {
                 config: cfg,
                 eligibility: { remote: getRemoteSkillEligibility() },
                 snapshotVersion: skillsSnapshotVersion,
+                skillFilter,
             })
             : sessionEntry?.skillsSnapshot;
         if (skillsSnapshot && sessionStore && sessionKey && needsSkillsSnapshot) {
@@ -141,9 +234,11 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
                 updatedAt: Date.now(),
                 skillsSnapshot,
             };
-            sessionStore[sessionKey] = next;
-            await updateSessionStore(storePath, (store) => {
-                store[sessionKey] = next;
+            await persistSessionEntry({
+                sessionStore,
+                sessionKey,
+                storePath,
+                entry: next,
             });
             sessionEntry = next;
         }
@@ -153,16 +248,16 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
                 sessionEntry ?? { sessionId, updatedAt: Date.now() };
             const next = { ...entry, sessionId, updatedAt: Date.now() };
             if (thinkOverride) {
-                if (thinkOverride === "off")
-                    delete next.thinkingLevel;
-                else
-                    next.thinkingLevel = thinkOverride;
+                next.thinkingLevel = thinkOverride;
             }
             applyVerboseOverride(next, verboseOverride);
-            sessionStore[sessionKey] = next;
-            await updateSessionStore(storePath, (store) => {
-                store[sessionKey] = next;
+            await persistSessionEntry({
+                sessionStore,
+                sessionKey,
+                storePath,
+                entry: next,
             });
+            sessionEntry = next;
         }
         const agentModelPrimary = resolveAgentModelPrimary(cfg, sessionAgentId);
         const cfgForModelSelection = agentModelPrimary
@@ -182,11 +277,12 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
                 },
             }
             : cfg;
-        const { provider: defaultProvider, model: defaultModel } = resolveConfiguredModelRef({
+        const configuredDefaultRef = resolveConfiguredModelRef({
             cfg: cfgForModelSelection,
             defaultProvider: DEFAULT_PROVIDER,
             defaultModel: DEFAULT_MODEL,
         });
+        const { provider: defaultProvider, model: defaultModel } = normalizeModelRef(configuredDefaultRef.provider, configuredDefaultRef.model);
         let provider = defaultProvider;
         let model = defaultModel;
         const hasAllowlist = agentCfg?.models && Object.keys(agentCfg.models).length > 0;
@@ -211,8 +307,9 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
             const overrideProvider = sessionEntry.providerOverride?.trim() || defaultProvider;
             const overrideModel = sessionEntry.modelOverride?.trim();
             if (overrideModel) {
-                const key = modelKey(overrideProvider, overrideModel);
-                if (!isCliProvider(overrideProvider, cfg) &&
+                const normalizedOverride = normalizeModelRef(overrideProvider, overrideModel);
+                const key = modelKey(normalizedOverride.provider, normalizedOverride.model);
+                if (!isCliProvider(normalizedOverride.provider, cfg) &&
                     allowedModelKeys.size > 0 &&
                     !allowedModelKeys.has(key)) {
                     const { updated } = applyModelOverrideToSessionEntry({
@@ -220,9 +317,11 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
                         selection: { provider: defaultProvider, model: defaultModel, isDefault: true },
                     });
                     if (updated) {
-                        sessionStore[sessionKey] = entry;
-                        await updateSessionStore(storePath, (store) => {
-                            store[sessionKey] = entry;
+                        await persistSessionEntry({
+                            sessionStore,
+                            sessionKey,
+                            storePath,
+                            entry,
                         });
                     }
                 }
@@ -232,12 +331,13 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
         const storedModelOverride = sessionEntry?.modelOverride?.trim();
         if (storedModelOverride) {
             const candidateProvider = storedProviderOverride || defaultProvider;
-            const key = modelKey(candidateProvider, storedModelOverride);
-            if (isCliProvider(candidateProvider, cfg) ||
+            const normalizedStored = normalizeModelRef(candidateProvider, storedModelOverride);
+            const key = modelKey(normalizedStored.provider, normalizedStored.model);
+            if (isCliProvider(normalizedStored.provider, cfg) ||
                 allowedModelKeys.size === 0 ||
                 allowedModelKeys.has(key)) {
-                provider = candidateProvider;
-                model = storedModelOverride;
+                provider = normalizedStored.provider;
+                model = normalizedStored.model;
             }
         }
         if (sessionEntry) {
@@ -281,15 +381,35 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
                 const entry = sessionEntry;
                 entry.thinkingLevel = "high";
                 entry.updatedAt = Date.now();
-                sessionStore[sessionKey] = entry;
-                await updateSessionStore(storePath, (store) => {
-                    store[sessionKey] = entry;
+                await persistSessionEntry({
+                    sessionStore,
+                    sessionKey,
+                    storePath,
+                    entry,
                 });
             }
         }
-        const sessionFile = resolveSessionFilePath(sessionId, sessionEntry, {
+        let sessionFile = resolveSessionFilePath(sessionId, sessionEntry, {
             agentId: sessionAgentId,
         });
+        if (sessionStore && sessionKey) {
+            const threadIdFromSessionKey = parseSessionThreadInfo(sessionKey).threadId;
+            const fallbackSessionFile = !sessionEntry?.sessionFile
+                ? resolveSessionTranscriptPath(sessionId, sessionAgentId, opts.threadId ?? threadIdFromSessionKey)
+                : undefined;
+            const resolvedSessionFile = await resolveAndPersistSessionFile({
+                sessionId,
+                sessionKey,
+                sessionStore,
+                storePath,
+                sessionEntry,
+                agentId: sessionAgentId,
+                sessionsDir: path.dirname(storePath),
+                fallbackSessionFile,
+            });
+            sessionFile = resolvedSessionFile.sessionFile;
+            sessionEntry = resolvedSessionFile.sessionEntry;
+        }
         const startedAt = Date.now();
         let lifecycleEnded = false;
         let result;
@@ -299,72 +419,48 @@ export async function agentCommand(opts, runtime = defaultRuntime, deps = create
             const runContext = resolveAgentRunContext(opts);
             const messageChannel = resolveMessageChannel(runContext.messageChannel, opts.replyChannel ?? opts.channel);
             const spawnedBy = opts.spawnedBy ?? sessionEntry?.spawnedBy;
+            // Keep fallback candidate resolution centralized so session model overrides,
+            // per-agent overrides, and default fallbacks stay consistent across callers.
+            const effectiveFallbacksOverride = resolveEffectiveModelFallbacks({
+                cfg,
+                agentId: sessionAgentId,
+                hasSessionModelOverride: Boolean(storedModelOverride),
+            });
+            // Track model fallback attempts so retries on an existing session don't
+            // re-inject the original prompt as a duplicate user message.
+            let fallbackAttemptIndex = 0;
             const fallbackResult = await runWithModelFallback({
                 cfg,
                 provider,
                 model,
                 agentDir,
-                fallbacksOverride: resolveAgentModelFallbacksOverride(cfg, sessionAgentId),
+                fallbacksOverride: effectiveFallbacksOverride,
                 run: (providerOverride, modelOverride) => {
-                    if (isCliProvider(providerOverride, cfg)) {
-                        const cliSessionId = getCliSessionId(sessionEntry, providerOverride);
-                        return runCliAgent({
-                            sessionId,
-                            sessionKey,
-                            sessionFile,
-                            workspaceDir,
-                            config: cfg,
-                            prompt: body,
-                            provider: providerOverride,
-                            model: modelOverride,
-                            thinkLevel: resolvedThinkLevel,
-                            timeoutMs,
-                            runId,
-                            extraSystemPrompt: opts.extraSystemPrompt,
-                            cliSessionId,
-                            images: opts.images,
-                            streamParams: opts.streamParams,
-                        });
-                    }
-                    const authProfileId = providerOverride === provider ? sessionEntry?.authProfileOverride : undefined;
-                    return runEmbeddedPiAgent({
+                    const isFallbackRetry = fallbackAttemptIndex > 0;
+                    fallbackAttemptIndex += 1;
+                    return runAgentAttempt({
+                        providerOverride,
+                        modelOverride,
+                        cfg,
+                        sessionEntry,
                         sessionId,
                         sessionKey,
-                        messageChannel,
-                        agentAccountId: runContext.accountId,
-                        messageTo: opts.replyTo ?? opts.to,
-                        messageThreadId: opts.threadId,
-                        groupId: runContext.groupId,
-                        groupChannel: runContext.groupChannel,
-                        groupSpace: runContext.groupSpace,
-                        spawnedBy,
-                        currentChannelId: runContext.currentChannelId,
-                        currentThreadTs: runContext.currentThreadTs,
-                        replyToMode: runContext.replyToMode,
-                        hasRepliedRef: runContext.hasRepliedRef,
-                        senderIsOwner: true,
+                        sessionAgentId,
                         sessionFile,
                         workspaceDir,
-                        config: cfg,
-                        skillsSnapshot,
-                        prompt: body,
-                        images: opts.images,
-                        clientTools: opts.clientTools,
-                        provider: providerOverride,
-                        model: modelOverride,
-                        authProfileId,
-                        authProfileIdSource: authProfileId
-                            ? sessionEntry?.authProfileOverrideSource
-                            : undefined,
-                        thinkLevel: resolvedThinkLevel,
-                        verboseLevel: resolvedVerboseLevel,
+                        body,
+                        isFallbackRetry,
+                        resolvedThinkLevel,
                         timeoutMs,
                         runId,
-                        lane: opts.lane,
-                        abortSignal: opts.abortSignal,
-                        extraSystemPrompt: opts.extraSystemPrompt,
-                        streamParams: opts.streamParams,
+                        opts,
+                        runContext,
+                        spawnedBy,
+                        messageChannel,
+                        skillsSnapshot,
+                        resolvedVerboseLevel,
                         agentDir,
+                        primaryProvider: provider,
                         onAgentEvent: (evt) => {
                             // Track lifecycle end for fallback emission below.
                             if (evt.stream === "lifecycle" &&

package/dist/commands/agents.bindings.js

@@ -15,14 +15,18 @@ function bindingMatchKey(match) {
 export function describeBinding(binding) {
     const match = binding.match;
     const parts = [match.channel];
-    if (match.accountId)
+    if (match.accountId) {
         parts.push(`accountId=${match.accountId}`);
-    if (match.peer)
+    }
+    if (match.peer) {
         parts.push(`peer=${match.peer.kind}:${match.peer.id}`);
-    if (match.guildId)
+    }
+    if (match.guildId) {
         parts.push(`guild=${match.guildId}`);
-    if (match.teamId)
+    }
+    if (match.teamId) {
         parts.push(`team=${match.teamId}`);
+    }
     return parts.join(" ");
 }
 export function applyAgentBindings(cfg, bindings) {
@@ -68,8 +72,9 @@ export function applyAgentBindings(cfg, bindings) {
 }
 function resolveDefaultAccountId(cfg, provider) {
     const plugin = getChannelPlugin(provider);
-    if (!plugin)
+    if (!plugin) {
         return DEFAULT_ACCOUNT_ID;
+    }
     return resolveChannelDefaultAccountId({ plugin, cfg });
 }
 export function buildChannelBindings(params) {
@@ -98,8 +103,9 @@ export function parseBindingSpecs(params) {
     const agentId = normalizeAgentId(params.agentId);
     for (const raw of specs) {
         const trimmed = raw?.trim();
-        if (!trimmed)
+        if (!trimmed) {
             continue;
+        }
         const [channelRaw, accountRaw] = trimmed.split(":", 2);
         const channel = normalizeChannelId(channelRaw);
         if (!channel) {
@@ -118,8 +124,9 @@ export function parseBindingSpecs(params) {
             }
         }
         const match = { channel };
-        if (accountId)
+        if (accountId) {
             match.accountId = accountId;
+        }
         bindings.push({ agentId, match });
     }
     return { bindings, errors };

package/dist/commands/agents.commands.add.js

@@ -13,8 +13,8 @@ import { WizardCancelledError } from "../wizard/prompts.js";
 import { applyAgentBindings, buildChannelBindings, describeBinding, parseBindingSpecs, } from "./agents.bindings.js";
 import { createQuietRuntime, requireValidConfig } from "./agents.command-shared.js";
 import { applyAgentConfig, findAgentEntryIndex, listAgentEntries } from "./agents.config.js";
-import { applyAuthChoice, warnIfModelConfigLooksOff } from "./auth-choice.js";
 import { promptAuthChoiceGrouped } from "./auth-choice-prompt.js";
+import { applyAuthChoice, warnIfModelConfigLooksOff } from "./auth-choice.js";
 import { setupChannels } from "./onboard-channels.js";
 import { ensureWorkspaceAndSessions } from "./onboard-helpers.js";
 async function fileExists(pathname) {
@@ -28,8 +28,9 @@ async function fileExists(pathname) {
 }
 export async function agentsAddCommand(opts, runtime = defaultRuntime, params) {
     const cfg = await requireValidConfig(runtime);
-    if (!cfg)
+    if (!cfg) {
         return;
+    }
     const workspaceFlag = opts.workspace?.trim();
     const nameInput = opts.name?.trim();
     const hasFlags = params?.hasFlags === true;
@@ -90,8 +91,9 @@ export async function agentsAddCommand(opts, runtime = defaultRuntime, params) {
             ? applyAgentBindings(nextConfig, bindingParse.bindings)
             : { config: nextConfig, added: [], skipped: [], conflicts: [] };
         await writeConfigFile(bindingResult.config);
-        if (!opts.json)
+        if (!opts.json) {
             logConfigUpdated(runtime);
+        }
         const quietRuntime = opts.json ? createQuietRuntime(runtime) : runtime;
         await ensureWorkspaceAndSessions(workspaceDir, quietRuntime, {
             skipBootstrap: Boolean(bindingResult.config.agents?.defaults?.skipBootstrap),
@@ -116,8 +118,9 @@ export async function agentsAddCommand(opts, runtime = defaultRuntime, params) {
             runtime.log(`Agent: ${agentId}`);
             runtime.log(`Workspace: ${shortenHomePath(workspaceDir)}`);
             runtime.log(`Agent dir: ${shortenHomePath(agentDir)}`);
-            if (model)
+            if (model) {
                 runtime.log(`Model: ${model}`);
+            }
             if (bindingResult.conflicts.length > 0) {
                 runtime.error([
                     "Skipped bindings already claimed by another agent:",
@@ -129,13 +132,14 @@ export async function agentsAddCommand(opts, runtime = defaultRuntime, params) {
     }
     const prompter = createClackPrompter();
     try {
-        await prompter.intro("Add Poolbot agent");
+        await prompter.intro("Add Pool Bot agent");
         const name = nameInput ??
             (await prompter.text({
                 message: "Agent name",
                 validate: (value) => {
-                    if (!value?.trim())
+                    if (!value?.trim()) {
                         return "Required";
+                    }
                     const normalized = normalizeAgentId(value);
                     if (normalized === DEFAULT_AGENT_ID) {
                         return `"${DEFAULT_AGENT_ID}" is reserved. Choose another name.`;
@@ -143,7 +147,7 @@ export async function agentsAddCommand(opts, runtime = defaultRuntime, params) {
                     return undefined;
                 },
             }));
-        const agentName = String(name).trim();
+        const agentName = String(name ?? "").trim();
         const agentId = normalizeAgentId(agentName);
         if (agentName !== agentId) {
             await prompter.note(`Normalized id to "${agentId}".`, "Agent id");
@@ -165,7 +169,7 @@ export async function agentsAddCommand(opts, runtime = defaultRuntime, params) {
             initialValue: workspaceDefault,
             validate: (value) => (value?.trim() ? undefined : "Required"),
         });
-        const workspaceDir = resolveUserPath(String(workspaceInput).trim() || workspaceDefault);
+        const workspaceDir = resolveUserPath(String(workspaceInput ?? "").trim() || workspaceDefault);
         const agentDir = resolveAgentDir(cfg, agentId);
         let nextConfig = applyAgentConfig(cfg, {
             agentId,
@@ -285,7 +289,7 @@ export async function agentsAddCommand(opts, runtime = defaultRuntime, params) {
     }
     catch (err) {
         if (err instanceof WizardCancelledError) {
-            runtime.exit(0);
+            runtime.exit(1);
             return;
         }
         throw err;

package/dist/commands/agents.commands.identity.js

@@ -38,8 +38,9 @@ function resolveAgentIdByWorkspace(cfg, workspaceDir) {
 }
 export async function agentsSetIdentityCommand(opts, runtime = defaultRuntime) {
     const cfg = await requireValidConfig(runtime);
-    if (!cfg)
+    if (!cfg) {
         return;
+    }
     const agentRaw = coerceTrimmed(opts.agent);
     const nameRaw = coerceTrimmed(opts.name);
     const emojiRaw = coerceTrimmed(opts.emoji);
@@ -155,14 +156,19 @@ export async function agentsSetIdentityCommand(opts, runtime = defaultRuntime) {
     }
     logConfigUpdated(runtime);
     runtime.log(`Agent: ${agentId}`);
-    if (nextIdentity.name)
+    if (nextIdentity.name) {
         runtime.log(`Name: ${nextIdentity.name}`);
-    if (nextIdentity.theme)
+    }
+    if (nextIdentity.theme) {
         runtime.log(`Theme: ${nextIdentity.theme}`);
-    if (nextIdentity.emoji)
+    }
+    if (nextIdentity.emoji) {
         runtime.log(`Emoji: ${nextIdentity.emoji}`);
-    if (nextIdentity.avatar)
+    }
+    if (nextIdentity.avatar) {
         runtime.log(`Avatar: ${nextIdentity.avatar}`);
-    if (workspaceDir)
+    }
+    if (workspaceDir) {
         runtime.log(`Workspace: ${shortenHomePath(workspaceDir)}`);
+    }
 }

package/dist/commands/agents.commands.list.js

@@ -1,6 +1,6 @@
+import { formatCliCommand } from "../cli/command-format.js";
 import { normalizeAgentId } from "../routing/session-key.js";
 import { defaultRuntime } from "../runtime.js";
-import { formatCliCommand } from "../cli/command-format.js";
 import { shortenHomePath } from "../utils.js";
 import { describeBinding } from "./agents.bindings.js";
 import { requireValidConfig } from "./agents.command-shared.js";
@@ -12,10 +12,12 @@ function formatSummary(summary) {
         ? `${summary.id}${defaultTag} (${summary.name})`
         : `${summary.id}${defaultTag}`;
     const identityParts = [];
-    if (summary.identityEmoji)
+    if (summary.identityEmoji) {
         identityParts.push(summary.identityEmoji);
-    if (summary.identityName)
+    }
+    if (summary.identityName) {
         identityParts.push(summary.identityName);
+    }
     const identityLine = identityParts.length > 0 ? identityParts.join(" ") : null;
     const identitySource = summary.identitySource === "identity"
         ? "IDENTITY.md"
@@ -28,8 +30,9 @@ function formatSummary(summary) {
     }
     lines.push(`  Workspace: ${shortenHomePath(summary.workspace)}`);
     lines.push(`  Agent dir: ${shortenHomePath(summary.agentDir)}`);
-    if (summary.model)
+    if (summary.model) {
         lines.push(`  Model: ${summary.model}`);
+    }
     lines.push(`  Routing rules: ${summary.bindings}`);
     if (summary.routes?.length) {
         lines.push(`  Routing: ${summary.routes.join(", ")}`);
@@ -50,8 +53,9 @@ function formatSummary(summary) {
 }
 export async function agentsListCommand(opts, runtime = defaultRuntime) {
     const cfg = await requireValidConfig(runtime);
-    if (!cfg)
+    if (!cfg) {
         return;
+    }
     const summaries = buildAgentSummaries(cfg);
     const bindingMap = new Map();
     for (const binding of cfg.bindings ?? []) {
@@ -84,8 +88,9 @@ export async function agentsListCommand(opts, runtime = defaultRuntime) {
             bindings,
             providerStatus,
         });
-        if (providerLines.length > 0)
+        if (providerLines.length > 0) {
             summary.providers = providerLines;
+        }
     }
     if (opts.json) {
         runtime.log(JSON.stringify(summaries, null, 2));