feat(agent): programmatic auto-continue on promissory stops

The system prompt forbids 'let me try another approach' followed by
silence, but the LLM regularly violates that rule — leaving the user
staring at a stderr with no resolution. Move enforcement from prompt
to code: after every streamText call, regex-match the final assistant
text against a promissory-phrase pattern. If matched, inject an
[auto-continue] user message and re-stream (up to 3 times per send).

Why code beats prompt:
- Deterministic. Regex either matches or doesn't, no model variance.
- Survives prompt drift. Future system-prompt rewrites can't silently
  remove the guard.
- Cheap. Capped at MAX_AUTOCONTINUE=3 — at most 3 extra round-trips.
- Visible. Emits a [agent: auto-continuing …] hint into the stream so
  the user sees why the agent kept going.

Pattern catches: 'let'?s try', 'let me (try|investigate|check|explore|
re-examine|verify|look)', 'i'?ll (try|explore|investigate|check|retry|
rerun)', 'another approach', 'trying (a different|another)',
'continue investigating', 'i need to (check|run|investigate)'.

Belt + suspenders: also tightened the prompt rule with explicit
forbidden phrases and a final-narration requirement, so a model that
ignores the regex still gets nagged via prompt.

Author: snomiao

src/agent/llm/session.ts

@@ -7,6 +7,22 @@ import { runScript } from '../shell/runtime'
 import type { ExecContext } from '../shell/runtime'
 import { collect } from '../shell/types'
 
+/**
+ * Phrases that signal the model promised follow-up action without
+ * executing it. Triggered programmatically — far more reliable than
+ * adding more "do not say this" rules to the system prompt, which
+ * the model regularly violates.
+ */
+const PROMISSORY_PATTERN =
+  /\b(let'?s try|let me (try|investigate|check|explore|re-?examine|verify|look)|i'?ll (try|explore|investigate|check|re-?try|re-?run)|another approach|trying (a different|another)|let me approach|could you|continue investigating|let me run|i need to (check|run|investigate))\b/i
+
+/**
+ * Up to this many extra streamText calls per send() to recover from
+ * promissory-stop. Caps the cost: the agent can't burn unlimited
+ * tokens looping on itself.
+ */
+const MAX_AUTOCONTINUE = 3
+
 const SYSTEM_PROMPT = `You operate ComfyUI through a POSIX-like shell running in the user's browser.
 
 THE ONLY EXISTING MOUNTS ARE:
@@ -260,6 +276,26 @@ Iteration / self-correction rules (CRITICAL):
   after the first attempt. The step budget is effectively unlimited.
 - If a run-js call throws, READ the error message and immediately retry
   with a corrected snippet in the SAME turn — no asking permission.
+  Phrases that MUST be followed by another tool call in the same turn,
+  not by a stop:
+    "Let's try another approach"
+    "Let me try a different way"
+    "I'll explore this further"
+    "Let me investigate"
+    "Let me check"
+    "I'll re-examine"
+    Any sentence ending with ":" or "..." that promises future action
+  If you write any of these, the very next tokens MUST be a run_shell
+  tool call. Stopping after such a sentence is forbidden — it leaves
+  the user staring at an error with no resolution.
+- Final answer narration rule: every turn that runs tools MUST end with
+  a 1-3 sentence plain-language summary of what you found, separate
+  from the tool output. Tool output alone is not an answer. Examples:
+    GOOD: "Found 2 orphan nodes: id 15 (MarkdownNote — looks
+           intentional, just documentation) and id 19 (Preview3D — has
+           model_file widget set but no upstream link)."
+    BAD: just leaving the JSON [15, 19] visible in the tool output and
+         going silent. The user shouldn't have to decode raw output.
 - "X is not defined" → the local name might be wrong; the injected locals
   are exactly: app, api, document, window, useCanvasStore, useCommandStore,
   useWorkflowStore, useMissingModelStore, useExecutionErrorStore,
@@ -505,44 +541,84 @@ export async function streamSession(
     ? { openai: { reasoningEffort: opts.reasoningEffort } }
     : undefined
 
-  const { textStream, text } = streamText({
-    model: openai(opts.model),
-    system,
-    messages: opts.messages,
-    abortSignal: opts.signal,
-    // Effectively unlimited — rely on the model to decide completion.
-    // A safety valve + repeat-script detection could be added later.
-    stopWhen: stepCountIs(opts.maxSteps ?? 1000),
-    providerOptions,
-    tools: {
-      run_shell: tool({
-        description:
-          'Run one or more shell commands. Supports pipes (|), sequencing (&&, ||, ;), and redirection (>, >>). Returns stdout, stderr, and exit code.',
-        inputSchema: z.object({
-          script: z.string().describe('The shell script to execute')
-        }),
-        execute: async ({ script }) => {
-          const res = await runScript(script, opts.execContext)
-          const stdout = await collect(res.stdout)
-          const inv: ToolInvocation = {
-            script,
-            stdout,
-            stderr: res.stderr,
-            exitCode: res.exitCode
-          }
-          toolCalls.push(inv)
-          onTool(inv)
-          return {
-            stdout,
-            stderr: res.stderr ?? '',
-            exitCode: res.exitCode
-          }
+  const tools = {
+    run_shell: tool({
+      description:
+        'Run one or more shell commands. Supports pipes (|), sequencing (&&, ||, ;), and redirection (>, >>). Returns stdout, stderr, and exit code.',
+      inputSchema: z.object({
+        script: z.string().describe('The shell script to execute')
+      }),
+      execute: async ({ script }: { script: string }) => {
+        const res = await runScript(script, opts.execContext)
+        const stdout = await collect(res.stdout)
+        const inv: ToolInvocation = {
+          script,
+          stdout,
+          stderr: res.stderr,
+          exitCode: res.exitCode
         }
-      })
-    }
-  })
-
-  for await (const delta of textStream) onDelta(delta)
-  const finalText = await text
-  return { text: finalText, toolCalls }
+        toolCalls.push(inv)
+        onTool(inv)
+        return {
+          stdout,
+          stderr: res.stderr ?? '',
+          exitCode: res.exitCode
+        }
+      }
+    })
+  }
+
+  let messages: ModelMessage[] = [...opts.messages]
+  let combinedText = ''
+  let autoContinues = 0
+
+  while (true) {
+    if (opts.signal?.aborted) break
+    const before = toolCalls.length
+    const { textStream, text } = streamText({
+      model: openai(opts.model),
+      system,
+      messages,
+      abortSignal: opts.signal,
+      stopWhen: stepCountIs(opts.maxSteps ?? 1000),
+      providerOptions,
+      tools
+    })
+    for await (const delta of textStream) onDelta(delta)
+    const finalText = await text
+    combinedText += finalText
+    const toolsDuringTurn = toolCalls.length - before
+
+    // Auto-continue heuristic: the model wrote a promissory phrase
+    // ("let me try another approach", "I'll investigate further", …)
+    // but stopped emitting tool calls. Inject a continue prompt and
+    // re-stream — up to MAX_AUTOCONTINUE times.
+    const stalled =
+      finalText.length > 0 &&
+      PROMISSORY_PATTERN.test(finalText) &&
+      // If the model just made a tool call this turn AND ended with the
+      // promise, it's mid-iteration — give it one more push. If it
+      // didn't make any tool call this turn, it's definitely stuck.
+      autoContinues < MAX_AUTOCONTINUE
+
+    if (!stalled) break
+
+    autoContinues++
+    messages = [
+      ...messages,
+      { role: 'assistant', content: finalText },
+      {
+        role: 'user',
+        content:
+          toolsDuringTurn === 0
+            ? '[auto-continue] You promised follow-up action but stopped without executing it. Run the next tool call now — do not narrate, act.'
+            : '[auto-continue] Your last turn surfaced something that needs another step. Take that step now via run_shell — no preamble.'
+      }
+    ]
+    onDelta(
+      `\n\n[agent: auto-continuing — promissory stop detected, attempt ${autoContinues}/${MAX_AUTOCONTINUE}]\n\n`
+    )
+  }
+
+  return { text: combinedText, toolCalls }
 }