ucode-agent 1.13.0 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "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

@@ -434,12 +434,41 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     '',
     '## How to work',
     '',
-    '- Say what you are about to do before you do it, in one short line, every time you',
-    '  pick up a new piece of work: "Right, the HTML structure first.", "Now the state',
-    '  and the render loop.", "That is the layout done - onto the animations." Without',
-    '  it the screen is a list of file operations and the user cannot tell what you are',
-    '  building or why. One sentence, in your own voice, then the actions. Not three',
-    '  sentences, and not a restatement of the request.',
+    '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',
+    'a phone). Keep it as the plan. Build against it, then go through it one item at a',
+    'time before you say a word about being finished. Most of what gets missed was',
+    'never written down.',
+    '',
+    'Do not put code in your reply. Not a snippet, not "here is the key part", not a',
+    'summary of the file. It is already in the file and the user can open it; pasting',
+    'it again buries the one or two sentences that actually matter. Say what it does',
+    'and what to try.',
+    '',
+    'Do not claim it is done while anything is still running or unchecked. "I have',
+    'built it" said before the build finishes is worse than saying nothing: the user',
+    'believes you, looks, and finds it broken. Finish, check, then say so — and if',
+    'something is incomplete, say which part and why.',
+    '',
+    'FIRST, EVERY TIME: one short line saying what you are about to do, then the tool',
+    'calls. Never open a turn with a tool call and no words. "Right, the HTML',
+    'structure first." / "Now the state and the render loop." / "That is the layout',
+    'done - onto the animations." / "Let me see what is there." One sentence, your own',
+    'voice, before the actions - not after them, not instead of them, not a',
+    'restatement of the request. The user watches this scroll past, and without those',
+    'lines it is a list of file operations they cannot read intent from.',
+    '',
+    'FIRST, EVERY TIME: write one short line saying what you are about to do, then',
+    'make the tool calls. Never open a turn with a tool call and no words. Examples:',
+    '"Right, the HTML structure first." / "Now the state and the render loop." /',
+    '"That is the layout done - onto the animations." / "Let me see what is there."',
+    'One sentence, your own voice, before the actions - not after them, not instead',
+    'of them, and not a restatement of what was asked. The user is watching this',
+    'scroll past; without those lines it is a list of file operations and they cannot',
+    'tell what you are building. This matters as much as the code.',
+    '',
+
     '',
     'Before you guess at an API, ask: type_of gives the exact signature from the',
     'TypeScript this project has installed, and find_symbol says where something is declared without',
@@ -974,7 +1003,7 @@ export class Agent {
         };
         // Only a real terminal has somewhere to stream into.
         if (this.full) {
-          opts.onThinking = () => this.ui.thinkingDelta();
+          opts.onThinking = (delta) => this.ui.thinkingDelta(delta);
           opts.onText = (delta) => {
             if (!streaming) {
               streaming = true;
@@ -1370,9 +1399,13 @@ export class Agent {
   reportFailure(call, err) {
     if (!(err instanceof ToolFailure)) throw err;
 
-    this.ui.toolFailed(
-      err instanceof Declined ? 'declined' : `${err.kind}: ${err.failed}`
-    );
+    // Bad arguments are the model talking to itself. "old_string and new_string
+    // are identical" is a correction it will make on the next step, and it means
+    // nothing to whoever is watching except that something went wrong. It goes
+    // to the model, which can act on it, and not to the screen. A refusal the
+    // user made, and anything that actually failed, still shows.
+    if (err instanceof Declined) this.ui.toolFailed('declined');
+    else if (err.kind !== 'bad_args') this.ui.toolFailed(`${err.kind}: ${err.failed}`);
     this.push({
       role: 'tool',
       toolCallId: call.id,

package/src/ui/screen.js

@@ -297,40 +297,66 @@ export class Screen {
     // U+25CF, not U+23FA: the latter carries emoji presentation, which Windows
     // Terminal draws as a white circle on a blue tile.
     const kind = groupKind(label);
-    const run = this.run;
-    // The run's own line is either the last one, or the last but one with its
-    // result underneath. Anything further down means something else was said
-    // in between, and the run is over.
-    const gap = run ? this.lines.length - 1 - run.at : Infinity;
-
-    // A second step of the same kind rewrites the line the first one wrote,
-    // rather than adding another almost-identical one beneath it.
-    if (run && run.kind === kind && gap <= 1) {
-      if (gap === 1) this.lines.pop();   // its single result line, now counted
+    // One line per kind of work for as long as the model is working on one
+    // thing. Reading, writing and reading again used to draw six lines that
+    // said three things; now the "Reading files" line it already has is the
+    // one that counts up, wherever it sits.
+    const run = (this.segment ??= new Map()).get(kind);
+
+    if (run && this.lines[run.at] !== undefined) {
       run.count++;
       run.label = label;
       run.targets.push(groupTarget(label));
-      this.paintRun();
+      this.run = run;
+      this.paintRun({ live: true });
     } else {
       this.push(`${narrationMark()} ${narration(asLabel(label))}`);
       this.run = {
         kind, count: 1, at: this.lines.length - 1, label,
         targets: [groupTarget(label)], added: 0, removed: 0,
       };
+      this.segment.set(kind, this.run);
+      this.paintRun({ live: true });
     }
     this.updateSpinner(label);
   }
 
-  /** Anything that is not another step of the same kind ends the run. */
-  endRun() { this.run = null; }
+  /**
+   * The model speaking — or a plan, or a failure — ends the segment.
+   *
+   * Up to that point a kind of work keeps one line and counts up on it. After
+   * it, the next read is a new piece of work and deserves its own line, which
+   * 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();
+  }
 
   /** Redraw the run's single line from what it has accumulated. */
-  paintRun() {
+  /**
+   * Redraw the run's single line from what it has accumulated.
+   *
+   * While its step is still running the text shimmers, which is the only
+   * thing on screen saying "this is happening now" once the per-step result
+   * lines are gone. It settles to plain dim the moment the step finishes, so
+   * the finished ones above stay quiet.
+   */
+  paintRun({ live = this.run?.live } = {}) {
     if (!this.run) return;
-    this.lines[this.run.at] = `${narrationMark()} ${narration(asLabel(runLine(this.run)))}`;
+    const text = asLabel(runLine(this.run));
+    this.run.live = live;
+    this.lines[this.run.at] = `${narrationMark()} ${live ? shimmer(text, this.tick * FRAME_MS) : narration(text)}`;
     this.render();
   }
 
+  /** Let the line in flight animate, one frame per tick. */
+  paintLiveRun() {
+    if (this.run?.live && this.lines[this.run.at] !== undefined) this.paintRun({ live: true });
+  }
+
   /**
    * A change, as its two numbers.
    *
@@ -361,7 +387,10 @@ export class Screen {
    * already names the step, and a change adds its numbers to that same line.
    * Only a failure earns a line of its own.
    */
-  toolResult() {}
+  toolResult() {
+    // The step is over: the line stops moving and joins the quiet ones above.
+    if (this.run) this.paintRun({ live: false });
+  }
 
   toolFailed(summary) {
     // A failure is never folded away.
@@ -503,17 +532,54 @@ export class Screen {
   // than silence. The spinner counts the seconds so the wait is visibly alive,
   // and the transcript gets one line afterwards saying how long it took.
 
-  thinkingDelta() {
+  /**
+   * The model's reasoning, live, one line at a time.
+   *
+   * Models reach for a tool before they say anything, so the first words of a
+   * step were arriving a minute after it began — while the reasoning channel
+   * had been streaming words the whole time and we were throwing them away to
+   * keep a timer. Its latest sentence now shows on one line that rewrites
+   * itself, which is something to read from the first second.
+   *
+   * It is scaffolding, not the answer: it shimmers while it is live and it is
+   * taken off the screen the moment the real reply starts.
+   */
+  thinkingDelta(text = '') {
     if (this.thoughtSince === undefined) this.thoughtSince = Date.now();
+    if (!text) return;
+
+    this.thought = ((this.thought ?? '') + text).slice(-2000);
+    // The last sentence it has finished, or what it has written of the next.
+    const parts = this.thought.split(/(?<=[.!?])\s+/).filter((p) => p.trim());
+    const latest = (parts[parts.length - 1] ?? '').replace(/\s+/g, ' ').trim();
+    if (!latest) return;
+
+    const line = `  ${shimmer(clip(latest, Math.max(20, this.width() - 6)), this.tick * FRAME_MS)}`;
+    if (this.thinkAt === undefined || this.lines[this.thinkAt] === undefined) {
+      this.thinkAt = this.lines.length;
+      this.push(line);
+    } else {
+      this.lines[this.thinkAt] = line;
+      this.render();
+    }
+  }
+
+  /** Keep the live thought moving between deltas. */
+  paintLiveThought() {
+    if (this.thinkAt !== undefined && this.lines[this.thinkAt] !== undefined) this.thinkingDelta('');
   }
 
   thinkingEnd() {
-    if (this.thoughtSince === undefined) return;
-    const seconds = Math.round((Date.now() - this.thoughtSince) / 1000);
-    // How long it thought is not what the reader is here for, and a line of it
-    // between every step broke every run of steps into singletons — which is
-    // why nothing folded. The time is still on the status row while it runs.
-    void seconds;
+    // The thought was the wait; once there is a reply it has nothing to add,
+    // so it comes off the screen rather than settling into the transcript.
+    if (this.thinkAt !== undefined) {
+      this.lines.splice(this.thinkAt, 1);
+      if (this.run && this.run.at > this.thinkAt) this.run.at--;
+      for (const run of this.segment?.values() ?? []) if (run.at > this.thinkAt) run.at--;
+      this.thinkAt = undefined;
+      this.render();
+    }
+    this.thought = '';
     this.thoughtSince = undefined;
   }
 
@@ -856,6 +922,8 @@ export class Screen {
     if (this.spinTimer) return;
     this.spinTimer = setInterval(() => {
       this.tick++;
+      this.paintLiveRun();
+      this.paintLiveThought();
       this.paintStatus();
     }, FRAME_MS);
     this.spinTimer.unref?.();