@lucid-agents/taskmarket 1.17.1 → 1.18.0

package/dist/{status-3Q55PBFC.js → prompter-LSICEYSQ.js}

@@ -1,18 +1,9 @@
 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 {
-  collectAgentStatus,
-  listSandboxes,
-  statusLines
-} from "./chunk-JAZ5BWPB.js";
-import "./chunk-MI2GPMCZ.js";
-import "./chunk-EIHZYRIU.js";
-import "./chunk-F5SS4NUF.js";
-import "./chunk-3S63AB3C.js";
+  terminalPrompter
+} from "./chunk-ZIC2YCLV.js";
 import "./chunk-YM4S6IE4.js";
-import "./chunk-73RXOYME.js";
 import "./chunk-S7SJMJ2I.js";
 export {
-  collectAgentStatus,
-  listSandboxes,
-  statusLines
+  terminalPrompter
 };

package/dist/reconcile-Q7XFHDQQ.js

@@ -0,0 +1,194 @@
+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 {
+  channelView,
+  openAgentChannels,
+  selectChannel
+} from "./chunk-MO5KMUTL.js";
+import {
+  BASE_CHANNEL_RAIL_ID,
+  X402_INVOCATION_ID_PATTERN,
+  getX402JournalPath,
+  listX402Payments
+} from "./chunk-S4A6V3J3.js";
+import "./chunk-75LS6XS6.js";
+import {
+  AGENT_VIEW_VERSION,
+  LOST_RESPONSE_TEXT,
+  formatUsdc
+} from "./chunk-EB6OJBF5.js";
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
+import "./chunk-S7SJMJ2I.js";
+
+// src/lib/agent/reconcile.ts
+function outcomeOf(status) {
+  if (status.state === "in_progress") return "in_progress";
+  if (status.charge === "manually_resolved") return "resolved_manually";
+  if (status.uncertain) return "uncertain";
+  if (status.charge === "settled") return "charged";
+  if (status.charge === "none" || status.charge === "released") return "not_charged";
+  return "uncertain";
+}
+function messageFor(outcome, status) {
+  const charged = status.payment?.settledAmount;
+  switch (outcome) {
+    case "charged":
+      return `Charged ${charged !== void 0 ? formatUsdc(charged) : "an amount the router committed"}. If its response did not reach you: ${LOST_RESPONSE_TEXT}`;
+    case "not_charged":
+      return "Nothing was charged. The request is not sent again; ask again in the agent if you still want an answer.";
+    case "in_progress":
+      return "It is still being sent by another process; reconcile it again once that finishes.";
+    case "resolved_manually":
+      return "It was resolved by hand; its recorded amount stands.";
+    default:
+      return "Its outcome is still unknown. It keeps its maximum counted and blocks new turns on its channel; reconcile it again later. It is never sent again.";
+  }
+}
+var code = (error) => error?.code;
+async function locate(rails, invocationId) {
+  let owner;
+  for (const rail of rails) {
+    try {
+      await rail.payer.status(invocationId);
+      owner = rail;
+      break;
+    } catch (error) {
+      if (code(error) !== "invocation_not_found") throw error;
+    }
+  }
+  const leased = [];
+  for (const rail of rails) {
+    const lease = (await rail.payer.channelStatus()).pendingOperation;
+    if (lease?.kind === "payment" && lease.id === invocationId) leased.push(rail);
+  }
+  return { owner, leased };
+}
+async function settle(rails, invocationId, only) {
+  const { owner, leased } = await locate(rails, invocationId);
+  if (only && owner && owner !== only) {
+    throw new AgentLaunchError(
+      "invocation_not_found",
+      `Purchase ${invocationId} was paid on the ${owner.rail.id} channel ${owner.payer.channelId}, not on ${only.payer.channelId}`
+    );
+  }
+  const releasedFrom = [];
+  if (owner) {
+    for (const rail2 of leased.filter((candidate) => candidate !== owner)) {
+      try {
+        await rail2.payer.reconcile(invocationId);
+      } catch (error) {
+        if (code(error) !== "invocation_not_found") throw error;
+      }
+      const lease2 = (await rail2.payer.channelStatus()).pendingOperation;
+      if (!(lease2?.kind === "payment" && lease2.id === invocationId))
+        releasedFrom.push(rail2.rail.id);
+    }
+  }
+  const rail = owner ?? (only && leased.includes(only) ? only : leased[0]);
+  if (!rail) {
+    throw new AgentLaunchError(
+      "invocation_not_found",
+      only ? `No agent purchase ${invocationId} is recorded on channel ${only.payer.channelId}` : `No agent purchase ${invocationId} is recorded on this device`
+    );
+  }
+  const status = await rail.payer.reconcile(invocationId);
+  const lease = (await rail.payer.channelStatus()).pendingOperation;
+  const outcome = outcomeOf(status);
+  return {
+    version: AGENT_VIEW_VERSION,
+    kind: "taskmarket.agent.reconcile",
+    invocationId,
+    rail: rail.rail.id,
+    outcome,
+    state: status.state,
+    charge: status.charge,
+    authorizedAtomic: status.payment?.authorizedAmount ?? null,
+    chargedAtomic: status.payment?.settledAmount ?? null,
+    blocksChannel: lease?.kind === "payment" && lease.id === invocationId,
+    releasedFrom,
+    message: messageFor(outcome, status)
+  };
+}
+var chosen = (choice) => choice.rail !== void 0 || choice.channel !== void 0;
+async function reconcileInvocation(invocationId, deps = {}) {
+  if (!X402_INVOCATION_ID_PATTERN.test(invocationId)) {
+    throw new AgentLaunchError("invalid_invocation_id", `Not an invocation ID: ${invocationId}`);
+  }
+  const opened = await (deps.openChannels ?? openAgentChannels)();
+  const rails = [...opened.rails, ...opened.retired ?? []];
+  const only = deps.choice && chosen(deps.choice) ? selectChannel(opened, deps.choice).rail : void 0;
+  return settle(rails, invocationId, only);
+}
+var UNDECIDED = /* @__PURE__ */ new Set([
+  "reserved",
+  "approval_pending",
+  "ready",
+  "dispatched",
+  "unknown",
+  "settled_amount_unknown"
+]);
+async function openPurchases(rail) {
+  const records = await listX402Payments({}, getX402JournalPath());
+  const byId = new Map(records.map((record) => [record.id, record]));
+  const found = [];
+  for (const record of records) {
+    if (!record.invocationId || record.rail?.id !== BASE_CHANNEL_RAIL_ID || record.funding?.sessionKey !== rail.payer.sessionKey)
+      continue;
+    const deposit = record.funding.depositId ? byId.get(record.funding.depositId) : void 0;
+    const depositOpen = deposit !== void 0 && ["reserved", "dispatched", "unknown"].includes(deposit.state);
+    if (UNDECIDED.has(record.state) || depositOpen)
+      found.push({ invocationId: record.invocationId, createdAt: record.createdAt });
+  }
+  return found.sort((a, b) => a.createdAt.localeCompare(b.createdAt)).map((p) => p.invocationId);
+}
+async function reconcileChannelPurchases(choice, deps = {}) {
+  const opened = await (deps.openChannels ?? openAgentChannels)();
+  const { rail, retired } = selectChannel(opened, choice);
+  const rails = [...opened.rails, ...opened.retired ?? []];
+  const lease = (await rail.payer.channelStatus()).pendingOperation;
+  const ids = [
+    .../* @__PURE__ */ new Set([...lease?.kind === "payment" ? [lease.id] : [], ...await openPurchases(rail)])
+  ];
+  const purchases = [];
+  let releasedLease = null;
+  for (const id of ids) {
+    try {
+      const view = await settle(rails, id);
+      if (view.releasedFrom.includes(rail.rail.id)) releasedLease = id;
+      purchases.push(view);
+    } catch (error) {
+      purchases.push({
+        invocationId: id,
+        outcome: "failed",
+        code: typeof code(error) === "string" ? code(error) : "request_failed",
+        message: error.message
+      });
+    }
+  }
+  const status = await rail.payer.channelStatus();
+  const channel = await channelView(rail, status, { retired });
+  const next = status.pendingOperation ? `It is still held by ${status.pendingOperation.kind} ${status.pendingOperation.id}; reconcile again later.` : status.closed ? "The channel is closed." : BigInt(status.funding.refundable) > 0n ? `Nothing holds it now. To refund its ${formatUsdc(status.funding.refundable)}: taskmarket agent close --channel ${status.channelId}` : "Nothing holds it now.";
+  return {
+    version: AGENT_VIEW_VERSION,
+    kind: "taskmarket.agent.reconcile-channel",
+    rail: rail.rail.id,
+    channelId: rail.payer.channelId,
+    retired,
+    purchases,
+    releasedLease,
+    channel,
+    message: ids.length === 0 ? `No purchase on this channel is undecided. ${next}` : `${ids.length} purchase(s) reconciled. ${next}`
+  };
+}
+async function reconcileLeasedPurchase(opened, invocationId) {
+  try {
+    await settle([...opened.rails, ...opened.retired ?? []], invocationId);
+  } catch {
+  }
+}
+export {
+  reconcileChannelPurchases,
+  reconcileInvocation,
+  reconcileLeasedPurchase
+};

package/dist/status-SDLSTJIA.js

@@ -0,0 +1,28 @@
+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 {
+  collectAgentStatus,
+  listSandboxes,
+  readSyncStatus,
+  readTaskStatus,
+  statusLines,
+  syncLines,
+  taskLines
+} from "./chunk-2QJMUHDT.js";
+import "./chunk-L6ZVRENW.js";
+import "./chunk-64HQ7ZF2.js";
+import "./chunk-W7CXEYST.js";
+import "./chunk-MO5KMUTL.js";
+import "./chunk-S4A6V3J3.js";
+import "./chunk-75LS6XS6.js";
+import "./chunk-EB6OJBF5.js";
+import "./chunk-YM4S6IE4.js";
+import "./chunk-S7SJMJ2I.js";
+export {
+  collectAgentStatus,
+  listSandboxes,
+  readSyncStatus,
+  readTaskStatus,
+  statusLines,
+  syncLines,
+  taskLines
+};

package/dist/sync-pull-TKM4EDGH.js

@@ -0,0 +1,409 @@
+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 {
+  SYNC_VIEW_VERSION,
+  SessionSync,
+  captureProblemMessage,
+  changeLine,
+  countsLine,
+  fullDiff,
+  leftOutNote,
+  savedState,
+  savedWorkspace,
+  summarize,
+  unsavedPaths
+} from "./chunk-ESPAXW2P.js";
+import {
+  BrokerConnector,
+  SshSandboxBackend,
+  applyChanges,
+  captureProblem,
+  claimProject,
+  diffWorkspace,
+  discardCapture,
+  forceUnclaim,
+  loadSyncState,
+  orphanOf,
+  releaseClaim,
+  unresolvedCount,
+  updateSyncState
+} from "./chunk-64HQ7ZF2.js";
+import {
+  apiUrl,
+  loadKeystore
+} from "./chunk-75LS6XS6.js";
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
+import "./chunk-S7SJMJ2I.js";
+
+// src/lib/agent/sync-pull.ts
+import { randomUUID } from "crypto";
+import { promises as fs } from "fs";
+var NONE = { clean: 0, conflict: 0, blocked: 0 };
+var RECOVER_TIMEOUT_MS = 3e5;
+async function brokerSandbox(sandboxId) {
+  const keystore = await loadKeystore();
+  const broker = new BrokerConnector({
+    apiUrl: apiUrl(),
+    deviceId: keystore.deviceId,
+    apiToken: keystore.apiToken,
+    purpose: "interactive",
+    idempotencyKey: randomUUID(),
+    sandboxId
+  });
+  const backend = new SshSandboxBackend({ connector: broker });
+  return { backend, stop: () => broker.stop(), close: () => backend.close() };
+}
+function leftOf(counts) {
+  return counts.clean + counts.conflict + counts.blocked + (counts.notSaved ?? 0) + (counts.tooDeep ?? 0);
+}
+async function confirmed(options, io, question, lines) {
+  if (options.yes === true) return true;
+  if (!io.interactive) return false;
+  const prompter = io.prompter();
+  try {
+    io.say(lines);
+    return await prompter.confirm(question);
+  } finally {
+    prompter.close();
+  }
+}
+async function runPull(options, io, cwd = process.cwd()) {
+  const project = await fs.realpath(cwd);
+  if (options.forceUnclaim) return unclaim(options, io, project);
+  const state = await claimProject(project, "pull");
+  try {
+    return await pullClaimed(options, io, project, state);
+  } finally {
+    await releaseClaim(project).catch(() => void 0);
+  }
+}
+async function unclaim(options, io, project) {
+  const view = {
+    version: SYNC_VIEW_VERSION,
+    kind: "taskmarket.agent.pull",
+    project,
+    capturedAt: null,
+    changes: [],
+    counts: NONE,
+    applied: [],
+    skipped: [],
+    keptLocal: [],
+    remaining: NONE,
+    discarded: false,
+    recovered: false,
+    unclaimed: false,
+    note: "Nothing holds this project."
+  };
+  const claim = (await loadSyncState(project)).claim;
+  if (!claim || claim.pid === process.pid) return view;
+  const question = `Release this project from process ${claim.pid} (${claim.purpose}, claimed ${claim.claimedAt})? Only do this if no taskmarket agent session or pull is running for it.`;
+  if (!await confirmed(options, io, question, [])) {
+    throw new AgentLaunchError(
+      "not_approved",
+      "Nothing was released; pass --yes to release without a prompt"
+    );
+  }
+  const dropped = await forceUnclaim(project);
+  return dropped ? {
+    ...view,
+    unclaimed: true,
+    note: `Released the project from process ${dropped.pid}. Run taskmarket agent status to see what the last session left.`
+  } : view;
+}
+async function pullClaimed(options, io, project, initial) {
+  let state = initial;
+  const view = {
+    version: SYNC_VIEW_VERSION,
+    kind: "taskmarket.agent.pull",
+    project,
+    capturedAt: null,
+    changes: [],
+    counts: NONE,
+    applied: [],
+    skipped: [],
+    keptLocal: [],
+    remaining: NONE,
+    discarded: false,
+    recovered: false,
+    unclaimed: false,
+    note: "No session left changes to pull in this project."
+  };
+  const problem = captureProblem(state);
+  if (problem) {
+    view.capturedAt = problem.at;
+    if (options.discard) {
+      const question = `Drop the record of the changes left in ${problem.sandboxId ? `sandbox ${problem.sandboxId}` : "the last sandbox"}? They were never saved here and cannot be pulled afterwards.`;
+      if (!await confirmed(options, io, question, [captureProblemMessage(problem)])) {
+        throw new AgentLaunchError(
+          "not_approved",
+          "Nothing was dropped; pass --yes to drop the record without a prompt"
+        );
+      }
+      await discardCapture(project);
+      return {
+        ...view,
+        discarded: true,
+        note: "The record was dropped. A sandbox the session left running stops on its own once idle."
+      };
+    }
+    if (!options.recover) {
+      throw new AgentLaunchError(
+        problem.kind === "interrupted" ? "sync_capture_interrupted" : "sync_capture_failed",
+        captureProblemMessage(problem)
+      );
+    }
+  }
+  const orphan = problem ? void 0 : orphanOf(state);
+  if (options.recover && (problem || orphan)) {
+    const target = problem ?? {
+      sandboxId: orphan.sandboxId,
+      base: orphan.base
+    };
+    if (!problem && state.capture?.state === "saved" && unresolvedCount(state.capture.pending) > 0) {
+      throw new AgentLaunchError(
+        "sync_pull_pending",
+        "Pull or drop the changes already saved here (taskmarket agent pull, or --discard) before recovering another sandbox."
+      );
+    }
+    if (!target.sandboxId || !target.base) {
+      throw new AgentLaunchError(
+        "sync_recover_unavailable",
+        "No sandbox was recorded for the last session, so there is nothing to recover from. Drop the record with taskmarket agent pull --discard."
+      );
+    }
+    let opened;
+    try {
+      opened = await (io.openSandbox ?? brokerSandbox)(target.sandboxId);
+      await opened.backend.connect();
+    } catch (error) {
+      throw new AgentLaunchError(
+        "sync_recover_unavailable",
+        `Sandbox ${target.sandboxId} cannot be reached (${error.message}); if it is gone, its changes are too. Drop the record with taskmarket agent pull --discard.`
+      );
+    }
+    let outcome;
+    try {
+      const recovery = new SessionSync({
+        projectRoot: project,
+        backend: opened.backend,
+        base: target.base,
+        uploaded: true,
+        includeSecrets: [],
+        sandboxId: target.sandboxId,
+        ...state.claim?.nonce ? { claimNonce: state.claim.nonce } : {}
+      });
+      outcome = await recovery.capture(AbortSignal.timeout(RECOVER_TIMEOUT_MS), {
+        endSession: false
+      });
+    } finally {
+      await opened.close().catch(() => void 0);
+    }
+    if (!outcome.saved) {
+      throw new AgentLaunchError(
+        "sync_capture_failed",
+        `The changes in sandbox ${target.sandboxId} could not be saved again (${outcome.reason}). The sandbox was left as it is; drop the record with taskmarket agent pull --discard if they cannot be recovered.`
+      );
+    }
+    await opened.stop().catch(
+      (error) => io.say([
+        `Sandbox ${target.sandboxId} could not be stopped (${error.message}); it stops on its own once idle.`
+      ])
+    );
+    view.recovered = true;
+    state = await loadSyncState(project);
+  } else if (options.recover) {
+    throw new AgentLaunchError(
+      "sync_recover_unavailable",
+      "There is nothing to recover: the last session saved its changes (or left none). Review them with taskmarket agent pull."
+    );
+  }
+  const capture = state.capture;
+  if (capture?.state !== "saved" && options.discard && orphan) {
+    await discardCapture(project);
+    return {
+      ...view,
+      discarded: true,
+      note: "The record of the killed --no-sync session was dropped; its sandbox stops on its own once idle."
+    };
+  }
+  if (capture?.state !== "saved") {
+    return view.recovered ? { ...view, note: "Recovered: the sandbox had no changes to bring back." } : view;
+  }
+  view.capturedAt = capture.capturedAt;
+  if (capture.leftOut?.length) view.leftOut = capture.leftOut;
+  const unsaved = unsavedPaths(capture.manifest);
+  let deep = (capture.leftOut ?? []).filter((dir) => dir.reason === "too_deep");
+  const withDeep = (counts2) => deep.length > 0 ? { ...counts2, tooDeep: deep.length } : counts2;
+  let base = capture.base;
+  const compare = () => diffWorkspace(savedWorkspace(project, capture.manifest), project, base);
+  let changeSet = await compare();
+  let { changes, counts } = summarize(changeSet, unsaved);
+  counts = withDeep(counts);
+  const keepLocal = options.keepLocal ?? [];
+  const overwrite = options.overwrite ?? [];
+  const deepKept = keepLocal.filter((rel) => deep.some((dir) => dir.path === rel));
+  for (const rel of keepLocal) {
+    if (deepKept.includes(rel)) continue;
+    if (!changes.some((change) => change.path === rel)) {
+      throw new AgentLaunchError(
+        "sync_invalid_path",
+        `--keep-local names a path that is not among the saved changes: ${rel}`
+      );
+    }
+    if (overwrite.includes(rel)) {
+      throw new AgentLaunchError(
+        "sync_invalid_path",
+        `--keep-local and --overwrite both name ${rel}; choose one`
+      );
+    }
+  }
+  if (keepLocal.length > 0 && !options.discard) {
+    const byPath = new Map(capture.manifest.map((entry) => [entry.path, entry]));
+    const entries = new Map(base.entries.map((entry) => [entry.path, entry]));
+    for (const rel of keepLocal) {
+      const kept = savedState(byPath.get(rel));
+      if (kept) entries.set(rel, kept);
+      else entries.delete(rel);
+    }
+    base = {
+      version: 1,
+      entries: [...entries.values()].sort(
+        (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+      )
+    };
+    changeSet = await compare();
+    deep = deep.filter((dir) => !deepKept.includes(dir.path));
+    ({ changes, counts } = summarize(changeSet, unsaved));
+    counts = withDeep(counts);
+    const resolved = base;
+    const leftOut = (capture.leftOut ?? []).filter((dir) => !deepKept.includes(dir.path));
+    view.leftOut = leftOut.length > 0 ? leftOut : void 0;
+    await updateSyncState(project, (next) => {
+      if (next.capture?.state === "saved") {
+        next.capture.base = resolved;
+        next.capture.pending = counts;
+        next.capture.leftOut = leftOut;
+      }
+    });
+    view.keptLocal = [...keepLocal];
+    if (leftOf(counts) === 0) {
+      await discardCapture(project);
+      return {
+        ...view,
+        changes,
+        counts,
+        note: `Kept your version of ${keepLocal.join(", ")}; nothing is left to pull.`
+      };
+    }
+  }
+  Object.assign(view, { changes, counts, remaining: counts });
+  if (JSON.stringify(counts) !== JSON.stringify(capture.pending)) {
+    const current = counts;
+    await updateSyncState(project, (next) => {
+      if (next.capture?.state === "saved") next.capture.pending = current;
+    });
+  }
+  if (options.discard) {
+    const approved2 = await confirmed(
+      options,
+      io,
+      `Drop these ${changes.length} saved change(s)? They cannot be pulled afterwards.`,
+      pullReviewLines(view)
+    );
+    if (!approved2) {
+      throw new AgentLaunchError(
+        "not_approved",
+        "Nothing was dropped; pass --yes to drop without a prompt"
+      );
+    }
+    await discardCapture(project);
+    return { ...view, remaining: NONE, discarded: true, note: "The saved changes were dropped." };
+  }
+  if (changes.length === 0 && deep.length === 0) {
+    await discardCapture(project);
+    return { ...view, note: "This project already matches what the session left." };
+  }
+  if (changes.length === 0) {
+    io.say(pullReviewLines(view));
+    return {
+      ...view,
+      note: `Nothing here can be applied: ${deep.length} director(ies) nested too deep were not saved. Acknowledge each with --keep-local <dir>, or drop everything with --discard.`
+    };
+  }
+  const conflicts = new Set(changes.filter((c) => c.status === "conflict").map((c) => c.path));
+  for (const rel of overwrite) {
+    if (!conflicts.has(rel)) {
+      throw new AgentLaunchError(
+        "sync_invalid_path",
+        `--overwrite names a path that is not in conflict: ${rel}`
+      );
+    }
+  }
+  io.say(pullReviewLines(view));
+  if (options.diff) {
+    view.diff = fullDiff(changeSet, Number.MAX_SAFE_INTEGER);
+    io.say([view.diff]);
+  }
+  const applicable = counts.clean + overwrite.length;
+  let approved = options.apply === true;
+  if (!approved && applicable > 0 && io.interactive) {
+    const prompter = io.prompter();
+    try {
+      if (!view.diff) {
+        const answer = await prompter.ask("Show the full diff first? (yes/no)", "no");
+        if (answer.trim().toLowerCase() === "yes")
+          io.say([fullDiff(changeSet, Number.MAX_SAFE_INTEGER)]);
+      }
+      approved = await prompter.confirm(
+        `Apply ${applicable} change(s) to ${project}${overwrite.length ? `, overwriting ${overwrite.join(", ")}` : ""}?`
+      );
+    } finally {
+      prompter.close();
+    }
+  }
+  if (!approved || applicable === 0) {
+    return {
+      ...view,
+      note: applicable === 0 ? unresolvedCount(counts) > 0 ? "Nothing here can be applied as it is. For each conflict, take the sandbox version with --overwrite <path> or keep yours with --keep-local <path>; a change that was not saved can only be dropped (--keep-local <path>, or --discard for all)." : "Nothing here can be applied; what is left is listed only. Drop it with --discard." : "Nothing was applied. Pass --apply to apply the clean changes."
+    };
+  }
+  const result = await applyChanges(changeSet, base, { overwrite });
+  base = result.base;
+  const remaining = withDeep(summarize(await compare(), unsaved).counts);
+  const left = leftOf(remaining);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (left === 0) {
+    await discardCapture(project);
+  }
+  await updateSyncState(project, (next) => {
+    if (next.capture?.state === "saved") {
+      next.capture.base = result.base;
+      next.capture.pending = remaining;
+    }
+    if (next.session) {
+      next.session.lastPullAt = now;
+      next.session.pending = { ...remaining, checkedAt: now };
+    }
+  });
+  return {
+    ...view,
+    applied: result.applied,
+    skipped: result.skipped,
+    remaining,
+    note: left === 0 ? `Applied ${result.applied.length} change(s); nothing is left to pull.` : `Applied ${result.applied.length} change(s); ${left} remain saved for a later pull.`
+  };
+}
+function pullReviewLines(view) {
+  const leftOut = view.leftOut?.length ? [leftOutNote(view.leftOut)] : [];
+  if (view.capturedAt === null || view.changes.length === 0) return leftOut;
+  return [
+    `Changes the session left in its sandbox (saved ${view.capturedAt}) for ${view.project}: ${countsLine(view.counts)}.`,
+    ...view.changes.map(changeLine),
+    ...leftOut
+  ];
+}
+export {
+  pullReviewLines,
+  runPull
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucid-agents/taskmarket",
-  "version": "1.17.1",
+  "version": "1.18.0",
   "type": "module",
   "bin": {
     "taskmarket": "./dist/index.js"