@selesai/code 0.13.25 → 0.13.26

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.26] - 2026-09-18
+
+### Added
+- **Goal-preserving automatic handoff.** The automatic handoff now runs with the same goal text as an explicit `/handoff-new`, so the continuation prompt keeps the overarching objective, success criteria, key decisions, reference files, and the next concrete action. `AUTO_HANDOFF_GOAL` is exported from the core handoff module.
+
+### Changed
+- **Failed handoffs retry instead of silently stopping.** A failed or empty handoff generation now surfaces the underlying error (previously reported as "Cancelled") and rejects the command, and the automatic handoff retries on the next settled turn while the session stays above the threshold.
+- **RPC handoff keeps the session name.** `handoff_new` carries the current session name into the replacement session, matching `/handoff-new`.
+- **Default model catalog refreshed.** Added `glm-5.3` (1M context, text+image), `kimi-k3` (512K), and `gemini-3.7-flash`; `celestial-pro` now accepts images; `deepseek-v4.1-flash` uses 64K max output tokens.
+- **Retired default models.** `deepseek-v4-flash`, `deepseek-v4-flash-vision-exp`, `kimi-k2.7-code`, and `glm-5.2` are no longer in the bundled Token-In catalog (`glm-5.3` supersedes `glm-5.2`). User-level `models.json` entries are unaffected.
+
 ## [0.13.25] - 2026-09-14
 
 ### Added

package/dist/core/agent-session-auto-handoff.test.js

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from "vitest";
 import { Type } from "typebox";
 import { AgentSession } from "./agent-session.js";
+import { AUTO_HANDOFF_GOAL } from "./handoff.js";
 import { SettingsManager } from "./settings-manager.js";
 function createMockSession({ enabled, threshold = 128_000, tokens, mode = "tui", command, customTools, allowedToolNames, }) {
     const settings = SettingsManager.inMemory({
@@ -78,6 +79,11 @@ describe("AgentSession tools", () => {
     });
 });
 describe("AgentSession auto handoff", () => {
+    it("uses a goal that preserves the overall objective and continuation details", () => {
+        expect(AUTO_HANDOFF_GOAL).toMatch(/overall objective/i);
+        expect(AUTO_HANDOFF_GOAL).toMatch(/next concrete action/i);
+        expect(AUTO_HANDOFF_GOAL).toMatch(/reference files/i);
+    });
     it("invokes handoff-new once when enabled and threshold reached in tui mode", async () => {
         const command = { handler: vi.fn() };
         const { session, getCommand, createCommandContext, emitError } = createMockSession({
@@ -90,7 +96,7 @@ describe("AgentSession auto handoff", () => {
         expect(getCommand).toHaveBeenCalledWith("handoff-new");
         expect(createCommandContext).toHaveBeenCalled();
         expect(command.handler).toHaveBeenCalledTimes(1);
-        expect(command.handler).toHaveBeenCalledWith("", expect.anything());
+        expect(command.handler).toHaveBeenCalledWith(AUTO_HANDOFF_GOAL, expect.anything());
         expect(emitError).not.toHaveBeenCalled();
     });
     it("dispatches auto handoff via _emitAgentSettled in tui mode", async () => {
@@ -156,13 +162,16 @@ describe("AgentSession auto handoff", () => {
         await session._checkAutoHandoff();
         expect(getCommand).toHaveBeenCalledWith("handoff-new");
     });
-    it("emits error when handoff-new throws but does not rethrow", async () => {
+    it("emits an error and retries on the next check when handoff-new fails", async () => {
         const command = {
             handler: vi.fn(() => Promise.reject(new Error("boom"))),
         };
         const { session, emitError } = createMockSession({ enabled: true, tokens: 200_000, command });
         await expect(session._checkAutoHandoff()).resolves.toBeUndefined();
-        expect(emitError).toHaveBeenCalledWith({
+        await expect(session._checkAutoHandoff()).resolves.toBeUndefined();
+        expect(command.handler).toHaveBeenCalledTimes(2);
+        expect(emitError).toHaveBeenCalledTimes(2);
+        expect(emitError).toHaveBeenLastCalledWith({
             extensionPath: "command:handoff-new",
             event: "auto-handoff",
             error: "boom",

package/dist/core/agent-session.js

@@ -27,6 +27,7 @@ import { calculateContextTokens, collectEntriesForBranchSummary, compact, estima
 import { DEFAULT_THINKING_LEVEL, THINKING_LEVEL_OPTIONS } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
+import { AUTO_HANDOFF_GOAL } from "./handoff.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { ModelRegistry } from "./model-registry.js";
@@ -375,7 +376,6 @@ export class AgentSession {
         }
         if (this._autoHandoffTriggered)
             return;
-        this._autoHandoffTriggered = true;
         // Auto-handoff is TUI-only: it runs at agent_settled, and headless/print
         // modes should not churn sessions on their own. The handoff-new command
         // itself now also works in non-TUI modes (direct generation, no loader).
@@ -384,11 +384,14 @@ export class AgentSession {
         const command = this._extensionRunner.getCommand("handoff-new");
         if (!command)
             return;
+        this._autoHandoffTriggered = true;
         const ctx = this._extensionRunner.createCommandContext();
         try {
-            await command.handler("", ctx);
+            await command.handler(AUTO_HANDOFF_GOAL, ctx);
         }
         catch (err) {
+            // Retry on the next settled turn while the session remains above the threshold.
+            this._autoHandoffTriggered = false;
             this._extensionRunner.emitError({
                 extensionPath: "command:handoff-new",
                 event: "auto-handoff",

package/dist/core/handoff.d.ts

@@ -3,6 +3,7 @@ import type { AssistantMessage, Context } from "@earendil-works/pi-ai";
 import type { Model } from "@earendil-works/pi-ai";
 import type { SessionEntry } from "./session-manager.ts";
 export declare const DEFAULT_HANDOFF_GOAL = "Continue the previous session from this handoff.";
+export declare const AUTO_HANDOFF_GOAL = "Continue the previous session without losing its direction. Preserve the big picture: the overall objective, why the work matters, the intended outcome and success criteria, the current approach and key decisions, relevant constraints, exact reference files or artifacts, completed and remaining work, known failures or test results, and the next concrete action. Make clear how the immediate next step contributes to the overall goal.";
 export declare function entryToMessage(entry: SessionEntry): AgentMessage | undefined;
 export declare function getHandoffMessages(branch: SessionEntry[]): AgentMessage[];
 export declare function buildAiContext(conversationText: string, goal: string): Context;

package/dist/core/handoff.js

@@ -1,6 +1,7 @@
 import { serializeConversation } from "./compaction/utils.js";
 import { convertToLlm } from "./messages.js";
 export const DEFAULT_HANDOFF_GOAL = "Continue the previous session from this handoff.";
+export const AUTO_HANDOFF_GOAL = `Continue the previous session without losing its direction. Preserve the big picture: the overall objective, why the work matters, the intended outcome and success criteria, the current approach and key decisions, relevant constraints, exact reference files or artifacts, completed and remaining work, known failures or test results, and the next concrete action. Make clear how the immediate next step contributes to the overall goal.`;
 const SYSTEM_PROMPT = `Write a handoff document for a fresh agent to continue the current conversation. Return only the handoff document text; do not save a file or describe saving one. No question, no fluff, just write the handoff. Do not reproduce, quote, or reformat the conversation history or its tool calls — distill it into what matters; never emit transcript-style markup or raw tool-call text.
 
 Include a "suggested skills" section in the document, which suggests skills that the agent should invoke.

package/dist/defaults/models.json

@@ -14,7 +14,7 @@
           "id": "celestial-pro",
           "name": "Celestial Pro",
           "reasoning": true,
-          "input": ["text"],
+          "input": ["text", "image"],
           "contextWindow": 393216,
           "maxTokens": 64000,
           "thinkingLevelMap": {
@@ -67,51 +67,13 @@
             "requiresReasoningContentOnAssistantMessages": true
             }
         },
-        {
-          "id": "deepseek-v4-flash",
-          "name": "DeepSeek V4 Flash",
-          "reasoning": true,
-          "input": ["text"],
-          "contextWindow": 512000,
-          "maxTokens": 64000,
-          "thinkingLevelMap": {
-            "minimal": null,
-            "low": null,
-            "medium": null,
-            "high": "high",
-            "xhigh": null,
-            "max": "max"
-          },
-          "compat": {
-            "requiresReasoningContentOnAssistantMessages": true
-            }
-        },
-        {
-          "id": "deepseek-v4-flash-vision-exp",
-          "name": "DeepSeek V4 Flash Vision Exp",
-          "reasoning": true,
-          "input": ["text", "image"],
-          "contextWindow": 512000,
-          "maxTokens": 128000,
-          "thinkingLevelMap": {
-            "minimal": null,
-            "low": null,
-            "medium": null,
-            "high": "high",
-            "xhigh": null,
-            "max": "max"
-          },
-          "compat": {
-            "requiresReasoningContentOnAssistantMessages": true
-            }
-        },
         {
           "id": "deepseek-v4.1-flash",
           "name": "DeepSeek V4.1 Flash",
           "reasoning": true,
           "input": ["text", "image"],
           "contextWindow": 512000,
-          "maxTokens": 128000,
+          "maxTokens": 64000,
           "thinkingLevelMap": {
             "minimal": null,
             "low": null,
@@ -207,38 +169,6 @@
             "max": "max"
           }
         },
-        {
-          "id": "kimi-k2.7-code",
-          "name": "Kimi K2.7 Code",
-          "reasoning": true,
-          "input": ["text", "image"],
-          "contextWindow": 262128,
-          "maxTokens": 64000,
-          "thinkingLevelMap": {
-            "minimal": null,
-            "low": "low",
-            "medium": null,
-            "high": "high",
-            "xhigh": null,
-            "max": "max"
-          }
-        },
-        {
-          "id": "glm-5.2",
-          "name": "GLM-5.2",
-          "reasoning": true,
-          "input": ["text"],
-          "contextWindow": 1000000,
-          "maxTokens": 64000,
-          "thinkingLevelMap": {
-            "minimal": null,
-            "low": "low",
-            "medium": null,
-            "high": "high",
-            "xhigh": null,
-            "max": null
-          }
-        },
         {
           "id": "glm-5.3-flash",
           "name": "GLM-5.3 Flash",

package/dist/extensions/handoff-new.test.ts

@@ -226,11 +226,11 @@ describe("handoff-new extension", () => {
 		expect(calls.newSession).not.toBeNull();
 	});
 
-	it("non-tui mode generation error notifies and opens no session", async () => {
+	it("non-tui mode generation error notifies, rejects, and opens no session", async () => {
 		(complete as any).mockRejectedValueOnce(new Error("api down"));
 		const { commands } = createPiHarness();
 		const { ctx, calls } = createCtx({ mode: "rpc" });
-		await commands.get("handoff-new")!.handler("goal", ctx);
+		await expect(commands.get("handoff-new")!.handler("goal", ctx)).rejects.toThrow("api down");
 		expect(calls.newSession).toBeNull();
 		expect(calls.notify.some((n) => /api down/.test(n.msg))).toBe(true);
 	});
@@ -259,10 +259,10 @@ describe("handoff-new extension", () => {
 		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
 	});
 
-	it("empty generated handoff does not open a blank session", async () => {
+	it("empty generated handoff notifies, rejects, and opens no blank session", async () => {
 		const { commands } = createPiHarness();
 		const { ctx, calls } = createCtx({ customResult: "  " });
-		await commands.get("handoff-new")!.handler("goal", ctx);
+		await expect(commands.get("handoff-new")!.handler("goal", ctx)).rejects.toThrow("returned no text");
 		expect(calls.newSession).toBeNull();
 		expect(calls.notify.some((n) => /returned no text/.test(n.msg))).toBe(true);
 	});
@@ -358,29 +358,29 @@ describe("handoff-new extension", () => {
 		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
 	});
 
-	it("factory: missing API key throws and notifies Cancelled", async () => {
+	it("factory: missing API key notifies and rejects", async () => {
 		const { commands } = createPiHarness();
 		const { ctx, calls } = createFactoryCtx({ auth: { ok: true, error: "no key" } });
-		await commands.get("handoff-new")!.handler("goal", ctx);
+		await expect(commands.get("handoff-new")!.handler("goal", ctx)).rejects.toThrow("No API key");
 		expect(calls.newSession).toBeNull();
-		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
+		expect(calls.notify.some((n) => /No API key/.test(n.msg))).toBe(true);
 	});
 
-	it("factory: auth error throws and notifies Cancelled", async () => {
+	it("factory: auth error notifies and rejects", async () => {
 		const { commands } = createPiHarness();
 		const { ctx, calls } = createFactoryCtx({ auth: { ok: false, error: "auth failed" } });
-		await commands.get("handoff-new")!.handler("goal", ctx);
+		await expect(commands.get("handoff-new")!.handler("goal", ctx)).rejects.toThrow("auth failed");
 		expect(calls.newSession).toBeNull();
-		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
+		expect(calls.notify.some((n) => /auth failed/.test(n.msg))).toBe(true);
 	});
 
-	it("factory: complete rejection is caught and notifies Cancelled", async () => {
+	it("factory: complete rejection notifies and rejects", async () => {
 		(complete as any).mockRejectedValueOnce(new Error("network down"));
 		const { commands } = createPiHarness();
 		const { ctx, calls } = createFactoryCtx({});
-		await commands.get("handoff-new")!.handler("goal", ctx);
+		await expect(commands.get("handoff-new")!.handler("goal", ctx)).rejects.toThrow("network down");
 		expect(calls.newSession).toBeNull();
-		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
+		expect(calls.notify.some((n) => /network down/.test(n.msg))).toBe(true);
 	});
 
 	it("factory: loader onAbort resolves null", async () => {

package/dist/extensions/handoff-new.ts

@@ -74,15 +74,20 @@ async function handoffNew(args: string, ctx: ExtensionCommandContext) {
 	const aiContext = buildAiContext(conversationText, goal);
 
 	let result: string | null;
+	let generationError: unknown;
 	if (ctx.mode === "tui") {
+		let cancelled = false;
 		result = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
 			const loader = new BorderedLoader(tui, theme, `Generating handoff prompt...`);
-			loader.onAbort = () => done(null);
+			loader.onAbort = () => {
+				cancelled = true;
+				done(null);
+			};
 
 			generateHandoffText(ctx, aiContext, loader.signal)
 				.then(done)
 				.catch((err) => {
-					console.error("handoff-new generation failed:", err);
+					if (!cancelled) generationError = err;
 					done(null);
 				});
 
@@ -94,18 +99,24 @@ async function handoffNew(args: string, ctx: ExtensionCommandContext) {
 		try {
 			result = await generateHandoffText(ctx, aiContext, ctx.signal);
 		} catch (err) {
-			ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
-			return;
+			generationError = err;
+			result = null;
 		}
 	}
 
+	if (generationError !== undefined) {
+		const error = generationError instanceof Error ? generationError : new Error(String(generationError));
+		ctx.ui.notify(error.message, "error");
+		throw error;
+	}
 	if (result === null) {
 		ctx.ui.notify("Cancelled", "info");
 		return;
 	}
 	if (!result.trim()) {
-		ctx.ui.notify("Handoff generation returned no text", "error");
-		return;
+		const error = new Error("Handoff generation returned no text");
+		ctx.ui.notify(error.message, "error");
+		throw error;
 	}
 
 	// Read the name before newSession: the original ctx is invalidated once

package/dist/modes/rpc/rpc-mode.js

@@ -466,8 +466,13 @@ export async function runRpcMode(runtimeHost) {
                     return error(id, "handoff_new", "No model selected");
                 try {
                     const handoff = await generateHandoff(session.model, session.modelRuntime, session.sessionManager.getBranch(), command.goal);
+                    const sessionName = session.sessionManager.getSessionName();
                     const result = await runtimeHost.newSession({
                         parentSession: session.sessionManager.getSessionFile(),
+                        setup: async (replacementManager) => {
+                            if (sessionName)
+                                replacementManager.appendSessionInfo(sessionName);
+                        },
                         withSession: async (replacementSession) => replacementSession.sendUserMessage(handoff),
                     });
                     if (!result.cancelled)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selesai/code",
-  "version": "0.13.25",
+  "version": "0.13.26",
   "description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
   "type": "module",
   "repository": {