ucode-agent 1.25.0 → 1.26.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.25.0",
+  "version": "1.26.1",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",

package/src/core/loop.js

@@ -435,13 +435,13 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     '',
     '## How to work',
     '',
-    'AN APP THAT IS AWKWARD TO USE IS NOT FINISHED. Before you call it done, look at',
-    'what you built as someone using it for the first time: is the button inside its',
-    'field or sitting on top of it, is there room to breathe between things, does the',
-    'empty state say anything, can every control be reached from the keyboard, does',
-    'it hold together at 360px wide. Controls that overlap or crowd each other are a',
-    'bug in the same way a crash is - fix it before you say a word about being done.',
-    '',
+    'AN APP THAT IS AWKWARD TO USE IS NOT FINISHED. Before you call it done, look at',
+    'what you built as someone using it for the first time: is the button inside its',
+    'field or sitting on top of it, is there room to breathe between things, does the',
+    'empty state say anything, can every control be reached from the keyboard, does',
+    'it hold together at 360px wide. Controls that overlap or crowd each other are a',
+    'bug in the same way a crash is - fix it before you say a word about being done.',
+    '',
     'Before building anything, turn the request into a list of what it must do — every',
     'feature named, and the ones any user would expect whether or not they were named',
     '(an empty state, an error state, the keyboard doing the obvious thing, working on',
@@ -493,18 +493,19 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     '',
     'YOUR FIRST WORDS, BEFORE ANY TOOL CALL, EVERY TIME. Nothing else appears on',
     'screen while you work, so if you say nothing the user watches a blank page.',
-    'Open with one line:  I will build Tide for you - a tasks app in a single HTML',
-    'file.  Then one line each time you start a new piece of the work:  Now the',
-    'components.  /  Now making the filter row.  /  Onto the animations.  Then one',
-    'line at the end saying it is done. Do not explain where the file is or how to',
-    'open it - they asked for it, they know where it went, and being told reads as',
-    'being talked down to.',
     '',
-    'Those lines are the whole of what the user reads. They are not thinking out',
-    'loud: never "I need to", never "Let me", never "The user wants", never a plan',
-    'of which files you will touch. Say what you are doing, the way you would to',
-    'someone watching over your shoulder.',
+    'Open with one plain sentence naming the thing and the shape of it:',
+    '  I will build Tide for you - a tasks app in a single HTML file, dark with a',
+    '  teal accent.',
+    'Then one line whenever you start a new piece of the work:  Now the filter row.',
+    'Then one line at the end saying it is done.',
     '',
+    'Plain words only. No methodology, no "component-based approach", no',
+    '"structured design", no listing the qualities the work will have. Never',
+    '"I need to", never "Let me", never a plan of which files you will touch, never',
+    'the request repeated back. Say it the way you would to someone watching over',
+    'your shoulder, who can already see the screen.',
+    '',
 
     '',
     'Before you guess at an API, ask: type_of gives the exact signature from the',
@@ -1015,6 +1016,7 @@ export class Agent {
     let argRetries = 0;
     let continuations = 0;
     let askedToVerify = false;
+    let squeezed = false;
     let askedToSpeak = false;
     let fixRounds = 0;
     this.failovers = 0;
@@ -1100,6 +1102,23 @@ export class Agent {
           continue;
         }
 
+        // An oversized conversation is a recoverable thing, not a dead end.
+        //
+        // The provider rejects the request, ucode prints the error and the
+        // half-built app stops there; typing "continue" sends the same
+        // oversized conversation again and fails the same way. Folding it and
+        // trying once is what the user would be told to do, so it happens
+        // without asking.
+        if (err.kind === 'bad_request' && !squeezed && !this.abort.signal.aborted) {
+          squeezed = true;
+          const before = this.working.length;
+          await this.maybeFold({ force: true });
+          if (this.working.length < before) {
+            this.ui.note('the conversation had grown too large — folded it and carried on');
+            continue;
+          }
+        }
+
         // Busy, slow or down: move to the next model and carry on, rather
         // than ending a half-built app with an error.
         if (passing(err) && !this.abort.signal.aborted && (await this.failover(err))) continue;
@@ -1841,10 +1860,16 @@ export class Agent {
     total.turns += 1;
   }
 
-  /** Fold older turns into a summary when the window gets tight. */
-  async maybeFold() {
+  /**
+   * Fold older turns into a summary when the window gets tight.
+   *
+   * `force` is for when the provider has already said the conversation is too
+   * large: its word beats our estimate of the same thing, and the estimate is
+   * what let it get here.
+   */
+  async maybeFold({ force = false } = {}) {
     const limit = contextLimit();
-    if (!tooBig(this.working, limit)) return;
+    if (!force && !tooBig(this.working, limit)) return;
 
     this.ui.startSpinner('context is filling up — summarizing earlier turns');
     try {

package/src/ui/screen.js

@@ -340,11 +340,19 @@ export class Screen {
    * is what makes the transcript read as a sequence of things done rather
    * than a set of running totals.
    */
-  endRun() {
-    if (this.run) this.paintRun({ live: false });
-    this.run = null;
-    this.segment = new Map();
-  }
+  /**
+   * Stop adding to the current run, but keep the lines already on screen.
+   *
+   * A kind of work gets one line for the whole turn. Starting a fresh set
+   * whenever the model spoke meant "Creating Tide from the HTML starter" five
+   * times down the page and "Reading files" four, each saying the same thing
+   * about a different moment. One line that counts up says all of it and
+   * costs one row.
+   */
+  endRun() { this.run = null; }
+
+  /** A new turn starts with a clean page's worth of lines. */
+  newSegment() { this.run = null; this.segment = new Map(); }
 
   /** Redraw the run's single line from what it has accumulated. */
   /**
@@ -869,6 +877,7 @@ export class Screen {
 
   /** A turn begins: the timer and step count run until turnEnd(). */
   turnStart() {
+    this.newSegment();
     this.activity = { start: Date.now(), steps: 0, movedAt: 0 };
     this.startTimer();
   }