ucode-agent 1.13.0 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.13.0",
+  "version": "1.14.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,24 @@ 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.',
+    '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',
@@ -1370,9 +1382,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.
@@ -856,6 +885,7 @@ export class Screen {
     if (this.spinTimer) return;
     this.spinTimer = setInterval(() => {
       this.tick++;
+      this.paintLiveRun();
       this.paintStatus();
     }, FRAME_MS);
     this.spinTimer.unref?.();