jeopi-cli 16.2.24 → 16.2.26

package/src/prompts/advisor/system.md

@@ -13,7 +13,7 @@ Look where the agent is NOT — bring the angle they skipped, NEVER re-run reaso
 Offer that view before they sink work into the wrong direction.
 
 <workflow>
-You receive the agent's transcript incrementally, including their thoughts.
+You receive the agent's transcript incrementally — their messages, tool calls, and results.
 Use the tools this session grants you to verify suspicions — by default read-only lookup (`read`, `grep`, `glob`); operators may extend the grant via `WATCHDOG.yml`. Advising is your primary channel; touch mutating tools (when granted) only when a verify step genuinely needs them.
 Keep exploration lean:
 - 2–3 tool calls per advise.

package/src/prompts/system/interrupted-thinking.md

@@ -1,7 +1,6 @@
 <system-notice type="interrupted-thinking">
-Your previous turn was interrupted while you were thinking.
-- You MUST treat the preserved reasoning as internal continuity context.
-- You MUST continue the user's task from the relevant unfinished point.
+Your previous turn was cut off before you finished. Below is your unfinished internal work state — use it silently to resume; do not quote, repeat, or restate it back.
+- Continue the user's task from the relevant unfinished point.
 ------
 {{reasoning}}
 </system-notice>

package/src/prompts/tools/subagent.md

@@ -8,7 +8,7 @@ Controls the background subagents you spawned with `task`. Results deliver thems
 - **`cancel`**: Stop subagents that have hung, stalled, or are no longer needed. Requires `id`/`ids`. Works whether the subagent is still on its first run or was later resumed.
 - **`steer`**: Send a message to a specific subagent (`id` + `message`). Delivered as steering to a running subagent, or wakes an idle/parked one with a real turn. Add `pause: true` to also ask it to stop at its next safe boundary after handling the message.
 - **`pause`**: Ask a running subagent to stop at its next safe boundary and go idle. Non-running subagents are a no-op — nothing to pause.
-- **`resume`**: Wake a subagent with a follow-up. A `running` or `queued` subagent is a no-op (nothing to resume). Any other subagent needs `message` — it has no pending work to continue on its own, but its session and full context are still alive, so a follow-up message continues it exactly where it left off.
+- **`resume`**: Wake a subagent with a follow-up. A `running` or `queued` subagent is a no-op (nothing to resume). A `paused` subagent (you asked it to stop) resumes even without `message` — it continues with a default "keep going" nudge, since you already know why it stopped. Any other subagent (`completed`/`failed`/`cancelled` on its own) needs an explicit `message` — it has no known pending work, but its session and full context are still alive, so a follow-up message continues it exactly where it left off.
 
 # Filtering Output
 

package/src/session/agent-session.ts

@@ -1593,6 +1593,14 @@ export class AgentSession {
 	#retryAttempt = 0;
 	/** Rung-4 classifier-refusal resend streak (post fallback-ladder). */
 	#refusalBackoff: { startedAt: number; attempt: number } | undefined = undefined;
+	/**
+	 * One-shot latch: `reasoning_extraction` classifier refusals are payload-shape-bound
+	 * (see advisor/runtime.ts `#includeThinking` degrade) — resending the identical batch
+	 * predictably re-refuses. Set the first time `#handleRetryableError` strips unsigned
+	 * thinking/redactedThinking from active context and resends on the same model; never
+	 * reset, mirroring the advisor's permanent-for-the-session degrade.
+	 */
+	#reasoningExtractionDegraded = false;
 	#retryPromise: Promise<void> | undefined = undefined;
 	#retryResolve: (() => void) | undefined = undefined;
 	#activeRetryFallback: ActiveRetryFallbackState | undefined = undefined;
@@ -12681,6 +12689,36 @@ export class AgentSession {
 		const stopType = message.stopDetails?.type;
 		return stopType === "refusal" || stopType === "sensitive";
 	}
+	/**
+	 * Strip unsigned `thinking` and every `redactedThinking` block from assistant
+	 * messages. Used once as a `reasoning_extraction` classifier-refusal degrade:
+	 * unlike {@link renderDemotedThinking}'s plain-text fallback (still a plaintext
+	 * reasoning replay for dialects outside the Fable/Mythos carve-out), dropping the
+	 * block outright removes the trigger instead of reformatting it. Signed thinking
+	 * is left untouched — it replays natively via the provider's structured thinking
+	 * block and is never demoted to plaintext.
+	 * @returns a rewritten array, or `undefined` if no message needed stripping.
+	 */
+	#stripUnsignedThinkingForRefusalDegrade(messages: readonly AgentMessage[]): AgentMessage[] | undefined {
+		let changed = false;
+		const next: AgentMessage[] = [];
+		for (const message of messages) {
+			if (message.role !== "assistant") {
+				next.push(message);
+				continue;
+			}
+			const content = message.content.filter(
+				block => block.type !== "redactedThinking" && (block.type !== "thinking" || !!block.thinkingSignature),
+			);
+			if (content.length === message.content.length) {
+				next.push(message);
+				continue;
+			}
+			changed = true;
+			if (content.length > 0) next.push({ ...message, content });
+		}
+		return changed ? next : undefined;
+	}
 
 	#getRetryFallbackChains(): RetryFallbackChains {
 		const configuredChains = this.settings.get("retry.fallbackChains");
@@ -13099,6 +13137,33 @@ export class AgentSession {
 		}
 
 		const errorMessage = message.errorMessage || "Unknown error";
+		// `reasoning_extraction` is payload-shape-bound (see advisor/runtime.ts): resending
+		// the identical batch predictably re-refuses, unlike probabilistic classifier flags
+		// where backoff/fallback genuinely help. Degrade once — strip unsigned
+		// thinking/redactedThinking from active context and resend immediately on the same
+		// model — before falling through to the generic fallback-pin / backoff ladder below,
+		// which would otherwise retry the unchanged, re-refusing payload.
+		if (
+			classifierRefusal &&
+			message.stopDetails?.category === "reasoning_extraction" &&
+			!this.#reasoningExtractionDegraded
+		) {
+			this.#reasoningExtractionDegraded = true;
+			const stripped = this.#stripUnsignedThinkingForRefusalDegrade(this.agent.state.messages);
+			if (stripped) this.agent.replaceMessages(stripped);
+			this.#removeAssistantMessageFromActiveContext(message, "reasoning-extraction-degrade");
+			await this.#emitSessionEvent({
+				type: "auto_retry_start",
+				attempt: this.#retryAttempt,
+				maxAttempts: retrySettings.maxRetries,
+				delayMs: 0,
+				errorMessage,
+				errorId: message.errorId,
+			});
+			this.#scheduleAgentContinue({ delayMs: 1, generation });
+			return true;
+		}
+
 		const id = this.#classifyRetryMessage(message);
 		const staleOpenAIResponsesReplayError = AIError.is(id, AIError.Flag.StaleResponsesItem);
 		const parsedRetryAfterMs = this.#parseRetryAfterMsFromError(errorMessage);

package/src/session/session-context.ts

@@ -138,10 +138,16 @@ export function buildSessionContext(
 		};
 	}
 
-	// Walk from leaf to root, collecting path
+	// Walk from leaf to root, collecting path. `seen` guards against a corrupt/
+	// cyclic parentId chain (e.g. A.parentId === B, B.parentId === A) looping
+	// forever and growing `path` unbounded — the same OOM class the sibling
+	// walks in session-manager.ts (`pathTo`) and session-loader.ts
+	// (`collectActiveBranchIds`) already guard against.
 	const path: SessionEntry[] = [];
+	const seen = new Set<string>();
 	let current: SessionEntry | undefined = leaf;
-	while (current) {
+	while (current && !seen.has(current.id)) {
+		seen.add(current.id);
 		path.push(current);
 		current = current.parentId ? byId.get(current.parentId) : undefined;
 	}

package/src/slash-commands/builtin-registry.ts

@@ -211,6 +211,7 @@ function parseShakeMode(args: string): ShakeMode | { error: string } {
 const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "settings",
+		priority: 40,
 		description: "Open settings menu",
 		handleTui: (_command, runtime) => {
 			runtime.ctx.showSettingsSelector();
@@ -265,6 +266,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "goal",
+		priority: 84,
 		description: "Toggle goal mode (persistent autonomous objective for this session)",
 		subcommands: [
 			{ name: "set", description: "Set or replace the goal", usage: "<objective>" },
@@ -558,6 +560,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "export",
+		priority: 50,
 		description: "Export session to HTML file",
 		inlineHint: "[path]",
 		allowArgs: true,
@@ -585,6 +588,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "dump",
+		priority: 54,
 		description: "Copy session transcript to clipboard (and write LLM request JSON to tmp)",
 		acpDescription: "Return full transcript as plain text, with LLM request JSON path",
 		allowArgs: true,
@@ -854,6 +858,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "copy",
+		priority: 55,
 		description: "Pick text or code from the conversation to copy",
 		allowArgs: true,
 		handleTui: async (command, runtime) => {
@@ -928,6 +933,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "session",
+		priority: 88,
 		description: "Session management commands",
 		acpDescription: "Show session information",
 		acpInputHint: "info|delete",
@@ -1344,6 +1350,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "new",
+		priority: 96,
 		description: "Start a new session",
 		handleTui: async (_command, runtime) => {
 			runtime.ctx.editor.setText("");
@@ -1381,6 +1388,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "compact",
+		priority: 72,
 		description: "Manually compact the session context",
 		acpDescription: "Compact the conversation",
 		subcommands: COMPACT_MODES.map(mode => ({
@@ -1467,6 +1475,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "resume",
+		priority: 92,
 		description: "Resume a different session",
 		inlineHint: "[session id]",
 		allowArgs: true,
@@ -1525,6 +1534,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "retry",
+		priority: 70,
 		description: "Retry the last failed agent turn",
 		handleTui: async (_command, runtime) => {
 			const didRetry = await runtime.ctx.session.retry();

package/src/slash-commands/types.ts

@@ -16,6 +16,8 @@ export interface BuiltinSlashCommand {
 	name: string;
 	aliases?: string[];
 	description: string;
+	/** Ranking boost for the empty-prefix `/` menu and tied fuzzy matches (higher shows first); flows straight through to `jeopi-tui`'s `SlashCommand.priority`. Commands without one default to 0. */
+	priority?: number;
 	/** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
 	subcommands?: SubcommandDef[];
 	/** Static inline hint when command takes a simple argument (no subcommands). */

package/src/tools/subagent.test.ts

@@ -186,6 +186,26 @@ describe("SubagentTool", () => {
 		const afterResume = await tool.execute("c4", { action: "list" });
 		expect(afterResume.details?.subagents[0].status).not.toBe("paused");
 	});
+	it("resume without a message succeeds on a paused subagent (GJC parity) but still requires one once terminal", async () => {
+		const { resolve } = registerPendingTaskJob(manager, "Main", "Sub1");
+		const fakeSession = { deliverIrcMessage: async () => "injected" as const } as unknown as AgentSession;
+		registry.register({ id: "Sub1", displayName: "Sub1", kind: "sub", session: fakeSession, status: "running" });
+		const tool = new SubagentTool(makeSession({ agentId: "Main", registry, manager }));
+
+		await tool.execute("c1", { action: "pause", id: "Sub1" });
+		resolve("stopped early");
+		await manager.getJob("Sub1")?.promise;
+		registry.setStatus("Sub1", "idle");
+
+		// No `message` — a paused subagent has known intent (we asked it to stop),
+		// so resume proceeds with a default continuation body instead of throwing.
+		const resumed = await tool.execute("c2", { action: "resume", id: "Sub1" });
+		expect(resumed.isError).toBeFalsy();
+		expect(resumed.details?.receipt?.outcome).toBe("injected");
+
+		// Once genuinely terminal again (no outstanding pause), resume still needs a message.
+		await expect(tool.execute("c3", { action: "resume", id: "Sub1" })).rejects.toThrow(ToolError);
+	});
 
 	it("a subagent that goes idle while running is never mistaken for paused", async () => {
 		const { resolve } = registerPendingTaskJob(manager, "Main", "Sub1");

package/src/tools/subagent.ts

@@ -76,6 +76,7 @@ const PREVIEW_CHARS = 2_000;
 const FULL_PREVIEW_CHARS = 12_000;
 const DEFAULT_PAUSE_DIRECTIVE =
 	"Stop at the next safe boundary and yield. You can be resumed later with more instructions.";
+const DEFAULT_RESUME_MESSAGE = "Continue from where you left off.";
 
 export type SubagentStatus = "queued" | "running" | "paused" | "completed" | "failed" | "cancelled" | "not_found";
 
@@ -522,18 +523,26 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			};
 		}
 
+		// GJC parity: a `paused` subagent has saved context it stopped *because
+		// we asked it to* — resume can proceed with a default continuation body,
+		// the same way GJC's native `resumeSubagent` continues a non-terminal
+		// record without requiring a message. A subagent that simply finished on
+		// its own (completed/failed/cancelled) has no such known intent, so that
+		// case still requires an explicit `message`.
+		const isPaused = this.#pausedIds.has(id);
 		const message = params.message?.trim();
-		if (!message) {
+		if (!message && !isPaused) {
 			throw new ToolError(
 				`\`message\` is required to resume "${id}" — it has no pending work to continue on its own.`,
 			);
 		}
+		const body = message || DEFAULT_RESUME_MESSAGE;
 		return this.#deliver(
 			manager,
 			registry,
 			senderId,
 			id,
-			message,
+			body,
 			"resume",
 			verbosity,
 			outcome => `Resumed ${id} (${outcome}).`,