@miller-tech/uap 1.195.2 → 1.196.0

package/dist/delivery/agentic-executor.d.ts

@@ -67,6 +67,41 @@ export declare function readFileWindow(contents: string, opts?: {
     windowBytes?: number;
     path?: string;
 }): string;
+/** Bytes a single `list_dir` / `run_bash` reply may occupy. */
+export declare const TOOL_OUTPUT_MAX_BYTES = 4000;
+/**
+ * One window of a directory listing, plus what it left out.
+ *
+ * Same defect as `read_file` had, in a different costume: `readdirSync(...)
+ * .join('\n').slice(0, 4000)` cut mid-name and said nothing, so a large
+ * directory was silently unlistable past its first ~200 entries and the agent
+ * had no way to learn the rest existed.
+ *
+ * Truncates on ENTRY boundaries — half a filename is worse than no filename,
+ * because the model will confidently `read_file` it — and takes the same
+ * 1-based `offset` as `read_file` so a big directory is reachable rather than
+ * merely honest about being cut.
+ */
+export declare function listingWindow(entries: readonly string[], opts?: {
+    offset?: number;
+    maxBytes?: number;
+    path?: string;
+}): string;
+/**
+ * A command's output, clipped from the MIDDLE rather than the end.
+ *
+ * `${stdout}${stderr}`.slice(0, 4000) keeps the head — which is the worst half
+ * to keep. A failing build puts its summary at the END ("error: could not
+ * compile", "3 failed, 41 passed", the exit line); head-only truncation hands
+ * the model a wall of compiler noise with the verdict cut off, and it cannot
+ * ask again because command output is not re-fetchable the way a file is.
+ *
+ * So both ends: the head carries the FIRST error (the one that usually causes
+ * the rest) and the invocation, the tail carries the verdict. The elision is
+ * stated in the middle where it happened, because a gap the reader cannot see
+ * is a gap the reader will read straight across.
+ */
+export declare function clipCommandOutput(output: string, maxBytes?: number): string;
 /** Tool-call rounds before a final answer is forced (knob `UAP_MAX_TOOL_ROUNDS`). */
 export declare function defaultMaxToolRounds(): number;
 export interface AgenticExecutorOptions {
@@ -193,13 +228,17 @@ declare const TOOLS: readonly [{
     readonly type: "function";
     readonly function: {
         readonly name: "list_dir";
-        readonly description: "List files/dirs at a path relative to the project root.";
+        readonly description: string;
         readonly parameters: {
             readonly type: "object";
             readonly properties: {
                 readonly path: {
                     readonly type: "string";
                 };
+                readonly offset: {
+                    readonly type: "integer";
+                    readonly description: "1-based entry to start at. Omit for the start of the listing.";
+                };
             };
             readonly required: readonly ["path"];
         };
@@ -319,6 +358,44 @@ declare const TOOLS: readonly [{
         };
     };
 }];
+/**
+ * Top-level definition HEADERS in a file, counted.
+ *
+ * Keyed on the whole header line, not the name, and that distinction is the
+ * whole design. Overloading is legal and common — Postgres `f(int)` beside
+ * `f(text)`, a TypeScript overload set — and those have DIFFERENT headers. An
+ * appended copy has an IDENTICAL one. Counting names would refuse the first and
+ * miss nothing extra; counting headers refuses only the copy.
+ *
+ * Column 0 only. A method inside a class or a nested helper is indented, and
+ * two classes may legitimately both define `run`. Top-level definitions are
+ * where re-adding is unambiguous.
+ *
+ * An unrecognised extension yields nothing, so the guard is inert rather than
+ * guessing at a language it does not know.
+ */
+export declare function topLevelDefinitionHeaders(content: string, path: string): Map<string, number>;
+/** Escape hatch for a file that genuinely repeats a header (generated code). */
+export declare function duplicateDefinitionGuardDisabled(): boolean;
+/**
+ * Refuse a write that RE-ADDS a definition the file already has.
+ *
+ * The guards around this one all watch a file get smaller — anti-gutting
+ * (bytes), stub-substance (empty bodies), byte-identical NO-OP. Nothing watched
+ * it get BIGGER by repetition, and that is the shape the damage actually took.
+ *
+ * Live (cognition-engine, 2026-08-11): setup.sql ended the day holding 65 copies
+ * of `CREATE FUNCTION cognition.join_by_i_sql`, 63 of `join_by_i_time_sql`, and
+ * 40+ each of six more objects — 246 KB / 8,025 lines grown to 361 KB / 11,785,
+ * with 8,604 duplicate non-comment lines. A client relaunching the same "add X"
+ * mission dozens of times, against a file the agent could only see 3% of, will
+ * re-add X every time. Worse, every cheap check read as SUCCESS: the six lateral
+ * joins the mission targeted really were gone.
+ *
+ * Only the FIRST new duplicate is named. A refusal listing sixty of them is a
+ * wall the model will not act on.
+ */
+export declare function duplicateDefinitionRefusal(path: string, before: string, after: string): string | null;
 /**
  * Add an accepted contracts epic's files to the live contract lock, skipping
  * files other machinery owns (manifests/lockfiles stay editable so later

package/dist/delivery/agentic-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agentic-executor.d.ts","sourceRoot":"","sources":["../../src/delivery/agentic-executor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"agentic-executor.d.ts","sourceRoot":"","sources":["../../src/delivery/agentic-executor.ts"],"names":[],"mappings":"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"}

package/dist/delivery/agentic-executor.js

@@ -118,6 +118,77 @@ export function readFileWindow(contents, opts = {}) {
     return (`${body}\n\n… showing lines ${startLine}-${endLine} of ${totalLines} ` +
         `(${contents.length} bytes total).${more}`);
 }
+/** Bytes a single `list_dir` / `run_bash` reply may occupy. */
+export const TOOL_OUTPUT_MAX_BYTES = 4_000;
+/**
+ * One window of a directory listing, plus what it left out.
+ *
+ * Same defect as `read_file` had, in a different costume: `readdirSync(...)
+ * .join('\n').slice(0, 4000)` cut mid-name and said nothing, so a large
+ * directory was silently unlistable past its first ~200 entries and the agent
+ * had no way to learn the rest existed.
+ *
+ * Truncates on ENTRY boundaries — half a filename is worse than no filename,
+ * because the model will confidently `read_file` it — and takes the same
+ * 1-based `offset` as `read_file` so a big directory is reachable rather than
+ * merely honest about being cut.
+ */
+export function listingWindow(entries, opts = {}) {
+    const maxBytes = Math.max(1, opts.maxBytes ?? TOOL_OUTPUT_MAX_BYTES);
+    const total = entries.length;
+    const rawOffset = Number(opts.offset);
+    const start = Number.isFinite(rawOffset) ? Math.max(1, Math.trunc(rawOffset)) : 1;
+    if (total === 0)
+        return '';
+    if (start > total) {
+        return `NOTE: offset ${start} is past the end of ${opts.path ?? 'this directory'} (${total} entries).`;
+    }
+    const shown = [];
+    let used = 0;
+    for (const entry of entries.slice(start - 1)) {
+        const cost = entry.length + 1;
+        if (shown.length > 0 && used + cost > maxBytes)
+            break;
+        shown.push(entry);
+        used += cost;
+    }
+    const end = start + shown.length - 1;
+    const body = shown.join('\n');
+    if (start === 1 && end >= total)
+        return body;
+    const next = end + 1;
+    const more = next <= total
+        ? ` Call list_dir with {"path":"${opts.path ?? '.'}","offset":${next}} for the rest.`
+        : '';
+    return `${body}\n\n… showing entries ${start}-${end} of ${total}.${more}`;
+}
+/**
+ * A command's output, clipped from the MIDDLE rather than the end.
+ *
+ * `${stdout}${stderr}`.slice(0, 4000) keeps the head — which is the worst half
+ * to keep. A failing build puts its summary at the END ("error: could not
+ * compile", "3 failed, 41 passed", the exit line); head-only truncation hands
+ * the model a wall of compiler noise with the verdict cut off, and it cannot
+ * ask again because command output is not re-fetchable the way a file is.
+ *
+ * So both ends: the head carries the FIRST error (the one that usually causes
+ * the rest) and the invocation, the tail carries the verdict. The elision is
+ * stated in the middle where it happened, because a gap the reader cannot see
+ * is a gap the reader will read straight across.
+ */
+export function clipCommandOutput(output, maxBytes = TOOL_OUTPUT_MAX_BYTES) {
+    if (output.length <= maxBytes)
+        return output;
+    const budget = Math.max(1, maxBytes);
+    // Tail-weighted: the verdict is worth more than the preamble, but the first
+    // error still has to survive.
+    const headBytes = Math.floor(budget * 0.4);
+    const tailBytes = budget - headBytes;
+    const head = output.slice(0, headBytes);
+    const tail = output.slice(output.length - tailBytes);
+    const elided = output.length - head.length - tail.length;
+    return `${head}\n\n… [${elided} bytes of output elided — this is the START and the END of ${output.length} bytes] …\n\n${tail}`;
+}
 /** Tool-call rounds before a final answer is forced (knob `UAP_MAX_TOOL_ROUNDS`). */
 export function defaultMaxToolRounds() {
     const set = (process.env.UAP_MAX_TOOL_ROUNDS ?? '').trim();
@@ -251,10 +322,17 @@ const TOOLS = [
         type: 'function',
         function: {
             name: 'list_dir',
-            description: 'List files/dirs at a path relative to the project root.',
+            description: 'List files/dirs at a path relative to the project root. A large directory comes ' +
+                'back one window at a time and the reply says so — pass offset (1-based entry) for the rest.',
             parameters: {
                 type: 'object',
-                properties: { path: { type: 'string' } },
+                properties: {
+                    path: { type: 'string' },
+                    offset: {
+                        type: 'integer',
+                        description: '1-based entry to start at. Omit for the start of the listing.',
+                    },
+                },
                 required: ['path'],
             },
         },
@@ -371,6 +449,149 @@ function editGuttingRefusal(path, before, after) {
         'that removes most of the file. If you meant to delete code, do it in smaller, ' +
         'reviewable edits; if you meant to replace it, send the replacement body.');
 }
+/**
+ * Top-level definition HEADERS in a file, counted.
+ *
+ * Keyed on the whole header line, not the name, and that distinction is the
+ * whole design. Overloading is legal and common — Postgres `f(int)` beside
+ * `f(text)`, a TypeScript overload set — and those have DIFFERENT headers. An
+ * appended copy has an IDENTICAL one. Counting names would refuse the first and
+ * miss nothing extra; counting headers refuses only the copy.
+ *
+ * Column 0 only. A method inside a class or a nested helper is indented, and
+ * two classes may legitimately both define `run`. Top-level definitions are
+ * where re-adding is unambiguous.
+ *
+ * An unrecognised extension yields nothing, so the guard is inert rather than
+ * guessing at a language it does not know.
+ */
+export function topLevelDefinitionHeaders(content, path) {
+    const ext = (path.split('.').pop() ?? '').toLowerCase();
+    const patterns = {
+        sql: [
+            /^CREATE\s+(?:OR\s+REPLACE\s+)?(?:MATERIALIZED\s+)?(?:FUNCTION|PROCEDURE|VIEW|TABLE|TYPE|INDEX)\b.*/i,
+        ],
+        ts: [TS_DEF, TS_CONST],
+        tsx: [TS_DEF, TS_CONST],
+        js: [TS_DEF, TS_CONST],
+        jsx: [TS_DEF, TS_CONST],
+        mjs: [TS_DEF, TS_CONST],
+        py: [/^(?:async\s+)?(?:def|class)\s+\w+.*/],
+        rs: [/^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?(?:fn|struct|enum|trait)\s+\w+.*/],
+        go: [/^func\s+\w+.*/, /^type\s+\w+\s+.*/],
+    }[ext];
+    if (!patterns)
+        return new Map();
+    const counts = new Map();
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        // Column 0: no leading whitespace.
+        if (raw !== raw.trimStart())
+            continue;
+        const line = raw.trim();
+        // No comment filter: every pattern is anchored at ^, so `-- CREATE …`,
+        // `// export function …` and `# def …` cannot match in the first place.
+        // A filter here survived mutation because it could never change an outcome.
+        if (!line)
+            continue;
+        for (const re of patterns) {
+            if (!re.test(line))
+                continue;
+            counts.set(signatureKey(lines, i), (counts.get(signatureKey(lines, i)) ?? 0) + 1);
+            break;
+        }
+    }
+    return counts;
+}
+/** How many lines of a wrapped signature to gather before giving up. */
+const SIGNATURE_MAX_LINES = 24;
+/**
+ * The WHOLE signature, not just the line the definition starts on.
+ *
+ * Found by running this over the repo itself: `src/benchmarks/model-integration.ts`
+ * declares `runModelBenchmark` three times — a legitimate TypeScript overload
+ * set — and two of those start with the identical line
+ * `export async function runModelBenchmark(`, because the parameters wrap. Keying
+ * on that first line alone would call a real overload a duplicate and refuse a
+ * legitimate write. The parameters are exactly what distinguishes overloads, so
+ * the key has to reach them.
+ *
+ * Gathers until the parentheses balance, bounded, so a malformed or enormous
+ * signature degrades to "just this line" instead of swallowing the file.
+ */
+function signatureKey(lines, start) {
+    let text = lines[start].trim();
+    let depth = countParens(text);
+    for (let j = start + 1; depth > 0 && j < lines.length && j - start < SIGNATURE_MAX_LINES; j++) {
+        text += ` ${lines[j].trim()}`;
+        depth += countParens(lines[j]);
+    }
+    // Collapse whitespace so reformatting is not read as a different signature,
+    // and drop a trailing brace/semicolon so `fn f() {` matches `fn f()`.
+    return text.replace(/\s+/g, ' ').replace(/[{;]\s*$/, '').trim();
+}
+function countParens(s) {
+    let d = 0;
+    for (const ch of s) {
+        if (ch === '(')
+            d += 1;
+        else if (ch === ')')
+            d -= 1;
+    }
+    return d;
+}
+const TS_DEF = /^(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function|class)\s+\w+.*/;
+const TS_CONST = /^(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?(?:\(|function\b|class\b).*/;
+/** Escape hatch for a file that genuinely repeats a header (generated code). */
+export function duplicateDefinitionGuardDisabled() {
+    return process.env.UAP_DELIVER_ALLOW_DUPLICATE_DEFS === '1';
+}
+/**
+ * Refuse a write that RE-ADDS a definition the file already has.
+ *
+ * The guards around this one all watch a file get smaller — anti-gutting
+ * (bytes), stub-substance (empty bodies), byte-identical NO-OP. Nothing watched
+ * it get BIGGER by repetition, and that is the shape the damage actually took.
+ *
+ * Live (cognition-engine, 2026-08-11): setup.sql ended the day holding 65 copies
+ * of `CREATE FUNCTION cognition.join_by_i_sql`, 63 of `join_by_i_time_sql`, and
+ * 40+ each of six more objects — 246 KB / 8,025 lines grown to 361 KB / 11,785,
+ * with 8,604 duplicate non-comment lines. A client relaunching the same "add X"
+ * mission dozens of times, against a file the agent could only see 3% of, will
+ * re-add X every time. Worse, every cheap check read as SUCCESS: the six lateral
+ * joins the mission targeted really were gone.
+ *
+ * Only the FIRST new duplicate is named. A refusal listing sixty of them is a
+ * wall the model will not act on.
+ */
+export function duplicateDefinitionRefusal(path, before, after) {
+    if (duplicateDefinitionGuardDisabled())
+        return null;
+    const now = topLevelDefinitionHeaders(after, path);
+    // Fast path only — the loop below is already a no-op on an empty map. It
+    // earns its place by skipping the second parse, not by changing an outcome,
+    // which is why mutating it away leaves every test passing.
+    if (now.size === 0)
+        return null;
+    const was = topLevelDefinitionHeaders(before, path);
+    for (const [header, count] of now) {
+        const prior = was.get(header) ?? 0;
+        // Adding a brand-new definition (0 -> 1) is the normal case. Editing one in
+        // place (1 -> 1) is fine. Going 1 -> 2 is re-adding what is already there.
+        if (count <= prior || count < 2)
+            continue;
+        const firstLine = before.split('\n').findIndex((l) => l === l.trimStart() && l.trim().replace(/\s+/g, ' ').replace(/[{;]\s*$/, '').trim() === header);
+        const where = firstLine >= 0 ? ` at line ${firstLine + 1}` : '';
+        return (`ERROR: refusing to write ${path} — it would add a SECOND copy of a definition the file ` +
+            `already contains${where}:\n\n    ${header.slice(0, 160)}\n\n` +
+            `The file already has this (${prior} ${prior === 1 ? 'copy' : 'copies'}; this write makes ${count}). ` +
+            `Do not append it again — use edit_file to change the existing one in place, or read the file ` +
+            `first to see what is already there. If this file genuinely repeats that header, set ` +
+            `UAP_DELIVER_ALLOW_DUPLICATE_DEFS=1.`);
+    }
+    return null;
+}
 /** Resolve a model-supplied path inside the project root, refusing escapes. */
 function safePath(projectRoot, p) {
     const abs = isAbsolute(p) ? p : resolve(projectRoot, p);
@@ -584,7 +805,9 @@ export function repeatReadNote(cache, projectRoot, name, args, round) {
     // page 1, and scolding a model for paging through a long file would push it
     // straight back into the read-loop this is meant to end. Only a genuine
     // repeat — same path, same window, unchanged on disk — earns the note.
-    const offsetKey = name === 'read_file' && Number.isFinite(Number(args.offset))
+    // Both windowed tools, not just read_file: list_dir pages too now, and a
+    // directory's second page is no more a re-read than a file's.
+    const offsetKey = Number.isFinite(Number(args.offset))
         ? `@${Math.max(1, Math.trunc(Number(args.offset)))}`
         : '';
     const key = `${name}:${args.path}${offsetKey}`;
@@ -641,11 +864,9 @@ sweep = disabledSweep()) {
             // see what is in there. Serve that intent instead of failing, and name the
             // right tool for next time. A wasted turn becomes a useful one.
             if (statSync(abs).isDirectory()) {
-                const entries = readdirSync(abs)
+                const entries = listingWindow(readdirSync(abs)
                     .filter((e) => !AGENT_INTERNAL_DIRS.includes(e))
-                    .map((e) => (statSync(join(abs, e)).isDirectory() ? `${e}/` : e))
-                    .join('\n')
-                    .slice(0, 4000);
+                    .map((e) => (statSync(join(abs, e)).isDirectory() ? `${e}/` : e)), { path: String(args.path) });
                 return (`NOTE: '${String(args.path)}' is a DIRECTORY, not a file — use list_dir for it. ` +
                     `Its contents:\n${entries}`);
             }
@@ -661,13 +882,11 @@ sweep = disabledSweep()) {
                 return internal;
             if (!existsSync(abs))
                 return `ERROR: not found: ${args.path}`;
-            return readdirSync(abs)
+            return listingWindow(readdirSync(abs)
                 // Also HIDE the internal dirs from any listing (e.g. the project root), so
                 // the agent never even sees `.uap/` and is not tempted to spelunk it.
                 .filter((e) => !AGENT_INTERNAL_DIRS.includes(e))
-                .map((e) => (statSync(join(abs, e)).isDirectory() ? `${e}/` : e))
-                .join('\n')
-                .slice(0, 4000);
+                .map((e) => (statSync(join(abs, e)).isDirectory() ? `${e}/` : e)), { offset: args.offset, path: String(args.path ?? '.') });
         }
         if (name === 'write_file') {
             const abs = safePath(projectRoot, String(args.path));
@@ -774,6 +993,17 @@ sweep = disabledSweep()) {
                 if (stub.isStub)
                     return stubRefusal(String(args.path), stub);
             }
+            // Growth by repetition. Ordered LAST among the write guards: it is the
+            // only one that reads the whole prior file for structure, so it never
+            // pays that cost for a write another guard has already refused.
+            if (existsSync(abs)) {
+                try {
+                    const dup = duplicateDefinitionRefusal(String(args.path), readFileSync(abs, 'utf-8'), String(args.content ?? ''));
+                    if (dup)
+                        return dup;
+                }
+                catch { /* unreadable — a guard that cannot read cannot judge */ }
+            }
             mkdirSync(dirname(abs), { recursive: true });
             writeFileSync(abs, String(args.content ?? ''), 'utf-8');
             recordAuthorisedWrite(sweep, rel, String(args.content ?? ''));
@@ -903,6 +1133,12 @@ sweep = disabledSweep()) {
                 if (stub.isStub)
                     return stubRefusal(String(args.path), stub);
             }
+            // An edit can append just as easily as a write can — an old_string anchored
+            // at the end of the file with the whole definition in new_string is exactly
+            // how a file grows a second copy.
+            const dupEdit = duplicateDefinitionRefusal(String(args.path), current, updated);
+            if (dupEdit)
+                return dupEdit;
             writeFileSync(abs, updated, 'utf-8');
             recordAuthorisedWrite(sweep, rel, updated);
             const rustCheckNote = maybeRustWriteCheck(projectRoot, rel);
@@ -1017,7 +1253,7 @@ sweep = disabledSweep()) {
                     /* best effort */
                 }
             }
-            const out = `${r.stdout ?? ''}${r.stderr ?? ''}`.slice(0, 4000);
+            const out = clipCommandOutput(`${r.stdout ?? ''}${r.stderr ?? ''}`);
             const note = (restored.length > 0
                 ? `\n[blocked: restored ${restored.length} protected file(s) your command modified]`
                 : '') +