npm - crewly - Versions diffs - 1.20.34 → 1.20.40 - Mend

crewly 1.20.34 → 1.20.40

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (78) hide show

package/frontend/dist/index.html CHANGED Viewed

@@ -7,7 +7,7 @@
     <meta name="color-scheme" content="dark" />
     <!-- Nunito font is self-hosted via @fontsource/nunito (imported in main.tsx) -->
     <title>Crewly AI Studio</title>
-    <script type="module" crossorigin src="/assets/index-e079a375.js"></script>
+    <script type="module" crossorigin src="/assets/index-e7785269.js"></script>
     <link rel="stylesheet" href="/assets/index-159eab4f.css">
   </head>
   <body class="bg-background-dark font-display text-text-primary-dark">

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "crewly",
-  "version": "1.20.34",
+  "version": "1.20.40",
   "type": "module",
   "description": "Multi-agent orchestration platform for AI coding teams — coordinates Claude Code, Gemini CLI, and Codex agents with a real-time web dashboard",
   "workspaces": [

package/packages/crewly-agent/src/runtime/agent-runner.service.test.ts CHANGED Viewed

@@ -55,9 +55,18 @@ describe('AgentRunnerService', () => {
     it('should initialize conversation state with empty messages', () => {
       const state = runner.getState();
       expect(state.messages).toEqual([]);
-      expect(state.systemPrompt).toBe('You are a test agent.');
+      expect(state.systemPrompt).toContain('You are a test agent.');
       expect(state.totalTokens).toEqual({ input: 0, output: 0 });
     });
+    it('appends the harness rules to every role prompt, so a weak model is told how to work', () => {
+      const prompt = runner.getState().systemPrompt;
+      expect(prompt.indexOf('You are a test agent.')).toBeLessThan(prompt.indexOf('## How to work'));
+      expect(prompt).toMatch(/never write a tool invocation as text/i);
+      expect(prompt).toMatch(/do the work in this turn/i);
+      // Naming the markup is what teaches a model to emit it.
+      expect(prompt).not.toMatch(/<\s*\/?\s*(invoke|parameter|function_calls)/i);
+    });
   });
   describe('initialize', () => {

package/packages/crewly-agent/src/runtime/agent-runner.service.ts CHANGED Viewed

@@ -15,11 +15,13 @@ import { createTools } from './tool-registry.js';
 import { connectAndLoadMcpTools } from './mcp-tool-bridge.js';
 import { ApprovalQueueService, type PendingApproval } from './approval-queue.service.js';
 import { OutputFilterService } from './output-filter.service.js';
+import { parseTextToolCalls, coerceArgs, resolveToolName, type TextToolCall, type SchemaLike } from './text-tool-calls.js';
 import type { ToolDefinition, McpClientLike } from './types.js';
 import {
   type CrewlyAgentConfig,
   type ConversationState,
   type AgentRunResult,
+  type IncompleteReason,
   type ToolCallRecord,
   type CompactionResult,
   type ContextBudgetStatus,
@@ -36,6 +38,109 @@ import {
   resolveMaxOutputTokens,
 } from './types.js';
+/**
+ * What a provider's finish reason means for the turn, and how to recover.
+ *
+ * `reason === null` is the only healthy outcome; everything else left work
+ * on the table. `recoverable` turns get `budget` more attempts, each
+ * prefixed with `nudge` so the model knows to carry on rather than restart.
+ */
+interface FinishOutcome {
+  reason: IncompleteReason | null;
+  detail: string;
+  recoverable: boolean;
+  budget: number;
+  nudge: string;
+}
+/** Nudge used when the model ran out of output tokens mid-answer. */
+const CONTINUE_NUDGE =
+  'Your previous message was cut off because it hit the output limit. Continue from exactly where you stopped. Do not repeat what you already wrote, and do not start over.';
+/** Nudge used after the provider ended a turn abnormally. */
+const RESUME_NUDGE =
+  'Your previous turn ended unexpectedly before the work was finished. Review what you had already done, then carry on and complete the task. Do not repeat completed steps.';
+/**
+ * Classify how a turn ended.
+ *
+ * @param finishReason - Raw provider finish reason
+ * @param steps - Steps the turn consumed
+ * @param maxSteps - The configured step ceiling
+ * @returns What it means and whether to retry
+ */
+export function classifyFinish(finishReason: string, steps: number, maxSteps: number): FinishOutcome {
+  const healthy: FinishOutcome = { reason: null, detail: '', recoverable: false, budget: 0, nudge: '' };
+  // Hitting the step ceiling is never a natural end, whatever the provider
+  // then reports — the loop was stopped from the outside mid-task.
+  if (steps >= maxSteps) {
+    return {
+      reason: 'steps-exhausted',
+      detail: `Stopped after the ${maxSteps}-step ceiling with work still outstanding.`,
+      recoverable: false,
+      budget: 0,
+      nudge: '',
+    };
+  }
+  switch (finishReason) {
+    case 'stop':
+    case 'tool-calls':
+      return healthy;
+    case 'length':
+      return {
+        reason: 'truncated',
+        detail: 'The model ran out of output tokens before finishing.',
+        recoverable: true,
+        budget: CREWLY_AGENT_DEFAULTS.MAX_CONTINUATIONS,
+        nudge: CONTINUE_NUDGE,
+      };
+    case 'content-filter':
+      return {
+        reason: 'content-filter',
+        detail: 'The provider refused to complete this turn on content grounds.',
+        recoverable: false,
+        budget: 0,
+        nudge: '',
+      };
+    default:
+      // 'other' | 'error' | 'unknown' | anything a provider invents.
+      return {
+        reason: 'abnormal-finish',
+        detail: `The provider ended the turn with "${finishReason}" before the work was finished.`,
+        recoverable: true,
+        budget: CREWLY_AGENT_DEFAULTS.MAX_ABNORMAL_RETRIES,
+        nudge: RESUME_NUDGE,
+      };
+  }
+}
+/**
+ * Fold a recovery attempt into the run it continues: text is appended (the
+ * model was told not to repeat itself), counters accumulate, and the newer
+ * finish reason wins.
+ *
+ * @param first - The run so far
+ * @param next - The continuation
+ * @returns The combined run
+ */
+export function mergeRuns(first: AgentRunResult, next: AgentRunResult): AgentRunResult {
+  const text = [first.text, next.text].map((t) => (t ?? '').trim()).filter(Boolean).join('\n\n');
+  return {
+    ...next,
+    text,
+    steps: first.steps + next.steps,
+    usage: {
+      input: first.usage.input + next.usage.input,
+      output: first.usage.output + next.usage.output,
+    },
+    toolCalls: [...first.toolCalls, ...next.toolCalls],
+    budgetWarning: next.budgetWarning ?? first.budgetWarning,
+    reasoning: next.reasoning ?? first.reasoning,
+  };
+}
 /**
  * No-op stubs for OSS-internal services. In OSS these resolve to concrete
  * implementations (tracing, memory flush, MCP client, Slack ID synth). The
@@ -378,6 +483,25 @@ export class AgentRunnerService {
    * @param modelManager - Optional model manager instance (for testing)
    * @param apiClient - Optional API client instance (for testing)
    */
+  /**
+   * Rules about *how* to work that every role prompt gets, whatever the model.
+   *
+   * These exist because a weaker model fails in ways a strong one does not:
+   * it writes its tool call as prose (so nothing runs and the user sees
+   * markup), or it narrates a plan and stops without carrying it out. The
+   * runtime recovers from both, but saying so plainly costs a few tokens and
+   * prevents most of it. The wording deliberately never shows the markup
+   * syntax — describing it is what teaches a model to emit it.
+   */
+  private static readonly HARNESS_RULES = [
+    '## How to work',
+    '',
+    '- Call tools through the tool-calling mechanism. Never write a tool invocation as text: your text is shown to the user verbatim and executes nothing.',
+    '- Do the work in this turn. If you say you will do something, do it before you finish — a plan with no action is a failed turn.',
+    '- Act, then check. Run the tool, read the result, and continue from what it actually returned rather than from what you expected.',
+    '- If something blocks you, say what blocked you and what you tried. Never report work as done that you did not verify.',
+  ].join('\n');
   constructor(
     config: CrewlyAgentConfig,
     modelManager?: ModelManager,
@@ -391,9 +515,10 @@ export class AgentRunnerService {
     );
     this.securityPolicy = { ...CREWLY_AGENT_DEFAULTS.SECURITY_POLICY };
     // In eval mode, strip delegation-first instructions so agent implements directly
-    this.effectiveSystemPrompt = config.evalMode
+    const rolePrompt = config.evalMode
       ? AgentRunnerService.stripDelegationInstructions(config.systemPrompt)
       : config.systemPrompt;
+    this.effectiveSystemPrompt = `${rolePrompt}\n\n${AgentRunnerService.HARNESS_RULES}`;
     // Conversation states are lazy-created on first access via the
     // `state` getter, so we don't need to seed `__default__` here.
     // The first message processed will create whichever conversation
@@ -1083,6 +1208,201 @@ export class AgentRunnerService {
   private async executeRunWithStreamText(
     tools: Record<string, unknown>,
     abortSignal: AbortSignal,
+  ): Promise<AgentRunResult> {
+    let result = await this.attemptWithSalvage(tools, abortSignal);
+    let outcome = classifyFinish(result.finishReason, result.steps, this.config.maxSteps);
+    let recoveryAttempts = 0;
+    // A turn only "finished" if the model chose to stop. Anything else left
+    // the job half-done, and until 0.1.2 that fragment was returned as if it
+    // were the answer — the agent would promise to do something, get cut off,
+    // and the user was told it was done (2026-09-19: the orchestrator ended
+    // 4 turns in a row on `other` and silently created nothing).
+    while (outcome.recoverable && recoveryAttempts < outcome.budget && !abortSignal.aborted) {
+      recoveryAttempts++;
+      this.streamingCallbacks.onTextChunk?.(`[recover] ${outcome.reason} — continuing (${recoveryAttempts}/${outcome.budget})\n`);
+      this.state.messages.push({ role: 'user', content: outcome.nudge });
+      const next = await this.attemptWithSalvage(tools, abortSignal);
+      result = mergeRuns(result, next);
+      outcome = classifyFinish(next.finishReason, next.steps, this.config.maxSteps);
+    }
+    if (outcome.reason === null) return result;
+    return {
+      ...result,
+      incomplete: {
+        reason: outcome.reason,
+        detail: outcome.detail,
+        finishReason: result.finishReason,
+        recoveryAttempts,
+      },
+    };
+  }
+  /**
+   * Run one turn, then rescue any tool call the model *wrote* instead of called.
+   *
+   * A weak model sometimes emits its call envelope into the text channel:
+   * the provider returns prose, the SDK sees no tool call, and the step ends
+   * having done nothing — the failure mode behind both the markup users saw
+   * in Slack and the turns that promised work and produced none. Rather than
+   * strip the markup and lose the intent, the envelope is parsed, the tools
+   * are executed for real, and the results are handed back so the turn can
+   * carry on.
+   *
+   * Salvaged calls go through the tool's own `execute`, so approval gates and
+   * command blocklists apply exactly as they do to a native call — this
+   * recovers lost work, it does not widen what the agent may do.
+   *
+   * @param tools - The tool registry for this run
+   * @param abortSignal - Cancels the turn and any further rounds
+   * @returns The turn's result, with salvaged calls folded into `toolCalls`
+   */
+  private async attemptWithSalvage(
+    tools: Record<string, unknown>,
+    abortSignal: AbortSignal,
+  ): Promise<AgentRunResult> {
+    let attempt = await this.attemptWithErrorRetries(tools, abortSignal);
+    const salvaged: ToolCallRecord[] = [];
+    for (let round = 0; round < CREWLY_AGENT_DEFAULTS.MAX_TEXT_TOOL_SALVAGES; round++) {
+      if (abortSignal.aborted) break;
+      const parsed = parseTextToolCalls(attempt.text ?? '');
+      if (parsed.calls.length === 0) break;
+      console.warn('[AgentRunner] Model wrote tool calls as text — executing them:', {
+        round: round + 1,
+        tools: parsed.calls.map(c => c.toolName),
+      });
+      this.streamingCallbacks.onTextChunk?.(
+        `[salvage] running ${parsed.calls.length} tool call(s) the model wrote as text\n`,
+      );
+      const { records, report } = await this.runSalvagedCalls(parsed.calls, tools);
+      salvaged.push(...records);
+      // Rewrite the turn's own message so the transcript does not keep
+      // teaching the model that writing markup is how a tool gets called.
+      this.replaceLastAssistantMessage(parsed.text || '(I wrote a tool call as text instead of calling the tool.)');
+      this.state.messages.push({ role: 'user', content: report });
+      const next = await this.attemptWithErrorRetries(tools, abortSignal);
+      attempt = mergeRuns({ ...attempt, text: parsed.text }, next);
+    }
+    return salvaged.length > 0
+      ? { ...attempt, toolCalls: [...attempt.toolCalls, ...salvaged] }
+      : attempt;
+  }
+  /**
+   * Execute the tool calls recovered from text and describe the results.
+   *
+   * Unknown tools and arguments the schema rejects are reported back rather
+   * than guessed at: the model gets a specific complaint it can act on, which
+   * is far more useful than silence.
+   *
+   * @param calls - Calls parsed out of the model's text
+   * @param tools - The tool registry for this run
+   * @returns Records for the run ledger, and the message to feed back
+   */
+  private async runSalvagedCalls(
+    calls: TextToolCall[],
+    tools: Record<string, unknown>,
+  ): Promise<{ records: ToolCallRecord[]; report: string }> {
+    const records: ToolCallRecord[] = [];
+    const sections: string[] = [];
+    const registry = tools as Record<string, ToolDefinition | undefined>;
+    for (const call of calls.slice(0, CREWLY_AGENT_DEFAULTS.MAX_SALVAGED_CALLS_PER_ROUND)) {
+      // A model that has seen another harness asks for `Bash`, not `bash_exec`.
+      const resolved = resolveToolName(call.toolName, Object.keys(registry));
+      const def = resolved ? registry[resolved] : undefined;
+      if (!resolved || !def || typeof def.execute !== 'function') {
+        sections.push(`### ${call.toolName}\nThere is no tool with that name. Available tools: ${Object.keys(registry).join(', ')}`);
+        continue;
+      }
+      const { args, error } = coerceArgs(call.args, def.inputSchema as unknown as SchemaLike | undefined);
+      if (error) {
+        sections.push(`### ${resolved}\nThe arguments were rejected: ${error}`);
+        continue;
+      }
+      const startedAt = Date.now();
+      this.streamingCallbacks.onToolCallStart?.(resolved, args);
+      let output: unknown;
+      try {
+        output = await def.execute(args);
+      } catch (err) {
+        output = { error: err instanceof Error ? err.message : String(err) };
+      }
+      this.streamingCallbacks.onToolCallFinish?.(resolved, args, output, Date.now() - startedAt);
+      records.push({ toolName: resolved, args, result: output });
+      // Name it as the model wrote it when that differed, so it learns the real name.
+      const heading = resolved === call.toolName ? resolved : `${resolved} (you wrote "${call.toolName}")`;
+      sections.push(`### ${heading}\n${this.summarizeSalvagedResult(output)}`);
+    }
+    const skipped = calls.length - Math.min(calls.length, CREWLY_AGENT_DEFAULTS.MAX_SALVAGED_CALLS_PER_ROUND);
+    const report = [
+      'You wrote your tool calls as text, so the model API never received them. I executed them for you; here is what they returned.',
+      ...sections,
+      skipped > 0 ? `(${skipped} further call(s) were not run — make them yourself.)` : '',
+      'Use the tool-calling mechanism from now on: text in your reply is shown to the user verbatim and executes nothing. Continue the task with these results.',
+    ].filter(Boolean).join('\n\n');
+    return { records, report };
+  }
+  /**
+   * Render a salvaged tool result small enough to feed back.
+   *
+   * @param output - Whatever the tool returned
+   * @returns A string, truncated with a note when it was long
+   */
+  private summarizeSalvagedResult(output: unknown): string {
+    let rendered: string;
+    try {
+      rendered = typeof output === 'string' ? output : JSON.stringify(output, null, 2) ?? String(output);
+    } catch {
+      rendered = String(output);
+    }
+    const limit = CREWLY_AGENT_DEFAULTS.SALVAGED_RESULT_MAX_CHARS;
+    return rendered.length > limit
+      ? `${rendered.slice(0, limit)}\n… (truncated, ${rendered.length - limit} more characters)`
+      : rendered;
+  }
+  /**
+   * Rewrite the assistant message this turn just added to the transcript.
+   *
+   * Stops at the user message that opened the turn, so an earlier, healthy
+   * reply is never touched.
+   *
+   * @param content - Replacement content
+   */
+  private replaceLastAssistantMessage(content: string): void {
+    for (let i = this.state.messages.length - 1; i >= 0; i--) {
+      const message = this.state.messages[i];
+      if (message.role === 'assistant') {
+        this.state.messages[i] = { ...message, content };
+        return;
+      }
+      if (message.role === 'user') return;
+    }
+  }
+  /**
+   * Run one turn, retrying only on *thrown* failures (rate limits, network,
+   * context length). A turn that returns with a bad `finishReason` is the
+   * caller's problem — see {@link executeRunWithStreamText}.
+   */
+  private async attemptWithErrorRetries(
+    tools: Record<string, unknown>,
+    abortSignal: AbortSignal,
   ): Promise<AgentRunResult> {
     const maxRetries = CREWLY_AGENT_DEFAULTS.MAX_RETRIES;
     const baseDelay = CREWLY_AGENT_DEFAULTS.RETRY_BASE_DELAY_MS;

package/packages/crewly-agent/src/runtime/finish-recovery.test.ts ADDED Viewed

@@ -0,0 +1,177 @@
+/**
+ * Tests for how a turn that did not end naturally is classified, continued
+ * and — when it cannot be rescued — reported as incomplete.
+ *
+ * The bug these lock down: a turn ending on `length` or `other` used to be
+ * returned as a finished answer, so the agent could promise work, get cut
+ * off, and report success (2026-09-19, the orchestrator ended four turns in
+ * a row on `other` and silently created nothing).
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AgentRunnerService, classifyFinish, mergeRuns } from './agent-runner.service.js';
+import { CREWLY_AGENT_DEFAULTS, type AgentRunResult, type CrewlyAgentConfig } from './types.js';
+const MAX_STEPS = 50;
+/** A run result with sensible defaults. */
+function runResult(over: Partial<AgentRunResult> = {}): AgentRunResult {
+  return {
+    text: 'text',
+    steps: 1,
+    usage: { input: 10, output: 5 },
+    toolCalls: [],
+    finishReason: 'stop',
+    ...over,
+  };
+}
+describe('classifyFinish', () => {
+  it('treats stop and tool-calls as the only healthy endings', () => {
+    for (const reason of ['stop', 'tool-calls']) {
+      expect(classifyFinish(reason, 3, MAX_STEPS)).toMatchObject({ reason: null, recoverable: false });
+    }
+  });
+  it('continues a turn cut off by the output limit, within the continuation budget', () => {
+    const out = classifyFinish('length', 3, MAX_STEPS);
+    expect(out).toMatchObject({ reason: 'truncated', recoverable: true, budget: CREWLY_AGENT_DEFAULTS.MAX_CONTINUATIONS });
+    expect(out.nudge).toMatch(/continue from exactly where you stopped/i);
+    expect(out.nudge).toMatch(/do not repeat/i);
+  });
+  it('retries an abnormal provider finish once, naming the reason', () => {
+    for (const reason of ['other', 'error', 'unknown', 'insufficient_system_resource']) {
+      const out = classifyFinish(reason, 3, MAX_STEPS);
+      expect(out).toMatchObject({ reason: 'abnormal-finish', recoverable: true, budget: CREWLY_AGENT_DEFAULTS.MAX_ABNORMAL_RETRIES });
+      expect(out.detail).toContain(reason);
+    }
+  });
+  it('never retries a content-filter refusal', () => {
+    expect(classifyFinish('content-filter', 3, MAX_STEPS)).toMatchObject({ reason: 'content-filter', recoverable: false, budget: 0 });
+  });
+  it('reports the step ceiling as incomplete whatever the provider says, and does not retry into it', () => {
+    // Even a 'stop' at the ceiling means the loop was cut from outside.
+    expect(classifyFinish('stop', MAX_STEPS, MAX_STEPS)).toMatchObject({ reason: 'steps-exhausted', recoverable: false });
+    expect(classifyFinish('length', MAX_STEPS + 2, MAX_STEPS)).toMatchObject({ reason: 'steps-exhausted' });
+    expect(classifyFinish('stop', MAX_STEPS - 1, MAX_STEPS)).toMatchObject({ reason: null });
+  });
+});
+describe('mergeRuns', () => {
+  it('appends text and accumulates steps, usage and tool calls', () => {
+    const merged = mergeRuns(
+      runResult({ text: 'part one', steps: 4, usage: { input: 10, output: 20 }, toolCalls: [{ toolName: 'a', args: {}, result: 1 }], finishReason: 'length' }),
+      runResult({ text: 'part two', steps: 2, usage: { input: 3, output: 7 }, toolCalls: [{ toolName: 'b', args: {}, result: 2 }], finishReason: 'stop' }),
+    );
+    expect(merged.text).toBe('part one\n\npart two');
+    expect(merged.steps).toBe(6);
+    expect(merged.usage).toEqual({ input: 13, output: 27 });
+    expect(merged.toolCalls.map((t) => t.toolName)).toEqual(['a', 'b']);
+    expect(merged.finishReason).toBe('stop');
+  });
+  it('drops empty halves rather than leaving blank gaps, and keeps the newer metadata', () => {
+    expect(mergeRuns(runResult({ text: '' }), runResult({ text: 'only' })).text).toBe('only');
+    expect(mergeRuns(runResult({ text: 'only' }), runResult({ text: '   ' })).text).toBe('only');
+    const merged = mergeRuns(runResult({ budgetWarning: 'old', reasoning: 'r1' }), runResult({ budgetWarning: undefined, reasoning: null }));
+    expect(merged.budgetWarning).toBe('old');
+    expect(merged.reasoning).toBe('r1');
+  });
+});
+describe('recovery loop', () => {
+  let runner: AgentRunnerService;
+  let attempts: AgentRunResult[];
+  let attemptSpy: ReturnType<typeof vi.fn>;
+  const config = {
+    sessionName: 'test-agent',
+    role: 'developer',
+    projectPath: '/tmp',
+    maxSteps: MAX_STEPS,
+    model: { provider: 'deepseek', modelId: 'deepseek-chat' },
+  } as unknown as CrewlyAgentConfig;
+  /** Drive the private recovery loop with a scripted sequence of attempts. */
+  async function runLoop(): Promise<AgentRunResult> {
+    return await (runner as unknown as {
+      executeRunWithStreamText(tools: Record<string, unknown>, signal: AbortSignal): Promise<AgentRunResult>;
+    }).executeRunWithStreamText({}, new AbortController().signal);
+  }
+  beforeEach(() => {
+    runner = new AgentRunnerService(config);
+    attempts = [];
+    attemptSpy = vi.fn(async () => attempts.shift() ?? runResult());
+    (runner as unknown as Record<string, unknown>).attemptWithErrorRetries = attemptSpy;
+  });
+  it('returns a healthy turn untouched, with no extra model call', async () => {
+    attempts = [runResult({ text: 'done', finishReason: 'stop' })];
+    const out = await runLoop();
+    expect(out.text).toBe('done');
+    expect(out.incomplete).toBeUndefined();
+    expect(attemptSpy).toHaveBeenCalledTimes(1);
+  });
+  it('continues a truncated turn until the model stops, and returns the joined answer', async () => {
+    attempts = [
+      runResult({ text: 'first half', finishReason: 'length' }),
+      runResult({ text: 'second half', finishReason: 'stop' }),
+    ];
+    const out = await runLoop();
+    expect(out.text).toBe('first half\n\nsecond half');
+    expect(out.incomplete).toBeUndefined();
+    expect(attemptSpy).toHaveBeenCalledTimes(2);
+  });
+  it('gives up after the continuation budget and reports what it kept', async () => {
+    attempts = Array.from({ length: 10 }, (_, i) => runResult({ text: `chunk ${i}`, finishReason: 'length' }));
+    const out = await runLoop();
+    expect(attemptSpy).toHaveBeenCalledTimes(CREWLY_AGENT_DEFAULTS.MAX_CONTINUATIONS + 1);
+    expect(out.incomplete).toMatchObject({ reason: 'truncated', recoveryAttempts: CREWLY_AGENT_DEFAULTS.MAX_CONTINUATIONS });
+    expect(out.text).toContain('chunk 0');
+  });
+  it('recovers the deepseek case: an abnormal finish retried once that then completes', async () => {
+    attempts = [
+      runResult({ text: "I'll create the team", finishReason: 'other' }),
+      runResult({ text: 'Team created.', finishReason: 'stop' }),
+    ];
+    const out = await runLoop();
+    expect(out.incomplete).toBeUndefined();
+    expect(out.text).toBe("I'll create the team\n\nTeam created.");
+  });
+  it('marks the turn incomplete when the provider keeps bailing', async () => {
+    attempts = [
+      runResult({ text: "I'll create the team", finishReason: 'other' }),
+      runResult({ text: '', finishReason: 'other' }),
+    ];
+    const out = await runLoop();
+    expect(attemptSpy).toHaveBeenCalledTimes(2);
+    expect(out.incomplete).toMatchObject({ reason: 'abnormal-finish', finishReason: 'other', recoveryAttempts: 1 });
+  });
+  it('does not retry a step-exhausted or content-filtered turn', async () => {
+    attempts = [runResult({ steps: MAX_STEPS, finishReason: 'tool-calls' })];
+    expect((await runLoop()).incomplete).toMatchObject({ reason: 'steps-exhausted', recoveryAttempts: 0 });
+    expect(attemptSpy).toHaveBeenCalledTimes(1);
+    attemptSpy.mockClear();
+    attempts = [runResult({ finishReason: 'content-filter' })];
+    expect((await runLoop()).incomplete).toMatchObject({ reason: 'content-filter' });
+    expect(attemptSpy).toHaveBeenCalledTimes(1);
+  });
+  it('pushes a continuation instruction into the conversation before retrying', async () => {
+    attempts = [runResult({ finishReason: 'length' }), runResult({ finishReason: 'stop' })];
+    await runLoop();
+    const messages = (runner as unknown as { state: { messages: Array<{ role: string; content: string }> } }).state.messages;
+    const nudge = messages.filter((m) => m.role === 'user').pop();
+    expect(nudge?.content).toMatch(/continue from exactly where you stopped/i);
+  });
+});