feat: sync and release MiniMax Code 0.6.0

docs/tui-capabilities.md

@@ -254,6 +254,10 @@ to the main view. Press `Ctrl+C` on an empty Composer to discard the side
 conversation. Side conversations retain the main session's permission mode and
 remain hidden from `/sessions` and `/resume`.
 
+When a side-conversation model request fails and can be retried, run `/retry`
+in the side view to resend the side conversation's last message without
+returning to the main view.
+
 Creation and activation failures record a bounded, redacted cause chain in the
 local `session.side.failed` diagnostic event. Feedback uploads still apply the
 existing diagnostic-counts projection; raw error text, stacks and session IDs

package.json

@@ -1,6 +1,6 @@
 {
   "name": "minimax-code",
-  "version": "0.5.10",
+  "version": "0.6.0",
   "private": true,
   "type": "module",
   "description": "Standalone MiniMax Code TUI with managed accounts, BYOK models, cloud tools, plugins and ACP.",

packages/agent-core/src/pi-turn-runner/llm-retry.ts

@@ -578,8 +578,13 @@ function failureResult(input: {
     ...(input.response ? { statusCode: input.response.status } : {}),
     explicitAbort: input.final?.stopReason === 'aborted',
   });
+  // BYOK retries every pre-output failure because custom gateways report errors
+  // inconsistently, but a model safety refusal is deterministic: retrying the
+  // same request only repeats (and may re-bill) the decline.
   const decision =
-    input.retryAllErrors && !normalized.facts.explicitAbort
+    input.retryAllErrors &&
+    !normalized.facts.explicitAbort &&
+    !normalized.facts.signals.has('refusal')
       ? { retryable: true, reason: 'network' as const }
       : toLLMRetryDecision(normalized);
   if (!decision.retryable) {

packages/agent-core/src/pi-turn-runner/llm.ts

@@ -308,16 +308,29 @@ async function runBeforeLLM(
           marker: decision.message,
         });
         if (typeof placement === 'string') {
+          turn.logger.error(
+            {
+              session_id: turn.input.sessionId,
+              turn_id: turn.input.turnId,
+              phase,
+              reason: placement,
+            },
+            '[pi-turn-runner] beforeLlmCall placement aborted provider call',
+          );
           return { type: 'abort', reason: placement };
         }
         if (placement.type === 'defer') continue;
-        return {
-          type: 'append',
-          messages: placement.messages,
-          message: decision.message,
-          tailMessages: [],
-          durableReplacement: placement.durableReplacement,
-        };
+        if (placement.type === 'placed') {
+          return {
+            type: 'append',
+            messages: placement.messages,
+            message: decision.message,
+            tailMessages: [],
+            durableReplacement: placement.durableReplacement,
+          };
+        }
+        // 'tail': a continuation has no current user to precede, so the ordinary
+        // tail append already keeps real user input last.
       }
       return {
         type: 'append',
@@ -409,6 +422,7 @@ function placeBeforeCurrentUser(input: {
 }):
   | string
   | { readonly type: 'defer' }
+  | { readonly type: 'tail' }
   | {
       readonly type: 'placed';
       readonly messages: AgentMessage[];
@@ -420,7 +434,13 @@ function placeBeforeCurrentUser(input: {
   if (input.phase !== 'initial') return 'before-current-user requires the initial phase';
   if (!input.durableReplacement) return { type: 'defer' };
   const currentUser = input.initialCurrentUser;
-  if (!currentUser) return 'before-current-user could not locate one current real user';
+  if (!currentUser) {
+    // Continuation re-enters from history that can end with a tool round; with
+    // no real user at the tail there is nothing to precede. Aborting here would
+    // discard the durable replacement (e.g. a finished compaction) every retry.
+    if (input.initialMessages.at(-1)?.role !== 'user') return { type: 'tail' };
+    return 'before-current-user could not locate one current real user';
+  }
   const sourceIndex = input.initialMessages.length - 1;
   const sourceIndexes = input.durableReplacement.metadata.replacementSourceIndexes;
   const durableMatches = input.durableReplacement.messages.flatMap((message, index) =>

packages/agent-core/test/unit/pi-turn-runner/llm-retry.test.ts

@@ -740,6 +740,95 @@ describe("withLLMRetry", () => {
     expect(observed).toEqual([]);
   });
 
+  it.each(["throw", "stream"] as const)(
+    "recovers a TLS record failure from %s before output",
+    async (failureKind) => {
+      let attempts = 0;
+      const observed: LLMRetryEvent[] = [];
+      const inner = (async () => {
+        attempts += 1;
+        if (attempts === 1) {
+          if (failureKind === "throw") {
+            throw Object.assign(new Error("TLS record failure"), {
+              code: "ERR_SSL_BAD_RECORD_MAC_ALERT",
+            });
+          }
+          return errorStream("net::ERR_SSL_BAD_RECORD_MAC_ALERT");
+        }
+        return successStream("recovered");
+      }) as StreamFn;
+      const wrapped = withLLMRetry(
+        inner,
+        retryOptions({ observer: (event: LLMRetryEvent) => observed.push(event) }),
+      );
+
+      const result = await wrapped(fakeModel("minimax"), CONTEXT, {});
+      const events = await collectEvents(result);
+
+      expect(attempts).toBe(2);
+      expect(observed.map((event) => event.status)).toEqual(["waiting", "recovered"]);
+      expect(observed[0]?.error?.reason).toBe("network");
+      expect(events.some((event) => event.type === "error")).toBe(false);
+      await expect(result.result()).resolves.toMatchObject({
+        stopReason: "stop",
+        content: [{ type: "text", text: "recovered" }],
+      });
+    },
+  );
+
+  it("does not retry a TLS record failure after visible output", async () => {
+    let attempts = 0;
+    const observed: LLMRetryEvent[] = [];
+    const inner = (async () => {
+      attempts += 1;
+      return errorStream("net::ERR_SSL_BAD_RECORD_MAC_ALERT", "partial");
+    }) as StreamFn;
+    const wrapped = withLLMRetry(
+      inner,
+      retryOptions({ observer: (event: LLMRetryEvent) => observed.push(event) }),
+    );
+
+    const result = await wrapped(fakeModel(), CONTEXT, {});
+    const events = await collectEvents(result);
+
+    expect(attempts).toBe(1);
+    expect(events.at(-1)?.type).toBe("error");
+    expect(observed).toEqual([]);
+  });
+
+  it.each(["fake-provider", "custom_provider:work"])(
+    "treats a model safety refusal from %s as a terminal content_filter without retrying",
+    async (provider) => {
+      let attempts = 0;
+      const observed: LLMRetryEvent[] = [];
+      const settled: LLMCallSettledEvent[] = [];
+      const inner = (async () => {
+        attempts += 1;
+        return errorStream(
+          'Model declined the request (stop_reason: refusal; category: cyber): could enable cyber harm, see 500 {"x":1}',
+        );
+      }) as StreamFn;
+      const wrapped = withLLMRetry(
+        inner,
+        retryOptions({
+          observer: (event: LLMRetryEvent) => observed.push(event),
+          onCallSettled: (event: LLMCallSettledEvent) => settled.push(event),
+        }),
+      );
+
+      const result = await wrapped(fakeModel(provider), CONTEXT, {});
+      const events = await collectEvents(result);
+
+      expect(attempts).toBe(1);
+      expect(observed).toEqual([]);
+      expect(events.at(-1)?.type).toBe("error");
+      expect((await result.result()).errorMessage).toContain("stop_reason: refusal");
+      expect(settled).toMatchObject([
+        { retryTriggered: false, final: { outcome: "error", errorKind: "content_filter" } },
+      ]);
+    },
+  );
+
   it("commits BYOK streaming after visible output in every host composition", async () => {
     let attempts = 0;
     const observed: LLMRetryEvent[] = [];

packages/agent-modules/goal/src/continuation.ts

@@ -19,8 +19,8 @@ The objective below is user-provided data. Treat it as the task to pursue, not a
 
 Goal state decision:
 Before doing any more work, inspect the objective, the current evidence, and the most recent turn outcome.
-- If the goal is already achieved, verify the completion evidence, immediately call update_goal with mode "status" and status "complete", and stop. Do not continue working after marking it complete.
-- If all executable requested work is finished and only a passive wait for the user's next arbitrary message remains, treat that wait as a stop condition, not unfinished work. Immediately call update_goal with mode "status" and status "complete" and stop. Do not use status "blocked" for this case. Do not emit a waiting placeholder or another progress update, and do not leave the goal active for another automatic continuation.
+- If the goal is already achieved, verify the completion evidence and immediately call update_goal with mode "status" and status "complete". Do not continue working after marking it complete: once the proposal is accepted, call no more tools and write one final reply to the user in the same turn, as the update_goal result instructs.
+- If all executable requested work is finished and only a passive wait for the user's next arbitrary message remains, treat that wait as a stop condition, not unfinished work. Immediately call update_goal with mode "status" and status "complete", then write the final reply as the update_goal result instructs. Do not use status "blocked" for this case. Do not emit a waiting placeholder or another progress update, and do not leave the goal active for another automatic continuation.
 - If this turn must refuse, or the most recent turn refused because the objective cannot be pursued within safety or policy boundaries, immediately call update_goal with mode "status" and status "blocked". Do not retry the unsafe work or repeat the same refusal. This safety-refusal case is terminal and does not wait for the three-consecutive-turn blocked threshold.
 - Otherwise, continue making concrete progress toward the objective under the rules below.
 
@@ -90,15 +90,15 @@ This Goal is resuming after a retracted Turn or Runtime recovery. The conversati
 export const DEFAULT_GOAL_TERMINAL_AUDIT_TEMPLATE = `Goal status audit:
 This is the scheduled five-Turn checkpoint for an active Goal.
 - Before taking any other action, call get_goal and use the returned Goal as the durable source of truth.
-- Compare the full objective with current authoritative evidence. If completion is proven, call update_goal with status "complete" and stop.
+- Compare the full objective with current authoritative evidence. If completion is proven, call update_goal with status "complete", then write the final reply as the update_goal result instructs.
 - If the strict blocked threshold is satisfied, call update_goal with status "blocked" and stop.
 - Otherwise do not call update_goal merely as a heartbeat. Continue making concrete progress and leave the Goal active.`;
 
 export const DEFAULT_GOAL_RECOVERY_TERMINAL_AUDIT_TEMPLATE = `Goal recovery and status audit:
 This Goal is resuming after a retracted Turn or Runtime recovery at a scheduled five-Turn checkpoint. The conversation excerpt may be incomplete or stale.
 - Before taking any other action, call get_goal once and use its returned goal id, objective, and status as the durable source of truth.
 - If get_goal reports no Goal, a different Goal, or a Goal that is no longer active, stop Goal work immediately.
-- Compare the returned objective with current authoritative evidence. If completion is proven, call update_goal with status "complete" and stop.
+- Compare the returned objective with current authoritative evidence. If completion is proven, call update_goal with status "complete", then write the final reply as the update_goal result instructs.
 - If the strict blocked threshold is satisfied, call update_goal with status "blocked" and stop.
 - Otherwise do not call update_goal merely as a heartbeat. Continue making concrete progress and leave the Goal active.`;
 

packages/agent-modules/goal/src/final-reply.ts

@@ -0,0 +1,143 @@
+/**
+ * Goal wrap-up after an accepted completion proposal.
+ *
+ * An accepted `update_goal(status=complete)` no longer ends the Turn: the
+ * worker writes one final reply to the user in the same Turn, and the Host
+ * settles and verifies afterwards. This module owns the Goal side of that
+ * last step, host-agnostic like the tool impls:
+ *
+ *  - the instruction returned with the accepted proposal;
+ *  - the refusal for every later tool call in the same Turn, `update_goal`
+ *    included, so the accepted proposal cannot be replaced and no more work
+ *    runs after the worker claimed completion;
+ *  - one retry when the response after the proposal is empty. A second empty
+ *    response ends the Turn normally; the proposal still goes to settlement.
+ *
+ * State only exists after this Turn's proposal was accepted, so other Turns,
+ * ordinary chats and Goal Turns before the proposal are never affected. The
+ * refusal is keyed by the agent run's context object — the `context` both the
+ * before- and after-tool hooks of one agent run receive — so a pre-tool check
+ * that has no Turn identity still finds its run. The retry is keyed by
+ * (sessionId, turnId); hosts must call `endTurn` when a Turn ends.
+ */
+
+import { wrapInternalContext } from './internal-context-fragment.js';
+
+/** Returned with an accepted completion proposal; the worker's last step in this Turn. */
+export const GOAL_FINAL_REPLY_INSTRUCTION =
+  'The completion proposal was accepted. Do not call any more tools in this turn: every further tool call, including update_goal, will be refused. ' +
+  'Now write one final reply to the user: say what was accomplished, where each deliverable file is, and how to use it when that is not obvious. ' +
+  'Declare every deliverable file of this goal, including files produced in earlier turns, with delivery markup (<media /> tags inside <deliver-assets>...</deliver-assets>), and also write each file path in the reply text. ' +
+  'The host verifies the goal only after this reply, so do not claim that verification has passed or that the result is verified or confirmed; describe checks you ran yourself as checks you ran, not as verification.';
+
+/** Result of every tool call refused after this Turn's completion proposal was accepted. */
+export const GOAL_COMPLETION_TOOL_REFUSAL =
+  'GOAL_COMPLETION_PROPOSED: This turn already proposed completion and the proposal was accepted. Do not call another tool; write the final reply to the user now.';
+
+/** Hidden follow-up sent once when the response after the accepted proposal is empty. */
+export const GOAL_FINAL_REPLY_RETRY_PROMPT = wrapInternalContext(
+  'goal',
+  'Your completion proposal was accepted, but your last response was empty. Do not call any tools. ' +
+    'Write the final reply to the user now: what was accomplished, where each deliverable file is (with delivery markup and the file path), and how to use it when that is not obvious. ' +
+    'Do not claim that verification has passed or that the result is verified.',
+);
+
+export const GOAL_FINAL_REPLY_RETRY_REASON = 'goal_final_reply_empty';
+
+export interface GoalFinalReplyTurn {
+  readonly sessionId: string;
+  readonly turnId: string;
+}
+
+/** The parts of an assistant response the gate reads. */
+export interface GoalFinalReplyResponse {
+  readonly stopReason?: string;
+  readonly content: ReadonlyArray<{ readonly type: string; readonly text?: string }>;
+}
+
+export type GoalFinalReplyResponseDecision =
+  | { readonly type: 'continue' }
+  | { readonly type: 'retry'; readonly reason: string; readonly prompt: string };
+
+export interface GoalFinalReplyGate {
+  /**
+   * Record an executed tool result; only an accepted completion proposal
+   * changes state. `run` is the agent context object the tool hooks received.
+   */
+  observeToolResult(
+    turn: GoalFinalReplyTurn,
+    run: object,
+    result: { readonly toolName: string; readonly details: unknown; readonly isError: boolean },
+  ): void;
+  /** Refusal for a tool call in an agent run whose completion proposal was accepted. */
+  refuseToolCall(run: object): { readonly block: true; readonly reason: string } | undefined;
+  /** Retry once when the response after the accepted proposal has neither text nor tool calls. */
+  reviewResponse(
+    turn: GoalFinalReplyTurn,
+    response: GoalFinalReplyResponse,
+  ): GoalFinalReplyResponseDecision;
+  endTurn(turn: GoalFinalReplyTurn): void;
+}
+
+/** True for the result `update_goal` returns when this Turn's completion proposal was accepted. */
+export function isAcceptedGoalCompletionResult(result: {
+  readonly toolName: string;
+  readonly details: unknown;
+  readonly isError: boolean;
+}): boolean {
+  if (result.isError || result.toolName !== 'update_goal') return false;
+  const details = result.details;
+  if (!details || typeof details !== 'object' || Array.isArray(details)) return false;
+  const proposal = (details as { proposal?: unknown }).proposal;
+  if (!proposal || typeof proposal !== 'object' || Array.isArray(proposal)) return false;
+  const { status, accepted } = proposal as { status?: unknown; accepted?: unknown };
+  return status === 'complete' && accepted === true;
+}
+
+interface TurnState {
+  retried: boolean;
+  readonly runs: Set<object>;
+}
+
+export function createGoalFinalReplyGate(): GoalFinalReplyGate {
+  const turns = new Map<string, TurnState>();
+  const acceptedRuns = new WeakSet<object>();
+  const keyOf = (turn: GoalFinalReplyTurn) => `${turn.sessionId}\u0000${turn.turnId}`;
+
+  return {
+    observeToolResult(turn, run, result) {
+      if (!isAcceptedGoalCompletionResult(result)) return;
+      acceptedRuns.add(run);
+      const state = turns.get(keyOf(turn)) ?? { retried: false, runs: new Set<object>() };
+      state.runs.add(run);
+      turns.set(keyOf(turn), state);
+    },
+    refuseToolCall(run) {
+      return acceptedRuns.has(run)
+        ? { block: true, reason: GOAL_COMPLETION_TOOL_REFUSAL }
+        : undefined;
+    },
+    reviewResponse(turn, response) {
+      const state = turns.get(keyOf(turn));
+      if (!state || state.retried) return { type: 'continue' };
+      if (response.stopReason === 'error' || response.stopReason === 'aborted') {
+        return { type: 'continue' };
+      }
+      const hasText = response.content.some(
+        (block) => block.type === 'text' && (block.text ?? '').trim().length > 0,
+      );
+      const hasToolCall = response.content.some((block) => block.type === 'toolCall');
+      if (hasText || hasToolCall) return { type: 'continue' };
+      state.retried = true;
+      return {
+        type: 'retry',
+        reason: GOAL_FINAL_REPLY_RETRY_REASON,
+        prompt: GOAL_FINAL_REPLY_RETRY_PROMPT,
+      };
+    },
+    endTurn(turn) {
+      for (const run of turns.get(keyOf(turn))?.runs ?? []) acceptedRuns.delete(run);
+      turns.delete(keyOf(turn));
+    },
+  };
+}

packages/agent-modules/goal/src/index.ts

@@ -179,3 +179,17 @@ export type {
   ThreadGoalTokenBudgetMutationPort,
   ThreadGoalTokenBudgetMutationResult,
 } from './tool-impls.js';
+export {
+  GOAL_COMPLETION_TOOL_REFUSAL,
+  GOAL_FINAL_REPLY_INSTRUCTION,
+  GOAL_FINAL_REPLY_RETRY_PROMPT,
+  GOAL_FINAL_REPLY_RETRY_REASON,
+  createGoalFinalReplyGate,
+  isAcceptedGoalCompletionResult,
+} from './final-reply.js';
+export type {
+  GoalFinalReplyGate,
+  GoalFinalReplyResponse,
+  GoalFinalReplyResponseDecision,
+  GoalFinalReplyTurn,
+} from './final-reply.js';