ucode-agent 1.52.0 → 1.54.0

package/package.json

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

package/src/core/loop.js

@@ -306,6 +306,9 @@ export function lean(messages, keep = 3) {
   });
 }
 
+/** Tools that write whole files, whose sizes are remembered for the turn. */
+const WHOLE_WRITES = new Set(['write_file', 'batch_write', 'create_app']);
+
 function trace(event) {
   if (!TRACE_FILE) return;
   try { appendFileSync(TRACE_FILE, `${JSON.stringify({ at: Date.now(), ...event })}
@@ -360,7 +363,9 @@ const MAX_WORKERS = 3;
 const WORKER_STEPS = Number(process.env.UCODE_WORKER_STEPS) || 60;
 
 /** Workers build; they do not plan, delegate further, or load skills themselves. */
-const WORKER_EXCLUDED = new Set(['delegate', 'update_plan', 'load_skill']);
+// create_app too: a worker builds a part of the app the lead already made,
+// and a second app from a worker would also end the lead's turn (see wrapUp).
+const WORKER_EXCLUDED = new Set(['delegate', 'update_plan', 'load_skill', 'create_app']);
 
 const planTool = {
   name: 'update_plan',
@@ -458,6 +463,28 @@ function pathsOf(call) {
   return a.path ? [a.path] : [];
 }
 
+/**
+ * A relative path with the project's own trailing folder names in front of
+ * it, taken back off: "scratchpad/run1/taskr" inside .../scratchpad/run1 is
+ * "taskr". Left alone when something by that first name is really there.
+ * ponytail: a genuinely new folder named like the project's own (run1/ inside
+ * run1) lands one level up; tell the two apart if that ever happens for real.
+ */
+export function unrepeat(p, cwd) {
+  if (!p || path.isAbsolute(p)) return p;
+  const parts = p.split(/[\\/]+/);
+  if (parts.length < 2 || existsSync(path.join(cwd, parts[0]))) return p;
+  const own = path.resolve(cwd).split(/[\\/]+/).filter(Boolean);
+  const same = process.platform === 'win32' || process.platform === 'darwin'
+    ? (x, y) => x.toLowerCase() === y.toLowerCase()
+    : (x, y) => x === y;
+  for (let n = Math.min(own.length, parts.length - 1); n > 0; n--) {
+    const tail = own.slice(-n);
+    if (tail.every((s, i) => same(s, parts[i]))) return parts.slice(n).join('/');
+  }
+  return p;
+}
+
 /**
  * Is everything that changed part of a page that has nothing to run?
  *
@@ -1189,6 +1216,8 @@ export class Agent {
     this.reads = new Map();
     this.declines = 0;
     this.apps = [];
+    this.wrote = new Map();
+    this.rewrite = null; // an Esc mid-cut must not end the next turn early
     forgetReviews(); // a new request: its apps get a fresh design review
     setRequest(input); // create_app checks this before choosing a starter
     const images = await this.attachImages(input);
@@ -1308,10 +1337,13 @@ export class Agent {
       let reply;
       let streaming = false;
       this.early = new Map();
+      // Its own signal, so one reply can be cut off without ending the turn.
+      // any() also sees an Esc that landed before this step began.
+      const cut = new AbortController();
 
       try {
         const opts = {
-          signal: this.abort.signal,
+          signal: AbortSignal.any([this.abort.signal, cut.signal]),
           onWait: (text) => this.ui.updateSpinner(text),
         };
         // Only a real terminal has somewhere to stream into.
@@ -1340,6 +1372,9 @@ export class Agent {
           // written now instead of sitting on "working" for ninety seconds.
           const writing = new Writing();
           opts.onToolArgs = ({ index, name, args }) => {
+            // create_app again over the app it already wrote. It would be
+            // refused anyway, after another ninety seconds of streaming it.
+            if (name === 'create_app' && !this.rewrite && (this.rewrite = this.builtApp())) cut.abort();
             const at = writing.seen(index, name, args);
             if (at) this.ui.updateSpinner(at);
           };
@@ -1368,6 +1403,12 @@ export class Agent {
         this.ui.thinkingEnd();
         if (streaming) this.ui.streamEnd();
 
+        if (this.rewrite && !this.abort.signal.aborted) {
+          this.ui.stopSpinner();
+          if (await this.wrapUp(fixRounds++)) continue;
+          return;
+        }
+
         // The model invented a tool and the provider rejected the request
         // outright. Tell it what it did and let it try again.
         if (err.kind === 'bad_tool_call' && argRetries < MAX_ARG_RETRIES) {
@@ -1412,6 +1453,13 @@ export class Agent {
       // the thinking timer has to be closed out here as well.
       this.ui.thinkingEnd();
       this.ui.stopSpinner();
+      // Cut off while writing the app again, but the stream ended quietly
+      // instead of throwing. Its half-written calls must not run.
+      if (this.rewrite && !this.abort.signal.aborted) {
+        if (streaming) this.ui.streamEnd();
+        if (await this.wrapUp(fixRounds++)) continue;
+        return;
+      }
       this.record(reply.usage);
       this.ui.step?.();
       this.stats.steps++;
@@ -1540,6 +1588,10 @@ export class Agent {
 
       const badArgs = await this.runCalls(reply.toolCalls);
       if (this.abort.signal.aborted) return;
+      if (this.rewrite) {
+        if (await this.wrapUp(fixRounds++)) continue;
+        return;
+      }
 
       // Malformed arguments go back to the model, but only so many times.
       if (badArgs) {
@@ -1776,6 +1828,7 @@ export class Agent {
     // goes on the same line, the way a change carries its two numbers.
     // Which app folders this turn actually made, so a second one can be
     // refused before it is built and any leftovers can be counted at the end.
+    if (WHOLE_WRITES.has(call.name)) for (const f of this.writesOf(call)) this.wrote?.set(f.abs, f.size);
     if (call.name === 'create_app' && call.args?.folder) {
       const made = path.resolve(this.cwd, String(call.args.folder));
       if (!(this.apps ??= []).includes(made)) this.apps.push(made);
@@ -1826,7 +1879,9 @@ export class Agent {
     // 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}`);
+    // A rewrite of the finished app is not a failure the user needs to see:
+    // the turn is about to end on the app already written.
+    else if (err.kind !== 'bad_args' && !this.rewrite) this.ui.toolFailed(`${err.kind}: ${err.failed}`);
 
     // Declines that keep coming are not decisions, they are a wall.
     //
@@ -1857,6 +1912,69 @@ export class Agent {
     return err.kind === 'bad_args';
   }
 
+  /** The app folder this turn already wrote a real file into (2 KB or more), or null. */
+  builtApp() {
+    for (const app of this.apps ?? []) {
+      for (const [abs, size] of this.wrote ?? []) {
+        const rel = path.relative(app, abs);
+        if (size >= 2000 && !rel.startsWith('..') && !path.isAbsolute(rel)) return app;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * End a turn whose app is already written, without asking the model again.
+   *
+   * DeepSeek writes the whole app in its first create_app, then writes it
+   * again — six more times in one traced build, ninety seconds each, every one
+   * refused. Refusing hands the turn straight back, so on screen the build
+   * kept starting over and never said it was done. The app on disk is the
+   * answer: check it once, hand back real errors, otherwise say so and stop.
+   *
+   * Returns true when there are errors for the model to fix.
+   */
+  async wrapUp(fixRounds) {
+    const app = this.rewrite;
+    this.rewrite = null;
+    const show = path.relative(this.cwd, app).split(path.sep).join('/') || '.';
+    // Everything this turn wrote, by where it really landed: create_app moves
+    // bare names into its folder, so the names the model used can miss.
+    for (const abs of this.wrote.keys()) this.sinceCheck.add(path.relative(this.cwd, abs));
+    const problems = await this.autoCheck();
+    if (problems && fixRounds < MAX_FIX_ROUNDS) {
+      this.push({
+        role: 'user',
+        content:
+          `The app is already written in ${show}; do not call create_app again. ucode checked it ` +
+          `and found errors. Fix them with edit_file, the smallest edits that do it, then finish.\n\n${problems}`,
+      });
+      return true;
+    }
+    const page = existsSync(path.join(app, 'index.html')) ? `${show}/index.html` : show;
+    const text = problems
+      ? `The app is in \`${show}\`, but the check still finds problems:\n\n${problems}`
+      : `Done — the app is in \`${show}\`. Open \`${page}\` in your browser to try it.`;
+    this.push({ role: 'assistant', content: text });
+    this.ui.assistant(text, { closing: true });
+    return false;
+  }
+
+  /** The files a whole-file write names, resolved the way the tool will resolve them. */
+  writesOf(call) {
+    const a = call.args ?? {};
+    const list = call.name === 'write_file' ? [{ path: a.path, content: a.content }] : normaliseFiles(a.files);
+    const home = call.name === 'create_app' && a.folder ? path.resolve(this.cwd, String(a.folder)) : null;
+    return list
+      .filter((f) => typeof f?.path === 'string' && typeof f?.content === 'string')
+      .map((f) => {
+        let abs = path.resolve(this.cwd, f.path);
+        const rel = home ? path.relative(home, abs) : '';
+        if (home && (rel.startsWith('..') || path.isAbsolute(rel))) abs = path.resolve(home, f.path.replace(/^[./\\]+/, ''));
+        return { abs, size: f.content.length, path: f.path };
+      });
+  }
+
   async dispatch(call) {
     // The model emitted arguments that were not valid JSON. Hand the parser's
     // own complaint straight back so it can correct itself next step.
@@ -1883,6 +2001,33 @@ export class Agent {
       });
     }
 
+    // Paths that start by repeating the project's own folder names. Told the
+    // working directory was .../scratchpad/run1, DeepSeek made its app at
+    // scratchpad/run1/taskr — the tree copied inside itself — and every later
+    // read of taskr/ missed, so it wrote the whole app again, six times.
+    const a = call.args;
+    if (a && typeof a === 'object') {
+      const fix = (p) => unrepeat(p, this.cwd);
+      for (const k of ['folder', 'path']) if (typeof a[k] === 'string') a[k] = fix(a[k]);
+      if (Array.isArray(a.paths)) a.paths = a.paths.map(fix);
+      if (Array.isArray(a.files)) for (const f of a.files) if (typeof f?.path === 'string') f.path = fix(f.path);
+    }
+
+    // A read of "index.html" right after create_app put it in tasker/. The
+    // model named the file that way, so it looks for it that way: DeepSeek got
+    // three not-founds and wrote the whole app again. A missing path that
+    // exists inside the one app made this turn is read from there.
+    if ((call.name === 'read_files' || call.name === 'read_file') && this.apps?.length === 1) {
+      const home = this.apps[0];
+      const inApp = (p) => {
+        if (typeof p !== 'string' || existsSync(path.resolve(this.cwd, p))) return p;
+        const there = path.resolve(home, p.replace(/^[./\\]+/, ''));
+        return existsSync(there) ? path.relative(this.cwd, there) : p;
+      };
+      if (call.name === 'read_file') call.args.path = inApp(call.args.path);
+      else if (Array.isArray(call.args?.paths)) call.args.paths = call.args.paths.map(inApp);
+    }
+
     // Reading the same unchanged file over and over.
     //
     // A traced build of a one-page app spent 53 of its 80 tool calls on
@@ -1911,6 +2056,19 @@ export class Agent {
       this.reads.set(key, seen + 1);
     }
 
+    // A whole app already written this turn, and create_app called again. The
+    // turn ends here (see wrapUp) instead of handing the refusal back to be
+    // retried: DeepSeek wrote the finished app, then wrote it six more times.
+    if (call.name === 'create_app' && (this.rewrite = this.builtApp())) {
+      const show = path.relative(this.cwd, this.rewrite) || '.';
+      throw new ToolFailure({
+        kind: 'already_made',
+        attempted: `creating ${show} again`,
+        failed: `${show} was already written this turn; nothing was changed.`,
+        fix: 'Do not call create_app again. To fix something in it, use edit_file on that part.',
+      });
+    }
+
     // create_app again for the app this turn already made. DeepSeek scaffolded
     // tasker with no files, then called create_app twice more — once with no
     // folder or name at all — and was refused both times while the empty
@@ -1924,6 +2082,23 @@ export class Agent {
       const files = args.files;
       const none = files == null || files === ''
         || (Array.isArray(files) ? !files.length : typeof files === 'object' && !Object.keys(files).length);
+      // Its files already written this turn, and create_app called over them
+      // again. DeepSeek does this to "verify" — and twice the second version
+      // was the broken one. The first stands; changes go through edit_file.
+      const written = [...(this.wrote?.keys() ?? [])].some((f) => {
+        const rel = path.relative(made, f);
+        return !rel.startsWith('..') && !path.isAbsolute(rel);
+      });
+      if (written && path.resolve(this.cwd, String(args.folder)) === made) {
+        const show = path.relative(this.cwd, made) || '.';
+        throw new ToolFailure({
+          kind: 'already_made',
+          attempted: `creating ${show} again`,
+          failed: `${show} was already created and written this turn; nothing was changed.`,
+          fix: 'The app is on disk as you wrote it. To check it, read it with read_files. To fix '
+            + 'something in it, use edit_file on that part. Do not call create_app again.',
+        });
+      }
       if (none && path.resolve(this.cwd, String(args.folder)) === made) {
         const show = path.relative(this.cwd, made) || '.';
         throw new ToolFailure({
@@ -1936,6 +2111,24 @@ export class Agent {
       }
     }
 
+    // A file written this turn, about to be replaced by a sliver of itself.
+    // DeepSeek built a 13.6 KB tasker, then "verified" it by writing it again
+    // as 24 bytes, and the app was gone. Checking a file is a read.
+    if (WHOLE_WRITES.has(call.name) && this.wrote?.size) {
+      for (const f of this.writesOf(call)) {
+        const had = this.wrote.get(f.abs);
+        if (had >= 2000 && f.size < had / 4) {
+          throw new ToolFailure({
+            kind: 'would_shrink',
+            attempted: `writing ${f.path}`,
+            failed: `You wrote ${f.path} earlier this turn (${had} characters), and this would replace it with ${f.size}.`,
+            fix: 'Nothing was written. To check a file, read it with read_files; do not write it again. '
+              + 'To change part of it, use edit_file.',
+          });
+        }
+      }
+    }
+
     // Starting a second app instead of fixing the first.
     //
     // A traced build hit a problem in todo/, abandoned it and made todo-fixed/

package/src/core/provider.js

@@ -168,7 +168,7 @@ export const stallLimit = () => Number(process.env.UCODE_STALL_MS) || 60_000;
 export const MAX_STALLS = 3;
 
 /** How long a reply may go quiet once it has started writing a tool call. */
-const writingLimit = () => Number(process.env.UCODE_STALL_MS) || 300_000;
+const writingLimit = () => Number(process.env.UCODE_STALL_MS) || 600_000;
 let stalls = 0;
 
 let current = process.env.UCODE_MODEL || DEFAULT_MODEL;
@@ -736,10 +736,18 @@ async function streamed(request, opts, id) {
   opts.signal?.addEventListener('abort', stop, { once: true });
   let stalled = false;
   let timer;
+  const frozen = (cause) => new Failure({
+    kind: 'timeout',
+    attempted: `asking ${modelName(id)} for a reply`,
+    failed: `${modelName(id)} went silent for too long, so ucode stopped waiting.`,
+    fix: 'ucode asks again by itself. If it keeps freezing, /model to North Mini Code.',
+    detail: { stalled: true, handed: handed.size },
+    cause,
+  });
   // Once a tool call has begun, the silence may be the call being written.
   // DeepSeek's free upstream holds a create_app back until the whole app is
   // done — two or three quiet minutes — and a one-minute watchdog killed every
-  // build it started. So a call in progress gets five minutes instead.
+  // build it started. So a call in progress gets ten minutes instead.
   const alive = () => {
     clearTimeout(timer);
     const limit = partial.size ? writingLimit() : stallLimit();
@@ -819,18 +827,15 @@ async function streamed(request, opts, id) {
     }
   } catch (err) {
     if (!stalled || opts.signal?.aborted) throw err;
-    throw new Failure({
-      kind: 'timeout',
-      attempted: `asking ${modelName(id)} for a reply`,
-      failed: `${modelName(id)} went silent for ${Math.round(stallLimit() / 1000)}s, so ucode stopped waiting.`,
-      fix: 'ucode asks again by itself. If it keeps freezing, /model to North Mini Code.',
-      detail: { stalled: true, handed: handed.size },
-      cause: err,
-    });
+    throw frozen(err);
   } finally {
     clearTimeout(timer);
     opts.signal?.removeEventListener('abort', stop);
   }
+  // The watchdog's abort can also end the stream quietly instead of throwing.
+  // Carrying on from there ran a half-written create_app: JSON repair closed
+  // it with no files, and five minutes of app were saved as an empty starter.
+  if (stalled && !opts.signal?.aborted) throw frozen();
 
   const toolCalls = [];
   for (const [index, slot] of partial) {

package/src/tools/index.js

@@ -3,6 +3,7 @@
  * line the user reads while each one runs.
  */
 
+import { jsonrepair } from 'jsonrepair';
 import { ToolFailure } from '../core/failure.js';
 import { readFile, readFiles, writeFile, batchWrite, editFile, multiEdit, editFiles } from './files.js';
 import { listDir, glob, grep } from './search.js';
@@ -573,6 +574,13 @@ export const FILE_WRITES = new Set(['write_file', 'batch_write', 'edit_file', 'm
  */
 const LENIENT = new Set(['create_app.files']);
 
+/** Names models use for an argument that the schema calls something else. */
+const ALIASES = {
+  path: ['file', 'filename', 'file_path', 'filepath'],
+  content: ['contents', 'text', 'code', 'body'],
+  paths: ['files'],
+};
+
 function check(name, args) {
   const schema = tools.find((t) => t.name === name).parameters;
   const problems = [];
@@ -584,6 +592,18 @@ function check(name, args) {
   // One file named as "path" where the tool takes a list called "paths".
   // DeepSeek did it to four read_files at once, a whole round trip spent being
   // told a plural it could simply have been given.
+  // The same argument under a neighbouring name: write_file sent "file"
+  // instead of "path" cost DeepSeek two and a half minutes to be told so.
+  for (const [key, others] of Object.entries(ALIASES)) {
+    if (!schema.properties[key] || args[key] != null) continue;
+    const other = others.find((o) => args[o] != null && !schema.properties[o]);
+    if (other) { args[key] = args[other]; delete args[other]; }
+  }
+  // read_files sent as files: [{ path }], the shape batch_write takes.
+  if (Array.isArray(args.paths)) {
+    args.paths = args.paths.map((p) => (typeof p?.path === 'string' ? p.path : p));
+  }
+
   for (const key of schema.required ?? []) {
     const one = key.endsWith('s') ? key.slice(0, -1) : '';
     if (args[key] == null && one && !schema.properties[one] && args[one] != null
@@ -619,7 +639,15 @@ function check(name, args) {
         const parsed = JSON.parse(value);
         const kind = Array.isArray(parsed) ? 'array' : typeof parsed;
         if (kind === wanted || LENIENT.has(`${name}.${key}`)) { args[key] = parsed; actual = kind; }
-      } catch { /* not JSON either — the message below is the right answer */ }
+      } catch {
+        // Nearly JSON: DeepSeek sent a whole app's files this way and was
+        // told only that a string is not an array. Repair it before refusing.
+        try {
+          const parsed = JSON.parse(jsonrepair(value));
+          const kind = Array.isArray(parsed) ? 'array' : typeof parsed;
+          if (kind === wanted) { args[key] = parsed; actual = kind; }
+        } catch { /* not JSON either — the message below is the right answer */ }
+      }
     }
 
     // A list of files written as a { path: contents } map. The tool reads it

package/src/tools/scaffold.js

@@ -454,11 +454,15 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // back — and only the ones this call did not already write over. A read is
   // another round trip to learn what ucode already knows.
   const starter = [];
+  const leftover = [];
   for (const rel of SHOW_BACK[template] ?? []) {
     const abs = path.join(target.abs, rel);
     if (written.has(abs)) continue;
     const text = await fs.readFile(abs, 'utf8').catch(() => null);
-    if (text !== null) starter.push(`=== ${target.show}/${rel} ===\n${text}`);
+    if (text !== null) {
+      starter.push(`=== ${target.show}/${rel} ===\n${text}`);
+      leftover.push(`${target.show}/${rel}`);
+    }
   }
 
   const out = result(
@@ -501,8 +505,18 @@ export async function createApp({ folder, name, description, template = 'plain-h
       (needsInstall
         ? `Run this app's commands with cwd: "${target.show}" (npm run build, npm run dev).\n\n${guide}`
         : `Nothing to install and nothing to build: open ${target.show}/index.html directly, or serve the ` +
-          `folder with "python -m http.server 8000" if it fetches anything.\n\n${guide}`) +
-      (starter.length
+          `folder with "python -m http.server 8000" if it fetches anything.\n` + (mine.length ? '' : `\n${guide}`)) +
+      // With the app passed in, the starter's placeholder files printed in full
+      // read as the app having been overwritten: DeepSeek took them for that
+      // and wrote the whole app a second time. So they are only named.
+      (mine.length
+        ? '\nYour files are on disk exactly as written above; nothing overwrote them.'
+          + (starter.length
+            ? ` Starter files you did not replace were left as they were: ${leftover.join(', ')}.`
+            : '')
+          + ' Do not write the app again: to check it, read it with read_files, and to change a '
+          + 'part of it, use edit_file. Writing it out again to verify it costs minutes and checks nothing.'
+        : starter.length
         ? `\n\nThe starter's files, in full — they are below, so do not read them back:\n\n${starter.join('\n\n')}`
         : ''),
     `${copied.length} files${wrote ? ` · ${mine.length} written` : ''}` +