@livx.cc/agentx 0.99.36 → 0.99.37

package/dist/{Agent-Fr8uwN_l.d.ts → Agent-B--fZNJy.d.ts}

@@ -532,6 +532,18 @@ declare class Agent {
      *  - only against the ledger for the WHOLE run, so referring back to a call it genuinely made earlier
      *    ("the screenshot showed an empty grid") is honest and stays silent;
      *  - only on a turn that made no tool calls of its own — a turn that DID call tools is closing normally.
+     *    (That is the enclosing `toolCalls.length === 0` branch. It is NOT extended to delegated activity:
+     *    a `cursor/*` turn runs its own tools and then fabricates in the SAME response, which is the exact
+     *    reported defect — see the call site.)
+     *
+     * What it deliberately does NOT catch, both verified:
+     *  - a fabrication that names no tool at all ("Let me take a look at the running app. The app view did
+     *    not respond in time.") — there is nothing to prove it against. Only prose matching could reach it,
+     *    and ungating `endsOnAnnouncedAction` for that was tried and reverted (it fires on ordinary English).
+     *  - a SECOND invented result for a tool the run genuinely called earlier. The ledger is per-run by
+     *    design, because that is the same fact that keeps an honest back-reference ("the screenshot showed
+     *    an empty grid") silent. Distinguishing them would need per-claim positional accounting, which buys
+     *    a rarer case at the cost of the common honest one.
      */
     private fabricatedToolNames;
     private dispatch;

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-Fr8uwN_l.js';
+import { H as Hooks, i as RunResult, R as ReasoningEffort, A as Agent } from './Agent-B--fZNJy.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, U as UserQuestion, H as HostBridge, c as ContentPart, g as MessageContent } from './tools-Byyh_bae.js';
 

package/dist/cli.js

@@ -4238,7 +4238,7 @@ var Agent = class _Agent {
       }
       if (toolCalls.length === 0) {
         if (this.drainInjections()) continue;
-        const fabricated = o.catchFabricatedToolUse && !closureNudged && delegatedTools.length === 0 ? this.fabricatedToolNames(contentText(res.content ?? "")) : [];
+        const fabricated = o.catchFabricatedToolUse && !closureNudged ? this.fabricatedToolNames(contentText(res.content ?? "")) : [];
         for (const n of fabricated) this.fabricatedClaims.add(n);
         if (fabricated.length && steps < o.maxSteps) {
           closureNudged = true;
@@ -4414,6 +4414,18 @@ var Agent = class _Agent {
    *  - only against the ledger for the WHOLE run, so referring back to a call it genuinely made earlier
    *    ("the screenshot showed an empty grid") is honest and stays silent;
    *  - only on a turn that made no tool calls of its own — a turn that DID call tools is closing normally.
+   *    (That is the enclosing `toolCalls.length === 0` branch. It is NOT extended to delegated activity:
+   *    a `cursor/*` turn runs its own tools and then fabricates in the SAME response, which is the exact
+   *    reported defect — see the call site.)
+   *
+   * What it deliberately does NOT catch, both verified:
+   *  - a fabrication that names no tool at all ("Let me take a look at the running app. The app view did
+   *    not respond in time.") — there is nothing to prove it against. Only prose matching could reach it,
+   *    and ungating `endsOnAnnouncedAction` for that was tried and reverted (it fires on ordinary English).
+   *  - a SECOND invented result for a tool the run genuinely called earlier. The ledger is per-run by
+   *    design, because that is the same fact that keeps an honest back-reference ("the screenshot showed
+   *    an empty grid") silent. Distinguishing them would need per-claim positional accounting, which buys
+   *    a rarer case at the cost of the common honest one.
    */
   fabricatedToolNames(text) {
     const out = [];