@lucid-agents/taskmarket 1.17.2 → 1.18.1

package/dist/{chunk-73RXOYME.js → chunk-EB6OJBF5.js}

@@ -73,6 +73,11 @@ function statusBarText(view) {
     parts.push(
       open ? `budget ${formatUsdc(remainingBudget(view))} left` : `channel ${active[0].state.replace("_", " ")}`
     );
+    const depositing = active.reduce(
+      (sum, channel) => sum + BigInt(channel.amounts.depositing),
+      0n
+    );
+    if (depositing > 0n) parts.push(`deposit ${formatUsdc(depositing)} confirming`);
   }
   const compute = view.compute;
   if (compute?.configured && compute.availableCredits !== null) {

package/dist/chunk-HEGWADBV.js

@@ -0,0 +1,447 @@
+import { createRequire as __tmCreateRequire } from 'node:module'; import { fileURLToPath as __tmFileURLToPath } from 'node:url'; import { dirname as __tmDirname } from 'node:path'; const require = __tmCreateRequire(import.meta.url); const __tmFilename = __tmFileURLToPath(import.meta.url); const __tmDirnameValue = __tmDirname(__tmFilename);
+import {
+  x402FeePost
+} from "./chunk-3LNZ766H.js";
+import {
+  createWalletAccountFromKeystore,
+  signMessage
+} from "./chunk-5VMWXDNO.js";
+import {
+  READ_AUTH_ADDRESS_HEADER,
+  READ_AUTH_SIGNATURE_HEADER,
+  TASK_ACCESS_GRANT_HEADER,
+  apiGet,
+  apiPost,
+  buildClaimMessage,
+  buildReadAuthMessage,
+  buildSubmitMessage,
+  getTaskmarketHome,
+  isRecordingPendingResponse,
+  loadKeystore
+} from "./chunk-YB2B5DPR.js";
+
+// src/lib/read-auth.ts
+async function signReadAuth() {
+  let keystore;
+  try {
+    keystore = await loadKeystore();
+  } catch {
+    return null;
+  }
+  try {
+    const account = await createWalletAccountFromKeystore(keystore);
+    const signature = await account.signMessage({
+      message: buildReadAuthMessage(keystore.walletAddress)
+    });
+    return {
+      walletAddress: keystore.walletAddress,
+      headers: {
+        [READ_AUTH_ADDRESS_HEADER]: keystore.walletAddress,
+        [READ_AUTH_SIGNATURE_HEADER]: signature
+      }
+    };
+  } catch {
+    return { walletAddress: keystore.walletAddress, headers: {} };
+  }
+}
+
+// src/lib/task-access-grants.ts
+import { promises as fs } from "fs";
+import path from "path";
+function getGrantsPath() {
+  return path.join(getTaskmarketHome(), "task-access-grants.json");
+}
+async function readGrantsFile() {
+  try {
+    const raw = await fs.readFile(getGrantsPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function loadTaskAccessGrant(taskId) {
+  const grants = await readGrantsFile();
+  const record = grants[taskId];
+  if (!record) return null;
+  if (new Date(record.expiresAt).getTime() <= Date.now()) return null;
+  return record.grant;
+}
+async function taskAccessGrantHeaders(taskId) {
+  const grant = await loadTaskAccessGrant(taskId);
+  return grant ? { [TASK_ACCESS_GRANT_HEADER]: grant } : {};
+}
+async function saveTaskAccessGrant(taskId, grant, expiresAt) {
+  const grants = await readGrantsFile();
+  grants[taskId] = { grant, expiresAt };
+  const dir = path.dirname(getGrantsPath());
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(getGrantsPath(), JSON.stringify(grants, null, 2), {
+    mode: 384
+  });
+}
+
+// src/sdk/artifact-upload.ts
+import { extname } from "path";
+import { Readable } from "stream";
+import https from "https";
+import http from "http";
+function mimeTypeForPath(filePath) {
+  switch (extname(filePath).toLowerCase()) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    case ".svg":
+      return "image/svg+xml";
+    case ".pdf":
+      return "application/pdf";
+    case ".mp4":
+      return "video/mp4";
+    case ".webm":
+      return "video/webm";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".wav":
+      return "audio/wav";
+    case ".md":
+      return "text/markdown";
+    case ".txt":
+      return "text/plain";
+    case ".json":
+      return "application/json";
+    case ".zip":
+      return "application/zip";
+    default:
+      return "application/octet-stream";
+  }
+}
+function putArtifactBytes(uploadUrl, data, mimeType, onProgress) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(uploadUrl);
+    const transport = url.protocol === "https:" ? https : http;
+    const req = transport.request(
+      url,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": mimeType,
+          "Content-Length": String(data.length)
+        }
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve();
+          } else {
+            const body = Buffer.concat(chunks).toString("utf8").slice(0, 500);
+            reject(
+              new Error(
+                `Upload failed (${res.statusCode ?? "unknown"}): ${body || "no response body"}`
+              )
+            );
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    let uploaded = 0;
+    const stream = Readable.from([data]);
+    stream.on("data", (chunk) => {
+      uploaded += chunk.length;
+      onProgress?.(Math.round(uploaded / data.length * 100));
+    });
+    stream.on("error", reject);
+    stream.pipe(req);
+  });
+}
+
+// src/lib/task-sdk.ts
+async function putWithProgress(upload) {
+  process.stderr.write(`  Uploading ${upload.fileName}...
+`);
+  await putArtifactBytes(upload.uploadUrl, upload.data, upload.mimeType, (percent) => {
+    process.stderr.write(`\r  ${upload.fileName}: ${percent}%`);
+  });
+  process.stderr.write("\n");
+}
+var cliTaskTransport = {
+  get: (path2, headers) => apiGet(path2, { headers }),
+  // A write the caller gave no key is sent exactly as before the SDK existed, with no options,
+  // so `apiPost` resolves its key itself (explicit, then TASKMARKET_IDEMPOTENCY_KEY, then fresh).
+  post: (path2, body, options) => options === void 0 ? apiPost(path2, body) : apiPost(path2, body, options),
+  feePost: (path2, body, options) => x402FeePost(path2, body, options),
+  put: putWithProgress
+};
+function keystoreTaskSigner(keystore) {
+  return {
+    address: keystore.walletAddress,
+    signMessage: (message) => signMessage(message, keystore)
+  };
+}
+function cliTaskReadContext() {
+  return {
+    transport: cliTaskTransport,
+    readAuth: signReadAuth,
+    accessGrantHeaders: taskAccessGrantHeaders
+  };
+}
+function cliTaskWriteContext(keystore) {
+  return { ...cliTaskReadContext(), signer: keystoreTaskSigner(keystore) };
+}
+
+// src/sdk/tasks.ts
+import { promises as fsPromises } from "fs";
+import { basename } from "path";
+import { createHash } from "crypto";
+import { keccak256 } from "viem";
+var TaskOperationError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "TaskOperationError";
+    this.code = code;
+  }
+};
+function withChainQuery(path2, chainId) {
+  if (chainId === void 0) return path2;
+  return `${path2}${path2.includes("?") ? "&" : "?"}chainId=${chainId}`;
+}
+function withChainBody(body, chainId) {
+  return chainId === void 0 ? body : { ...body, chainId };
+}
+function writeOptions(idempotencyKey) {
+  return idempotencyKey === void 0 ? void 0 : { idempotencyKey };
+}
+async function readAuthHeaders(ctx) {
+  return (await ctx.readAuth?.())?.headers ?? {};
+}
+async function getTask(ctx, ref) {
+  const headers = {
+    ...await readAuthHeaders(ctx),
+    ...await ctx.accessGrantHeaders?.(ref.taskId) ?? {}
+  };
+  const task = await ctx.transport.get(
+    withChainQuery(`/api/tasks/${ref.taskId}`, ref.chainId),
+    headers
+  );
+  return task ?? null;
+}
+async function getTaskTerms(ctx, ref) {
+  const headers = {
+    ...await readAuthHeaders(ctx),
+    ...await ctx.accessGrantHeaders?.(ref.taskId) ?? {}
+  };
+  const detail = await ctx.transport.get(
+    withChainQuery(`/api/tasks/${ref.taskId}/terms`, ref.chainId),
+    headers
+  );
+  return detail ?? null;
+}
+async function listTasks(ctx, filter = {}) {
+  const params = new URLSearchParams();
+  if (filter.chainId !== void 0) params.set("chainId", String(filter.chainId));
+  if (filter.q) params.set("q", filter.q);
+  if (filter.sort) params.set("sort", filter.sort);
+  if (filter.status) params.set("status", filter.status);
+  if (filter.phase) params.set("phase", filter.phase);
+  if (filter.mode) params.set("mode", filter.mode);
+  if (filter.auctionType) params.set("auctionType", filter.auctionType);
+  if (filter.tags) params.set("tags", filter.tags);
+  if (filter.minReward) params.set("minReward", filter.minReward);
+  if (filter.maxReward) params.set("maxReward", filter.maxReward);
+  if (filter.deadlineHours) params.set("deadlineHours", filter.deadlineHours);
+  if (filter.limit) params.set("limit", filter.limit);
+  if (filter.cursor) params.set("cursor", filter.cursor);
+  const result = await ctx.transport.get(
+    `/api/tasks?${params.toString()}`,
+    await readAuthHeaders(ctx)
+  );
+  return { tasks: result.tasks, hasMore: result.hasMore, nextCursor: result.nextCursor };
+}
+async function listTaskSubmissions(ctx, ref) {
+  const headers = await readAuthHeaders(ctx);
+  return await ctx.transport.get(
+    withChainQuery(`/api/tasks/${ref.taskId}/submissions`, ref.chainId),
+    headers
+  );
+}
+async function listWorkerSubmissions(ctx, options = {}) {
+  const auth = await ctx.readAuth?.();
+  const address = options.address ?? auth?.walletAddress;
+  if (!address) {
+    throw new TaskOperationError(
+      "no_address",
+      "No worker address was given and there is no reading wallet to default to"
+    );
+  }
+  return ctx.transport.get(`/api/submissions/mine?workerAddress=${encodeURIComponent(address)}`, {
+    ...auth?.headers ?? {}
+  });
+}
+async function getWorkerInbox(ctx) {
+  const auth = await ctx.readAuth?.();
+  if (!auth?.walletAddress) {
+    throw new TaskOperationError("no_address", "There is no reading wallet to ask about");
+  }
+  const raw = await ctx.transport.get(
+    `/api/agents/inbox?address=${encodeURIComponent(auth.walletAddress)}`,
+    auth.headers
+  );
+  return {
+    address: auth.walletAddress,
+    proven: Object.keys(auth.headers).length > 0,
+    inbox: {
+      asRequester: raw?.asRequester ?? [],
+      asWorker: raw?.asWorker ?? [],
+      invitedPrivateTasks: raw?.invitedPrivateTasks ?? []
+    }
+  };
+}
+async function getAgentStats(ctx, options) {
+  return await ctx.transport.get(
+    withChainQuery(
+      `/api/agents/stats?address=${encodeURIComponent(options.address)}`,
+      options.chainId
+    ),
+    {}
+  );
+}
+async function claimTask(ctx, ref, options = {}) {
+  const signature = await ctx.signer.signMessage(buildClaimMessage(ref.taskId));
+  const { data, idempotencyKey } = await ctx.transport.post(
+    `/api/tasks/${ref.taskId}/claim`,
+    withChainBody({ workerAddress: ctx.signer.address, signature }, ref.chainId),
+    writeOptions(options.idempotencyKey)
+  );
+  return { claimId: data.claimId, idempotencyKey };
+}
+async function authorizeUploads(ctx, ref) {
+  return { signature: await ctx.signer.signMessage(buildSubmitMessage(ref.taskId)) };
+}
+async function readArtifactFile(file) {
+  const fileName = file.fileName ?? basename(file.path);
+  const data = await fsPromises.readFile(file.path);
+  if (data.length === 0) {
+    throw new TaskOperationError("empty_artifact", `File is empty: ${fileName}`);
+  }
+  return {
+    data,
+    artifact: {
+      fileName,
+      mimeType: file.mimeType ?? mimeTypeForPath(file.path),
+      role: file.role,
+      sizeBytes: data.length,
+      sha256Hash: createHash("sha256").update(data).digest("hex"),
+      keccak256Hash: keccak256(new Uint8Array(data))
+    }
+  };
+}
+async function requestArtifactUpload(ctx, ref, artifact, authorization) {
+  const {
+    data: { uploadUrl, artifactKey }
+  } = await ctx.transport.post(
+    `/api/tasks/${ref.taskId}/submissions/request-upload-url`,
+    withChainBody(
+      {
+        taskId: ref.taskId,
+        workerAddress: ctx.signer.address,
+        signature: authorization.signature,
+        fileName: artifact.fileName,
+        mimeType: artifact.mimeType,
+        role: artifact.role,
+        sizeBytes: artifact.sizeBytes
+      },
+      ref.chainId
+    )
+  );
+  return { uploadUrl, artifactKey };
+}
+async function uploadArtifact(ctx, ref, file, authorization) {
+  const { data, artifact } = await readArtifactFile(file);
+  const { uploadUrl, artifactKey } = await requestArtifactUpload(ctx, ref, artifact, authorization);
+  await ctx.transport.put({
+    uploadUrl,
+    data,
+    mimeType: artifact.mimeType,
+    fileName: artifact.fileName
+  });
+  return { artifactKey, ...artifact };
+}
+async function submitUploadedArtifacts(ctx, ref, artifacts, options = {}) {
+  if (artifacts.length === 0) {
+    throw new TaskOperationError("no_artifacts", "At least one artifact is required");
+  }
+  const signature = await ctx.signer.signMessage(
+    buildSubmitMessage(
+      ref.taskId,
+      artifacts.map((artifact) => artifact.artifactKey)
+    )
+  );
+  const { data, idempotencyKey } = await ctx.transport.feePost(
+    `/api/tasks/${ref.taskId}/submissions/from-keys`,
+    withChainBody(
+      {
+        taskId: ref.taskId,
+        workerAddress: ctx.signer.address,
+        artifacts,
+        signature
+      },
+      ref.chainId
+    ),
+    options
+  );
+  if (isRecordingPendingResponse(data)) {
+    return {
+      submissionId: data.submissionId,
+      idempotencyKey,
+      recordingPending: {
+        ...typeof data.intentId === "string" ? { intentId: data.intentId } : {},
+        ...typeof data.txHash === "string" ? { txHash: data.txHash } : {}
+      }
+    };
+  }
+  return { submissionId: data.submissionId, idempotencyKey };
+}
+async function submitTaskFiles(ctx, ref, files, options = {}) {
+  if (files.length === 0) {
+    throw new TaskOperationError("no_artifacts", "At least one file is required");
+  }
+  const authorization = await authorizeUploads(ctx, ref);
+  const artifacts = await Promise.all(
+    files.map((file) => uploadArtifact(ctx, ref, file, authorization))
+  );
+  return submitUploadedArtifacts(ctx, ref, artifacts, options);
+}
+
+export {
+  signReadAuth,
+  taskAccessGrantHeaders,
+  saveTaskAccessGrant,
+  mimeTypeForPath,
+  putArtifactBytes,
+  cliTaskTransport,
+  keystoreTaskSigner,
+  cliTaskReadContext,
+  cliTaskWriteContext,
+  TaskOperationError,
+  getTask,
+  getTaskTerms,
+  listTasks,
+  listTaskSubmissions,
+  listWorkerSubmissions,
+  getWorkerInbox,
+  getAgentStats,
+  claimTask,
+  authorizeUploads,
+  readArtifactFile,
+  requestArtifactUpload,
+  submitUploadedArtifacts,
+  submitTaskFiles
+};

package/dist/{chunk-GJQUALXN.js → chunk-LEVAZYR5.js}

@@ -6,21 +6,23 @@ import {
   createBaseChannelRpcReader,
   createWalletAccountFromKeystore,
   createX402Allocations,
-  getTaskmarketHome,
   getX402JournalPath,
   getX402PolicyPath,
-  keystoreExists,
   listX402Payments,
-  loadKeystore,
   loadX402Policy,
   rpcUrlForNetwork
-} from "./chunk-FRV3ZHUR.js";
+} from "./chunk-5VMWXDNO.js";
 import {
-  AgentLaunchError
-} from "./chunk-YM4S6IE4.js";
+  getTaskmarketHome,
+  keystoreExists,
+  loadKeystore
+} from "./chunk-YB2B5DPR.js";
 import {
   formatUsdc
-} from "./chunk-73RXOYME.js";
+} from "./chunk-EB6OJBF5.js";
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
 
 // src/lib/agent/channels.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -334,7 +336,11 @@ async function createAgentRails(options) {
       budgetAmount: rail.limits.total,
       depositAmount: rail.limits.deposit,
       policyRuleId: rail.policyRuleId,
-      ...options.fetch ? { fetch: options.fetch } : {}
+      ...options.fetch ? { fetch: options.fetch } : {},
+      confirmationWait: {
+        ...options.confirmationWait,
+        ...options.onConfirmationWait ? { onWait: (progress) => options.onConfirmationWait(rail, progress) } : {}
+      }
     });
     const transport = createTaskMarketTransport({
       payer,
@@ -438,10 +444,12 @@ function createAgentTransport(rails) {
   };
 }
 async function reconcileLeftoverOperations(rails, log = () => void 0) {
-  for (const { rail, payer } of rails) {
+  const usable = [];
+  const blocked = [];
+  for (const entry of rails) {
+    const { rail, payer } = entry;
     let pending = (await payer.channelStatus()).pendingOperation;
-    if (!pending) continue;
-    if (pending.kind === "payment") {
+    if (pending?.kind === "payment") {
       log(`Reconciling payment ${pending.id} left on rail ${rail.id}`);
       try {
         await payer.reconcile(pending.id);
@@ -451,13 +459,22 @@ async function reconcileLeftoverOperations(rails, log = () => void 0) {
         );
       }
       pending = (await payer.channelStatus()).pendingOperation;
-      if (!pending) continue;
     }
+    if (!pending) {
+      usable.push(entry);
+      continue;
+    }
+    const reason = `The ${rail.id} channel has an unresolved ${pending.kind} operation ${pending.id} from an earlier session; it must be reconciled (taskmarket agent reconcile ${pending.id}) before anything else is bought on that channel.`;
+    log(`${reason} Its models are left out of this session.`);
+    blocked.push(reason);
+  }
+  if (usable.length === 0 && blocked.length > 0) {
     throw new AgentLaunchError(
       "channel_operation_pending",
-      `The ${rail.id} channel has an unresolved ${pending.kind} operation ${pending.id} from an earlier session; it must be reconciled before anything else is bought on that channel. Try again later.`
+      `${blocked.join(" ")} Try again later.`
     );
   }
+  return usable;
 }
 
 // src/lib/agent/policy.ts
@@ -469,7 +486,7 @@ var XGATE_ROUTES = [
   "/providers/anthropic/v1/messages",
   "/providers/openai/v1/responses"
 ];
-var WORKSPACE_CONSENT_VERSION = "boat-eu-2026-10";
+var WORKSPACE_CONSENT_VERSION = "boat-eu-2026-10-sync";
 var address = z.string().regex(/^0x[0-9a-fA-F]{40}$/, "expected a 0x-prefixed 20-byte address");
 var atomic2 = z.string().regex(/^(0|[1-9][0-9]{0,30})$/, "expected an integer amount string");
 var positiveAtomic = atomic2.refine((value) => BigInt(value) > 0n, "expected an amount above 0");
@@ -669,15 +686,31 @@ async function assessAgentPolicy(policy, options) {
   }
   return { reasons, usage };
 }
-function selectModels(policy, requested) {
-  if (requested === void 0) return [...policy.models];
-  if (!policy.models.includes(requested)) {
+function requireApprovedModel(policy, requested) {
+  if (requested !== void 0 && !policy.models.includes(requested)) {
     throw new AgentLaunchError(
       "model_not_allowed",
       `Model ${requested} is not in the approved spending policy (${policy.models.join(", ")})`
     );
   }
-  return [requested];
+}
+function planSessionModels(options) {
+  const { approved, offered, requested, previous } = options;
+  const unavailable = approved.filter((model) => !offered.includes(model));
+  if (offered.length === 0) {
+    throw new AgentLaunchError(
+      "no_qualified_models",
+      `None of the approved models (${approved.join(", ")}) is qualified by xgate on a route the policy pays for`
+    );
+  }
+  if (requested !== void 0 && !offered.includes(requested)) {
+    throw new AgentLaunchError(
+      "model_not_offered",
+      `Model ${requested} is approved, but xgate does not offer it on a route a usable rail of the policy pays for, so this session cannot buy it. This session offers ${offered.join(", ")}`
+    );
+  }
+  const start = requested ?? (previous !== void 0 && offered.includes(previous) ? previous : offered[0]);
+  return { start, unavailable };
 }
 
 // src/lib/agent/retired.ts
@@ -738,7 +771,9 @@ async function openAgentChannels(options = {}) {
     models: options.models ? options.models(policy) : [...policy.models],
     walletAddress: keystore.walletAddress,
     getAccount,
-    ...options.fetch ? { fetch: options.fetch } : {}
+    ...options.fetch ? { fetch: options.fetch } : {},
+    ...options.onConfirmationWait ? { onConfirmationWait: options.onConfirmationWait } : {},
+    ...options.confirmationWait ? { confirmationWait: options.confirmationWait } : {}
   };
   const rails = await createAgentRails(common);
   const retired = await createAgentRails({
@@ -863,9 +898,7 @@ async function uncertainPurchases(rails, statuses = /* @__PURE__ */ new Map()) {
   for (const record2 of records) {
     if (!record2.invocationId || record2.rail?.id !== BASE_CHANNEL_RAIL_ID) continue;
     if (!UNDECIDED.has(record2.state)) continue;
-    const rail = rails.find(
-      (r) => record2.origin === r.rail.origin && record2.pathname === r.rail.route
-    );
+    const rail = rails.find((r) => record2.funding?.sessionKey === r.payer.sessionKey);
     if (!rail) continue;
     const lease = statuses.get(rail.rail.id)?.pendingOperation;
     found.push({
@@ -955,6 +988,34 @@ function outcomeOf(operation) {
   if (operation.state === "failed") return "failed";
   return "pending";
 }
+var REFUND_WAIT_TIMEOUT_MS = 9e4;
+var REFUND_WAIT_INTERVAL_MS = 3e3;
+async function awaitRefund(rail, operation, wait = {}) {
+  const timeoutMs = wait.timeoutMs ?? REFUND_WAIT_TIMEOUT_MS;
+  const intervalMs = Math.max(1, wait.intervalMs ?? REFUND_WAIT_INTERVAL_MS);
+  const sleep = wait.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  let current = operation;
+  let waitedMs = 0;
+  while ((current.state === "dispatched" || current.state === "unknown") && current.transaction && waitedMs < timeoutMs) {
+    try {
+      wait.onWait?.({
+        transaction: current.transaction,
+        amount: current.amount,
+        waitedMs,
+        timeoutMs
+      });
+    } catch {
+    }
+    const step = Math.min(intervalMs, timeoutMs - waitedMs);
+    await sleep(step);
+    waitedMs += step;
+    try {
+      current = await rail.payer.reconcileOperation(current.operationId);
+    } catch {
+    }
+  }
+  return current;
+}
 async function closeSession(allocationId2) {
   try {
     await allocationsReader().close(allocationId2);
@@ -975,7 +1036,11 @@ function closeLines(channel) {
 }
 async function closeChannel(rail, confirm, options = {}) {
   const retired = options.retired ?? false;
-  const status = await rail.payer.channelStatus();
+  let status = await rail.payer.channelStatus();
+  if (status.pendingOperation?.kind === "payment" && options.reconcilePurchase) {
+    await options.reconcilePurchase(status.pendingOperation.id);
+    status = await rail.payer.channelStatus();
+  }
   const channel = await channelView(rail, status, { retired });
   const result = async (outcome, operation2, reconciled) => {
     const after = operation2 ? await channelView(rail, void 0, { retired }) : channel;
@@ -1002,7 +1067,11 @@ async function closeChannel(rail, confirm, options = {}) {
   if (status.closed) return result("closed", null, false);
   const lease = status.pendingOperation;
   if (lease?.kind === "lifecycle") {
-    const operation2 = await rail.payer.reconcileOperation(lease.id);
+    const operation2 = await awaitRefund(
+      rail,
+      await rail.payer.reconcileOperation(lease.id),
+      options.wait
+    );
     return result(outcomeOf(operation2), operation2, true);
   }
   if (lease?.kind === "payment") {
@@ -1026,10 +1095,17 @@ async function closeChannel(rail, confirm, options = {}) {
   if (!await confirm(closeLines(channel))) {
     throw new AgentLaunchError("not_approved", "The channel was not closed");
   }
-  const operation = await rail.payer.refund({
-    operationId: `agent-close-${randomUUID2()}`,
-    close: true
-  });
+  const operationId = `agent-close-${randomUUID2()}`;
+  let operation;
+  try {
+    operation = await rail.payer.refund({ operationId, close: true });
+  } catch (error) {
+    if (error.code !== "outcome_uncertain") throw error;
+    const recorded = await rail.payer.reconcileOperation(operationId).catch(() => void 0);
+    if (!recorded || recorded.state !== "dispatched" && recorded.state !== "unknown") throw error;
+    operation = recorded;
+  }
+  operation = await awaitRefund(rail, operation, options.wait);
   return result(outcomeOf(operation), operation, false);
 }
 
@@ -1047,7 +1123,8 @@ export {
   loadAgentPolicy,
   saveAgentPolicy,
   assessAgentPolicy,
-  selectModels,
+  requireApprovedModel,
+  planSessionModels,
   settledRetiredRails,
   openAgentChannels,
   selectChannel,