opencrowd 0.5.4 → 0.6.1

package/bundle/opencrowd.js

@@ -15548,7 +15548,7 @@ var init_commands = __esm({
 });
 
 // ../../packages/protocol/dist/events.js
-var eventBase, runScoped, turnField, WorkerReadyEventSchema, CommandAcceptedEventSchema, CommandRejectionReasonSchema, CommandRejectedEventSchema, RunStateEventSchema, AssistantDeltaEventSchema, AssistantMessageEventSchema, ToolStartedEventSchema, ToolStatusSchema, ToolFinishedEventSchema, ArtifactCreatedEventSchema, UsageUpdatedEventSchema, ApprovalRequestSchema, ApprovalRequiredEventSchema, FundingRequiredEventSchema, DelegationProblemSchema, DelegationRequiredEventSchema, PaymentUnknownEventSchema, CheckpointReasonSchema, CheckpointCompletedEventSchema, RunFinishedEventSchema, RuntimeErrorEventSchema, UserMessageEventSchema, EVENT_TYPES, EventTypeSchema, EventSchema;
+var eventBase, runScoped, turnField, WorkerReadyEventSchema, CommandAcceptedEventSchema, CommandRejectionReasonSchema, CommandRejectedEventSchema, RunStateEventSchema, AssistantDeltaEventSchema, AssistantMessageEventSchema, ToolStartedEventSchema, ToolStatusSchema, ToolFinishedEventSchema, ModelStartedEventSchema, ModelFinishedEventSchema, ArtifactCreatedEventSchema, UsageUpdatedEventSchema, ApprovalRequestSchema, ApprovalRequiredEventSchema, FundingRequiredEventSchema, DelegationProblemSchema, DelegationRequiredEventSchema, PaymentUnknownEventSchema, CheckpointReasonSchema, CheckpointCompletedEventSchema, RunFinishedEventSchema, RuntimeErrorEventSchema, UserMessageEventSchema, EVENT_TYPES, EventTypeSchema, EventSchema;
 var init_events = __esm({
   "../../packages/protocol/dist/events.js"() {
     "use strict";
@@ -15667,6 +15667,22 @@ var init_events = __esm({
         ...turnField
       })
     });
+    ModelStartedEventSchema = external_exports.looseObject({
+      ...runScoped,
+      type: external_exports.literal("model.started"),
+      payload: external_exports.looseObject({ callId: IdSchema, model: external_exports.string(), ...turnField })
+    });
+    ModelFinishedEventSchema = external_exports.looseObject({
+      ...runScoped,
+      type: external_exports.literal("model.finished"),
+      payload: external_exports.looseObject({
+        callId: IdSchema,
+        model: external_exports.string(),
+        status: ToolStatusSchema,
+        durationMs: external_exports.number().nonnegative(),
+        ...turnField
+      })
+    });
     ArtifactCreatedEventSchema = external_exports.looseObject({
       ...runScoped,
       type: external_exports.literal("artifact.created"),
@@ -15805,6 +15821,8 @@ var init_events = __esm({
       "assistant.delta",
       "assistant.message",
       "user.message",
+      "model.started",
+      "model.finished",
       "tool.started",
       "tool.finished",
       "artifact.created",
@@ -15826,6 +15844,8 @@ var init_events = __esm({
       RunStateEventSchema,
       AssistantDeltaEventSchema,
       AssistantMessageEventSchema,
+      ModelStartedEventSchema,
+      ModelFinishedEventSchema,
       ToolStartedEventSchema,
       ToolFinishedEventSchema,
       ArtifactCreatedEventSchema,
@@ -15875,6 +15895,48 @@ var init_redact = __esm({
   }
 });
 
+// ../../packages/protocol/dist/telemetry.js
+function scrubText(text) {
+  return text.replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/g, "[REDACTED]").replace(/\bBearer\s+[A-Za-z0-9._~+\/-]+=*/gi, "Bearer [REDACTED]").replace(/\b(?:sk-[A-Za-z0-9_-]{16,}|ph[csx]_[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)\b/g, "[REDACTED]").replace(/\b((?:[A-Z_]*(?:SECRET|PASSWORD|API_KEY|PRIVATE_KEY|ACCESS_TOKEN)[A-Z_]*|authorization|cookie|signature|x-amz-signature)\s*[=:]\s*)[^\s&,;]+/gi, "$1[REDACTED]").replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/g, "$1[REDACTED]@");
+}
+function captureDetail(input2, maxBytes = 96 * 1024) {
+  let redacted = false;
+  const clean3 = (value2, depth = 0) => {
+    if (depth > 30)
+      return "[depth limit]";
+    if (typeof value2 === "string") {
+      const s3 = scrubText(value2);
+      redacted ||= s3 !== value2;
+      return s3;
+    }
+    if (Array.isArray(value2))
+      return value2.map((v) => clean3(v, depth + 1));
+    if (value2 && typeof value2 === "object") {
+      return Object.fromEntries(Object.entries(value2).map(([key, v]) => {
+        if (isSensitiveKey(key) || /^(signature|privatekey|seedphrase|mnemonic)$/i.test(key)) {
+          redacted = true;
+          return [key, "[REDACTED]"];
+        }
+        return [key, clean3(v, depth + 1)];
+      }));
+    }
+    return typeof value2 === "bigint" ? value2.toString() : value2 ?? null;
+  };
+  const value = clean3(input2), json3 = JSON.stringify(value), bytes = new TextEncoder().encode(json3).length;
+  return {
+    value: bytes > maxBytes ? { preview: json3.slice(0, Math.floor(maxBytes / 6)) } : value,
+    redacted,
+    truncated: bytes > maxBytes,
+    bytes
+  };
+}
+var init_telemetry = __esm({
+  "../../packages/protocol/dist/telemetry.js"() {
+    "use strict";
+    init_redact();
+  }
+});
+
 // ../../packages/protocol/dist/seq.js
 var init_seq = __esm({
   "../../packages/protocol/dist/seq.js"() {
@@ -16052,6 +16114,41 @@ var init_spending = __esm({
   }
 });
 
+// ../../packages/protocol/dist/financial-state.js
+var usdc, FinancialStateSchema;
+var init_financial_state = __esm({
+  "../../packages/protocol/dist/financial-state.js"() {
+    "use strict";
+    init_zod();
+    usdc = external_exports.string().regex(/^\d+\.\d{6}$/);
+    FinancialStateSchema = external_exports.discriminatedUnion("status", [
+      external_exports.object({
+        status: external_exports.literal("available"),
+        run_id: external_exports.string().uuid(),
+        observed_at: external_exports.string().datetime(),
+        currency: external_exports.literal("USDC"),
+        wallet: external_exports.object({
+          balance_status: external_exports.enum(["available", "unavailable"]),
+          balance_usdc: usdc.nullable(),
+          reserved_usdc: usdc,
+          available_usdc: usdc.nullable()
+        }),
+        current_run: external_exports.object({
+          inference_spent_usdc: usdc,
+          service_spent_usdc: usdc,
+          total_spent_usdc: usdc,
+          reserved_usdc: usdc,
+          budget_limit_usdc: usdc,
+          remaining_budget_usdc: usdc,
+          per_call_approval_threshold_usdc: usdc,
+          approval_mode: external_exports.enum(["auto", "ask", "off"])
+        })
+      }),
+      external_exports.object({ status: external_exports.literal("unavailable"), reason: external_exports.string() })
+    ]);
+  }
+});
+
 // ../../packages/protocol/dist/index.js
 var init_dist = __esm({
   "../../packages/protocol/dist/index.js"() {
@@ -16062,10 +16159,12 @@ var init_dist = __esm({
     init_commands();
     init_events();
     init_redact();
+    init_telemetry();
     init_seq();
     init_codec();
     init_context();
     init_spending();
+    init_financial_state();
   }
 });
 
@@ -16348,7 +16447,7 @@ function normalizeConfig(value) {
   const proxyDefaults = providerDefaults(raw["openrouter-x402-proxy"] ?? raw.x402, DEFAULT_CONFIG["openrouter-x402-proxy"]);
   const mcpServers = recordValue(raw.mcpServers);
   const servers = { ...DEFAULT_CONFIG.mcpServers, ...mcpServers };
-  if (servers.crowdcode?.command === "npx" && ["0.5", "0.5.2"].some((version6) => JSON.stringify(servers.crowdcode.args) === JSON.stringify(["--yes", `crowdcode-mcp@${version6}`]))) {
+  if (servers.crowdcode?.command === "npx" && ["0.5", "0.5.2", "0.5.3"].some((version6) => JSON.stringify(servers.crowdcode.args) === JSON.stringify(["--yes", `crowdcode-mcp@${version6}`]))) {
     servers.crowdcode = { ...servers.crowdcode, args: [...DEFAULT_CONFIG.mcpServers.crowdcode.args] };
   }
   return {
@@ -16398,7 +16497,7 @@ var init_config = __esm({
       configVersion: 3,
       mcpServers: {
         agentcash: { command: "npx", args: ["--yes", "agentcash@0.17"] },
-        crowdcode: { command: "npx", args: ["--yes", "crowdcode-mcp@0.5.3"] }
+        crowdcode: { command: "npx", args: ["--yes", "crowdcode-mcp@0.6.0"] }
       },
       // GAIA provider benchmark (2026-08-25): same-model BlockRun matched the
       // current route's accuracy and completed the sample 6.7x faster. The
@@ -33523,6 +33622,9 @@ var init_crowdcode = __esm({
       constructor(connection) {
         this.connection = connection;
       }
+      async manage(name, args) {
+        return this.connection.call(name, args);
+      }
       async getServiceScore(query) {
         const result = await this.connection.call("get_service_score", {
           ...query.apiEndpoint ? { api_endpoint: query.apiEndpoint } : {},
@@ -33555,6 +33657,53 @@ var init_crowdcode = __esm({
   }
 });
 
+// ../../packages/economy/dist/crowdcode-preferences.js
+import { mkdir as mkdir8, readFile as readFile8, rename as rename2, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname7, join as join9 } from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
+var CrowdCodePreferences;
+var init_crowdcode_preferences = __esm({
+  "../../packages/economy/dist/crowdcode-preferences.js"() {
+    "use strict";
+    CrowdCodePreferences = class {
+      session;
+      constructor(session) {
+        this.session = session;
+      }
+      path(scope) {
+        return join9(scope === "session" ? this.session.sessionDir : this.session.workspaceRoot, "crowdcode-preferences.json");
+      }
+      async read(scope) {
+        try {
+          const value = JSON.parse(await readFile8(this.path(scope), "utf8"));
+          return typeof value.enabled === "boolean" ? value.enabled : void 0;
+        } catch (error53) {
+          if (error53.code === "ENOENT")
+            return void 0;
+          throw error53;
+        }
+      }
+      async status() {
+        const default_enabled = await this.read("default") ?? true;
+        const session_enabled = await this.read("session");
+        return { enabled: session_enabled ?? default_enabled, default_enabled, scope: session_enabled === void 0 ? "default" : "session" };
+      }
+      async write(scope, enabled) {
+        const path3 = this.path(scope), temporary = `${path3}.${randomUUID4()}.tmp`;
+        await mkdir8(dirname7(path3), { recursive: true });
+        await writeFile4(temporary, JSON.stringify({ enabled }) + "\n", { mode: 384 });
+        await rename2(temporary, path3);
+      }
+      async set(enabled, scope) {
+        await this.write(scope, enabled);
+        if (scope === "default")
+          await this.write("session");
+        return this.status();
+      }
+    };
+  }
+});
+
 // ../../packages/economy/dist/media.js
 import { createHash as createHash2 } from "node:crypto";
 async function extractMedia(session, value, depth = 0) {
@@ -33586,14 +33735,14 @@ var init_media = __esm({
 });
 
 // ../../packages/economy/dist/purchases.js
-import { appendFile as appendFile3, mkdir as mkdir8, readFile as readFile8 } from "node:fs/promises";
-import { dirname as dirname7, join as join9 } from "node:path";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { appendFile as appendFile3, mkdir as mkdir9, readFile as readFile9 } from "node:fs/promises";
+import { dirname as dirname8, join as join10 } from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
 function purchasesPath(session) {
-  return join9(session.sessionDir, "purchases.jsonl");
+  return join10(session.sessionDir, "purchases.jsonl");
 }
 function newPurchaseId() {
-  return `pur_${randomUUID4().slice(0, 12)}`;
+  return `pur_${randomUUID5().slice(0, 12)}`;
 }
 async function appendPurchase(session, record3) {
   await appendPurchaseEvent(session, { type: "purchase", record: record3 });
@@ -33609,16 +33758,20 @@ async function recordReviewSubmitted(session, purchaseId, rating) {
 async function recordReviewFailed(session, purchaseId) {
   await appendPurchaseEvent(session, { type: "review_failed", purchase_id: purchaseId, attempted_at: (/* @__PURE__ */ new Date()).toISOString() });
 }
+async function skipPendingReviews(session) {
+  for (const state of await pendingRequiredReviews(session))
+    await appendPurchaseEvent(session, { type: "review_skipped", purchase_id: state.record.purchase_id });
+}
 async function appendPurchaseEvent(session, event) {
   const path3 = purchasesPath(session);
-  await mkdir8(dirname7(path3), { recursive: true });
+  await mkdir9(dirname8(path3), { recursive: true });
   await appendFile3(path3, `${JSON.stringify(event)}
 `, "utf8");
 }
 async function listPurchases(session) {
   let text;
   try {
-    text = await readFile8(purchasesPath(session), "utf8");
+    text = await readFile9(purchasesPath(session), "utf8");
   } catch (error53) {
     if (error53.code === "ENOENT") {
       return [];
@@ -33641,6 +33794,10 @@ async function listPurchases(session) {
         record: event.record,
         reviewStatus: event.record.review_required ? "pending" : "not_required"
       });
+    } else if (event.type === "review_skipped") {
+      const state = states.get(event.purchase_id);
+      if (state)
+        state.reviewStatus = "not_required";
     } else if (event.type === "review_failed") {
       const state = states.get(event.purchase_id);
       if (state)
@@ -33683,6 +33840,8 @@ var init_purchases = __esm({
 });
 
 // ../../packages/economy/dist/gateway.js
+import { readFile as readFile10, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join11 } from "node:path";
 function inspectionKey(endpoint, method) {
   return `${method} ${endpoint}`;
 }
@@ -33743,11 +33902,17 @@ var GATEWAY_TOOL_NAMES, EconomyGateway, GATEWAY_TOOL_DEFINITIONS;
 var init_gateway = __esm({
   "../../packages/economy/dist/gateway.js"() {
     "use strict";
+    init_crowdcode_preferences();
     init_media();
     init_dist2();
     init_approvals();
     init_purchases();
     GATEWAY_TOOL_NAMES = [
+      "crowdcode_status",
+      "set_crowdcode_enabled",
+      "request_service",
+      "list_my_reviews",
+      "delete_my_review",
       "read_service",
       "get_wallet_status",
       "find_paid_service",
@@ -33758,10 +33923,36 @@ var init_gateway = __esm({
     ];
     EconomyGateway = class {
       options;
-      inspections = /* @__PURE__ */ new Map();
+      /**
+       * Inspections are keyed by endpoint+method and persisted under the session so
+       * a run resumed on a fresh gateway instance (funds pause, worker restart) still
+       * honours the inspect-before-call rule instead of failing its first call.
+       */
+      inspections;
       constructor(options) {
         this.options = options;
       }
+      get inspectionsPath() {
+        return join11(this.options.session.sessionDir, "inspections.json");
+      }
+      async loadInspections() {
+        if (this.inspections)
+          return this.inspections;
+        const map3 = /* @__PURE__ */ new Map();
+        try {
+          const stored = JSON.parse(await readFile10(this.inspectionsPath, "utf8"));
+          for (const [key, value] of Object.entries(stored))
+            map3.set(key, value);
+        } catch {
+        }
+        this.inspections = map3;
+        return map3;
+      }
+      async rememberInspection(key, inspection) {
+        const map3 = await this.loadInspections();
+        map3.set(key, inspection);
+        await writeFile5(this.inspectionsPath, JSON.stringify(Object.fromEntries(map3)), "utf8");
+      }
       definitions() {
         return GATEWAY_TOOL_DEFINITIONS;
       }
@@ -33770,11 +33961,17 @@ var init_gateway = __esm({
       }
       /** True while a confirmed paid purchase still needs its required review. */
       async hasPendingRequiredReviews() {
-        return (await pendingRequiredReviews(this.options.session)).length > 0;
+        return await this.crowdcodeEnabled() && (await pendingRequiredReviews(this.options.session)).length > 0;
       }
       async execute(name, args, operationId) {
         try {
           switch (name) {
+            case "crowdcode_status":
+            case "set_crowdcode_enabled":
+            case "request_service":
+            case "list_my_reviews":
+            case "delete_my_review":
+              return await this.manageCrowdCode(name, args);
             case "get_wallet_status":
               return await this.getWalletStatus();
             case "find_paid_service":
@@ -33798,6 +33995,38 @@ var init_gateway = __esm({
           return { ok: false, error: error53.message };
         }
       }
+      async crowdcodeEnabled() {
+        if (!this.options.hostedSpending && !this.options.crowdcode.manage)
+          return true;
+        const status = await this.manageCrowdCode("crowdcode_status", {});
+        if (!status.ok)
+          throw new Error(status.error ?? "CrowdCode preferences unavailable");
+        return status.data?.enabled === true;
+      }
+      async manageCrowdCode(name, args) {
+        if (name === "set_crowdcode_enabled") {
+          if (typeof args.enabled !== "boolean" || args.scope !== void 0 && args.scope !== "session" && args.scope !== "default")
+            return { ok: false, error: "Provide enabled (boolean) and scope (session or default)" };
+        }
+        if (this.options.hostedSpending && (name === "crowdcode_status" || name === "set_crowdcode_enabled")) {
+          const preferences = new CrowdCodePreferences(this.options.session);
+          const data = name === "crowdcode_status" ? await preferences.status() : await preferences.set(args.enabled, args.scope ?? "session");
+          if (name === "set_crowdcode_enabled" && args.enabled === false)
+            await skipPendingReviews(this.options.session);
+          return { ok: true, data };
+        }
+        if (name === "request_service" && !await this.crowdcodeEnabled())
+          return { ok: false, error: "CrowdCode is off. Turn it on to submit service requests." };
+        if (!this.options.crowdcode.manage)
+          return { ok: false, error: "CrowdCode management is unavailable" };
+        const result = await this.options.crowdcode.manage(name, args);
+        if (result.ok && name === "set_crowdcode_enabled" && args.enabled === false)
+          await skipPendingReviews(this.options.session);
+        return result;
+      }
+      async serviceEvidence(endpoint) {
+        return await this.crowdcodeEnabled() ? this.options.crowdcode.getServiceScore({ apiEndpoint: endpoint }) : { ok: true, unproven: true, summary: "CrowdCode is off; reputation checks and submissions are disabled." };
+      }
       async getWalletStatus() {
         const result = await this.options.agentcash.getBalance();
         if (!result.ok) {
@@ -33832,10 +34061,10 @@ var init_gateway = __esm({
         if (!schema.ok) {
           return { ok: false, error: schema.error };
         }
-        const evidence = await this.options.crowdcode.getServiceScore({ apiEndpoint: endpoint });
+        const evidence = await this.serviceEvidence(endpoint);
         const rail = railFromSchema(schema.data);
         const priceCeilingCents = priceCeilingFromSchema(schema.data);
-        this.inspections.set(inspectionKey(endpoint, method), {
+        await this.rememberInspection(inspectionKey(endpoint, method), {
           endpoint,
           method,
           rail,
@@ -33869,7 +34098,7 @@ var init_gateway = __esm({
             error: "external-service purchases are disabled (approval mode `off`). Local tools and LLM inference remain available; switch with /approval ask|auto."
           };
         }
-        const pending = await pendingRequiredReviews(session);
+        const pending = await this.crowdcodeEnabled() ? await pendingRequiredReviews(session) : [];
         if (pending.length > 0) {
           return {
             ok: false,
@@ -33881,7 +34110,7 @@ var init_gateway = __esm({
           return { ok: false, error: "call_paid_service requires `url`" };
         }
         const method = (stringArg(args.method) ?? "POST").toUpperCase();
-        const inspection = this.inspections.get(inspectionKey(endpoint, method));
+        const inspection = (await this.loadInspections()).get(inspectionKey(endpoint, method));
         if (!inspection) {
           return { ok: false, error: `inspect_paid_service must run for ${method} ${endpoint} before call_paid_service` };
         }
@@ -33908,7 +34137,7 @@ var init_gateway = __esm({
         if (quotedCostCents === void 0) {
           return { ok: false, error: "no price ceiling: pass `max_cost_cents` (the inspection did not report a price)" };
         }
-        const evidence = await this.options.crowdcode.getServiceScore({ apiEndpoint: endpoint });
+        const evidence = await this.serviceEvidence(endpoint);
         if (!evidence.ok) {
           return {
             ok: false,
@@ -33967,7 +34196,7 @@ var init_gateway = __esm({
           artifact_path: artifact?.path,
           // Confirmed paid successes AND paid failures require reviews; free,
           // SIWX, and unknown outcomes create no paid receipt to review.
-          review_required: paid && supportedRail,
+          review_required: paid && supportedRail && await this.crowdcodeEnabled(),
           evidence: result.payment,
           notes: result.ambiguous ? `${result.ambiguityReason ?? "ambiguous"}: payment state unknown; never auto-retried` : result.error
         };
@@ -33989,6 +34218,7 @@ var init_gateway = __esm({
         if (outcome === "unknown") {
           const missingReceipt = result.ambiguityReason === "missing_receipt";
           const unsupportedReceipt = result.ambiguityReason === "unsupported_receipt";
+          const timedOut = result.ambiguityReason === "timeout";
           return {
             ok: false,
             error: missingReceipt ? [
@@ -33997,6 +34227,9 @@ var init_gateway = __esm({
             ].join(" ") : unsupportedReceipt ? [
               `the call to ${endpoint} returned a settlement receipt on an unsupported payment rail (recorded as purchase ${purchaseId}).`,
               "It was NOT retried and must not be retried automatically; reconcile the payment manually before continuing."
+            ].join(" ") : timedOut ? [
+              `the call to ${endpoint} did not answer within the wait limit and its payment state is unknown (recorded as purchase ${purchaseId}).`,
+              "The stored purchase was checked once without a final result. It was NOT retried and must not be retried automatically; the owner can reconcile it from the payment ledger."
             ].join(" ") : [
               `the call to ${endpoint} failed in transport and its payment state is unknown (recorded as purchase ${purchaseId}).`,
               "It was NOT retried and must not be retried automatically; verify the service state before calling again."
@@ -34083,6 +34316,8 @@ var init_gateway = __esm({
         return void 0;
       }
       async reviewPaidService(args) {
+        if (!await this.crowdcodeEnabled())
+          return { ok: false, error: "CrowdCode is off; review submission is disabled." };
         const purchaseId = stringArg(args.purchase_id);
         const rating = intArg(args.rating);
         const reason = stringArg(args.reason);
@@ -34164,6 +34399,11 @@ var init_gateway = __esm({
       }
     };
     GATEWAY_TOOL_DEFINITIONS = [
+      { name: "crowdcode_status", description: "Check whether CrowdCode is enabled for this session and by default.", parameters: { type: "object", properties: {}, additionalProperties: false } },
+      { name: "set_crowdcode_enabled", description: "Handle 'CrowdCode on/off'. Disable reputation checks, automatic reviews and requests. Default scope is this session; scope default also sets the agent default for future sessions. Listing and deleting your reviews remain available while off. Does not change spending permissions.", parameters: { type: "object", properties: { enabled: { type: "boolean" }, scope: { type: "string", enum: ["session", "default"] } }, required: ["enabled"], additionalProperties: false } },
+      { name: "request_service", description: "Before finishing a real task, record a concrete service worth paying for that would fix an observed failure, poor result, excessive cost or detour. State exact input, paid deliverable, acceptance criteria, actual obstacle and why paying is worthwhile. No purchase or spending authority is required. Skip generic Python/runtime wishes, web search that worked well, and gaps without a sellable remedy. Submit distinct gaps once; submit nothing if everything worked well and cheaply. Exclude private data and secrets.", parameters: { type: "object", properties: { service_description: { type: "string", maxLength: 8e3 }, task_context: { type: "string", maxLength: 4e3 } }, required: ["service_description"], additionalProperties: false } },
+      { name: "list_my_reviews", description: "List this agent's own submitted reviews with IDs for selective deletion; works while CrowdCode is off. Paginate with next_before_id.", parameters: { type: "object", properties: { before_id: { type: "integer", minimum: 0 }, limit: { type: "integer", minimum: 1, maximum: 100 } }, additionalProperties: false } },
+      { name: "delete_my_review", description: "Delete one of this agent's reviews when the user asks, using its ID from list_my_reviews. Works while CrowdCode is off. Never delete unrelated reviews.", parameters: { type: "object", properties: { review_id: { type: "integer", minimum: 1 } }, required: ["review_id"], additionalProperties: false } },
       {
         name: "read_service",
         description: "Read a service URL without payment, authenticating with the wallet when required (SIWX). Use this to poll a paid generation job until complete; never resubmit a pending job. Download returned media URLs with run_shell.",
@@ -34452,7 +34692,7 @@ async function sharedEconomyRuntime(log) {
         agentcash: new McpAgentCashAdapter(agentcashConnection),
         crowdcode: new McpCrowdCodeAdapter(crowdcodeConnection),
         instructions: () => [agentcashConnection, crowdcodeConnection].map((connection) => connection.instructions()).filter((text) => Boolean(text)).map((text, index2) => `Instructions from the ${index2 === 0 ? "agentcash" : "crowdcode"} vendor:
-${text.slice(0, 2400)}`),
+${text.slice(0, 16e3)}`),
         close: async () => {
           await Promise.all([agentcashConnection.close(), crowdcodeConnection.close()]);
           shared = void 0;
@@ -34518,7 +34758,7 @@ var init_dist4 = __esm({
 
 // ../../packages/agent-runtime/dist/context.js
 import { createHash as createHash3 } from "node:crypto";
-import { relative as relative3, join as join10 } from "node:path";
+import { relative as relative3, join as join12 } from "node:path";
 async function completeWithContext(session, messages, options) {
   for (; ; ) {
     options.signal?.throwIfAborted();
@@ -34576,13 +34816,13 @@ async function compactContext(session, messages, options) {
     return { tokensBefore, tokensAfter: tokensBefore };
   const raw = messages.map((message) => JSON.stringify(message)).join("\n") + "\n";
   const digest = createHash3("sha256").update(raw).digest("hex");
-  const dir = await containedPath(session.sessionDir, join10("context", digest));
-  const path3 = join10(dir, "transcript.jsonl");
+  const dir = await containedPath(session.sessionDir, join12("context", digest));
+  const path3 = join12(dir, "transcript.jsonl");
   await atomicWrite(path3, raw);
   const archivePath = relative3(session.workspaceRoot, path3).split("\\").join("/");
   const ref = (index2) => `${relative3(session.workspaceRoot, dir).split("\\").join("/")}/message-${index2 + 1}.txt`;
   const externalize = async (message, index2) => {
-    await atomicWrite(join10(dir, `message-${index2 + 1}.txt`), messages[index2].content);
+    await atomicWrite(join12(dir, `message-${index2 + 1}.txt`), messages[index2].content);
     return `[Full ${message.role} message saved verbatim to ${ref(index2)}. Use rg/grep and sed/head/tail to read relevant portions before proceeding; do not load the entire file.]`;
   };
   const list = messages.map((m, index2) => ({ message: structuredClone(m), index: index2 })).filter(({ message }) => !message.contextArchive);
@@ -34644,11 +34884,11 @@ var init_context2 = __esm({
 });
 
 // ../../packages/agent-runtime/dist/knowledge.js
-import { access, cp, mkdir as mkdir9, readFile as readFile9, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname8, join as join11, resolve as resolve4 } from "node:path";
+import { access, cp, mkdir as mkdir10, readFile as readFile11, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname9, join as join13, resolve as resolve4 } from "node:path";
 import { fileURLToPath } from "node:url";
 function bundledKnowledgeDir() {
-  return resolve4(dirname8(fileURLToPath(import.meta.url)), "..", "knowledge");
+  return resolve4(dirname9(fileURLToPath(import.meta.url)), "..", "knowledge");
 }
 function knowledgeDisabledByEnv() {
   const value = process.env.OPENCROWD_KNOWLEDGE_DIR?.trim().toLowerCase();
@@ -34664,7 +34904,7 @@ async function resolveKnowledgeDir(options = {}) {
   }
   const bundled = bundledKnowledgeDir();
   try {
-    await access(join11(bundled, "L0.md"));
+    await access(join13(bundled, "L0.md"));
     return bundled;
   } catch {
     return void 0;
@@ -34677,20 +34917,20 @@ async function loadKnowledgeTree(session, options = {}) {
   }
   let l0;
   try {
-    l0 = (await readFile9(join11(dir, "L0.md"), "utf8")).trim();
+    l0 = (await readFile11(join13(dir, "L0.md"), "utf8")).trim();
   } catch {
     return void 0;
   }
   const version6 = await readVersion(dir, l0);
-  const target = join11(session.artifactsDir, "knowledge");
+  const target = join13(session.artifactsDir, "knowledge");
   if (await currentVersion(target) !== version6) {
-    await mkdir9(session.artifactsDir, { recursive: true });
+    await mkdir10(session.artifactsDir, { recursive: true });
     await cp(dir, target, {
       recursive: true,
       force: true,
       filter: (source) => !source.endsWith("proposal.raw.txt")
     });
-    await writeFile4(join11(target, VERSION_FILE), `${version6}
+    await writeFile6(join13(target, VERSION_FILE), `${version6}
 `, "utf8");
   }
   if (session.knowledge?.version !== version6 || session.knowledge?.source !== dir) {
@@ -34708,7 +34948,7 @@ function renderCapabilityIndex(l0) {
 }
 async function readVersion(dir, l0) {
   try {
-    const meta4 = JSON.parse(await readFile9(join11(dir, "meta.json"), "utf8"));
+    const meta4 = JSON.parse(await readFile11(join13(dir, "meta.json"), "utf8"));
     if (typeof meta4.content_hash === "string" && meta4.content_hash) {
       return meta4.id ? `${meta4.id}@${meta4.content_hash}` : meta4.content_hash;
     }
@@ -34719,7 +34959,7 @@ async function readVersion(dir, l0) {
 }
 async function currentVersion(target) {
   try {
-    return (await readFile9(join11(target, VERSION_FILE), "utf8")).trim();
+    return (await readFile11(join13(target, VERSION_FILE), "utf8")).trim();
   } catch {
     return void 0;
   }
@@ -35345,7 +35585,7 @@ function alphabet(letters) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function join12(separator = "") {
+function join14(separator = "") {
   astr("join", separator);
   return {
     encode: (from16) => {
@@ -35425,7 +35665,7 @@ function radix(num2) {
 var genBase58, base58;
 var init_esm = __esm({
   "../../node_modules/@scure/base/lib/esm/index.js"() {
-    genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join12(""));
+    genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join14(""));
     base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
   }
 });
@@ -79842,14 +80082,29 @@ var init_llm_runtime = __esm({
 
 // ../../packages/agent-runtime/dist/economy-tools.js
 function economyTools(economy, options = {}) {
+  let reflected = false;
+  const supportsReflection = economy.definitions().some((tool) => tool.name === "request_service");
   return {
     definitions: economy.definitions().filter((tool) => !options.hidden?.has(tool.name)),
     execute: async (name, args, operationId) => {
       if (options.resuming && name === "call_paid_service")
         await economy.execute("inspect_paid_service", { url: args.url, method: args.method, sample_body: args.body });
-      return economy.execute(name, args, operationId);
+      const result = await economy.execute(name, args, operationId);
+      if (name === "request_service" && result.ok)
+        reflected = true;
+      return result;
     },
-    completionGate: async () => !await economy.hasPendingRequiredReviews() ? void 0 : "a paid purchase still needs its required review; submit it with review_paid_service"
+    completionGate: async (alreadyNudged = false) => {
+      const pending = await economy.hasPendingRequiredReviews();
+      const review = pending ? "A paid purchase still needs its required review; submit it with review_paid_service." : "";
+      if (reflected || alreadyNudged || !supportsReflection)
+        return review || void 0;
+      reflected = true;
+      const status = await economy.execute("crowdcode_status", {});
+      if (!status.ok || !status.data?.enabled)
+        return review || void 0;
+      return [review, "Before your final answer, reflect once: What concrete services would have been worth paying for to solve this task? For each observed failure, poor result, excessive cost or avoidable detour with a reusable paid remedy, call request_service. Specify exact inputs, the paid deliverable, acceptance criteria, the actual use case and why paying would help. A prior purchase or spending permission is not required. Do not invent budgets. Skip generic local computation, ordinary agent mistakes without a sellable remedy, and services such as web search that already worked well. If everything worked well and cheaply, submit nothing. Then finish the user's task."].filter(Boolean).join(" ");
+    }
   };
 }
 var init_economy_tools = __esm({
@@ -79860,9 +80115,9 @@ var init_economy_tools = __esm({
 });
 
 // ../../packages/agent-runtime/dist/runtime.js
-import { readFile as readFile10, rm as rm2 } from "node:fs/promises";
-import { join as join17 } from "node:path";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { readFile as readFile12, rm as rm2 } from "node:fs/promises";
+import { join as join19 } from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function createOpenCrowdRuntime(options) {
   const storage = options.storage ?? localRuntimeStorage;
   async function prepare(session, runOptions) {
@@ -79889,10 +80144,10 @@ function createOpenCrowdRuntime(options) {
     };
   }
   async function execute2(session, task, runOptions = {}) {
-    const path3 = join17(session.sessionDir, "query-checkpoint.json");
+    const path3 = join19(session.sessionDir, "query-checkpoint.json");
     let persisted;
     try {
-      persisted = JSON.parse(await readFile10(path3, "utf8"));
+      persisted = JSON.parse(await readFile12(path3, "utf8"));
     } catch (error53) {
       if (error53.code !== "ENOENT")
         throw error53;
@@ -79900,7 +80155,7 @@ function createOpenCrowdRuntime(options) {
     const resuming = task === "" && !!persisted;
     if (persisted && !resuming)
       throw new Error("A query is unfinished. Resume it or decline its pending approval before starting another query.");
-    const saved = resuming ? persisted : { id: runOptions.runId ?? randomUUID5(), task };
+    const saved = resuming ? persisted : { id: runOptions.runId ?? randomUUID6(), task };
     await beginQuery(session, saved.id);
     const checkpoint = async (value) => {
       saved.checkpoint = value;
@@ -79962,7 +80217,7 @@ import { isAbsolute as isAbsolute3 } from "node:path";
 function createHostedProvider(options) {
   if (!isAbsolute3(options.socketPath))
     throw new Error("Hosted bridge socket must be absolute");
-  const tools = [...OPEN_CROWD_TOOLS.filter((tool) => !["spawn_subagent", "check_subagents"].includes(tool.name)), ...options.extraTools ?? []];
+  const tools = [...OPEN_CROWD_TOOLS.filter((tool) => !["spawn_subagent", "check_subagents"].includes(tool.name)).map((tool) => tool.name === "get_budget_status" ? { ...tool, description: "Read authoritative hosted finances: live USDC wallet balance, settled inference and service spending, pending holds, and remaining authorized budget for this run." } : tool), ...options.extraTools ?? []];
   return {
     async complete(messages, context) {
       const operationId = context?.operationId;
@@ -80042,6 +80297,16 @@ function rejectedRequest(status, text) {
     return void 0;
   }
 }
+async function readHostedFinancialState(options) {
+  try {
+    const reply = await postHostedTool(options, "economy.balance", {}, { timeoutMs: 1e4 });
+    const parsed = FinancialStateSchema.safeParse(reply.data?.financial_state);
+    if (reply.ok && parsed.success && parsed.data.status === "available" && parsed.data.run_id === options.runId)
+      return parsed.data;
+  } catch {
+  }
+  return { status: "unavailable", reason: "Hosted financial state could not be read. Do not infer balance or spending from the local session budget." };
+}
 async function postHostedTool(options, name, args, settings = {}) {
   if (!isAbsolute3(options.socketPath))
     throw new Error("Hosted bridge socket must be absolute");
@@ -80076,7 +80341,8 @@ async function postHostedTool(options, name, args, settings = {}) {
         }
       });
     });
-    req.setTimeout(settings.timeoutMs ?? SERVICE_BRIDGE_TIMEOUT_MS, () => req.destroy(new Error("Hosted tool timed out")));
+    const timeoutMs = settings.timeoutMs ?? SERVICE_BRIDGE_TIMEOUT_MS;
+    req.setTimeout(timeoutMs, () => req.destroy(new HostedToolTimeout(name, timeoutMs)));
     req.on("error", reject);
     req.end(body);
   });
@@ -80110,7 +80376,7 @@ function createHostedToolExecutor(options) {
     }
   };
 }
-var HostedRequestError, HOSTED_TOOL_REQUEST_BYTES;
+var HostedRequestError, HOSTED_TOOL_REQUEST_BYTES, HostedToolTimeout;
 var init_hosted_provider = __esm({
   "../../packages/agent-runtime/dist/hosted-provider.js"() {
     "use strict";
@@ -80128,29 +80394,39 @@ var init_hosted_provider = __esm({
       }
     };
     HOSTED_TOOL_REQUEST_BYTES = 1024 * 1024;
+    HostedToolTimeout = class extends Error {
+      timeoutMs;
+      code = "hosted_tool_timeout";
+      constructor(name, timeoutMs) {
+        super(`Hosted tool ${name} timed out after ${Math.round(timeoutMs / 1e3)}s`);
+        this.timeoutMs = timeoutMs;
+        this.name = "HostedToolTimeout";
+      }
+    };
   }
 });
 
 // ../../packages/agent-runtime/dist/hosted-economy.js
-import { randomUUID as randomUUID6, createHash as createHash4 } from "node:crypto";
-import { join as join18 } from "node:path";
+import { randomUUID as randomUUID7, createHash as createHash4 } from "node:crypto";
+import { join as join20 } from "node:path";
 function createHostedEconomy(options) {
   const fetcher = options.fetcher ?? fetch;
   const socket = { socketPath: options.socketPath, runId: options.runId, sessionId: options.sessionId };
   const directory = new ServiceDirectory(fetcher, (options.crowdcodeBase ?? DEFAULT_CROWDCODE_BASE).replace(/\/+$/, ""));
   return new EconomyGateway({
     session: options.session,
-    agentcash: new HostedAgentCashAdapter(directory, socket, fetcher),
+    agentcash: new HostedAgentCashAdapter(directory, socket, fetcher, options.reconcileDelayMs),
     crowdcode: new HostedCrowdCodeAdapter(directory, socket),
     approvalMode: "auto",
     hostedSpending: true,
     minServiceScore: 2,
     // Hosted rules live with the agent's session, never in a user config dir.
-    approvalRulesPath: join18(options.session.sessionDir, "approval-rules.json")
+    approvalRulesPath: join20(options.session.sessionDir, "approval-rules.json")
   });
 }
 function hostedDynamicTools(economy) {
-  return economyTools(economy, { hidden: HIDDEN_HOSTED_TOOLS });
+  const tools = economyTools(economy, { hidden: HIDDEN_HOSTED_TOOLS });
+  return { ...tools, definitions: tools.definitions.map((tool) => tool.name === "get_wallet_status" ? { ...tool, description: "Read this hosted agent's USDC wallet balance and authoritative current-run inference spending, service spending, payment holds and authorized budget. Read-only." } : tool) };
 }
 function parseListedService(raw) {
   const row = objectValue4(raw);
@@ -80214,7 +80490,7 @@ function numberValue6(value) {
   }
   return void 0;
 }
-var DEFAULT_CROWDCODE_BASE, LIST_CACHE_MS, PAY_TIMEOUT_MS, FREE_FETCH_TIMEOUT_MS, USDC_ATOMIC_PER_USD, HIDDEN_HOSTED_TOOLS, ServiceDirectory, HostedAgentCashAdapter, HostedCrowdCodeAdapter;
+var DEFAULT_CROWDCODE_BASE, LIST_CACHE_MS, PAY_TIMEOUT_MS, RECONCILE_DELAY_MS, NOT_SENT_CODES, FREE_FETCH_TIMEOUT_MS, USDC_ATOMIC_PER_USD, HIDDEN_HOSTED_TOOLS, ServiceDirectory, HostedAgentCashAdapter, HostedCrowdCodeAdapter;
 var init_hosted_economy = __esm({
   "../../packages/agent-runtime/dist/hosted-economy.js"() {
     "use strict";
@@ -80222,14 +80498,17 @@ var init_hosted_economy = __esm({
     init_worker();
     init_dist2();
     init_dist4();
+    init_dist();
     init_hosted_provider();
     init_economy_tools();
     DEFAULT_CROWDCODE_BASE = "https://crowdcode-backend.onrender.com";
     LIST_CACHE_MS = 6e4;
-    PAY_TIMEOUT_MS = 12e4;
+    PAY_TIMEOUT_MS = SERVICE_GATEWAY_TIMEOUT_MS + 3e4;
+    RECONCILE_DELAY_MS = 2e3;
+    NOT_SENT_CODES = /* @__PURE__ */ new Set(["ENOENT", "ECONNREFUSED", "EACCES", "ENOTDIR"]);
     FREE_FETCH_TIMEOUT_MS = 3e4;
     USDC_ATOMIC_PER_USD = 1e6;
-    HIDDEN_HOSTED_TOOLS = /* @__PURE__ */ new Set(["bridge_usdc", "get_wallet_status"]);
+    HIDDEN_HOSTED_TOOLS = /* @__PURE__ */ new Set(["bridge_usdc"]);
     ServiceDirectory = class {
       fetcher;
       base;
@@ -80276,12 +80555,14 @@ var init_hosted_economy = __esm({
       directory;
       socket;
       fetcher;
+      reconcileDelayMs;
       /** Rails observed by inspection; `fetch` refuses anything but Base x402 regardless of the caller's rail. */
       inspectedRails = /* @__PURE__ */ new Map();
-      constructor(directory, socket, fetcher) {
+      constructor(directory, socket, fetcher, reconcileDelayMs = RECONCILE_DELAY_MS) {
         this.directory = directory;
         this.socket = socket;
         this.fetcher = fetcher;
+        this.reconcileDelayMs = reconcileDelayMs;
         this.discovery = new BaseServiceDiscovery(async (query, options) => {
           const reply = await postHostedTool(this.socket, "economy.read", {
             url: "https://agentcash.dev/api/search",
@@ -80336,25 +80617,32 @@ var init_hosted_economy = __esm({
         const method = request2.method.toUpperCase();
         const body = request2.body === void 0 ? void 0 : typeof request2.body === "string" ? request2.body : JSON.stringify(request2.body);
         const hash5 = request2.operationId ? createHash4("sha256").update(`${this.socket.runId}:${request2.operationId}`).digest("hex") : void 0;
-        const purchaseId = hash5 ? `${hash5.slice(0, 8)}-${hash5.slice(8, 12)}-4${hash5.slice(13, 16)}-8${hash5.slice(17, 20)}-${hash5.slice(20, 32)}` : randomUUID6();
-        let reply;
+        const purchaseId = hash5 ? `${hash5.slice(0, 8)}-${hash5.slice(8, 12)}-4${hash5.slice(13, 16)}-8${hash5.slice(17, 20)}-${hash5.slice(20, 32)}` : randomUUID7();
+        const payArgs = {
+          purchase_request_id: purchaseId,
+          service_id: serviceId,
+          url: request2.url,
+          method,
+          body,
+          max_cost_cents: Math.ceil(request2.maxAmountUsd * 100)
+        };
+        const timeoutMs = Math.min(request2.timeoutMs ?? PAY_TIMEOUT_MS, PAY_TIMEOUT_MS);
+        let reply, timedOut = false;
         try {
-          reply = await postHostedTool(this.socket, "economy.pay", {
-            purchase_request_id: purchaseId,
-            service_id: serviceId,
-            url: request2.url,
-            method,
-            body,
-            max_cost_cents: Math.ceil(request2.maxAmountUsd * 100)
-          }, { timeoutMs: request2.timeoutMs ?? PAY_TIMEOUT_MS });
+          reply = await postHostedTool(this.socket, "economy.pay", payArgs, { timeoutMs });
         } catch (error53) {
-          return {
-            ok: false,
-            ambiguous: true,
-            ambiguityReason: "transport",
-            data: void 0,
-            error: `payment request to the supervisor failed in transport: ${error53.message}`
-          };
+          timedOut = error53 instanceof HostedToolTimeout;
+          const recovered = await this.reconcile(error53, payArgs, timeoutMs);
+          if (!recovered) {
+            return {
+              ok: false,
+              ambiguous: true,
+              ambiguityReason: timedOut ? "timeout" : "transport",
+              data: void 0,
+              error: timedOut ? `the paid call did not answer within ${Math.round(timeoutMs / 1e3)}s and its stored purchase has no final result yet` : `payment request to the supervisor failed in transport: ${error53.message}`
+            };
+          }
+          reply = recovered;
         }
         if (reply.ok) {
           const data = objectValue4(reply.data) ?? {};
@@ -80387,13 +80675,29 @@ var init_hosted_economy = __esm({
           return {
             ok: false,
             ambiguous: true,
-            ambiguityReason: "transport",
+            ambiguityReason: timedOut ? "timeout" : "transport",
             data: void 0,
-            error: reply.error ?? "the supervisor could not determine whether the payment settled"
+            error: timedOut ? `the paid call did not answer within ${Math.round(timeoutMs / 1e3)}s and its stored purchase has no final result yet` : reply.error ?? "the supervisor could not determine whether the payment settled"
           };
         }
         return refuse(reply.code ? `${reply.error ?? "payment refused"} (${reply.code})` : reply.error ?? "payment refused");
       }
+      /**
+       * Re-post the same purchase once. A finished attempt replays from the ledger;
+       * an attempt still in flight answers payment_unknown; a request that never
+       * reached the supervisor is not reconciled because nothing was started.
+       */
+      async reconcile(error53, payArgs, timeoutMs) {
+        const code = error53?.code;
+        if (typeof code === "string" && NOT_SENT_CODES.has(code))
+          return void 0;
+        await new Promise((resolve9) => setTimeout(resolve9, this.reconcileDelayMs));
+        try {
+          return await postHostedTool(this.socket, "economy.pay", payArgs, { timeoutMs });
+        } catch {
+          return void 0;
+        }
+      }
       /** The supervisor found no 402: the endpoint is free, so the worker fetches it itself. */
       async fetchUnpaid(url3, method, body, headers) {
         try {
@@ -80423,6 +80727,9 @@ var init_hosted_economy = __esm({
     HostedCrowdCodeAdapter = class {
       directory;
       socket;
+      async manage(name, args) {
+        return postHostedTool(this.socket, "economy.crowdcode", { name, ...args });
+      }
       constructor(directory, socket) {
         this.directory = directory;
         this.socket = socket;
@@ -80484,9 +80791,9 @@ var init_hosted_economy = __esm({
 });
 
 // ../../packages/agent-runtime/dist/worker.js
-import { readFile as readFile11, mkdir as mkdir10 } from "node:fs/promises";
-import { join as join19 } from "node:path";
-import { createHash as createHash5, randomUUID as randomUUID7 } from "node:crypto";
+import { readFile as readFile13, mkdir as mkdir11 } from "node:fs/promises";
+import { join as join21 } from "node:path";
+import { createHash as createHash5, randomUUID as randomUUID8 } from "node:crypto";
 function isWaiting(outcome) {
   return ["waiting_for_approval", "waiting_for_funds", "waiting_for_delegation", "payment_unknown"].includes(outcome);
 }
@@ -80513,6 +80820,7 @@ var RuntimePause, MachineWorker;
 var init_worker = __esm({
   "../../packages/agent-runtime/dist/worker.js"() {
     "use strict";
+    init_dist();
     init_dist2();
     init_dist2();
     init_dist();
@@ -80541,13 +80849,13 @@ var init_worker = __esm({
       constructor(options) {
         this.options = options;
         this.paths = resolveAgentPaths({ agentHome: options.agentHome });
-        this.statePath = join19(this.paths.metadata, "worker.json");
+        this.statePath = join21(this.paths.metadata, "worker.json");
       }
       async initialize() {
         await containedPath(this.paths.home, "metadata/worker.json");
-        await mkdir10(this.paths.metadata, { recursive: true });
+        await mkdir11(this.paths.metadata, { recursive: true });
         try {
-          this.state = JSON.parse(await readFile11(this.statePath, "utf8"));
+          this.state = JSON.parse(await readFile13(this.statePath, "utf8"));
           if (this.state.version !== 1 || !Number.isSafeInteger(this.state.seq) || !this.state.commands || !this.state.runs) {
             throw new Error("worker checkpoint version or shape is invalid");
           }
@@ -80574,7 +80882,7 @@ var init_worker = __esm({
         await this.mutate(() => {
           line = encodeEvent({
             protocolVersion: 1,
-            id: this.options.id?.() ?? randomUUID7(),
+            id: this.options.id?.() ?? randomUUID8(),
             seq: ++this.state.seq,
             emittedAt: (this.options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
             type,
@@ -80683,9 +80991,9 @@ var init_worker = __esm({
         } else if (!run) {
           run = {
             start: command,
-            sessionId: command.payload.session.sessionId ?? randomUUID7(),
+            sessionId: command.payload.session.sessionId ?? randomUUID8(),
             commandId: command.id,
-            checkpointId: randomUUID7(),
+            checkpointId: randomUUID8(),
             tools: /* @__PURE__ */ Object.create(null)
           };
         }
@@ -80732,9 +81040,18 @@ var init_worker = __esm({
           const hosted = this.options.hostedTools?.(run.start, session);
           const economy = this.options.economy?.(run.start, session);
           const dynamicTools = economy ? hostedDynamicTools(economy) : void 0;
+          let latestFinancialState = { status: "unavailable", reason: "Hosted financial state has not been read." };
+          const financialState = this.options.financialState ? async () => {
+            try {
+              latestFinancialState = await this.options.financialState(run.start, session);
+            } catch {
+              latestFinancialState = { status: "unavailable", reason: "Hosted financial state could not be read; do not use local budget figures." };
+            }
+            return latestFinancialState;
+          } : void 0;
           const record3 = async (name, args, invoke) => {
             const call2 = run.checkpoint?.response?.toolCalls.find((c) => c.name === name && !run.checkpoint?.completedTools[c.id]);
-            const id = `${run.checkpoint?.turn ?? 0}:${call2?.id ?? randomUUID7()}`;
+            const id = `${run.checkpoint?.turn ?? 0}:${call2?.id ?? randomUUID8()}`;
             const digest = createHash5("sha256").update(JSON.stringify({ name, args })).digest("hex");
             const saved = run.tools[id];
             if (saved && saved.digest !== digest)
@@ -80748,17 +81065,31 @@ var init_worker = __esm({
             await this.mutate(() => {
               run.tools[id] = { digest };
             });
-            await this.emit("tool.started", { toolCallId: id, toolName: name, input: summarizeToolInput(name, args) }, runId, run.commandId);
+            await this.emit("tool.started", { toolCallId: id, toolName: name, input: summarizeToolInput(name, args), details: captureDetail({ input: args }), turn: run.checkpoint?.turn ?? 0 }, runId, run.commandId);
+            const started = Date.now();
             let output3;
             try {
               if (saved?.approvalPending && name === "call_paid_service" && economy)
                 await economy.execute("inspect_paid_service", { url: args.url, method: args.method, sample_body: args.body });
               output3 = await invoke();
+              if (financialState && name === "get_budget_status")
+                output3 = { ok: true, data: latestFinancialState };
+              if (financialState && name === "complete_session" && output3.ok && output3.data && typeof output3.data === "object")
+                output3 = { ...output3, data: { ...output3.data, budget: latestFinancialState } };
             } catch (error53) {
               if (error53 instanceof RuntimePause && error53.outcome === "waiting_for_approval")
                 await this.mutate(() => {
                   run.tools[id].approvalPending = true;
                 });
+              await this.emit("tool.finished", {
+                toolCallId: id,
+                toolName: name,
+                status: error53 instanceof RuntimePause ? "blocked" : signal.aborted ? "cancelled" : "error",
+                durationMs: Date.now() - started,
+                turn: run.checkpoint?.turn ?? 0,
+                error: scrubText(error53 instanceof Error ? error53.message : String(error53)),
+                details: captureDetail({ error: error53 instanceof Error ? { name: error53.name, message: error53.message, stack: error53.stack } : String(error53) })
+              }, runId, run.commandId);
               throw error53;
             }
             await this.mutate(() => {
@@ -80768,7 +81099,10 @@ var init_worker = __esm({
               toolCallId: id,
               toolName: name,
               status: output3.ok ? "ok" : "error",
-              error: output3.error
+              error: output3.error ? scrubText(output3.error) : void 0,
+              durationMs: Date.now() - started,
+              turn: run.checkpoint?.turn ?? 0,
+              details: captureDetail({ output: output3 })
             }, runId, run.commandId);
             if (name === "save_file" && output3.ok)
               await this.emit("artifact.created", {
@@ -80778,6 +81112,42 @@ var init_worker = __esm({
               }, runId, run.commandId);
             return output3;
           };
+          const baseProvider = this.options.provider(run.start, session, dynamicTools?.definitions ?? []);
+          const provider = {
+            complete: async (messages, context) => {
+              const callId = randomUUID8(), started = Date.now(), turn = run.checkpoint?.turn ?? 0;
+              await this.emit("model.started", {
+                callId,
+                model: run.start.payload.modelPolicy.model ?? "demo",
+                turn,
+                details: captureDetail({ input: messages })
+              }, runId, run.commandId);
+              try {
+                const result2 = await baseProvider.complete(messages, context);
+                await this.emit("model.finished", {
+                  callId,
+                  model: run.start.payload.modelPolicy.model ?? "demo",
+                  turn,
+                  status: "ok",
+                  durationMs: Date.now() - started,
+                  usage: result2.usage,
+                  details: captureDetail({ output: result2 })
+                }, runId, run.commandId);
+                return result2;
+              } catch (error53) {
+                await this.emit("model.finished", {
+                  callId,
+                  model: run.start.payload.modelPolicy.model ?? "demo",
+                  turn,
+                  status: error53 instanceof RuntimePause ? "blocked" : signal.aborted ? "cancelled" : "error",
+                  durationMs: Date.now() - started,
+                  error: scrubText(error53 instanceof Error ? error53.message : String(error53)),
+                  details: captureDetail({ error: error53 instanceof Error ? { name: error53.name, message: error53.message, stack: error53.stack } : String(error53) })
+                }, runId, run.commandId);
+                throw error53;
+              }
+            }
+          };
           const acknowledgedMessages = /* @__PURE__ */ new Set();
           const result = await runAgentTaskDetailed(session, run.start.payload.prompt, {
             inbox: {
@@ -80800,24 +81170,25 @@ var init_worker = __esm({
             maxTurns: run.start.payload.maxTurns,
             contextWindowTokens: run.start.payload.modelPolicy.contextWindowTokens,
             maxOutputTokens: run.start.payload.modelPolicy.maxOutputTokens,
-            provider: this.options.provider(run.start, session, dynamicTools?.definitions ?? []),
+            provider,
+            financialState,
             history: run.checkpoint ? void 0 : await this.history(session),
             ...dynamicTools ? {
               dynamicTools: { definitions: dynamicTools.definitions, execute: (name, args) => record3(name, args, () => dynamicTools.execute(name, args, `${run.checkpoint?.turn ?? 0}:${run.checkpoint?.response?.toolCalls.find((c) => c.name === name && !run.checkpoint?.completedTools[c.id])?.id}`)) },
-              completionGate: () => dynamicTools.completionGate(),
+              completionGate: (alreadyNudged) => dynamicTools.completionGate(alreadyNudged),
               knowledge: await this.knowledgeOption(session)
             } : {},
             onCheckpoint: async (checkpoint) => {
               await this.mutate(() => {
                 run.checkpoint = checkpoint;
-                run.checkpointId = randomUUID7();
+                run.checkpointId = randomUUID8();
               });
-              await atomicWrite(join19(session.sessionDir, "messages.jsonl"), checkpoint.messages.filter((m) => m.role !== "system").map((message) => JSON.stringify({ type: "message", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message }) + "\n").join(""));
+              await atomicWrite(join21(session.sessionDir, "messages.jsonl"), checkpoint.messages.filter((m) => m.role !== "system").map((message) => JSON.stringify({ type: "message", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message }) + "\n").join(""));
             },
             onMessage: async (message) => {
               if (message.role === "assistant" && message.content)
                 await this.emit("assistant.message", {
-                  messageId: randomUUID7(),
+                  messageId: randomUUID8(),
                   content: message.content
                 }, runId, run.commandId);
             },
@@ -80825,6 +81196,13 @@ var init_worker = __esm({
           });
           await this.finish(runId, run, result.outcome === "stopped" ? "user_stopped" : result.outcome, String(result.summary.final_message ?? ""));
         } catch (error53) {
+          if (!(error53 instanceof RuntimePause) && !signal.aborted)
+            await this.emit("runtime.error", {
+              code: "run_exception",
+              message: scrubText(error53 instanceof Error ? error53.message : String(error53)),
+              fatal: false,
+              details: captureDetail({ error: error53 instanceof Error ? { name: error53.name, message: error53.message, stack: error53.stack } : String(error53) })
+            }, runId, run.commandId);
           if (signal.aborted)
             await this.finish(runId, run, "cancelled", "Run cancelled");
           else if (error53 instanceof RuntimePause) {
@@ -80849,7 +81227,7 @@ var init_worker = __esm({
       }
       async history(session) {
         try {
-          return (await readFile11(join19(session.sessionDir, "messages.jsonl"), "utf8")).split("\n").filter(Boolean).map((line) => JSON.parse(line).message).filter(Boolean);
+          return (await readFile13(join21(session.sessionDir, "messages.jsonl"), "utf8")).split("\n").filter(Boolean).map((line) => JSON.parse(line).message).filter(Boolean);
         } catch (error53) {
           if (error53.code === "ENOENT")
             return [];
@@ -80860,7 +81238,7 @@ var init_worker = __esm({
         await this.mutate(() => {
           run.outcome = outcome;
           run.summary = summary;
-          run.checkpointId = randomUUID7();
+          run.checkpointId = randomUUID8();
           if (!isWaiting(outcome) && this.state.activeRunId === runId)
             this.state.activeRunId = void 0;
         });
@@ -80887,7 +81265,7 @@ var init_worker = __esm({
 });
 
 // ../../packages/agent-runtime/dist/inbox.js
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 var FileSteeringInbox;
 var init_inbox = __esm({
   "../../packages/agent-runtime/dist/inbox.js"() {
@@ -80901,7 +81279,7 @@ var init_inbox = __esm({
       }
       async read() {
         try {
-          return JSON.parse(await readFile12(this.path, "utf8"));
+          return JSON.parse(await readFile14(this.path, "utf8"));
         } catch (e6) {
           if (e6.code === "ENOENT")
             return [];
@@ -80929,8 +81307,8 @@ var init_inbox = __esm({
 
 // ../../packages/agent-runtime/dist/index.js
 import { createHash as createHash6 } from "node:crypto";
-import { appendFile as appendFile4, mkdir as mkdir11, readFile as readFile13 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { appendFile as appendFile4, mkdir as mkdir12, readFile as readFile15 } from "node:fs/promises";
+import { join as join22 } from "node:path";
 function lastUserMessageIndex(messages) {
   for (let index2 = messages.length - 1; index2 >= 0; index2 -= 1) {
     if (messages[index2].role === "user") {
@@ -81120,8 +81498,10 @@ async function runAgentTaskDetailed(session, task, options = {}) {
     "Try to solve the user's task completely. Use local files and bash when they are sufficient, but remember they are bounded by the user's installed tools, credentials, network, open ports, and process lifetime.",
     "Before repeatedly fighting the local environment, decide whether the task needs external capability such as hosting, persistent infrastructure, remote compute, specialized APIs, live data, or access the user's device does not have."
   ];
+  if (options.hosted)
+    systemPromptParts.push("You operate this service for its owner. Inference and paid tools debit its USDC wallet. When authorized to build or sell a service, take concrete steps within the owner's configured scope and budget. Ask only for missing information or permissions that materially block progress. Report actual costs and outcomes. Financial sustainability is the owner's business objective; respect their stop controls.", "Financial state: the current hosted financial snapshot is authoritative; historical local session budget figures are not wallet balances and may omit inference spending. Wallet balance, pending payment holds, settled inference spend, settled service spend, and remaining run budget are separate. Spending totals cover only the identified current run. A budget limit does not supply funds. An unavailable balance is unknown, not zero. The snapshot before a model call excludes that call's eventual charge; never claim a response was free or that you spent nothing merely because no paid tool ran. Use get_budget_status or get_wallet_status for refreshed financial state. Respect approval mode and per-call limits; over-limit requests require the owner's approval.");
   if (options.dynamicTools) {
-    systemPromptParts.push("When the local computer is not the right environment, or after one clear local capability failure, buy external capability: find_paid_service to discover, inspect_paid_service to see the exact schema/price/reputation, call_paid_service to execute through the enforced purchase lifecycle, and review_paid_service for the required review after every confirmed paid call (success or failure). The same review tool accepts unpaid experiences; review relevant free results or failed attempts without inventing payment evidence. Distinguish provider faults from local errors and uncertain failures.", ...options.hosted ? ["Discover services through AgentCash search and provider catalogs. You can use new services without prior CrowdCode reviews. Only x402 USDC on Base is payable, within the user's configured limits; over-limit quotes request approval. Use read_service for authenticated job polling and never resubmit a pending generation job."] : [], capabilityIndex ?? DEFAULT_CAPABILITY_INDEX, "When a task needs current web facts, search results, or unfamiliar page content, make one paid web search your FIRST move \u2014 do not serially guess URLs with curl; one paid search replaces minutes of blind fetching and costs less than the LLM turns it saves.", "Approval, budget, reputation, and payment rails are enforced in code \u2014 you cannot bypass them, so state costs plainly and never invent payment details.", "Each tool result includes the budget before and after that tool call. Never ask for wallet private keys or secrets.", ...options.promptSections ?? []);
+    systemPromptParts.push("When the local computer is not the right environment, or after one clear local capability failure, buy external capability: find_paid_service to discover, inspect_paid_service to see the exact schema/price/reputation, call_paid_service to execute through the enforced purchase lifecycle, and review_paid_service for the required review after every confirmed paid call (success or failure). The same review tool accepts unpaid experiences; review relevant free results or failed attempts without inventing payment evidence. Distinguish provider faults from local errors and uncertain failures.", ...options.hosted ? ["Discover services through AgentCash search and provider catalogs. You can use new services without prior CrowdCode reviews. Only x402 USDC on Base is payable, within the user's configured limits; over-limit quotes request approval. Use read_service for authenticated job polling and never resubmit a pending generation job."] : [], capabilityIndex ?? DEFAULT_CAPABILITY_INDEX, "When a task needs current web facts, search results, or unfamiliar page content, make one paid web search your FIRST move \u2014 do not serially guess URLs with curl; one paid search replaces minutes of blind fetching and costs less than the LLM turns it saves.", "Approval, budget, reputation, and payment rails are enforced in code \u2014 you cannot bypass them, so state costs plainly and never invent payment details.", "When the user says CrowdCode on/off, call set_crowdcode_enabled; default to session scope unless they ask for a persistent default. Use list_my_reviews and delete_my_review for user-directed review management, including while off. Before finishing a substantive task, consider concrete paid services that would fix real shortcomings and submit qualifying demand with request_service, unless CrowdCode is off. Never invent a purchase or demand.", "Each tool result includes the budget before and after that tool call. Never ask for wallet private keys or secrets.", ...options.promptSections ?? []);
   } else {
     systemPromptParts.push("Paid external services are unavailable in this run; work with local tools only and say so if the task truly requires external capability.");
   }
@@ -81141,11 +81521,24 @@ async function runAgentTaskDetailed(session, task, options = {}) {
     ...options.history ?? [],
     { role: "user", content: task }
   ];
+  let financial = { status: "unavailable", reason: "Hosted financial state has not been read." };
+  const refreshFinancialState = async () => {
+    if (!options.financialState)
+      return;
+    try {
+      financial = FinancialStateSchema.parse(await options.financialState());
+    } catch {
+      financial = { status: "unavailable", reason: "Hosted financial state could not be read; do not use local budget figures." };
+    }
+  };
+  const currentBudget = () => options.financialState ? financial : budgetStatus(session);
+  const financialPrefix = "Current hosted financial snapshot: ";
   if (!options.resume)
     await options.onMessage?.({ role: "user", content: task });
   const maxTurns = options.maxTurns ?? 100;
   const repeatedFailures = new Map(options.resume?.repeatedFailures);
   let completionNudges = options.resume?.completionNudges ?? 0;
+  let pendingFinalMessage = options.resume?.pendingFinalMessage;
   let outputContinuationNudges = options.resume?.outputContinuationNudges ?? 0;
   let outputContinuationPrefix = options.resume?.outputContinuationPrefix ?? "";
   let serviceCallFailures = options.resume?.serviceCallFailures ?? 0;
@@ -81159,6 +81552,7 @@ async function runAgentTaskDetailed(session, task, options = {}) {
       context: contextState,
       deliveredMessageIds: [...deliveredMessageIds],
       completionNudges,
+      pendingFinalMessage,
       outputContinuationNudges,
       outputContinuationPrefix,
       serviceCallFailures,
@@ -81172,8 +81566,11 @@ async function runAgentTaskDetailed(session, task, options = {}) {
       messages.push({ role: "user", content: message.prompt });
       deliveredMessageIds.add(message.id);
     }
-    if (fresh.length)
+    if (fresh.length) {
+      pendingFinalMessage = void 0;
+      outputContinuationPrefix = "";
       await checkpoint(turn);
+    }
     for (const message of fresh)
       await options.onMessage?.({ role: "user", content: message.prompt });
     if (pending.length)
@@ -81201,6 +81598,15 @@ async function runAgentTaskDetailed(session, task, options = {}) {
     options.onProgress?.({ type: "calling_llm", message: `Calling LLM provider (turn ${turn + 1}/${maxTurns})` });
     let response;
     try {
+      if (options.financialState && !restored?.response && !contextState.prepared) {
+        await refreshFinancialState();
+        const snapshot = { role: "system", content: financialPrefix + JSON.stringify(financial) };
+        const index2 = messages.findIndex((m) => m.role === "system" && m.content.startsWith(financialPrefix));
+        if (index2 === -1)
+          messages.splice(1, 0, snapshot);
+        else
+          messages[index2] = snapshot;
+      }
       response = restored?.response ?? await completeWithContext(session, messages, {
         provider: provider instanceof MockLlmProvider ? { complete: (input2) => completeMockLlmCall(session, provider, input2, turn + 1) } : provider,
         tools: wireToolDefinitions(enabledTools, dynamicDefinitions),
@@ -81217,6 +81623,7 @@ async function runAgentTaskDetailed(session, task, options = {}) {
         }
       });
       options.signal?.throwIfAborted();
+      await refreshFinancialState();
     } catch (error53) {
       if (error53 instanceof BudgetExhaustedError) {
         const summary2 = await completeSession(session, `Stopped: the session budget is exhausted (${error53.message}).`);
@@ -81250,7 +81657,10 @@ ${outputContinuationPrefix}`);
     if (response.toolCalls.length === 0) {
       if (await injectMessages(turn + 1))
         continue;
-      const blocker = await options.completionGate?.();
+      const finalMessage = response.content.trim() ? outputContinuationPrefix + response.content : pendingFinalMessage ?? outputContinuationPrefix;
+      if (finalMessage.trim())
+        pendingFinalMessage = finalMessage;
+      const blocker = await options.completionGate?.(completionNudges > 0);
       if (blocker) {
         if (completionNudges >= 1) {
           const summary3 = await completeSession(session, `Stopped: ${blocker}`);
@@ -81260,9 +81670,12 @@ ${outputContinuationPrefix}`);
         const nudge = { role: "user", content: `You cannot finish yet: ${blocker}` };
         messages.push(nudge);
         await options.onMessage?.(nudge);
+        await checkpoint(turn + 1);
         continue;
       }
-      const summary2 = await completeSession(session, outputContinuationPrefix + (response.content || "Session completed."));
+      if (!pendingFinalMessage?.trim())
+        throw new Error("The model ended without an answer.");
+      const summary2 = await completeSession(session, pendingFinalMessage);
       return { outcome: "completed", summary: summary2, turns: turn + 1 };
     }
     const spawnedThisTurn = /* @__PURE__ */ new Map();
@@ -81305,7 +81718,7 @@ ${outputContinuationPrefix}`);
         message: `Tool call: ${summarizeToolCall(call2)}`,
         data: { tool: call2.name, arguments: call2.arguments }
       });
-      const budgetBeforeToolCall = budgetStatus(session);
+      const budgetBeforeToolCall = currentBudget();
       const callArguments = call2.name === "complete_session" && outputContinuationPrefix ? {
         ...call2.arguments,
         final_message: outputContinuationPrefix + (typeof call2.arguments.final_message === "string" ? call2.arguments.final_message : "")
@@ -81343,7 +81756,13 @@ ${outputContinuationPrefix}`);
       } else {
         result = { ok: false, error: `unknown tool: ${call2.name}` };
       }
-      const budgetAfterToolCall = budgetStatus(session);
+      await refreshFinancialState();
+      const budgetAfterToolCall = currentBudget();
+      if (options.financialState && call2.name === "get_budget_status")
+        result = { ok: true, data: financial };
+      if (options.financialState && call2.name === "complete_session" && result.ok && result.data && typeof result.data === "object") {
+        result = { ...result, data: { ...result.data, budget: financial } };
+      }
       options.onProgress?.({
         type: "tool_result",
         message: `Tool result: ${summarizeToolResult(call2.name, result)}`,
@@ -81364,6 +81783,8 @@ ${outputContinuationPrefix}`);
         await checkpoint(turn, response, completedTools);
         await options.onMessage?.(toolMessage);
       }
+      if (call2.name === "call_paid_service" && result.ok)
+        serviceCallFailures = 0;
       if (!result.ok) {
         if (call2.name === "call_paid_service") {
           serviceCallFailures += 1;
@@ -81387,7 +81808,12 @@ ${outputContinuationPrefix}`);
       const result = completedTools[call2.id];
       if (await injectMessages(turn + 1))
         continue;
-      const blocker = await options.completionGate?.();
+      if (!result.ok)
+        continue;
+      const finalMessage = result.data && typeof result.data === "object" ? result.data.final_message : void 0;
+      if (typeof finalMessage === "string" && finalMessage.trim())
+        pendingFinalMessage = finalMessage;
+      const blocker = await options.completionGate?.(completionNudges > 0);
       if (blocker) {
         if (completionNudges >= 1) {
           const summary3 = await completeSession(session, `Stopped: ${blocker}`);
@@ -81395,23 +81821,25 @@ ${outputContinuationPrefix}`);
         }
         completionNudges += 1;
         const gateMessage = {
-          role: "tool",
-          toolCallId: call2.id,
-          content: JSON.stringify({ result: { ok: false, error: `cannot complete yet: ${blocker}` } })
+          role: "user",
+          content: `You cannot finish yet: ${blocker}`
         };
         messages.push(gateMessage);
         await options.onMessage?.(gateMessage);
+        await checkpoint(turn + 1);
         continue;
       }
+      if (!pendingFinalMessage?.trim())
+        throw new Error("The model ended without an answer.");
       const backgroundResults = backgroundSubagents.size > 0 ? await drainBackground() : void 0;
-      if (result.ok && result.data && typeof result.data === "object") {
-        const summary3 = { ...result.data };
+      if (result.data && typeof result.data === "object") {
+        const summary3 = { ...result.data, final_message: pendingFinalMessage };
         if (backgroundResults) {
           summary3.background_subagents = backgroundResults;
         }
         return { outcome: "completed", summary: summary3, turns: turn + 1 };
       }
-      const summary2 = await completeSession(session, outputContinuationPrefix + (response.content || result.error || "Session completed."));
+      const summary2 = await completeSession(session, pendingFinalMessage);
       if (backgroundResults) {
         summary2.background_subagents = backgroundResults;
       }
@@ -81449,9 +81877,9 @@ async function runSubagentTask(session, args, subagent, index2, parentOptions, o
     return { ok: false, error: "spawn_subagent requires a task" };
   }
   const subagentId = `${session.sessionId}#sub${index2}`;
-  const trajectoryDir = join20(session.sessionDir, "subagents", operationKey ?? String(index2));
-  const trajectoryPath = join20(trajectoryDir, "messages.jsonl");
-  await mkdir11(trajectoryDir, { recursive: true });
+  const trajectoryDir = join22(session.sessionDir, "subagents", operationKey ?? String(index2));
+  const trajectoryPath = join22(trajectoryDir, "messages.jsonl");
+  await mkdir12(trajectoryDir, { recursive: true });
   const record3 = async (message) => {
     await appendFile4(trajectoryPath, `${JSON.stringify({ type: "message", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message })}
 `, "utf8");
@@ -81481,11 +81909,11 @@ async function runSubagentTask(session, args, subagent, index2, parentOptions, o
       ].filter(Boolean).join("\n\n")
     }
   ];
-  const statePath = join20(trajectoryDir, "checkpoint.json");
+  const statePath = join22(trajectoryDir, "checkpoint.json");
   let saved;
   if (operationKey)
     try {
-      saved = JSON.parse(await readFile13(statePath, "utf8"));
+      saved = JSON.parse(await readFile15(statePath, "utf8"));
     } catch (e6) {
       if (e6.code !== "ENOENT")
         throw e6;
@@ -81903,6 +82331,8 @@ function summarizeToolResult(name, result) {
     return `call_paid_service ${String(data.outcome ?? "?")} HTTP ${String(data.status ?? "?")}, charged ${formatCents(Number(data.charged_cost_cents ?? 0))}${data.artifact_path ? `, saved ${String(data.artifact_path)}` : ""}`;
   }
   if (name === "get_budget_status" && result.data && typeof result.data === "object") {
+    if ("status" in result.data)
+      return `hosted finances: ${String(result.data.status)}`;
     const data = result.data;
     return `remaining ${formatCents(Number(data.remaining_cents ?? 0))}`;
   }
@@ -82202,7 +82632,7 @@ var init_dist6 = __esm({
 
 // src/shared.ts
 import { readdir } from "node:fs/promises";
-import { join as join21, resolve as resolve5 } from "node:path";
+import { join as join23, resolve as resolve5 } from "node:path";
 import { stdout as output } from "node:process";
 function renderKeyValues(value) {
   return Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => `  ${style(key, "muted").padEnd(24)} ${formatCell(item, 80, key)}`).join("\n");
@@ -82324,7 +82754,7 @@ function isConsumedOption(args, index2, options) {
   return options.includes(args[index2]) || index2 > 0 && options.includes(args[index2 - 1]);
 }
 async function latestSessionId(workspaceRoot) {
-  const sessionsDir = join21(resolve5(workspaceRoot), "sessions");
+  const sessionsDir = join23(resolve5(workspaceRoot), "sessions");
   try {
     const entries = await readdir(sessionsDir, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
@@ -82357,6 +82787,7 @@ async function workerCommand(args) {
     provider: (run, session, extraTools) => socketPath ? createHostedProvider({ socketPath, runId: run.runId, sessionId: session.sessionId, extraTools }) : createWorkerDemoProvider(),
     hostedTools: socketPath ? (run, session) => createHostedToolExecutor({ socketPath, runId: run.runId, sessionId: session.sessionId }) : void 0,
     economy: socketPath ? (run, session) => createHostedEconomy({ socketPath, runId: run.runId, sessionId: session.sessionId, session }) : void 0,
+    financialState: socketPath ? (run, session) => readHostedFinancialState({ socketPath, runId: run.runId, sessionId: session.sessionId }) : void 0,
     output: (line) => {
       process.stdout.write(line);
     }
@@ -82471,8 +82902,8 @@ var init_doctor = __esm({
 });
 
 // ../../packages/evals/dist/gaia.js
-import { mkdir as mkdir12, readFile as readFile14, writeFile as writeFile5, access as access2 } from "node:fs/promises";
-import { dirname as dirname10, join as join23 } from "node:path";
+import { mkdir as mkdir13, readFile as readFile16, writeFile as writeFile7, access as access2 } from "node:fs/promises";
+import { dirname as dirname11, join as join25 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 function isUnsupportedModality(fileName) {
   if (!fileName) {
@@ -82482,18 +82913,18 @@ function isUnsupportedModality(fileName) {
   return UNSUPPORTED_EXTENSIONS.some((extension2) => lower.endsWith(extension2));
 }
 function defaultGaiaCacheDir() {
-  return process.env.OPENCROWD_GAIA_CACHE_DIR ?? join23(homedir7(), ".cache", "opencrowd", "gaia", "2023", "validation");
+  return process.env.OPENCROWD_GAIA_CACHE_DIR ?? join25(homedir7(), ".cache", "opencrowd", "gaia", "2023", "validation");
 }
 async function fetchGaiaValidation(options = {}) {
   const cacheDir = options.cacheDir ?? defaultGaiaCacheDir();
-  await mkdir12(cacheDir, { recursive: true });
-  const metadataPath = join23(cacheDir, "metadata.jsonl");
+  await mkdir13(cacheDir, { recursive: true });
+  const metadataPath = join25(cacheDir, "metadata.jsonl");
   let metadataText;
   try {
-    metadataText = await readFile14(metadataPath, "utf8");
+    metadataText = await readFile16(metadataPath, "utf8");
   } catch {
     metadataText = await fetchValidationRows(options);
-    await writeFile5(metadataPath, metadataText, "utf8");
+    await writeFile7(metadataPath, metadataText, "utf8");
   }
   return metadataText.split(/\r?\n/).filter(Boolean).map((line) => parseGaiaRecord(JSON.parse(line)));
 }
@@ -82542,7 +82973,7 @@ async function ensureGaiaAttachments(questions, options = {}) {
   const cacheDir = options.cacheDir ?? defaultGaiaCacheDir();
   for (const question of questions) {
     if (question.file_name && !isUnsupportedModality(question.file_name)) {
-      const filePath = join23(cacheDir, question.file_name);
+      const filePath = join25(cacheDir, question.file_name);
       await cachedDownload(filePath, `${GAIA_BASE_URL}/${encodeURIComponent(question.file_name)}`, options, true);
       question.file_path = filePath;
     }
@@ -82572,7 +83003,7 @@ function parseGaiaRecord(record3) {
 async function cachedDownload(path3, url3, options, binary = false) {
   try {
     await access2(path3);
-    return binary ? "" : await readFile14(path3, "utf8");
+    return binary ? "" : await readFile16(path3, "utf8");
   } catch {
   }
   options.log?.(`fetching ${url3}`);
@@ -82591,14 +83022,14 @@ async function cachedDownload(path3, url3, options, binary = false) {
   if (!response.ok) {
     throw new Error(`GAIA download failed: ${response.status} ${response.statusText} for ${url3}`);
   }
-  await mkdir12(dirname10(path3), { recursive: true });
+  await mkdir13(dirname11(path3), { recursive: true });
   if (binary) {
     const buffer2 = Buffer.from(await response.arrayBuffer());
-    await writeFile5(path3, buffer2);
+    await writeFile7(path3, buffer2);
     return "";
   }
   const text = await response.text();
-  await writeFile5(path3, text, "utf8");
+  await writeFile7(path3, text, "utf8");
   return text;
 }
 var GAIA_BASE_URL, GAIA_ROWS_URL, GAIA_TIERS, UNSUPPORTED_EXTENSIONS;
@@ -82632,9 +83063,9 @@ var init_gaia = __esm({
 });
 
 // ../../packages/evals/dist/grader.js
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 async function gradeTrajectoryFile(path3) {
-  const text = await readFile15(path3, "utf8");
+  const text = await readFile17(path3, "utf8");
   const entries = text.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
   return gradeTrajectory(entries);
 }
@@ -82767,8 +83198,8 @@ var init_grader = __esm({
 // ../../packages/evals/dist/harnesses.js
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { copyFile, mkdir as mkdir13, readFile as readFile16 } from "node:fs/promises";
-import { basename, join as join24 } from "node:path";
+import { copyFile, mkdir as mkdir14, readFile as readFile18 } from "node:fs/promises";
+import { basename, join as join26 } from "node:path";
 function resolveHarness(name) {
   switch (name) {
     case "opencrowd":
@@ -82797,7 +83228,7 @@ function gaiaPrompt(question, attachmentNote) {
 }
 async function countPaidPurchases(path3) {
   try {
-    const text = await readFile16(path3, "utf8");
+    const text = await readFile18(path3, "utf8");
     return text.split(/\r?\n/).filter(Boolean).filter((line) => {
       const entry = asRecord3(parseJson3(line));
       const outcome = asRecord3(entry.record).outcome ?? entry.outcome;
@@ -82812,7 +83243,7 @@ async function comparatorPrompt(context) {
     return context.prompt;
   }
   const name = basename(context.attachmentPath);
-  await copyFile(context.attachmentPath, join24(context.runDir, name));
+  await copyFile(context.attachmentPath, join26(context.runDir, name));
   return `${context.prompt}
 
 An input file is available in the working directory at ./${name}`;
@@ -82906,11 +83337,11 @@ var init_harnesses = __esm({
         let prompt = context.prompt;
         if (context.attachmentPath) {
           const name = basename(context.attachmentPath);
-          await mkdir13(session.artifactsDir, { recursive: true });
-          await copyFile(context.attachmentPath, join24(session.artifactsDir, name));
+          await mkdir14(session.artifactsDir, { recursive: true });
+          await copyFile(context.attachmentPath, join26(session.artifactsDir, name));
           prompt = `${prompt}
 
-An input file is available at the session artifact path \`${name}\` (use read_file, or run_shell against ${join24(session.artifactsDir, name)}).`;
+An input file is available at the session artifact path \`${name}\` (use read_file, or run_shell against ${join26(session.artifactsDir, name)}).`;
         }
         const llm = context.testMode ? void 0 : await resolveLlmRuntime(session, {
           model: context.model,
@@ -82941,7 +83372,7 @@ An input file is available at the session artifact path \`${name}\` (use read_fi
           onMessage: (message) => appendConversationMessage(session, message)
         });
         const budget = asRecord3(result.summary.budget);
-        const trajectoryPath = join24(session.sessionDir, "messages.jsonl");
+        const trajectoryPath = join26(session.sessionDir, "messages.jsonl");
         return {
           final_message: String(result.summary.final_message ?? ""),
           turns: result.turns,
@@ -82952,7 +83383,7 @@ An input file is available at the session artifact path \`${name}\` (use read_fi
           knowledge_version: session.knowledge?.version,
           session_dir: session.sessionDir,
           artifacts_dir: session.artifactsDir,
-          paid_calls: await countPaidPurchases(join24(session.sessionDir, "purchases.jsonl")),
+          paid_calls: await countPaidPurchases(join26(session.sessionDir, "purchases.jsonl")),
           model_policy: llm?.models,
           compliance: await gradeTrajectoryFile(trajectoryPath).catch(() => void 0)
         };
@@ -83155,8 +83586,8 @@ var init_scorer = __esm({
 });
 
 // ../../packages/evals/dist/runner.js
-import { appendFile as appendFile5, mkdir as mkdir14, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join25, resolve as resolve6 } from "node:path";
+import { appendFile as appendFile5, mkdir as mkdir15, writeFile as writeFile8 } from "node:fs/promises";
+import { join as join27, resolve as resolve6 } from "node:path";
 async function runGaiaBenchmark(options) {
   const log = options.log ?? (() => void 0);
   const harnesses = options.harnesses.map(resolveHarness);
@@ -83182,8 +83613,8 @@ async function runGaiaBenchmark(options) {
   }
   const runId = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const resultsDir = resolve6(options.workspaceRoot, "evals", "gaia", runId);
-  await mkdir14(resultsDir, { recursive: true });
-  const resultsPath = join25(resultsDir, "results.jsonl");
+  await mkdir15(resultsDir, { recursive: true });
+  const resultsPath = join27(resultsDir, "results.jsonl");
   log(`GAIA ${options.tier}: ${runnable.length} questions, ${skipped.length} skipped (unsupported modality), results in ${resultsDir}`);
   const parallel = Math.max(1, options.parallel ?? 4);
   const rows = [];
@@ -83209,13 +83640,13 @@ async function runGaiaBenchmark(options) {
     harnesses: harnesses.map((harness) => summarizeHarness(harness, rows.filter((row) => row.harness === harness.name))),
     rows
   };
-  await writeFile6(join25(resultsDir, "report.json"), `${JSON.stringify(report, null, 2)}
+  await writeFile8(join27(resultsDir, "report.json"), `${JSON.stringify(report, null, 2)}
 `, "utf8");
   return report;
 }
 async function runOneQuestion(harness, question, resultsDir, options) {
-  const runDir = join25(resultsDir, harness.name, question.task_id);
-  await mkdir14(runDir, { recursive: true });
+  const runDir = join27(resultsDir, harness.name, question.task_id);
+  await mkdir15(runDir, { recursive: true });
   const prompt = gaiaPrompt(question);
   const started = Date.now();
   let run;
@@ -83346,9 +83777,9 @@ var init_runner = __esm({
 });
 
 // ../../packages/evals/dist/tasks.js
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile19 } from "node:fs/promises";
 import { createHash as createHash7 } from "node:crypto";
-import { dirname as dirname11, join as join26 } from "node:path";
+import { dirname as dirname12, join as join28 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { homedir as homedir8 } from "node:os";
 async function loadTaskSet(name, options = {}) {
@@ -83370,10 +83801,10 @@ async function loadTaskSet(name, options = {}) {
   }
 }
 function tasksDir() {
-  return join26(dirname11(fileURLToPath2(import.meta.url)), "..", "tasks");
+  return join28(dirname12(fileURLToPath2(import.meta.url)), "..", "tasks");
 }
 async function loadUsageTasks() {
-  const raw = JSON.parse(await readFile17(join26(tasksDir(), "usage.json"), "utf8"));
+  const raw = JSON.parse(await readFile19(join28(tasksDir(), "usage.json"), "utf8"));
   return raw.tasks.map((task) => ({
     task_id: String(task.id),
     suite: "usage",
@@ -83385,7 +83816,7 @@ async function loadUsageTasks() {
     capability: typeof task.capability === "string" ? task.capability : void 0,
     expect_paid: task.expect_paid,
     file_name: typeof task.attachment === "string" ? task.attachment : void 0,
-    file_path: typeof task.attachment === "string" ? join26(tasksDir(), "attachments", task.attachment) : void 0
+    file_path: typeof task.attachment === "string" ? join28(tasksDir(), "attachments", task.attachment) : void 0
   }));
 }
 async function loadGaiaHard(options = {}) {
@@ -83411,13 +83842,13 @@ function gaiaToTask(question) {
   };
 }
 function defaultAssistantBenchCachePath() {
-  return process.env.OPENCROWD_ASSISTANTBENCH_CACHE ?? join26(homedir8(), ".cache", "opencrowd", "assistantbench", "validation.jsonl");
+  return process.env.OPENCROWD_ASSISTANTBENCH_CACHE ?? join28(homedir8(), ".cache", "opencrowd", "assistantbench", "validation.jsonl");
 }
 async function loadAssistantBench(options = {}) {
   const cachePath = defaultAssistantBenchCachePath();
   let text;
   try {
-    text = await readFile17(cachePath, "utf8");
+    text = await readFile19(cachePath, "utf8");
   } catch {
     options.log?.(`fetching ${ASSISTANTBENCH_ROWS_URL}`);
     const headers = options.hfToken ? { authorization: `Bearer ${options.hfToken}` } : {};
@@ -83428,9 +83859,9 @@ async function loadAssistantBench(options = {}) {
     const body = await response.json();
     text = `${(body.rows ?? []).map((item) => JSON.stringify(item.row)).join("\n")}
 `;
-    const { mkdir: mkdir20, writeFile: writeFile11 } = await import("node:fs/promises");
-    await mkdir20(dirname11(cachePath), { recursive: true });
-    await writeFile11(cachePath, text, "utf8");
+    const { mkdir: mkdir21, writeFile: writeFile13 } = await import("node:fs/promises");
+    await mkdir21(dirname12(cachePath), { recursive: true });
+    await writeFile13(cachePath, text, "utf8");
   }
   const rows = text.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
   const selected = seededSample(rows, ASSISTANTBENCH_COUNT, `${options.seed ?? DEFAULT_SEED}:assistantbench`, (row) => String(row.id));
@@ -83486,9 +83917,9 @@ var init_tasks = __esm({
 });
 
 // ../../packages/evals/dist/scoring.js
-import { readFile as readFile18, stat } from "node:fs/promises";
+import { readFile as readFile20, stat } from "node:fs/promises";
 import { resolve as resolveDns } from "node:dns/promises";
-import { join as join27 } from "node:path";
+import { join as join29 } from "node:path";
 async function scoreTask(task, finalMessage, context = {}) {
   const answer = extractAnswerText(finalMessage);
   const spec = task.scorer;
@@ -83533,7 +83964,7 @@ async function scoreTask(task, finalMessage, context = {}) {
         return { score: 0, correct: false, detail: "no artifacts dir" };
       }
       for (const name of spec.names) {
-        const path3 = join27(context.artifactsDir, name);
+        const path3 = join29(context.artifactsDir, name);
         let size5;
         try {
           size5 = (await stat(path3)).size;
@@ -83543,7 +83974,7 @@ async function scoreTask(task, finalMessage, context = {}) {
         if (spec.min_bytes !== void 0 && size5 < spec.min_bytes) {
           return { score: 0, correct: false, detail: `${name} too small (${size5} bytes)` };
         }
-        const buffer2 = await readFile18(path3);
+        const buffer2 = await readFile20(path3);
         if (spec.image && !looksLikeImage(buffer2)) {
           return { score: 0, correct: false, detail: `${name} is not a PNG/JPEG/WebP` };
         }
@@ -83730,8 +84161,8 @@ var init_scoring = __esm({
 });
 
 // ../../packages/evals/dist/suite.js
-import { appendFile as appendFile6, mkdir as mkdir15, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join28, resolve as resolve7 } from "node:path";
+import { appendFile as appendFile6, mkdir as mkdir16, writeFile as writeFile9 } from "node:fs/promises";
+import { join as join30, resolve as resolve7 } from "node:path";
 async function runSuite(options) {
   const log = options.log ?? (() => void 0);
   const harness = resolveHarness(options.harness ?? "opencrowd");
@@ -83745,8 +84176,8 @@ async function runSuite(options) {
   }
   const runId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}${options.tag ? `-${slug(options.tag)}` : ""}`;
   const resultsDir = resolve7(options.resultsRoot, runId);
-  await mkdir15(resultsDir, { recursive: true });
-  const resultsPath = join28(resultsDir, "results.jsonl");
+  await mkdir16(resultsDir, { recursive: true });
+  const resultsPath = join30(resultsDir, "results.jsonl");
   log(`suite ${options.set}${options.tag ? ` [${options.tag}]` : ""}: ${tasks.length} tasks, knowledge=${options.knowledgeDir ?? "none"}, results in ${resultsDir}`);
   const limit = createLimiter3(Math.max(1, options.parallel ?? 3));
   const rows = await Promise.all(tasks.map((task, index2) => limit(async () => {
@@ -83770,15 +84201,15 @@ async function runSuite(options) {
     summary: summarize(rows),
     rows
   };
-  await writeFile7(join28(resultsDir, "report.json"), `${JSON.stringify(report, null, 2)}
+  await writeFile9(join30(resultsDir, "report.json"), `${JSON.stringify(report, null, 2)}
 `, "utf8");
-  await writeFile7(join28(resultsDir, "report.md"), `${renderSuiteReport(report)}
+  await writeFile9(join30(resultsDir, "report.md"), `${renderSuiteReport(report)}
 `, "utf8");
   return report;
 }
 async function runOneTask(harnessName, harness, task, resultsDir, runId, options) {
-  const runDir = join28(resultsDir, harnessName, task.task_id);
-  await mkdir15(runDir, { recursive: true });
+  const runDir = join30(resultsDir, harnessName, task.task_id);
+  await mkdir16(runDir, { recursive: true });
   const started = Date.now();
   let run;
   try {
@@ -83937,13 +84368,13 @@ var init_suite = __esm({
 });
 
 // ../../packages/evals/dist/evidence.js
-import { mkdir as mkdir16, readFile as readFile19, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname12 } from "node:path";
+import { mkdir as mkdir17, readFile as readFile21, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname as dirname13 } from "node:path";
 async function fetchCrowdCodeEvidence(options = {}) {
   const cachePath = options.cachePath;
   if (cachePath && options.useCache !== false) {
     try {
-      return JSON.parse(await readFile19(cachePath, "utf8"));
+      return JSON.parse(await readFile21(cachePath, "utf8"));
     } catch {
     }
   }
@@ -83955,8 +84386,8 @@ async function fetchCrowdCodeEvidence(options = {}) {
     const exported = await fetchGatedExport(fetchImpl, baseUrl, exportToken, log);
     if (exported) {
       if (cachePath) {
-        await mkdir16(dirname12(cachePath), { recursive: true });
-        await writeFile8(cachePath, `${JSON.stringify(exported, null, 1)}
+        await mkdir17(dirname13(cachePath), { recursive: true });
+        await writeFile10(cachePath, `${JSON.stringify(exported, null, 1)}
 `, "utf8");
       }
       return exported;
@@ -83986,8 +84417,8 @@ async function fetchCrowdCodeEvidence(options = {}) {
     }
   };
   if (cachePath) {
-    await mkdir16(dirname12(cachePath), { recursive: true });
-    await writeFile8(cachePath, `${JSON.stringify(bundle, null, 1)}
+    await mkdir17(dirname13(cachePath), { recursive: true });
+    await writeFile10(cachePath, `${JSON.stringify(bundle, null, 1)}
 `, "utf8");
   }
   return bundle;
@@ -84155,8 +84586,8 @@ var init_evidence = __esm({
 
 // ../../packages/evals/dist/knowledge.js
 import { createHash as createHash8 } from "node:crypto";
-import { mkdir as mkdir17, readdir as readdir2, readFile as readFile20, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname13, join as join29, relative as relative4 } from "node:path";
+import { mkdir as mkdir18, readdir as readdir2, readFile as readFile22, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname14, join as join31, relative as relative4 } from "node:path";
 function approxTokens(text) {
   return Math.ceil(text.length / 4);
 }
@@ -84245,32 +84676,32 @@ function validateTree(tree, evidence) {
   };
 }
 async function writeTree(dir, tree, meta4) {
-  await mkdir17(dir, { recursive: true });
+  await mkdir18(dir, { recursive: true });
   for (const [name, content] of Object.entries(tree)) {
-    const path3 = join29(dir, name);
-    await mkdir17(dirname13(path3), { recursive: true });
-    await writeFile9(path3, content.endsWith("\n") ? content : `${content}
+    const path3 = join31(dir, name);
+    await mkdir18(dirname14(path3), { recursive: true });
+    await writeFile11(path3, content.endsWith("\n") ? content : `${content}
 `, "utf8");
   }
-  await writeFile9(join29(dir, "meta.json"), `${JSON.stringify(meta4, null, 2)}
+  await writeFile11(join31(dir, "meta.json"), `${JSON.stringify(meta4, null, 2)}
 `, "utf8");
 }
 async function readTree(dir) {
   const tree = {};
   const walk3 = async (current) => {
     for (const entry of await readdir2(current, { withFileTypes: true })) {
-      const path3 = join29(current, entry.name);
+      const path3 = join31(current, entry.name);
       if (entry.isDirectory()) {
         await walk3(path3);
       } else if (entry.name.endsWith(".md")) {
-        tree[relative4(dir, path3)] = await readFile20(path3, "utf8");
+        tree[relative4(dir, path3)] = await readFile22(path3, "utf8");
       }
     }
   };
   await walk3(dir);
   let meta4;
   try {
-    meta4 = JSON.parse(await readFile20(join29(dir, "meta.json"), "utf8"));
+    meta4 = JSON.parse(await readFile22(join31(dir, "meta.json"), "utf8"));
   } catch {
     meta4 = void 0;
   }
@@ -84278,7 +84709,7 @@ async function readTree(dir) {
 }
 async function updateTreeMeta(dir, patch) {
   const { meta: meta4 } = await readTree(dir);
-  await writeFile9(join29(dir, "meta.json"), `${JSON.stringify({ ...meta4 ?? {}, ...patch }, null, 2)}
+  await writeFile11(join31(dir, "meta.json"), `${JSON.stringify({ ...meta4 ?? {}, ...patch }, null, 2)}
 `, "utf8");
 }
 async function proposeTree(options) {
@@ -84394,23 +84825,23 @@ var init_knowledge2 = __esm({
 });
 
 // ../../packages/evals/dist/evolve.js
-import { mkdir as mkdir18, readFile as readFile21, writeFile as writeFile10 } from "node:fs/promises";
-import { join as join30, resolve as resolve8 } from "node:path";
+import { mkdir as mkdir19, readFile as readFile23, writeFile as writeFile12 } from "node:fs/promises";
+import { join as join32, resolve as resolve8 } from "node:path";
 async function runEvolution(options) {
   const log = options.log ?? (() => void 0);
   const root = resolve8(options.resultsRoot);
-  const treesDir = join30(root, "trees");
-  const runsDir = join30(root, "runs");
-  await mkdir18(treesDir, { recursive: true });
-  await mkdir18(runsDir, { recursive: true });
-  const evidencePath = options.evidencePath ?? join30(root, "evidence", "crowdcode-evidence.json");
+  const treesDir = join32(root, "trees");
+  const runsDir = join32(root, "runs");
+  await mkdir19(treesDir, { recursive: true });
+  await mkdir19(runsDir, { recursive: true });
+  const evidencePath = options.evidencePath ?? join32(root, "evidence", "crowdcode-evidence.json");
   const evidence = await fetchCrowdCodeEvidence({ cachePath: evidencePath, useCache: !options.refreshEvidence, log });
   const digest = renderEvidenceDigest(evidence, { detailTop: 90, maxReviewsPerService: 4 });
   const evidenceHash = hashContent(digest);
   log(`evidence: ${evidence.stats.services} services, ${evidence.stats.reviews} reviews, digest ~${Math.round(digest.length / 4)} tokens`);
   const heldin = await loadTaskSet("heldin", { hfToken: options.hfToken, log });
   const proposer = await buildProposerProviders(root, options.proposerModels);
-  const archivePath = join30(root, "archive.json");
+  const archivePath = join32(root, "archive.json");
   const archive = await readArchive(archivePath) ?? {
     started_at: (/* @__PURE__ */ new Date()).toISOString(),
     agent_model: options.agentModel,
@@ -84418,9 +84849,9 @@ async function runEvolution(options) {
     entries: []
   };
   const save = async () => {
-    await writeFile10(archivePath, `${JSON.stringify(archive, null, 2)}
+    await writeFile12(archivePath, `${JSON.stringify(archive, null, 2)}
 `, "utf8");
-    await writeFile10(join30(root, "frontier.md"), `${renderArchive(archive)}
+    await writeFile12(join32(root, "frontier.md"), `${renderArchive(archive)}
 `, "utf8");
   };
   const evaluate = async (entry, knowledgeDir) => {
@@ -84447,7 +84878,7 @@ async function runEvolution(options) {
   if (!archive.entries.some((entry) => entry.id === "baseline")) {
     const baseline = { id: "baseline", generation: 0, children: 0, status: "evaluated" };
     if (options.baselineReport) {
-      const report = JSON.parse(await readFile21(options.baselineReport, "utf8"));
+      const report = JSON.parse(await readFile23(options.baselineReport, "utf8"));
       const rows = report.rows.filter((row) => row.suite === "usage");
       baseline.report_dir = report.results_dir;
       baseline.metrics = metricsOfRows(rows);
@@ -84528,7 +84959,7 @@ async function runEvolution(options) {
   }
   const best = bestEntry(archive);
   if (best?.dir) {
-    await writeFile10(join30(root, "BEST"), `${best.dir}
+    await writeFile12(join32(root, "BEST"), `${best.dir}
 `, "utf8");
   }
   await save();
@@ -84561,9 +84992,9 @@ async function proposeCandidate(input2) {
         log: input2.log
       });
       const validation = validateTree(proposal.tree, input2.evidence);
-      const dir = join30(input2.treesDir, id);
-      await mkdir18(dir, { recursive: true });
-      await writeFile10(join30(dir, "proposal.raw.txt"), proposal.rawResponse, "utf8");
+      const dir = join32(input2.treesDir, id);
+      await mkdir19(dir, { recursive: true });
+      await writeFile12(join32(dir, "proposal.raw.txt"), proposal.rawResponse, "utf8");
       if (!validation.ok) {
         errors = validation.errors;
         input2.log(`${id}: invalid (${validation.errors.join("; ")})`);
@@ -84650,7 +85081,7 @@ function metricsOfRows(rows) {
   };
 }
 async function casesFromReport(reportDir) {
-  const report = JSON.parse(await readFile21(join30(reportDir, "report.json"), "utf8"));
+  const report = JSON.parse(await readFile23(join32(reportDir, "report.json"), "utf8"));
   const cases = [];
   for (const row of report.rows) {
     cases.push({
@@ -84671,7 +85102,7 @@ async function casesFromReport(reportDir) {
 async function summarizeTrajectory(path3) {
   let text;
   try {
-    text = await readFile21(path3, "utf8");
+    text = await readFile23(path3, "utf8");
   } catch {
     return void 0;
   }
@@ -84703,7 +85134,7 @@ async function summarizeTrajectory(path3) {
   return steps.length > 0 ? steps.join(" -> ") : void 0;
 }
 async function buildProposerProviders(root, models) {
-  const session = await createOpenCrowdSession({ workspaceRoot: join30(root, "proposer"), approvalMode: "auto", shellEnabled: false });
+  const session = await createOpenCrowdSession({ workspaceRoot: join32(root, "proposer"), approvalMode: "auto", shellEnabled: false });
   const providers = /* @__PURE__ */ new Map();
   for (const model of new Set(models)) {
     const llm = await resolveLlmRuntime(session, { model, subagentModel: "off", nonInteractive: true });
@@ -84720,7 +85151,7 @@ async function buildProposerProviders(root, models) {
 }
 async function readArchive(path3) {
   try {
-    return JSON.parse(await readFile21(path3, "utf8"));
+    return JSON.parse(await readFile23(path3, "utf8"));
   } catch {
     return void 0;
   }
@@ -84865,8 +85296,8 @@ init_dist2();
 init_dist4();
 init_dist6();
 init_shared();
-import { copyFile as copyFile2, mkdir as mkdir19, readFile as readFile22, rm as rm3 } from "node:fs/promises";
-import { basename as basename2, join as join31 } from "node:path";
+import { copyFile as copyFile2, mkdir as mkdir20, readFile as readFile24, rm as rm3 } from "node:fs/promises";
+import { basename as basename2, join as join33 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { stdin as input, stdout as output2 } from "node:process";
 
@@ -85597,8 +86028,8 @@ function indent(text) {
 
 // src/tui/app.tsx
 init_dist2();
-import { join as join22 } from "node:path";
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { join as join24 } from "node:path";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, render, Static, Text, useApp, useInput, usePaste, useStdout } from "ink";
 init_dist6();
@@ -85637,7 +86068,7 @@ function App({ session: initialSession, initialTestMode, initialTestSeed, defaul
   const runningRef = useRef(false);
   const inboxPausedRef = useRef(false);
   const [inboxRevision, setInboxRevision] = useState(0);
-  const inbox = useMemo(() => new FileSteeringInbox(join22(session.sessionDir, "inbox.json")), [session.sessionDir]);
+  const inbox = useMemo(() => new FileSteeringInbox(join24(session.sessionDir, "inbox.json")), [session.sessionDir]);
   const [activity, setActivity] = useState("");
   const [spinnerFrame, setSpinnerFrame] = useState(0);
   const [modal, setModal] = useState(null);
@@ -86071,7 +86502,7 @@ function App({ session: initialSession, initialTestMode, initialTestSeed, defaul
         if (text) {
           setInput("");
           setCursor(0);
-          void inbox.push({ id: randomUUID8(), prompt: text }).then(() => {
+          void inbox.push({ id: randomUUID9(), prompt: text }).then(() => {
             push({ kind: "user", text: `${text} (queued)` });
             setInboxRevision((n) => n + 1);
           }).catch((e6) => push({ kind: "error", text: e6.message }));
@@ -86490,7 +86921,7 @@ async function main(argv) {
     case "--version":
     case "-v":
     case "version": {
-      const pkg2 = JSON.parse(await readFile22(new URL("../package.json", import.meta.url), "utf8"));
+      const pkg2 = JSON.parse(await readFile24(new URL("../package.json", import.meta.url), "utf8"));
       console.log(pkg2.version);
       return;
     }
@@ -86595,11 +87026,11 @@ async function headlessRunCommand(args) {
   let task = prompt;
   if (attach) {
     const attachmentName = basename2(attach);
-    await mkdir19(session.artifactsDir, { recursive: true });
-    await copyFile2(attach, join31(session.artifactsDir, attachmentName));
+    await mkdir20(session.artifactsDir, { recursive: true });
+    await copyFile2(attach, join33(session.artifactsDir, attachmentName));
     task = `${prompt}
 
-An input file is available at the session artifact path \`${attachmentName}\` (use read_file, or run_shell against ${join31(session.artifactsDir, attachmentName)}).`;
+An input file is available at the session artifact path \`${attachmentName}\` (use read_file, or run_shell against ${join33(session.artifactsDir, attachmentName)}).`;
   }
   const result = await runPersistentAgentTaskDetailed(session, task, {
     model: readOption(args, "--model"),
@@ -86623,7 +87054,7 @@ An input file is available at the session artifact path \`${attachmentName}\` (u
     final_message: result.summary.final_message ?? null,
     session_id: session.sessionId,
     session_dir: session.sessionDir,
-    trajectory_path: join31(session.sessionDir, "messages.jsonl"),
+    trajectory_path: join33(session.sessionDir, "messages.jsonl"),
     turns: result.turns,
     model_policy: session.models ?? null,
     usdc_spent_cents: {
@@ -86706,7 +87137,7 @@ async function ledgerCommand(args) {
   if (!sessionId) {
     throw new Error("no local sessions found");
   }
-  const rows = await readLedger(join31(process.cwd(), "sessions", sessionId, "ledger.csv"));
+  const rows = await readLedger(join33(process.cwd(), "sessions", sessionId, "ledger.csv"));
   printValue("Ledger", rows, {
     json: json3,
     pretty: renderTable(rows.map(asRecord), [
@@ -86743,7 +87174,7 @@ async function resumeCommand(args) {
       } catch (e6) {
         if (!(e6 instanceof SpendingDeclined)) throw e6;
       }
-      await rm3(join31(session.sessionDir, "query-checkpoint.json"), { force: true });
+      await rm3(join33(session.sessionDir, "query-checkpoint.json"), { force: true });
       console.log("Query declined. Nothing was paid for the pending call.");
       return;
     }
@@ -86882,7 +87313,7 @@ async function evalsSuiteCommand(rest) {
   const report = await runSuite2({
     set: set3,
     harness: readOption(rest, "--harness") ?? "opencrowd",
-    resultsRoot: readOption(rest, "--out") ?? join31(process.cwd(), "evals", "suite"),
+    resultsRoot: readOption(rest, "--out") ?? join33(process.cwd(), "evals", "suite"),
     tag: readOption(rest, "--tag"),
     knowledgeDir: readOption(rest, "--knowledge"),
     hfToken: readOption(rest, "--hf-token") ?? process.env.HF_TOKEN,
@@ -86901,7 +87332,7 @@ async function evalsSuiteCommand(rest) {
 async function evalsEvolveCommand(rest) {
   const { runEvolution: runEvolution2, renderArchive: renderArchive2 } = await Promise.resolve().then(() => (init_dist7(), dist_exports));
   const { archive, best } = await runEvolution2({
-    resultsRoot: readOption(rest, "--out") ?? join31(process.cwd(), "evals", "evolve"),
+    resultsRoot: readOption(rest, "--out") ?? join33(process.cwd(), "evals", "evolve"),
     evidencePath: readOption(rest, "--evidence"),
     refreshEvidence: rest.includes("--refresh-evidence"),
     generations: Number(readOption(rest, "--generations") ?? 2),