@heyanon-arp/cli 0.0.7 → 0.0.9

package/dist/cli.js

@@ -289,8 +289,7 @@ var init_api = __esm({
       }
       /**
        * Public `GET /v1/agents` — discovery / marketplace catalog.
-       * Unauthenticated. Server pins `publicationStatus = active` so
-       * drafts / paused agents never appear here.
+       * Unauthenticated. Returns registered agents.
        *
        * Filters AND-compose: pass multiple tags to require all of them,
        * combine with `q` for free-text. `after` is the `id` of the
@@ -321,18 +320,6 @@ var init_api = __esm({
       async updateAgent(did, body, signer) {
         return this.signedRequest("PATCH", `/v1/agents/${encodeURIComponent(did)}`, body, signer);
       }
-      async publishAgent(did, signer) {
-        return this.signedRequest("POST", `/v1/agents/${encodeURIComponent(did)}/publish`, {}, signer);
-      }
-      async pauseAgent(did, signer) {
-        return this.signedRequest("POST", `/v1/agents/${encodeURIComponent(did)}/pause`, {}, signer);
-      }
-      async unpauseAgent(did, signer) {
-        return this.signedRequest("POST", `/v1/agents/${encodeURIComponent(did)}/unpause`, {}, signer);
-      }
-      async rotateIdentityKey(did, body, signer) {
-        return this.signedRequest("POST", `/v1/agents/${encodeURIComponent(did)}/rotate-identity-key`, body, signer);
-      }
       /**
        * Ingest a signed envelope. Endpoint is public (no
        * `X-ARP-Signer-DID` headers) — authentication is the envelope's
@@ -933,18 +920,6 @@ var init_state = __esm({
 
 // src/commands/lifecycle.ts
 function registerLifecycleCommands(root) {
-  root.command("publish").description("Publish a draft agent (draft \u2192 active), making it discoverable in the catalog.").argument("<did>", "Agent DID (did:arp:...) \u2014 must have local state").option("--server <url>", "Override ARP server base URL").action(async (did, opts) => {
-    const agent = await actSigned(did, opts.server, (api, signer) => api.publishAgent(did, signer));
-    printAgent("Published", agent);
-  });
-  root.command("pause").description("Pause an active agent (active \u2192 paused).").argument("<did>").option("--server <url>", "Override ARP server base URL").action(async (did, opts) => {
-    const agent = await actSigned(did, opts.server, (api, signer) => api.pauseAgent(did, signer));
-    printAgent("Paused", agent);
-  });
-  root.command("unpause").description("Unpause a paused agent (paused \u2192 active).").argument("<did>").option("--server <url>", "Override ARP server base URL").action(async (did, opts) => {
-    const agent = await actSigned(did, opts.server, (api, signer) => api.unpauseAgent(did, signer));
-    printAgent("Unpaused", agent);
-  });
   root.command("update").description("Update an agent profile (name / description / tags). At least one flag is required.").argument("<did>").option("--server <url>", "Override ARP server base URL").option("--name <s>", "New display name").option("--description <s>", "New description").option("--tag <s>", "Capability tag \u2014 REPLACES the existing list. Repeatable: --tag translation --tag fr", accumulate2, []).option("--clear-tags", "Drop all tags (cannot be combined with --tag)", false).action(
     async (did, opts) => {
       const body = buildUpdateBody(opts);
@@ -996,7 +971,6 @@ function printAgent(verb, agent) {
   console.log(import_chalk4.default.green(`
 ${verb}.`));
   console.log(`${import_chalk4.default.bold("DID")}: ${import_chalk4.default.cyan(agent.did)}`);
-  console.log(`${import_chalk4.default.bold("Status")}: ${import_chalk4.default.cyan(agent.publicationStatus)}`);
   console.log(import_chalk4.default.bold("\nAgent profile:"));
   console.log(formatJson(agent));
 }
@@ -1238,9 +1212,11 @@ function isPhaseTerminallyUnreachable(phase, s) {
 function untilPhaseMatched(phase, s) {
   switch (phase) {
     case "delegation.proposed":
-      return s.latestDelegation?.state === "proposed" || s.latestDelegation?.state === "offered" || s.latestDelegation?.state === "pending_lock_finalization";
+      return s.latestDelegation?.state === "proposed" || s.latestDelegation?.state === "offered";
     case "delegation.accepted":
       return s.latestDelegation?.state === "accepted";
+    case "delegation.locked":
+      return s.latestDelegation?.state === "locked";
     case "delegation.canceled":
       return s.latestDelegation?.state === "canceled";
     case "delegation.declined":
@@ -1279,7 +1255,7 @@ function parseWaitInterval(raw) {
   return n;
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function composeStatus(api, signerDid, relationshipId, signer) {
   const [relationshipsOrNull, delegationsOrError] = await Promise.all([
@@ -1315,7 +1291,7 @@ async function composeStatus(api, signerDid, relationshipId, signer) {
   const relationship = relationships.find((r) => r.relationshipId === relationshipId);
   const counterpartyDid = relationship ? relationship.pairDidA === signerDid ? relationship.pairDidB : relationship.pairDidA : inferCounterpartyFromEntities(signerDid, allDelegations);
   const delegations = allDelegations;
-  const latestDelegation = pickLatestLive(delegations, ["proposed", "offered", "pending_lock_finalization", "accepted", "awaiting_release_finalization"]);
+  const latestDelegation = pickLatestLive(delegations, ["proposed", "offered", "accepted", "pending_lock_finalization", "locked", "awaiting_release_finalization"]);
   const [workLogs, receipts] = await Promise.all([
     latestDelegation ? fetchAllPages(
       (after) => api.listWorkLogs(relationshipId, signer, { limit: 100, delegationId: latestDelegation.delegationId, ...after ? { after } : {} })
@@ -1437,7 +1413,7 @@ function nextAction(input) {
   }
   if (!latestDelegation || latestDelegation.state === "declined" || latestDelegation.state === "canceled") {
     return {
-      hint: "No live delegation \u2014 buyer funds escrow `heyarp wallet create-lock \u2026` then offers `heyarp delegation offer <peer> --delegation-id <new-uuid> --title \u2026 --scope \u2026 --pricing-model flat --settlement-model escrow --amount \u2026 --currency USDC:solana-devnet --deadline \u2026 --escrow-lock-from-file <path>`",
+      hint: "No live delegation \u2014 buyer offers (terms only, no lock) `heyarp delegation offer <peer> --delegation-id <new-uuid> --title \u2026 --scope \u2026 --pricing-model flat --amount \u2026 --currency USDC:solana-devnet --deadline \u2026`, then funds the escrow lock AFTER the worker accepts via `heyarp delegation fund <del-id> --escrow-lock-from-file <path>`",
       owner: "either",
       complete: false
     };
@@ -1451,7 +1427,7 @@ function nextAction(input) {
       complete: false
     };
   }
-  if (latestDelegation.state === "proposed" || latestDelegation.state === "offered" || latestDelegation.state === "pending_lock_finalization") {
+  if (latestDelegation.state === "proposed" || latestDelegation.state === "offered") {
     const iAmOfferer = latestDelegation.offererDid === signerDid;
     const stateLabel = latestDelegation.state === "proposed" ? "PROPOSED" : `${latestDelegation.state.toUpperCase()} (\u2261 proposed)`;
     return {
@@ -1460,10 +1436,25 @@ function nextAction(input) {
       complete: false
     };
   }
+  if (latestDelegation.state === "accepted" && !latestWorkLog) {
+    const iAmOfferer = latestDelegation.offererDid === signerDid;
+    return {
+      hint: iAmOfferer ? `Delegation ${latestDelegation.delegationId} is ACCEPTED \u2014 you (buyer) owe \`heyarp wallet create-lock --delegation-id ${latestDelegation.delegationId} --condition-hash <hex> ... > lock.json\` then \`heyarp delegation fund ${latestDelegation.delegationId} --escrow-lock-from-file lock.json\` (fund the escrow lock; work begins once it is LOCKED on chain)` : `Delegation ${latestDelegation.delegationId} is ACCEPTED \u2014 counterparty (the buyer) owes \`heyarp delegation fund\` to lock the escrow; wait for the delegation to reach LOCKED before working`,
+      owner: iAmOfferer ? "me" : "counterparty",
+      complete: false
+    };
+  }
+  if (latestDelegation.state === "pending_lock_finalization" && !latestWorkLog) {
+    return {
+      hint: `Delegation ${latestDelegation.delegationId} is PENDING_LOCK_FINALIZATION \u2014 the escrow lock was funded and is awaiting on-chain confirmation; both sides wait (auto-advances to LOCKED). Poll with \`heyarp status ${relationship.relationshipId} --wait --until delegation.locked\`.`,
+      owner: "none",
+      complete: false
+    };
+  }
   if (!latestWorkLog) {
     const iAmOfferer = latestDelegation.offererDid === signerDid;
     return {
-      hint: iAmOfferer ? `Delegation ${latestDelegation.delegationId} is ACCEPTED \u2014 you owe \`heyarp work request <peer> ${latestDelegation.delegationId} --request-id <new-uuid> --params '{\u2026}'\`` : `Delegation ${latestDelegation.delegationId} is ACCEPTED \u2014 counterparty (the caller) owes \`heyarp work request\``,
+      hint: iAmOfferer ? `Delegation ${latestDelegation.delegationId} is LOCKED \u2014 you owe \`heyarp work request <peer> ${latestDelegation.delegationId} --request-id <new-uuid> --params '{\u2026}'\`` : `Delegation ${latestDelegation.delegationId} is LOCKED \u2014 counterparty (the caller) owes \`heyarp work request\``,
       owner: iAmOfferer ? "me" : "counterparty",
       complete: false
     };
@@ -1576,7 +1567,7 @@ function cycleHeadline(s) {
   }
 }
 function stateColor(state) {
-  const c = state === "active" || state === "accepted" || state === "cosigned" || state === "responded" || state === "completed" ? import_chalk5.default.green : state === "pending" || state === "proposed" || state === "requested" || state === "offered" || state === "pending_lock_finalization" || state === "awaiting_release_finalization" ? import_chalk5.default.yellow : state === "closed" || state === "declined" || state === "canceled" || state === "replaced" || state === "not_found" || // Terminal failure states deserve the same red
+  const c = state === "active" || state === "accepted" || state === "locked" || state === "cosigned" || state === "responded" || state === "completed" ? import_chalk5.default.green : state === "pending" || state === "proposed" || state === "requested" || state === "offered" || state === "pending_lock_finalization" || state === "awaiting_release_finalization" ? import_chalk5.default.yellow : state === "closed" || state === "declined" || state === "canceled" || state === "replaced" || state === "not_found" || // Terminal failure states deserve the same red
   // treatment as declined/canceled so an operator
   // scanning `heyarp status` immediately sees
   // "this is dead, don't follow the hint blindly".
@@ -1594,6 +1585,7 @@ var init_status = __esm({
     UNTIL_PHASES = [
       "delegation.proposed",
       "delegation.accepted",
+      "delegation.locked",
       "delegation.canceled",
       "delegation.declined",
       "work.requested",
@@ -1839,7 +1831,7 @@ async function verifyReleaseHandler(opts) {
   if (shouldRetrySigCheck) {
     const retryDelaysMs = [3e3, 3e3];
     for (const delay of retryDelaysMs) {
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      await new Promise((resolve) => setTimeout(resolve, delay));
       const retriedSigs = await conn.getSignaturesForAddress(lockPda, { limit: 5 });
       if (retriedSigs.length > 0) {
         lockSeenInSignatures = true;
@@ -1953,7 +1945,7 @@ function mapReleaseMethodToStatus(method) {
 }
 function registerCreateLock(cmd) {
   cmd.command("create-lock").description(
-    "Build + sign a create_lock Solana tx (native SOL or an SPL token); output JSON ready for attachments.escrow_lock. This command does NOT submit the tx to chain \u2014 it only signs the blob locally. The actual on-chain submission happens inside `heyarp delegation offer --escrow-lock-from-file <path>` (the server's escrow worker picks up the signed blob from the offer envelope's attachments and posts it). Watch for the `lock_id` appearing on-chain only AFTER `delegation offer` runs, not after this command."
+    "Build + sign a create_lock Solana tx (native SOL or an SPL token); output JSON ready for attachments.escrow_lock. This command does NOT submit the tx to chain \u2014 it only signs the blob locally. M6 lock-at-accept: run this AFTER the worker accepts your offer; the actual on-chain submission happens inside `heyarp delegation fund <delegation-id> --escrow-lock-from-file <path>` (the server's escrow worker picks up the signed blob from the fund envelope's attachments and posts it). Watch for the `lock_id` appearing on-chain only AFTER `delegation fund` runs, not after this command."
   ).option("--server <url>", "Override server URL for sender-key resolution").option("--from-did <did>", "Sender DID (= payer of the lock). Required when more than one agent on the host.").requiredOption("--delegation-id <id>", "Delegation UUID (drives the lock_id derivation)").requiredOption("--recipient-pubkey <base58>", "Payee Solana pubkey (recipient agent's settlement_pubkey)").option("--amount-lamports <int>", "NATIVE SOL: lock amount in lamports (1 SOL = 1_000_000_000). Required when --mint-pubkey is omitted; not allowed with it.").option("--mint-pubkey <base58>", "SPL token mint to lock. Omit for native SOL. Must be a legacy SPL Token mint (Token-2022 is not supported).").option("--amount-base-units <int>", "SPL: lock amount in the mint's base units (e.g. 1000000 = 1 USDC at 6 decimals). Canonical SPL amount input.").option(
     "--amount <decimal>",
     "SPL: lock amount as a human decimal (e.g. 1.5); converted using the mint's on-chain decimals. Convenience alternative to --amount-base-units."
@@ -2199,7 +2191,7 @@ async function createLockHandler(opts) {
     asset_id: asset.assetId,
     expiry: Number(expiry),
     // Persist the BARE UUID form. The consumer is
-    // `delegation offer --escrow-lock-from-file`, which validates
+    // `delegation fund --escrow-lock-from-file`, which validates
     // this field with a bare-UUID regex (the wire form for
     // `body.content.delegation_id`). The `del_<uuid>` prefix is an
     // SDK-internal byte-encoding marker — not the wire-form. Keeping
@@ -2385,6 +2377,7 @@ var init_wallet = __esm({
 function registerDelegationCommands(root) {
   const cmd = root.command("delegation").description("Delegation FSM actions: offer / accept / decline / cancel");
   registerOffer(cmd);
+  registerFund(cmd);
   registerAccept(cmd);
   registerDecline(cmd);
   registerCancel(cmd);
@@ -2393,19 +2386,7 @@ function isPostCommitErrorCode(code) {
   return POST_COMMIT_ERROR_CODES.has(code) || code.startsWith("ESC_LOCK_") || code.startsWith("SDK_");
 }
 function registerOffer(parent) {
-  parent.command("offer").description("Open a new delegation addressed to <recipient-did> with the agreed terms INLINE.").argument("<recipient-did>", "Recipient agent DID (did:arp:...)").option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server").option("--delegation-id <uuid>", "Override the auto-generated delegation id (UUID). Useful for replay / scripting.").option("--title <s>", "Required: human-readable title for the offer").option("--brief <json>", "Optional structured brief (JSON object)").option("--criterion <s>", "acceptance_criteria \u2014 repeatable; pass --criterion once per bullet", collectRepeated, []).option("--deadline <rfc3339>", 'Optional RFC 3339 deadline (e.g. "2026-12-31T23:59:59Z")').option("--scope <text>", "scope_summary \u2014 short prose describing the agreed work. Required for escrow offers.").option("--pricing-model <flat|usage_based>", "pricing_model (flat|usage_based). Required for escrow offers.").option("--settlement-model <prepaid|escrow>", "settlement_model (prepaid|escrow). Required for escrow offers.").option("--rate-amount <decimal>", 'rate_amount \u2014 decimal as string (e.g. "10.00"). Optional per-unit rate bound into the condition_hash.').option("--rate-unit <task|thread|handoff>", "rate_unit (task|thread|handoff). Optional.").option("--amount <s>", 'Optional decimal-as-string amount (e.g. "10.00"). REQUIRES --currency if set.').option("--currency <s>", `Asset identifier: shorthand (${import_sdk4.WELL_KNOWN_ASSET_KEYS.join("|")}) OR raw CAIP-19 string.`).option("--currency-decimals <n>", "Decimal places for base-unit conversion (0-18). Required only when --currency is raw CAIP-19.").option("--currency-symbol <s>", 'Optional UI hint ("USDC", "SOL"). Max 16 chars.').option("--ttl <seconds>", "Envelope TTL in seconds (max 86400 = 24h)", "3600").option("--verbose", "Print the full envelope before sending and the full server response", false).option(
-    "--escrow-lock-from-file <path>",
-    "Path to JSON output of `heyarp wallet create-lock` (recommended). Contains all 5 escrow_lock fields: signed_tx_blob, lock_id, amount, asset_id, expiry. Mutually exclusive with the inline --escrow-lock-* flags below."
-  ).option(
-    "--escrow-lock-blob <base64>",
-    "INLINE alternative: the signed Solana tx blob (base64). Requires --escrow-lock-id, --escrow-lock-amount, --escrow-lock-asset-id, --escrow-lock-expiry together."
-  ).option("--escrow-lock-id <hex32>", "INLINE lock_id (32-byte hex). Used with --escrow-lock-blob.").option("--escrow-lock-amount <int>", "INLINE lock amount in base units (e.g. lamports for native SOL). Used with --escrow-lock-blob.").option("--escrow-lock-asset-id <caip19>", "INLINE currency CAIP-19 asset_id (e.g. solana:<cluster_id>/slip44:501). Used with --escrow-lock-blob.").option("--escrow-lock-expiry <unix>", "INLINE expiry as unix seconds. Used with --escrow-lock-blob.").option(
-    "--program-id <pubkey>",
-    "Expected ARP escrow program id for pre-flight against the lock file's embedded `program_id`. Precedence: this flag > ARP_ESCROW_PROGRAM_ID env > server protocol-fee endpoint. Mismatch throws BEFORE the envelope ships, so a wrong-program lock never silently fails on chain after the offer was already delivered. Pre-flight is skipped only for old lock files lacking `program_id`, or when no expected value can be resolved."
-  ).option(
-    "--no-escrow",
-    "Opt-out for test_mode servers. Default REQUIRES the escrow_lock attachment; without --no-escrow, missing flags throw BEFORE the envelope is sent (avoids ESC_LOCK_MISSING POST_COMMIT consuming sender_sequence)."
-  ).option(
+  parent.command("offer").description("Open a new delegation addressed to <recipient-did> with the agreed terms INLINE (no escrow lock \u2014 fund AFTER acceptance via `delegation fund`).").argument("<recipient-did>", "Recipient agent DID (did:arp:...)").option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server").option("--delegation-id <uuid>", "Override the auto-generated delegation id (UUID). Reuse the SAME id at `heyarp delegation fund` time. Useful for replay / scripting.").option("--title <s>", "Required: human-readable title for the offer").option("--brief <json>", "Optional structured brief (JSON object)").option("--criterion <s>", "acceptance_criteria \u2014 repeatable; pass --criterion once per bullet", collectRepeated, []).option("--deadline <rfc3339>", 'Optional RFC 3339 deadline (e.g. "2026-12-31T23:59:59Z")').option("--scope <text>", "scope_summary \u2014 short prose describing the agreed work. Required.").option("--pricing-model <flat|usage_based>", "pricing_model (flat|usage_based). Required.").option("--amount <s>", 'Optional decimal-as-string amount (e.g. "10.00"). REQUIRES --currency if set.').option("--currency <s>", `Asset identifier: shorthand (${import_sdk4.WELL_KNOWN_ASSET_KEYS.join("|")}) OR raw CAIP-19 string.`).option("--currency-decimals <n>", "Decimal places for base-unit conversion (0-18). Required only when --currency is raw CAIP-19.").option("--currency-symbol <s>", 'Optional UI hint ("USDC", "SOL"). Max 16 chars.').option("--ttl <seconds>", "Envelope TTL in seconds (max 86400 = 24h)", "3600").option("--verbose", "Print the full envelope before sending and the full server response", false).option(
     "--wait-until <phase>",
     'Block after delivery until the named FSM phase is reached (e.g. delegation.accepted). One of the UNTIL_PHASES from `heyarp status --help`. Exit code 124 on --wait-timeout. Recovers the "sub-agent exits before counterparty accepts" antipattern.'
   ).option("--wait-timeout <seconds>", "When --wait-until is set: max wall-clock wait (default 300). Exit code 124 on timeout.").option("--wait-interval <seconds>", "When --wait-until is set: poll cadence (default 3, bound [1, 60]).").option(
@@ -2435,39 +2416,35 @@ function assembleEscrowLockAttachment(opts) {
   const someInlineSet = inlineFlags.some((f) => f !== void 0 && f !== "");
   const allInlineSet = inlineFlags.every((f) => f !== void 0 && f !== "");
   if (fromFile && someInlineSet) {
-    throw new Error("delegation offer: --escrow-lock-from-file and --escrow-lock-blob/--escrow-lock-* are mutually exclusive. Pick one path.");
+    throw new Error("delegation fund: --escrow-lock-from-file and --escrow-lock-blob/--escrow-lock-* are mutually exclusive. Pick one path.");
   }
   if (!fromFile && !someInlineSet) {
-    if (opts.escrow === false) return void 0;
     throw new Error(
-      "delegation offer: escrow_lock is required. Pass --escrow-lock-from-file <path> (JSON output of `heyarp wallet create-lock`), OR all of --escrow-lock-blob/--escrow-lock-id/--escrow-lock-amount/--escrow-lock-asset-id/--escrow-lock-expiry, OR --no-escrow if the server is in test_mode."
+      "delegation fund: escrow_lock is required. Pass --escrow-lock-from-file <path> (JSON output of `heyarp wallet create-lock`), OR all of --escrow-lock-blob/--escrow-lock-id/--escrow-lock-amount/--escrow-lock-asset-id/--escrow-lock-expiry."
     );
   }
-  if (opts.escrow === false) {
-    throw new Error("delegation offer: --no-escrow is mutually exclusive with explicit escrow_lock flags. Pick one path.");
-  }
   if (fromFile) {
     let raw;
     try {
       raw = (0, import_node_fs4.readFileSync)(fromFile, "utf8");
     } catch (err) {
-      throw new Error(`delegation offer: failed to read --escrow-lock-from-file '${fromFile}': ${err.message}`);
+      throw new Error(`delegation fund: failed to read --escrow-lock-from-file '${fromFile}': ${err.message}`);
     }
     let parsed;
     try {
       parsed = JSON.parse(raw);
     } catch (err) {
-      throw new Error(`delegation offer: --escrow-lock-from-file '${fromFile}' is not valid JSON: ${err.message}`);
+      throw new Error(`delegation fund: --escrow-lock-from-file '${fromFile}' is not valid JSON: ${err.message}`);
     }
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error(`delegation offer: --escrow-lock-from-file '${fromFile}' must be a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}.`);
+      throw new Error(`delegation fund: --escrow-lock-from-file '${fromFile}' must be a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}.`);
     }
     const p = parsed;
     const required = ["signed_tx_blob", "lock_id", "amount", "asset_id", "expiry"];
     const missing = required.filter((k) => p[k] === void 0);
     if (missing.length > 0) {
       throw new Error(
-        `delegation offer: --escrow-lock-from-file '${fromFile}' is missing required fields: ${missing.join(", ")}. Expected JSON output of \`heyarp wallet create-lock\`.`
+        `delegation fund: --escrow-lock-from-file '${fromFile}' is missing required fields: ${missing.join(", ")}. Expected JSON output of \`heyarp wallet create-lock\`.`
       );
     }
     const expiryRaw = p.expiry;
@@ -2478,19 +2455,19 @@ function assembleEscrowLockAttachment(opts) {
       expiryNum2 = Number(expiryRaw);
       if (String(expiryNum2) !== expiryRaw.trim()) {
         throw new Error(
-          `delegation offer: --escrow-lock-from-file '${fromFile}' has invalid 'expiry' (must be positive integer unix seconds): ${JSON.stringify(expiryRaw)}.`
+          `delegation fund: --escrow-lock-from-file '${fromFile}' has invalid 'expiry' (must be positive integer unix seconds): ${JSON.stringify(expiryRaw)}.`
         );
       }
     } else {
-      throw new Error(`delegation offer: --escrow-lock-from-file '${fromFile}' has invalid 'expiry' (must be positive integer unix seconds): ${JSON.stringify(expiryRaw)}.`);
+      throw new Error(`delegation fund: --escrow-lock-from-file '${fromFile}' has invalid 'expiry' (must be positive integer unix seconds): ${JSON.stringify(expiryRaw)}.`);
     }
     if (!Number.isFinite(expiryNum2) || !Number.isInteger(expiryNum2) || expiryNum2 <= 0) {
-      throw new Error(`delegation offer: --escrow-lock-from-file '${fromFile}' has invalid 'expiry' (must be positive integer unix seconds): ${JSON.stringify(expiryRaw)}.`);
+      throw new Error(`delegation fund: --escrow-lock-from-file '${fromFile}' has invalid 'expiry' (must be positive integer unix seconds): ${JSON.stringify(expiryRaw)}.`);
     }
     let delegationIdFromLock;
     if (p.delegation_id !== void 0) {
       if (typeof p.delegation_id !== "string" || !UUID_RE.test(p.delegation_id)) {
-        throw new Error(`delegation offer: --escrow-lock-from-file '${fromFile}' has invalid 'delegation_id' (must be a UUID): ${JSON.stringify(p.delegation_id)}.`);
+        throw new Error(`delegation fund: --escrow-lock-from-file '${fromFile}' has invalid 'delegation_id' (must be a UUID): ${JSON.stringify(p.delegation_id)}.`);
       }
       delegationIdFromLock = p.delegation_id.toLowerCase();
     }
@@ -2498,7 +2475,7 @@ function assembleEscrowLockAttachment(opts) {
     if (p.program_id !== void 0) {
       if (typeof p.program_id !== "string" || p.program_id.length < 32 || p.program_id.length > 44) {
         throw new Error(
-          `delegation offer: --escrow-lock-from-file '${fromFile}' has invalid 'program_id' (must be a base58 Solana pubkey, 32-44 chars): ${JSON.stringify(p.program_id)}.`
+          `delegation fund: --escrow-lock-from-file '${fromFile}' has invalid 'program_id' (must be a base58 Solana pubkey, 32-44 chars): ${JSON.stringify(p.program_id)}.`
         );
       }
       lockProgramId = p.program_id;
@@ -2517,13 +2494,13 @@ function assembleEscrowLockAttachment(opts) {
   }
   if (!allInlineSet) {
     throw new Error(
-      "delegation offer: when using inline escrow flags, --escrow-lock-blob requires all of --escrow-lock-id, --escrow-lock-amount, --escrow-lock-asset-id, --escrow-lock-expiry to be set together."
+      "delegation fund: when using inline escrow flags, --escrow-lock-blob requires all of --escrow-lock-id, --escrow-lock-amount, --escrow-lock-asset-id, --escrow-lock-expiry to be set together."
     );
   }
   const expiryStr = opts.escrowLockExpiry ?? "";
   const expiryNum = Number.parseInt(expiryStr, 10);
   if (!Number.isFinite(expiryNum) || !Number.isInteger(expiryNum) || expiryNum <= 0 || String(expiryNum) !== expiryStr) {
-    throw new Error(`delegation offer: --escrow-lock-expiry must be a positive integer (unix seconds), got '${expiryStr}'.`);
+    throw new Error(`delegation fund: --escrow-lock-expiry must be a positive integer (unix seconds), got '${expiryStr}'.`);
   }
   return {
     attachment: {
@@ -2545,47 +2522,22 @@ async function runOffer(recipientDid, opts) {
     throw new Error("delegation offer: --title is required (server-side validator rejects empty offers)");
   }
   const terms = parseOfferTerms("delegation offer", opts);
-  const escrowResult = assembleEscrowLockAttachment(opts);
-  const delegationId = resolveOfferDelegationId(opts.delegationId, escrowResult);
-  if (escrowResult !== void 0) {
-    if (terms.amount === void 0 || terms.currency === void 0) {
-      throw new Error(
-        "delegation offer: escrow-backed offers require both --amount and --currency (server cross-checks body.content.amount/currency against attachments.escrow_lock.amount/asset_id)."
-      );
-    }
-    const missingTerms = [
-      terms.scope_summary === void 0 ? "--scope" : null,
-      terms.pricing_model === void 0 ? "--pricing-model" : null,
-      terms.settlement_model === void 0 ? "--settlement-model" : null
-    ].filter((x) => x !== null);
-    if (missingTerms.length > 0) {
-      throw new Error(
-        `delegation offer: escrow-backed offers require the inline terms ${missingTerms.join(", ")} (the on-chain condition_hash binds scope_summary/pricing_model/settlement_model/rate_amount/rate_unit/currency; a missing or divergent term is rejected by the server with ESC_LOCK_CONDITION_HASH_MISMATCH). Pass the SAME values you fed to \`heyarp escrow derive-condition-hash\`.`
-      );
-    }
+  const delegationId = resolveOfferDelegationId(opts.delegationId, void 0);
+  if (terms.amount === void 0 || terms.currency === void 0) {
+    throw new Error(
+      "delegation offer: escrow-backed offers require both --amount and --currency (these are the agreed terms; the buyer funds the matching escrow_lock later via `heyarp delegation fund`)."
+    );
+  }
+  const missingTerms = [terms.scope_summary === void 0 ? "--scope" : null, terms.pricing_model === void 0 ? "--pricing-model" : null].filter(
+    (x) => x !== null
+  );
+  if (missingTerms.length > 0) {
+    throw new Error(
+      `delegation offer: escrow-backed offers require the inline terms ${missingTerms.join(", ")} (the on-chain condition_hash binds scope_summary/pricing_model/currency at fund time; a missing or divergent term is rejected with ESC_LOCK_CONDITION_HASH_MISMATCH when you run \`heyarp delegation fund\`). Pass the SAME values you will feed to \`heyarp escrow derive-condition-hash\`.`
+    );
   }
   const api = new ArpApiClient(opts.server);
   const sender = resolveSenderAgent("delegation offer", opts.server, opts.fromDid);
-  if (escrowResult?.lockProgramId !== void 0) {
-    const expected = await resolveProgramIdWithSource(api, { programId: opts.programId });
-    const result2 = preflightLockProgramId({
-      lockProgramId: escrowResult.lockProgramId,
-      expectedProgramId: expected.programId,
-      expectedSource: expected.source
-    });
-    if (result2.kind === "mismatch") {
-      throw new Error(
-        `delegation offer: lock file program_id ${result2.lockProgramId} does not match the expected escrow program ${result2.expectedProgramId} (resolved from --program-id flag > ARP_ESCROW_PROGRAM_ID env > server protocol-fee). The lock tx would be rejected on chain (ESC_LOCK_TX_PROGRAM_ID_MISMATCH) and the delegation would silently fail ~26s after offer. Regenerate the lock with the correct program id via \`heyarp wallet create-lock --program-id ${result2.expectedProgramId} ...\`.`
-      );
-    }
-    if (result2.kind === "skipped_no_expected_program_id") {
-      console.error(
-        import_chalk6.default.yellow(
-          `\u26A0 delegation offer: no authoritative expected program-id available (--program-id missing, ARP_ESCROW_PROGRAM_ID env unset, server protocol-fee unreachable). Pre-flight skipped; server-side ESC_LOCK_TX_PROGRAM_ID_MISMATCH check is the only backstop. Set ARP_ESCROW_PROGRAM_ID or pass --program-id to enable pre-flight.`
-        )
-      );
-    }
-  }
   const content = {
     action: "offer",
     delegation_id: delegationId,
@@ -2593,22 +2545,21 @@ async function runOffer(recipientDid, opts) {
     ...terms
   };
   const body = { type: "delegation", content };
-  const attachments = escrowResult ? { escrow_lock: escrowResult.attachment } : void 0;
   console.log(import_chalk6.default.dim(`Server: ${api.serverUrl}`));
   console.log(import_chalk6.default.dim(`Sender: ${sender.did}`));
   console.log(import_chalk6.default.dim(`Recipient: ${recipientDid}`));
   console.log(import_chalk6.default.dim(`Delegation: ${delegationId}`));
-  if (escrowResult) {
-    const a = escrowResult.attachment;
-    console.log(import_chalk6.default.dim(`Escrow lock attached: lock_id=${a.lock_id} amount=${a.amount} asset_id=${a.asset_id}`));
-  }
-  const result = await sendDelegationEnvelope({ api, sender, recipientDid, body, attachments, ttlSeconds, verbose: opts.verbose, server: opts.server });
+  const result = await sendDelegationEnvelope({ api, sender, recipientDid, body, ttlSeconds, verbose: opts.verbose, server: opts.server });
   printIngestResult(result);
   console.log(import_chalk6.default.dim(`
 Reference this delegation on subsequent calls with:`));
   console.log(import_chalk6.default.dim(`  heyarp delegation accept ${result.relationshipId} ${delegationId}`));
   console.log(import_chalk6.default.dim(`  heyarp delegation decline ${result.relationshipId} ${delegationId}`));
   console.log(import_chalk6.default.dim(`  heyarp delegation cancel  ${result.relationshipId} ${delegationId}`));
+  console.log(import_chalk6.default.dim(`
+After the worker accepts, fund the escrow lock:`));
+  console.log(import_chalk6.default.dim(`  heyarp wallet create-lock --delegation-id ${delegationId} --condition-hash <hex> ... > lock.json`));
+  console.log(import_chalk6.default.dim(`  heyarp delegation fund ${delegationId} --escrow-lock-from-file lock.json`));
   if (opts.waitUntil) {
     const untilPhase = parseUntilPhase(opts.waitUntil);
     if (untilPhase === void 0) {
@@ -2628,6 +2579,152 @@ Reference this delegation on subsequent calls with:`));
     });
   }
 }
+function registerFund(parent) {
+  parent.command("fund").description("Fund an ACCEPTED delegation with the escrow lock (buyer-only). Run AFTER the worker accepts the offer.").argument("<delegation-id>", "Delegation UUID (the one you offered + the worker accepted)").option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server").option("--ttl <seconds>", "Envelope TTL in seconds (max 86400 = 24h)", "3600").option("--verbose", "Print the full envelope before sending and the full server response. Mutually exclusive with --json.", false).option(
+    "--json",
+    'Machine-readable mode \u2014 emit a single JSON object on stdout ({ok, action:"fund", delegationId, eventId, relationshipId, relationshipEventIndex, serverTimestamp, serverEventHash}). Prelude moves off stdout; on failure stderr carries `{code, message}`. Mutually exclusive with --verbose.',
+    false
+  ).option(
+    "--escrow-lock-from-file <path>",
+    "Path to JSON output of `heyarp wallet create-lock` (recommended). Contains all 5 escrow_lock fields: signed_tx_blob, lock_id, amount, asset_id, expiry (+ delegation_id / program_id for pre-flight). Mutually exclusive with the inline --escrow-lock-* flags below."
+  ).option(
+    "--escrow-lock-blob <base64>",
+    "INLINE alternative: the signed Solana tx blob (base64). Requires --escrow-lock-id, --escrow-lock-amount, --escrow-lock-asset-id, --escrow-lock-expiry together."
+  ).option("--escrow-lock-id <hex32>", "INLINE lock_id (32-byte hex). Used with --escrow-lock-blob.").option("--escrow-lock-amount <int>", "INLINE lock amount in base units (e.g. lamports for native SOL). Used with --escrow-lock-blob.").option("--escrow-lock-asset-id <caip19>", "INLINE currency CAIP-19 asset_id (e.g. solana:<cluster_id>/slip44:501). Used with --escrow-lock-blob.").option("--escrow-lock-expiry <unix>", "INLINE expiry as unix seconds. Used with --escrow-lock-blob.").option(
+    "--program-id <pubkey>",
+    "Expected ARP escrow program id for pre-flight against the lock file's embedded `program_id`. Precedence: this flag > ARP_ESCROW_PROGRAM_ID env > server protocol-fee endpoint. Mismatch throws BEFORE the envelope ships, so a wrong-program lock never silently fails on chain after fund was already delivered. Pre-flight is skipped only for old lock files lacking `program_id`, or when no expected value can be resolved."
+  ).option(
+    "--wait-until <phase>",
+    "Block after delivery until the named FSM phase is reached (typically delegation.locked \u2014 resolves once the escrow lock confirms on chain). One of the UNTIL_PHASES from `heyarp status --help`. Exit code 124 on --wait-timeout."
+  ).option("--wait-timeout <seconds>", "When --wait-until is set: max wall-clock wait (default 300). Exit code 124 on timeout.").option("--wait-interval <seconds>", "When --wait-until is set: poll cadence (default 3, bound [1, 60]).").option("--wait-verbose", "When --wait-until is set: emit one dim line per poll tick showing the current FSM state.", false).action(async (delegationId, opts) => {
+    await runFund(delegationId, opts);
+  });
+}
+async function runFund(delegationId, opts) {
+  if (opts.verbose && opts.json) {
+    throw new Error(
+      "delegation fund: --verbose and --json are mutually exclusive. --json emits the structured server response; --verbose adds dumps that would break `--json | jq`."
+    );
+  }
+  delegationId = requireUuidNormalised("delegation fund", delegationId, "<delegation-id>");
+  const ttlSeconds = parseTtl("delegation fund", opts.ttl);
+  const escrowResult = assembleEscrowLockAttachment({
+    escrowLockFromFile: opts.escrowLockFromFile,
+    escrowLockBlob: opts.escrowLockBlob,
+    escrowLockId: opts.escrowLockId,
+    escrowLockAmount: opts.escrowLockAmount,
+    escrowLockAssetId: opts.escrowLockAssetId,
+    escrowLockExpiry: opts.escrowLockExpiry
+  });
+  if (escrowResult.delegationIdFromLock !== void 0 && escrowResult.delegationIdFromLock !== delegationId) {
+    throw new Error(
+      `delegation fund: <delegation-id> (${delegationId}) disagrees with the lock file's delegation_id (${escrowResult.delegationIdFromLock}). The on-chain lock_id is derived from the lock-side id; funding a different delegation would guarantee ESC_LOCK_ID_MISMATCH. Fund the delegation the lock was built for, or regenerate the lock with --delegation-id ${delegationId}.`
+    );
+  }
+  const api = new ArpApiClient(opts.server);
+  const sender = resolveSenderAgent("delegation fund", opts.server, opts.fromDid);
+  const signer = makeSigner(sender);
+  const resolved = await resolveFundRefs("delegation fund", api, signer, { delegationId, selfDid: sender.did });
+  if (escrowResult.lockProgramId !== void 0) {
+    const expected = await resolveProgramIdWithSource(api, { programId: opts.programId });
+    const result2 = preflightLockProgramId({
+      lockProgramId: escrowResult.lockProgramId,
+      expectedProgramId: expected.programId,
+      expectedSource: expected.source
+    });
+    if (result2.kind === "mismatch") {
+      throw new Error(
+        `delegation fund: lock file program_id ${result2.lockProgramId} does not match the expected escrow program ${result2.expectedProgramId} (resolved from --program-id flag > ARP_ESCROW_PROGRAM_ID env > server protocol-fee). The lock tx would be rejected on chain (ESC_LOCK_TX_PROGRAM_ID_MISMATCH) and the delegation would silently fail ~26s after fund. Regenerate the lock with the correct program id via \`heyarp wallet create-lock --program-id ${result2.expectedProgramId} ...\`.`
+      );
+    }
+    if (result2.kind === "skipped_no_expected_program_id") {
+      console.error(
+        import_chalk6.default.yellow(
+          "\u26A0 delegation fund: no authoritative expected program-id available (--program-id missing, ARP_ESCROW_PROGRAM_ID env unset, server protocol-fee unreachable). Pre-flight skipped; server-side ESC_LOCK_TX_PROGRAM_ID_MISMATCH check is the only backstop. Set ARP_ESCROW_PROGRAM_ID or pass --program-id to enable pre-flight."
+        )
+      );
+    }
+  }
+  const content = { action: "fund", delegation_id: delegationId };
+  const body = { type: "delegation", content };
+  const attachments = { escrow_lock: escrowResult.attachment };
+  progress(opts.json, import_chalk6.default.dim(`Server: ${api.serverUrl}`));
+  progress(opts.json, import_chalk6.default.dim(`Sender: ${sender.did}`));
+  progress(opts.json, import_chalk6.default.dim(`Recipient: ${resolved.recipientDid}`));
+  progress(opts.json, import_chalk6.default.dim(`Relationship: ${resolved.relationshipId}`));
+  progress(opts.json, import_chalk6.default.dim(`Delegation: ${delegationId} (action=fund)`));
+  {
+    const a = escrowResult.attachment;
+    progress(opts.json, import_chalk6.default.dim(`Escrow lock attached: lock_id=${a.lock_id} amount=${a.amount} asset_id=${a.asset_id}`));
+  }
+  const result = await sendDelegationEnvelope({
+    api,
+    sender,
+    recipientDid: resolved.recipientDid,
+    body,
+    attachments,
+    ttlSeconds,
+    verbose: opts.verbose,
+    server: opts.server
+  });
+  if (opts.json) {
+    jsonOut({
+      ok: true,
+      action: "fund",
+      delegationId,
+      eventId: result.eventId,
+      relationshipId: result.relationshipId,
+      relationshipEventIndex: result.relationshipEventIndex,
+      serverTimestamp: result.serverTimestamp,
+      serverEventHash: result.serverEventHash,
+      prevServerEventHash: result.prevServerEventHash ?? null
+    });
+  } else {
+    printIngestResult(result);
+    console.log(import_chalk6.default.dim("\nThe worker waits for the on-chain lock to confirm (LOCKED), then begins work."));
+  }
+  if (opts.waitUntil && !opts.json) {
+    const untilPhase = parseUntilPhase(opts.waitUntil);
+    if (untilPhase === void 0) {
+      throw new Error(`delegation fund: --wait-until requires a phase value (got ${JSON.stringify(opts.waitUntil)})`);
+    }
+    await awaitFsmTransitionAfterAction({
+      api,
+      signerDid: sender.did,
+      signer,
+      relationshipId: result.relationshipId,
+      untilPhase,
+      waitIntervalSec: parseWaitInterval(opts.waitInterval),
+      waitTimeoutSec: parseWaitTimeout(opts.waitTimeout),
+      waitVerbose: !!opts.waitVerbose,
+      json: false
+    });
+  }
+}
+async function resolveFundRefs(cmdName, api, signer, args) {
+  const relationships = await api.listRelationships(args.selfDid, signer, { limit: 100 });
+  for (const rel of relationships) {
+    let after;
+    for (; ; ) {
+      const page = await api.listDelegations(rel.relationshipId, signer, { limit: 100, after });
+      const row = page.find((d) => d.delegationId === args.delegationId);
+      if (row) {
+        if (row.offererDid !== args.selfDid) {
+          throw new Error(
+            `${cmdName}: delegation ${args.delegationId} was offered by ${row.offererDid}, not you (${args.selfDid}). Funding the escrow lock is the BUYER's (offerer's) action.`
+          );
+        }
+        const recipientDid = rel.pairDidA === args.selfDid ? rel.pairDidB : rel.pairDidA;
+        return { relationshipId: rel.relationshipId, recipientDid, state: row.state };
+      }
+      if (page.length < 100) break;
+      after = page[page.length - 1].id;
+    }
+  }
+  throw new Error(
+    `${cmdName}: delegation ${args.delegationId} not found in any of your relationships (checked the first 100 by recent activity). Confirm the worker accepted your offer and that you are the offerer; inspect with \`heyarp delegations <relationship-id> --from-did ${args.selfDid}\`.`
+  );
+}
 function registerAccept(parent) {
   parent.command("accept").description("Accept a PROPOSED delegation \u2014 promotes to ACCEPTED. Counterparty-only.").argument("<relationship-id>", "Relationship UUID").argument("<delegation-id>", "Delegation UUID").option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server").option("--ttl <seconds>", "Envelope TTL in seconds", "3600").option("--verbose", "Print the full envelope before sending and the full server response. Mutually exclusive with --json.", false).option(
     "--json",
@@ -2654,7 +2751,7 @@ function registerDecline(parent) {
   });
 }
 function registerCancel(parent) {
-  parent.command("cancel").description("Cancel a PROPOSED delegation \u2014 moves to CANCELED. Offerer-only (the OTHER side uses decline).").argument("<relationship-id>", "Relationship UUID").argument("<delegation-id>", "Delegation UUID").option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server").option("--ttl <seconds>", "Envelope TTL in seconds", "3600").option("--verbose", "Print the full envelope before sending and the full server response", false).option(
+  parent.command("cancel").description("Cancel an OFFERED delegation \u2014 moves to CANCELED. Offerer-only (the OTHER side uses decline).").argument("<relationship-id>", "Relationship UUID").argument("<delegation-id>", "Delegation UUID").option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server").option("--ttl <seconds>", "Envelope TTL in seconds", "3600").option("--verbose", "Print the full envelope before sending and the full server response", false).option(
     "--no-wait-for-lock",
     "Opt-out of the pending-lock pre-flight poll. Default is ON: when the resolved delegation is in `pending_lock_finalization`, the CLI polls until the on-chain lock is confirmed before signing the envelope (avoids the racy DELEGATION_PENDING_LOCK 409 that consumes sender_sequence)."
   ).option("--lock-wait-timeout <seconds>", "Max wall-clock seconds to wait for pending-lock pre-flight (default 300).", "300").option("--lock-wait-interval <seconds>", "Poll cadence for pending-lock pre-flight in seconds. Bound to [1, 60].", "3").action(async (relationshipId, delegationId, opts) => {
@@ -2931,11 +3028,6 @@ function parseOfferTerms(cmdName, opts) {
   if (opts.scope) out.scope_summary = opts.scope;
   const pricingModel = parsePricingModel(cmdName, opts.pricingModel);
   if (pricingModel !== void 0) out.pricing_model = pricingModel;
-  const settlementModel = parseSettlementModel(cmdName, opts.settlementModel);
-  if (settlementModel !== void 0) out.settlement_model = settlementModel;
-  if (opts.rateAmount) out.rate_amount = opts.rateAmount;
-  const rateUnit = parseRateUnit(cmdName, opts.rateUnit);
-  if (rateUnit !== void 0) out.rate_unit = rateUnit;
   if (opts.amount) {
     out.amount = opts.amount;
     if (!opts.currency) {
@@ -2954,20 +3046,6 @@ function parsePricingModel(cmdName, raw) {
   }
   return raw;
 }
-function parseSettlementModel(cmdName, raw) {
-  if (raw === void 0 || raw === "") return void 0;
-  if (raw !== "prepaid" && raw !== "escrow") {
-    throw new Error(`${cmdName}: --settlement-model must be one of prepaid|escrow (got '${raw}')`);
-  }
-  return raw;
-}
-function parseRateUnit(cmdName, raw) {
-  if (raw === void 0 || raw === "") return void 0;
-  if (raw !== "task" && raw !== "thread" && raw !== "handoff") {
-    throw new Error(`${cmdName}: --rate-unit must be one of task|thread|handoff (got '${raw}')`);
-  }
-  return raw;
-}
 function parseTtl(cmdName, raw) {
   if (raw === void 0) return 3600;
   const n = Number(raw);
@@ -3095,6 +3173,17 @@ var init_delegation = __esm({
       // against a PENDING_LOCK delegation consumes sender_sequence
       // even though it rejects.
       "DELEGATION_PENDING_LOCK",
+      // M6 lock-at-accept: the `fund` body handler (`handleFund`) emits
+      // these AFTER the event row is committed (same lifecycle as
+      // DELEGATION_INVALID_STATE). `DELEGATION_FUNDER_NOT_OFFERER` (403)
+      // when a non-offerer attempts the fund; `DELEGATION_ALREADY_FUNDED`
+      // (409) on a re-fund of a delegation that already moved into the
+      // lock lifecycle (pending_lock_finalization / locked, or an
+      // in-flight create_lock op). Both consume sender_sequence, so the
+      // CLI must advance `lastSenderSequence` or a retry trips
+      // `ENV_SEQUENCE_BACKWARDS`.
+      "DELEGATION_FUNDER_NOT_OFFERER",
+      "DELEGATION_ALREADY_FUNDED",
       // V1.5 lock-validator mint.owner pre-flight — kept here for
       // documentation, but the `isPostCommitErrorCode` helper below
       // also matches any `ESC_LOCK_*` prefix. The full lock-validator
@@ -3346,11 +3435,8 @@ function projectDelegationRowForHash(d) {
   const out = {
     delegationId: d.delegationId,
     scopeSummary: d.scopeSummary,
-    pricingModel: d.pricingModel,
-    settlementModel: d.settlementModel
+    pricingModel: d.pricingModel
   };
-  if (d.rateAmount !== void 0) out.rateAmount = d.rateAmount;
-  if (d.rateUnit !== void 0) out.rateUnit = d.rateUnit;
   if (d.currency !== void 0) {
     out.currency = {
       asset_id: d.currency.assetId,
@@ -3461,9 +3547,15 @@ async function readOnChainLock(api, opts, delegationId) {
     const programId = new import_web33.PublicKey(resolved.programId);
     const { lockPda } = deriveLockPda(programId, delegationId);
     const conn = new import_web33.Connection(rpcUrl, "confirmed");
-    const info = await conn.getAccountInfo(lockPda);
+    let info = await conn.getAccountInfo(lockPda);
+    for (let attempt = 1; attempt <= LOCK_READ_NOT_VISIBLE_RETRIES && !info; attempt++) {
+      await new Promise((r) => setTimeout(r, LOCK_READ_RETRY_DELAY_MS));
+      info = await conn.getAccountInfo(lockPda);
+    }
     if (!info) {
-      return { skipReason: `lock account ${lockPda.toBase58()} not visible on this RPC yet (create_lock may still be confirming)` };
+      return {
+        skipReason: `lock account ${lockPda.toBase58()} not visible on this RPC yet after ${LOCK_READ_NOT_VISIBLE_RETRIES + 1} attempts (create_lock may still be confirming / RPC lag)`
+      };
     }
     const lock = decodeLockAccount(info.data);
     if (!lock) {
@@ -3492,10 +3584,10 @@ async function autoSignAndDeliverPayeeSig(opts, cmdName = "receipt propose") {
   const api = new ArpApiClient(opts.server);
   const sender = resolveSenderAgent(cmdName, opts.server, opts.fromDid);
   const signer = makeSigner(sender);
-  say(import_chalk18.default.dim(`Server: ${api.serverUrl}`));
-  say(import_chalk18.default.dim(`Signer (payee): ${sender.did}`));
+  say(import_chalk17.default.dim(`Server: ${api.serverUrl}`));
+  say(import_chalk17.default.dim(`Signer (payee): ${sender.did}`));
   const relId = opts.relId ?? await resolveAutoRelId(api, sender, delegationId);
-  say(import_chalk18.default.dim(`Relationship: ${relId}`));
+  say(import_chalk17.default.dim(`Relationship: ${relId}`));
   const receiptMatches = await collectReceiptRows(api, signer, relId, delegationId);
   const receipt = selectReceipt(receiptMatches, opts.receiptEventHash, cmdName);
   if (!receipt) {
@@ -3516,7 +3608,7 @@ async function autoSignAndDeliverPayeeSig(opts, cmdName = "receipt propose") {
       if (opts.json) {
         jsonOut({ ok: true, idempotent: true, alreadyCosigned: true, delegationId, relationshipId: relId, buyerDid: receipt.callerDid });
       } else {
-        progress(opts.json, import_chalk18.default.yellow("\n[idempotent] Receipt already cosigned \u2014 escrow release is settled. Nothing to send."));
+        progress(opts.json, import_chalk17.default.yellow("\n[idempotent] Receipt already cosigned \u2014 escrow release is settled. Nothing to send."));
       }
     }
     return { delivered: false, idempotent: true, alreadyCosigned: true, relationshipId: relId, buyerDid: receipt.callerDid };
@@ -3539,8 +3631,8 @@ async function autoSignAndDeliverPayeeSig(opts, cmdName = "receipt propose") {
             expiresAt: ps.expires_at
           });
         } else {
-          progress(opts.json, import_chalk18.default.yellow("\n[idempotent] Payee settlement signature already delivered + still valid for this receipt \u2014 skipping re-send."));
-          progress(opts.json, import_chalk18.default.dim(`  purpose=${ps.purpose} settlement_pubkey=${ps.settlement_pubkey} expires_at=${ps.expires_at}`));
+          progress(opts.json, import_chalk17.default.yellow("\n[idempotent] Payee settlement signature already delivered + still valid for this receipt \u2014 skipping re-send."));
+          progress(opts.json, import_chalk17.default.dim(`  purpose=${ps.purpose} settlement_pubkey=${ps.settlement_pubkey} expires_at=${ps.expires_at}`));
         }
       }
       return {
@@ -3554,14 +3646,14 @@ async function autoSignAndDeliverPayeeSig(opts, cmdName = "receipt propose") {
         expiresAt: ps.expires_at
       };
     }
-    say(import_chalk18.default.yellow(`
+    say(import_chalk17.default.yellow(`
 [refresh] Existing payee settlement sig expires at ${ps.expires_at} (\u2264 now+${SETTLEMENT_REFRESH_HEADROOM_SECS}s) \u2014 re-signing with a fresh expiry.`));
   }
   const buyerDid = receipt.callerDid;
   const receiptEventHash = receipt.receiptEventHash;
   const deliverableHash = receipt.deliverableHash ?? receipt.responseHash;
-  say(import_chalk18.default.dim(`Buyer (payer): ${buyerDid}`));
-  say(import_chalk18.default.dim(`Receipt event hash: ${receiptEventHash}`));
+  say(import_chalk17.default.dim(`Buyer (payer): ${buyerDid}`));
+  say(import_chalk17.default.dim(`Receipt event hash: ${receiptEventHash}`));
   const delegation = await findDelegationRow(api, signer, relId, delegationId);
   if (!delegation) {
     throw new Error(`${cmdName}: delegation ${delegationId} not found under relationship ${relId} (paginated 5000 rows).`);
@@ -3601,11 +3693,6 @@ async function autoSignAndDeliverPayeeSig(opts, cmdName = "receipt propose") {
       `${cmdName}: settlement expires_at (${Number.isFinite(expiresAt6) ? expiresAt6 : "NaN"}) is not far enough in the future \u2014 it must be > now+${SETTLEMENT_MIN_EXPIRY_HEADROOM_SECS}s (${minSafeExpiry}) or the server rejects it post-commit (SETTLEMENT_SIG_EXPIRES_AT_*), burning a sender_sequence. ${fromExplicit ? "Pass a later --expires-at <unix-seconds> (still \u2264 the lock's on-chain expiry)." : `Derived from deadline ${JSON.stringify(delegation.deadline)} + buffer ${bufferSecs}s \u2014 the deadline is too close or in the past. Increase --settlement-buffer-secs or pass --expires-at <unix-seconds> \u2264 the lock's expiry.`}`
     );
   }
-  if (delegation.settlementModel === "prepaid") {
-    throw new Error(
-      `${cmdName}: delegation ${delegationId} settlementModel is 'prepaid' (non-escrow). This command delivers an on-chain escrow-release signature; a prepaid delegation has no lock to settle and the server would reject post-commit (SETTLEMENT_SIG_LOCK_NOT_FOUND). Nothing to settle on-chain.`
-    );
-  }
   const subset = projectDelegationRowForHash(delegation);
   const conditionHash = (0, import_utils3.bytesToHex)((0, import_sdk10.deriveDelegationConditionHash)(subset));
   const buyerDidDoc = await api.getDidDocument(buyerDid);
@@ -3667,9 +3754,9 @@ async function autoSignAndDeliverPayeeSig(opts, cmdName = "receipt propose") {
     });
     effectiveFeeBpsAtLock = resolvedFee.feeBpsAtLock;
     effectiveFeeRecipientAtLock = resolvedFee.feeRecipientAtLock;
-    say(import_chalk18.default.dim(`On-chain lock pre-flight OK \u2014 payee/amount/expiry/mint match; fee_bps_at_lock=${resolvedFee.feeBpsAtLock}.`));
+    say(import_chalk17.default.dim(`On-chain lock pre-flight OK \u2014 payee/amount/expiry/mint match; fee_bps_at_lock=${resolvedFee.feeBpsAtLock}.`));
   } else {
-    say(import_chalk18.default.yellow(`On-chain lock pre-flight skipped: ${lockCheck.skipReason}. The server remains the validation boundary.`));
+    say(import_chalk17.default.yellow(`On-chain lock pre-flight skipped: ${lockCheck.skipReason}. The server remains the validation boundary.`));
   }
   const signOpts = {
     server: opts.server,
@@ -3692,7 +3779,7 @@ async function autoSignAndDeliverPayeeSig(opts, cmdName = "receipt propose") {
     ...effectiveFeeRecipientAtLock !== void 0 ? { feeRecipientAtLock: effectiveFeeRecipientAtLock } : {},
     ...partialPayeeAmount !== void 0 ? { partialPayeeAmount } : {}
   };
-  say(import_chalk18.default.dim(`Signing ${partialPayeeAmount !== void 0 ? "PARTIAL" : "full"} release: lock_amount=${lockAmount}, expires_at=${expiresAt6}, cluster_tag=${clusterTag}`));
+  say(import_chalk17.default.dim(`Signing ${partialPayeeAmount !== void 0 ? "PARTIAL" : "full"} release: lock_amount=${lockAmount}, expires_at=${expiresAt6}, cluster_tag=${clusterTag}`));
   const signed = await signSettlementHandler(signOpts);
   const content = {
     delegation_id: delegationId,
@@ -3723,16 +3810,16 @@ async function autoSignAndDeliverPayeeSig(opts, cmdName = "receipt propose") {
         serverTimestamp: result.serverTimestamp
       });
     } else {
-      console.log(import_chalk18.default.green("\nSettlement signature signed + delivered."));
-      console.log(`${import_chalk18.default.bold("Delegation")}: ${import_chalk18.default.cyan(delegationId)}`);
-      console.log(`${import_chalk18.default.bold("Buyer")}: ${import_chalk18.default.cyan(buyerDid)}`);
-      console.log(`${import_chalk18.default.bold("Purpose")}: ${import_chalk18.default.cyan(signed.purpose)}`);
+      console.log(import_chalk17.default.green("\nSettlement signature signed + delivered."));
+      console.log(`${import_chalk17.default.bold("Delegation")}: ${import_chalk17.default.cyan(delegationId)}`);
+      console.log(`${import_chalk17.default.bold("Buyer")}: ${import_chalk17.default.cyan(buyerDid)}`);
+      console.log(`${import_chalk17.default.bold("Purpose")}: ${import_chalk17.default.cyan(signed.purpose)}`);
       if (partialPayeeAmount !== void 0) {
-        console.log(`${import_chalk18.default.bold("Payee amount")}: ${import_chalk18.default.cyan(partialPayeeAmount)} (partial release)`);
+        console.log(`${import_chalk17.default.bold("Payee amount")}: ${import_chalk17.default.cyan(partialPayeeAmount)} (partial release)`);
       }
-      console.log(`${import_chalk18.default.bold("Expires at")}: ${import_chalk18.default.cyan(String(expiresAt6))}`);
-      console.log(`${import_chalk18.default.bold("Delivered event")}: ${import_chalk18.default.cyan(result.serverEventHash)}`);
-      console.log(import_chalk18.default.dim("\nThe buyer cosigns with: heyarp receipt cosign <rel-id> <del-id> --auto-hashes --auto-resolve-payee-sig --payer-sig-from-file <path>"));
+      console.log(`${import_chalk17.default.bold("Expires at")}: ${import_chalk17.default.cyan(String(expiresAt6))}`);
+      console.log(`${import_chalk17.default.bold("Delivered event")}: ${import_chalk17.default.cyan(result.serverEventHash)}`);
+      console.log(import_chalk17.default.dim("\nThe buyer cosigns with: heyarp receipt cosign <rel-id> <del-id> --auto-hashes --auto-resolve-payee-sig --payer-sig-from-file <path>"));
     }
   }
   return {
@@ -3751,13 +3838,13 @@ async function autoSignAndDeliverPayeeSig(opts, cmdName = "receipt propose") {
     serverTimestamp: result.serverTimestamp
   };
 }
-var import_sdk10, import_utils3, import_web33, import_chalk18, NATIVE_SOL_MINT2, SETTLEMENT_MIN_EXPIRY_HEADROOM_SECS, SETTLEMENT_REFRESH_HEADROOM_SECS;
+var import_sdk10, import_utils3, import_web33, import_chalk17, NATIVE_SOL_MINT2, SETTLEMENT_MIN_EXPIRY_HEADROOM_SECS, SETTLEMENT_REFRESH_HEADROOM_SECS, LOCK_READ_NOT_VISIBLE_RETRIES, LOCK_READ_RETRY_DELAY_MS;
 var init_settlement = __esm({
   "src/commands/settlement.ts"() {
     import_sdk10 = require("@heyanon-arp/sdk");
     import_utils3 = require("@noble/hashes/utils");
     import_web33 = require("@solana/web3.js");
-    import_chalk18 = __toESM(require("chalk"));
+    import_chalk17 = __toESM(require("chalk"));
     init_api();
     init_format();
     init_state();
@@ -3771,6 +3858,8 @@ var init_settlement = __esm({
     NATIVE_SOL_MINT2 = "11111111111111111111111111111111";
     SETTLEMENT_MIN_EXPIRY_HEADROOM_SECS = 120;
     SETTLEMENT_REFRESH_HEADROOM_SECS = 600;
+    LOCK_READ_NOT_VISIBLE_RETRIES = 3;
+    LOCK_READ_RETRY_DELAY_MS = 2e3;
   }
 });
 
@@ -3798,10 +3887,10 @@ function registerPropose(parent) {
     false
   ).option(
     "--cluster-tag <int>",
-    "Solana cluster the escrow lock lives on: 0 = devnet, 1 = mainnet-beta. MUST match the create_lock cluster or the server-reconstructed release digest will not verify. REQUIRED for an escrow delegation \u2014 there is no default (a defaulted/wrong cluster silently signs an invalid settlement digest that fails at cosign). Ignored for prepaid."
+    "Solana cluster the escrow lock lives on: 0 = devnet, 1 = mainnet-beta. MUST match the create_lock cluster or the server-reconstructed release digest will not verify. REQUIRED (every delegation is escrow-backed) \u2014 there is no default (a defaulted/wrong cluster silently signs an invalid settlement digest that fails at cosign)."
   ).option(
     "--settlement-buffer-secs <int>",
-    "Seconds added to the delegation deadline for the settlement digest expires_at (dispute buffer). Default 86400 (1 day). Ignored when --expires-at is given, and for prepaid delegations.",
+    "Seconds added to the delegation deadline for the settlement digest expires_at (dispute buffer). Default 86400 (1 day). Ignored when --expires-at is given.",
     "86400"
   ).option(
     "--expires-at <unix>",
@@ -3826,6 +3915,14 @@ function registerPropose(parent) {
       await runPropose(recipientDid, delegationId, requestHash, responseHash, opts);
     } catch (err) {
       emitActionError(err, cmd);
+      if (!opts.json && err instanceof ApiError && err.payload.code === "RECEIPT_ALREADY_EXISTS") {
+        console.error(
+          import_chalk18.default.dim(
+            `  This receipt already exists (a prior propose committed it). Do NOT re-propose \u2014 to (re)deliver the payee settlement signature, run:
+    'heyarp receipt send-payee-sig ${recipientDid} --delegation-id ${delegationId} --auto --cluster-tag ${opts.clusterTag ?? "<0|1>"}'`
+          )
+        );
+      }
       process.exitCode = 1;
     }
   });
@@ -3850,15 +3947,13 @@ async function runPropose(recipientDid, delegationId, requestHashArg, responseHa
     opts.relId = await resolveAutoRelId(api, sender, delegationId);
     progress(
       opts.json,
-      import_chalk19.default.dim(`[auto-rel-id] resolved --rel-id=${opts.relId} (delegation found in exactly one of your relationships; pass --rel-id explicitly to override)`)
+      import_chalk18.default.dim(`[auto-rel-id] resolved --rel-id=${opts.relId} (delegation found in exactly one of your relationships; pass --rel-id explicitly to override)`)
     );
   }
-  let delegationRow;
   if (opts.relId) {
-    delegationRow = await assertSenderIsReceiptPayee(api, sender, opts.relId, delegationId);
+    await assertSenderIsReceiptPayee(api, sender, opts.relId, delegationId);
   }
-  const isEscrow = delegationRow?.settlementModel === "escrow";
-  if (isEscrow) {
+  {
     const ct = opts.clusterTag;
     if (ct === void 0 || ct === "") {
       throw new Error(
@@ -3879,7 +3974,7 @@ async function runPropose(recipientDid, delegationId, requestHashArg, responseHa
       opts.requestId = await resolveAutoRequestId(api, sender, opts.relId, delegationId);
       progress(
         opts.json,
-        import_chalk19.default.dim(
+        import_chalk18.default.dim(
           `[auto-request-id] resolved --request-id=${opts.requestId} (unique 'responded' work_log under this delegation; pass --request-id explicitly to override)`
         )
       );
@@ -3898,8 +3993,8 @@ async function runPropose(recipientDid, delegationId, requestHashArg, responseHa
     }
     requestHash = computed.requestHash;
     responseHash = computed.responseHash;
-    progress(opts.json, import_chalk19.default.dim(`[auto-hashes] request_hash:  ${requestHash} (from work-log ${opts.relId}/${delegationId}/${opts.requestId})`));
-    progress(opts.json, import_chalk19.default.dim(`[auto-hashes] response_hash: ${responseHash}`));
+    progress(opts.json, import_chalk18.default.dim(`[auto-hashes] request_hash:  ${requestHash} (from work-log ${opts.relId}/${delegationId}/${opts.requestId})`));
+    progress(opts.json, import_chalk18.default.dim(`[auto-hashes] response_hash: ${responseHash}`));
   } else {
     if (requestHashArg === void 0 || responseHashArg === void 0) {
       throw new Error("receipt propose: <request-hash> and <response-hash> are required (or pass --auto-hashes + --rel-id + --request-id to derive them from the work-log)");
@@ -3919,15 +4014,15 @@ async function runPropose(recipientDid, delegationId, requestHashArg, responseHa
   if (opts.deliverableHash) content.deliverable_hash = opts.deliverableHash;
   if (usage) content.usage = usage;
   const body = { type: "receipt", content };
-  progress(opts.json, import_chalk19.default.dim(`Server: ${api.serverUrl}`));
-  progress(opts.json, import_chalk19.default.dim(`Sender (payee): ${sender.did}`));
-  progress(opts.json, import_chalk19.default.dim(`Recipient (caller): ${recipientDid}`));
-  progress(opts.json, import_chalk19.default.dim(`Delegation: ${delegationId}`));
-  progress(opts.json, import_chalk19.default.dim(`Verdict (proposed): ${verdict}`));
+  progress(opts.json, import_chalk18.default.dim(`Server: ${api.serverUrl}`));
+  progress(opts.json, import_chalk18.default.dim(`Sender (payee): ${sender.did}`));
+  progress(opts.json, import_chalk18.default.dim(`Recipient (caller): ${recipientDid}`));
+  progress(opts.json, import_chalk18.default.dim(`Delegation: ${delegationId}`));
+  progress(opts.json, import_chalk18.default.dim(`Verdict (proposed): ${verdict}`));
   const result = await sendReceiptEnvelope({ api, sender, recipientDid, body, attachments: void 0, ttlSeconds, verbose: opts.verbose, server: opts.server });
   let settlementResult;
   let settlementError;
-  if (isEscrow && opts.relId) {
+  if (opts.relId) {
     const { autoSignAndDeliverPayeeSig: autoSignAndDeliverPayeeSig2 } = await Promise.resolve().then(() => (init_settlement(), settlement_exports));
     try {
       settlementResult = await autoSignAndDeliverPayeeSig2({
@@ -3975,7 +4070,12 @@ async function runPropose(recipientDid, delegationId, requestHashArg, responseHa
       json.settlement = {
         delivered: false,
         error: settlementError.message,
-        recovery: `heyarp receipt send-payee-sig ${recipientDid} --delegation-id ${delegationId} --receipt-event-hash ${result.serverEventHash} --sig-from-file <path> --expires-at <unix> (after signing with 'heyarp wallet sign-settlement-release')`
+        // Authoritative recovery (SR-2/SR-3): re-sign + re-deliver via
+        // --auto, which resolves condition_hash + the on-chain lock
+        // snapshot itself — no hand-typed hashes, no sig file, no
+        // lock_id/condition_hash trap. Do NOT re-run `receipt propose`
+        // (the receipt already exists; a second propose is a duplicate).
+        recovery: `heyarp receipt send-payee-sig ${recipientDid} --delegation-id ${delegationId} --auto --cluster-tag ${opts.clusterTag ?? "<0|1>"} (do NOT re-run 'receipt propose' \u2014 the receipt already exists, a second propose is rejected as a duplicate)`
       };
     } else if (settlementResult) {
       json.settlement = {
@@ -3995,32 +4095,31 @@ async function runPropose(recipientDid, delegationId, requestHashArg, responseHa
     return;
   }
   printIngestResult2(result);
-  console.log(import_chalk19.default.dim(`
-Receipt event hash: ${import_chalk19.default.cyan(result.serverEventHash)}`));
+  console.log(import_chalk18.default.dim(`
+Receipt event hash: ${import_chalk18.default.cyan(result.serverEventHash)}`));
   if (settlementError) {
-    console.error(import_chalk19.default.yellow("\nWARNING: receipt proposed, but the payee settlement signature was NOT delivered."));
-    console.error(import_chalk19.default.yellow(`  reason: ${settlementError.message}`));
-    console.error(import_chalk19.default.dim("  The receipt stays committed \u2014 re-running `receipt propose` will NOT help (it hits RECEIPT_ALREADY_EXISTS)."));
-    console.error(import_chalk19.default.dim("  Recover by signing + delivering the payee sig directly, once the on-chain lock / RPC is reachable:"));
-    console.error(
-      import_chalk19.default.dim(
-        `    'heyarp wallet sign-settlement-release ... --write-to <path>' then
-    'heyarp receipt send-payee-sig ${recipientDid} --delegation-id ${delegationId} --receipt-event-hash ${result.serverEventHash} --sig-from-file <path> --expires-at <unix>'`
+    console.error(import_chalk18.default.yellow("\nWARNING: receipt proposed, but the payee settlement signature was NOT delivered."));
+    console.error(import_chalk18.default.yellow(`  reason: ${settlementError.message}`));
+    console.error(import_chalk18.default.dim("  The receipt stays committed \u2014 do NOT re-run `receipt propose` (the receipt already exists; a second propose is rejected as a duplicate)."));
+    console.error(import_chalk18.default.dim("  Recover authoritatively \u2014 this resolves condition_hash + the on-chain lock snapshot for you (no manual hashes, no sig file):"));
+    console.error(import_chalk18.default.dim(`    'heyarp receipt send-payee-sig ${recipientDid} --delegation-id ${delegationId} --auto --cluster-tag ${opts.clusterTag ?? "<0|1>"}'`));
+  } else if (settlementResult?.delivered) {
+    console.log(import_chalk18.default.green("\nPayee settlement signature signed + delivered (escrow)."));
+    console.log(
+      import_chalk18.default.dim(
+        `  purpose=${settlementResult.purpose} expires_at=${settlementResult.expiresAt}${settlementResult.payeeAmount !== void 0 ? ` payee_amount=${settlementResult.payeeAmount} (partial)` : ""}`
       )
     );
-  } else if (settlementResult?.delivered) {
-    console.log(import_chalk19.default.green("\nPayee settlement signature signed + delivered (escrow)."));
-    console.log(import_chalk19.default.dim(`  purpose=${settlementResult.purpose} expires_at=${settlementResult.expiresAt}${settlementResult.payeeAmount !== void 0 ? ` payee_amount=${settlementResult.payeeAmount} (partial)` : ""}`));
   } else if (settlementResult?.idempotent) {
-    console.log(import_chalk19.default.yellow(`
-[idempotent] Payee settlement signature already ${settlementResult.alreadyCosigned ? "settled (receipt cosigned)" : "delivered"} \u2014 nothing to re-send.`));
-  }
-  console.log(import_chalk19.default.dim(`The caller cosigns with:`));
-  if (isEscrow) {
-    console.log(import_chalk19.default.dim(`  heyarp receipt cosign ${result.relationshipId} ${delegationId} --auto-hashes --auto-resolve-payee-sig --payer-sig-from-file <path>`));
-  } else {
-    console.log(import_chalk19.default.dim(`  heyarp receipt cosign ${result.relationshipId} ${delegationId} ${requestHash} ${responseHash} --verdict ${verdict}`));
+    console.log(
+      import_chalk18.default.yellow(
+        `
+[idempotent] Payee settlement signature already ${settlementResult.alreadyCosigned ? "settled (receipt cosigned)" : "delivered"} \u2014 nothing to re-send.`
+      )
+    );
   }
+  console.log(import_chalk18.default.dim(`The caller cosigns with:`));
+  console.log(import_chalk18.default.dim(`  heyarp receipt cosign ${result.relationshipId} ${delegationId} --auto-hashes --auto-resolve-payee-sig --payer-sig-from-file <path>`));
 }
 async function assertSenderIsReceiptPayee(api, sender, relationshipId, delegationId) {
   const signer = makeSigner(sender);
@@ -4168,7 +4267,7 @@ function registerCosign(parent) {
 function loadSettlementSigFromFile(path, flagPrefix) {
   let raw;
   try {
-    raw = (0, import_node_fs8.readFileSync)(path, "utf8");
+    raw = (0, import_node_fs7.readFileSync)(path, "utf8");
   } catch (err) {
     throw new Error(`receipt cosign: failed to read ${flagPrefix} '${path}': ${err.message}`);
   }
@@ -4415,28 +4514,28 @@ async function runCosign(relationshipId, delegationId, requestHashArg, responseH
     content.notes_hash = cosignNotesHash;
   }
   const body = { type: "receipt", content };
-  console.log(import_chalk19.default.dim(`Server: ${api.serverUrl}`));
-  console.log(import_chalk19.default.dim(`Sender (caller): ${sender.did}`));
-  console.log(import_chalk19.default.dim(`Recipient (payee): ${resolved.payeeDid}`));
-  console.log(import_chalk19.default.dim(`Delegation: ${delegationId}`));
-  console.log(import_chalk19.default.dim(`Verdict (final): ${verdict}`));
-  console.log(import_chalk19.default.dim(`Receipt event hash bound: ${resolved.receiptEventHash}`));
+  console.log(import_chalk18.default.dim(`Server: ${api.serverUrl}`));
+  console.log(import_chalk18.default.dim(`Sender (caller): ${sender.did}`));
+  console.log(import_chalk18.default.dim(`Recipient (payee): ${resolved.payeeDid}`));
+  console.log(import_chalk18.default.dim(`Delegation: ${delegationId}`));
+  console.log(import_chalk18.default.dim(`Verdict (final): ${verdict}`));
+  console.log(import_chalk18.default.dim(`Receipt event hash bound: ${resolved.receiptEventHash}`));
   if (cosignNotesHash !== null) {
-    console.log(import_chalk19.default.dim(`Notes hash bound: ${cosignNotesHash}`));
+    console.log(import_chalk18.default.dim(`Notes hash bound: ${cosignNotesHash}`));
   } else if (opts.clearNotes) {
-    console.log(import_chalk19.default.dim("Notes binding: cleared (--clear-notes)"));
+    console.log(import_chalk18.default.dim("Notes binding: cleared (--clear-notes)"));
   }
   if (opts.autoResolvePayeeSig) {
     applyAutoResolvePayeeSig("receipt cosign", opts, resolved.payeeSettlement);
     console.log(
-      import_chalk19.default.dim(`Auto-resolved payee sig from receipt.payeeSettlement (purpose=${resolved.payeeSettlement?.purpose}, expires_at=${resolved.payeeSettlement?.expires_at})`)
+      import_chalk18.default.dim(`Auto-resolved payee sig from receipt.payeeSettlement (purpose=${resolved.payeeSettlement?.purpose}, expires_at=${resolved.payeeSettlement?.expires_at})`)
     );
   }
   const settlementSigs = assembleSettlementSignaturesAttachment(opts);
   const attachments = { co_signature: cosignature };
   if (settlementSigs) {
     attachments.settlement_signatures = settlementSigs;
-    console.log(import_chalk19.default.dim(`Settlement signatures attached: purpose=${settlementSigs.purpose}`));
+    console.log(import_chalk18.default.dim(`Settlement signatures attached: purpose=${settlementSigs.purpose}`));
   }
   const result = await sendReceiptEnvelope({
     api,
@@ -4468,18 +4567,32 @@ async function runCosign(relationshipId, delegationId, requestHashArg, responseH
   }
 }
 function registerSendPayeeSig(parent) {
-  parent.command("send-payee-sig").description("Send the payee's settlement signature to the buyer via a settlement_signature envelope. Replaces /tmp/*.json coordination for cross-host escrow cycles.").argument("<recipient-did>", "Buyer DID (= caller / offerer of the parent delegation; the cycle sends the sig to the side that will cosign)").requiredOption("--delegation-id <id>", "Parent delegation UUID \u2014 must match what was passed to `heyarp wallet sign-settlement-release`.").requiredOption(
+  parent.command("send-payee-sig").description(
+    "Send the payee's settlement signature to the buyer via a settlement_signature envelope. Replaces /tmp/*.json coordination for cross-host escrow cycles. Two modes: (1) MANUAL \u2014 supply --receipt-event-hash + --sig-from-file + --expires-at from a prior `wallet sign-settlement-release`; (2) --auto (RECOMMENDED for recovery) \u2014 resolves condition_hash + the on-chain lock snapshot AUTHORITATIVELY and re-signs (force), so you pass NO --sig-from-file and NO hand-typed hashes. Use --auto to recover when `receipt propose` did not deliver the sig (e.g. the just-confirmed lock was not yet RPC-visible); do NOT re-run `receipt propose` (the receipt already exists \u2014 a second propose is rejected as a duplicate)."
+  ).argument(
+    "[recipient-did]",
+    "Buyer DID (= caller / offerer of the parent delegation; the cycle sends the sig to the side that will cosign). Optional under --auto \u2014 the buyer is resolved from the delegation/receipt."
+  ).requiredOption("--delegation-id <id>", "Parent delegation UUID \u2014 must match what was passed to `heyarp wallet sign-settlement-release`.").option(
+    "--auto",
+    "Authoritative recovery: resolve condition_hash (over the delegation terms) + the on-chain lock snapshot (mint / amount / expiry / fee) and re-sign the release digest (force), then deliver it. Use this to recover when `receipt propose` did not deliver the sig \u2014 you do NOT pass --sig-from-file or --receipt-event-hash with --auto, and there is no lock_id/condition_hash trap. Requires --cluster-tag; mutually exclusive with --sig-from-file. Do NOT re-run `receipt propose` (the receipt already exists; a second propose is rejected as a duplicate)."
+  ).option(
+    "--cluster-tag <0|1>",
+    "REQUIRED under --auto: 0 = devnet, 1 = mainnet-beta. Binds the cluster into the signed release digest (no safe default; a wrong cluster fails at the buyer cosign)."
+  ).option(
+    "--rpc-url <url>",
+    "Solana RPC endpoint for the --auto on-chain lock read (resolves mint / amount / expiry / fee). Falls back to ARP_ESCROW_RPC_URL then `heyarp config get rpcUrl`; when none is set the on-chain check is skipped and the server stays the boundary."
+  ).option("--program-id <pubkey>", "Escrow program id for the --auto on-chain lock read (auto-discovered from the server when omitted).").option("--rel-id <id>", "Relationship UUID \u2014 under --auto, auto-derived from the delegation when omitted.").option(
     "--receipt-event-hash <sha256:hex>",
-    "Server-assigned `serverEventHash` of the receipt-propose envelope this signature settles. Read it from the JSON response of `heyarp receipt propose` (the field is `Server event hash` in human output, or `.serverEventHash` in --json). MUST equal the value the digest was signed over \u2014 the server cross-checks against `Receipt.receiptEventHash` and rejects with SETTLEMENT_SIG_RECEIPT_NOT_FOUND otherwise."
-  ).requiredOption(
+    "MANUAL path: server-assigned `serverEventHash` of the receipt-propose envelope this signature settles. Read it from the JSON response of `heyarp receipt propose` (the field is `Server event hash` in human output, or `.serverEventHash` in --json). MUST equal the value the digest was signed over \u2014 the server cross-checks against `Receipt.receiptEventHash` and rejects with SETTLEMENT_SIG_RECEIPT_NOT_FOUND otherwise. NOT needed with --auto (the helper resolves the receipt; pass it only to disambiguate >1 proposed receipt)."
+  ).option(
     "--sig-from-file <path>",
-    "JSON file produced by `heyarp wallet sign-settlement-release --write-to <path>`. Reads `{settlement_pubkey, sig, purpose, digest_hex}` \u2014 the digest_hex is bound through for cross-file consistency (catches truncated or hand-edited files)."
-  ).requiredOption(
+    "MANUAL path: JSON file produced by `heyarp wallet sign-settlement-release --write-to <path>`. Reads `{settlement_pubkey, sig, purpose, digest_hex}` \u2014 the digest_hex is bound through for cross-file consistency (catches truncated or hand-edited files). MUTUALLY EXCLUSIVE with --auto."
+  ).option(
     "--expires-at <unix>",
-    "Unix-seconds expires_at value baked into the signed digest \u2014 MUST match the value passed to `--expires-at` on `heyarp wallet sign-settlement-release`. Server cross-checks against the buyer-side value at cosign time; wrong value \u2192 ESC_SETTLEMENT_EXPIRES_AT_PAST/_TOO_SOON."
+    "MANUAL path: unix-seconds expires_at value baked into the signed digest \u2014 MUST match the value passed to `--expires-at` on `heyarp wallet sign-settlement-release`. Server cross-checks against the buyer-side value at cosign time; wrong value \u2192 ESC_SETTLEMENT_EXPIRES_AT_PAST/_TOO_SOON. Under --auto this is optional (derived from the delegation deadline; pass it only to override)."
   ).option(
     "--payee-amount <int>",
-    "Base-unit decimal-integer payee_amount \u2014 REQUIRED when the sig file's purpose is `ARP-SOLANA-PARTIAL-RELEASE-v1.5` (usage_based delegations). Same value passed to `--partial-payee-amount` on sign-settlement-release. FORBIDDEN for `ARP-SOLANA-RELEASE-v1.5` (full release settles the whole lock)."
+    "Base-unit decimal-integer payee_amount \u2014 REQUIRED on the MANUAL path when the sig file's purpose is `ARP-SOLANA-PARTIAL-RELEASE-v1.5` (usage_based delegations). Same value passed to `--partial-payee-amount` on sign-settlement-release. FORBIDDEN for `ARP-SOLANA-RELEASE-v1.5` (full release settles the whole lock). Under --auto the partial amount is bound from the receipt; pass it only as a confirmation that must match."
   ).option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server (= payee)").option("--ttl <seconds>", "Envelope TTL in seconds", "3600").option("--verbose", "Print the full envelope before sending and the full server response", false).action(async (recipientDid, opts, cmd) => {
     try {
       await runSendPayeeSig(recipientDid, opts);
@@ -4491,20 +4604,85 @@ function registerSendPayeeSig(parent) {
 }
 async function runSendPayeeSig(recipientDid, opts) {
   const cmdName = "receipt send-payee-sig";
+  if (opts.auto) {
+    if (opts.sigFromFile !== void 0 && opts.sigFromFile !== "") {
+      throw new Error(
+        `${cmdName}: --auto and --sig-from-file are mutually exclusive. --auto re-signs the release digest AUTHORITATIVELY (it resolves condition_hash + the on-chain lock itself); a --sig-from-file is the MANUAL path's pre-signed input. Pick one: --auto for recovery, or the manual --sig-from-file + --receipt-event-hash + --expires-at trio.`
+      );
+    }
+    if (opts.clusterTag === void 0 || opts.clusterTag === "") {
+      throw new Error(
+        `${cmdName}: --cluster-tag is required with --auto (0 = devnet, 1 = mainnet-beta). It binds the cluster into the signed release digest; there is no safe default \u2014 pass the cluster where the create_lock lives.`
+      );
+    }
+    if (opts.clusterTag !== "0" && opts.clusterTag !== "1") {
+      throw new Error(`${cmdName}: --cluster-tag must be '0' (devnet) or '1' (mainnet-beta), got '${opts.clusterTag}'`);
+    }
+    const delegationIdAuto = requireUuidNormalised2(cmdName, opts.delegationId, "--delegation-id");
+    if (recipientDid !== void 0 && recipientDid !== "") {
+      requireDid2(cmdName, recipientDid, "[recipient-did]");
+    }
+    const { autoSignAndDeliverPayeeSig: autoSignAndDeliverPayeeSig2 } = await Promise.resolve().then(() => (init_settlement(), settlement_exports));
+    await autoSignAndDeliverPayeeSig2(
+      {
+        server: opts.server,
+        fromDid: opts.fromDid,
+        delegationId: delegationIdAuto,
+        ...opts.relId !== void 0 ? { relId: opts.relId } : {},
+        clusterTag: opts.clusterTag,
+        ...opts.expiresAt !== void 0 ? { expiresAt: opts.expiresAt } : {},
+        ...opts.rpcUrl !== void 0 ? { rpcUrl: opts.rpcUrl } : {},
+        ...opts.programId !== void 0 ? { programId: opts.programId } : {},
+        ...opts.payeeAmount !== void 0 ? { partialPayeeAmount: opts.payeeAmount } : {},
+        ...opts.receiptEventHash !== void 0 ? { receiptEventHash: opts.receiptEventHash } : {},
+        // Recovery semantics: re-sign + re-deliver even if a (bad) sig
+        // already exists. The helper short-circuits a cosigned receipt.
+        force: true
+        // `send-payee-sig` has no --json flag (the manual path prints a
+        // plain human block); leave the helper in its human-output mode.
+        // Do NOT pass silent — the helper owns + prints the recovery output.
+      },
+      cmdName
+    );
+    return;
+  }
+  if (recipientDid === void 0 || recipientDid === "") {
+    throw new Error(
+      `${cmdName}: <recipient-did> (the buyer DID) is required on the manual path. Pass it, or use --auto --cluster-tag <0|1> to resolve the buyer + re-sign authoritatively.`
+    );
+  }
   requireDid2(cmdName, recipientDid, "<recipient-did>");
+  const recipient = recipientDid;
   const delegationId = requireUuidNormalised2(cmdName, opts.delegationId, "--delegation-id");
+  if (opts.sigFromFile === void 0 || opts.sigFromFile === "") {
+    throw new Error(
+      `${cmdName}: --sig-from-file is required (the MANUAL path's pre-signed input). For authoritative recovery without a sig file, use --auto --cluster-tag <0|1> instead.`
+    );
+  }
+  if (opts.receiptEventHash === void 0 || opts.receiptEventHash === "") {
+    throw new Error(
+      `${cmdName}: --receipt-event-hash is required on the manual path. For authoritative recovery without hand-typed hashes, use --auto --cluster-tag <0|1> instead.`
+    );
+  }
+  if (opts.expiresAt === void 0 || opts.expiresAt === "") {
+    throw new Error(
+      `${cmdName}: --expires-at is required on the manual path (must match the value signed). For authoritative recovery, use --auto --cluster-tag <0|1> instead.`
+    );
+  }
   requireSha256(cmdName, opts.receiptEventHash, "--receipt-event-hash");
+  const receiptEventHash = opts.receiptEventHash;
+  const sigFromFile = opts.sigFromFile;
   const expiresAtSeconds = parseInteger(cmdName, "--expires-at", opts.expiresAt);
   if (expiresAtSeconds <= 0) {
     throw new Error(`${cmdName}: --expires-at must be a positive unix-seconds integer (got ${opts.expiresAt})`);
   }
   const ttlSeconds = parseTtl2(cmdName, opts.ttl);
-  const sigFile = loadSettlementSigFromFile(opts.sigFromFile, "--sig-from-file");
+  const sigFile = loadSettlementSigFromFile(sigFromFile, "--sig-from-file");
   const isPartial = sigFile.purpose === "ARP-SOLANA-PARTIAL-RELEASE-v1.5";
   const isFull = sigFile.purpose === "ARP-SOLANA-RELEASE-v1.5";
   if (!isPartial && !isFull) {
     throw new Error(
-      `${cmdName}: sig file at '${opts.sigFromFile}' has purpose='${sigFile.purpose}' but only ARP-SOLANA-RELEASE-v1.5 and ARP-SOLANA-PARTIAL-RELEASE-v1.5 are valid on a settlement_signature envelope. (REFUND-v1 sigs ride other paths \u2014 they don't bind to receipt_event_hash, so this envelope isn't the right channel for them.)`
+      `${cmdName}: sig file at '${sigFromFile}' has purpose='${sigFile.purpose}' but only ARP-SOLANA-RELEASE-v1.5 and ARP-SOLANA-PARTIAL-RELEASE-v1.5 are valid on a settlement_signature envelope. (REFUND-v1 sigs ride other paths \u2014 they don't bind to receipt_event_hash, so this envelope isn't the right channel for them.)`
     );
   }
   if (isPartial && (opts.payeeAmount === void 0 || opts.payeeAmount === "")) {
@@ -4526,28 +4704,28 @@ async function runSendPayeeSig(recipientDid, opts) {
   const api = new ArpApiClient(opts.server);
   const content = {
     delegation_id: delegationId,
-    receipt_event_hash: opts.receiptEventHash,
+    receipt_event_hash: receiptEventHash,
     purpose: sigFile.purpose,
     payee_settlement_pubkey: sigFile.settlement_pubkey,
     sig: sigFile.sig,
     expires_at: expiresAtSeconds,
     ...isPartial ? { payee_amount: opts.payeeAmount } : {}
   };
-  console.log(import_chalk19.default.dim(`Server: ${api.serverUrl}`));
-  console.log(import_chalk19.default.dim(`Sender (payee): ${sender.did}`));
-  console.log(import_chalk19.default.dim(`Recipient (buyer): ${recipientDid}`));
-  console.log(import_chalk19.default.dim(`Delegation: ${delegationId}`));
-  console.log(import_chalk19.default.dim(`Receipt event hash: ${opts.receiptEventHash}`));
-  console.log(import_chalk19.default.dim(`Purpose: ${sigFile.purpose}`));
+  console.log(import_chalk18.default.dim(`Server: ${api.serverUrl}`));
+  console.log(import_chalk18.default.dim(`Sender (payee): ${sender.did}`));
+  console.log(import_chalk18.default.dim(`Recipient (buyer): ${recipient}`));
+  console.log(import_chalk18.default.dim(`Delegation: ${delegationId}`));
+  console.log(import_chalk18.default.dim(`Receipt event hash: ${receiptEventHash}`));
+  console.log(import_chalk18.default.dim(`Purpose: ${sigFile.purpose}`));
   if (isPartial) {
-    console.log(import_chalk19.default.dim(`Payee amount: ${opts.payeeAmount}`));
+    console.log(import_chalk18.default.dim(`Payee amount: ${opts.payeeAmount}`));
   }
-  console.log(import_chalk19.default.dim(`Settlement pubkey: ${sigFile.settlement_pubkey}`));
-  console.log(import_chalk19.default.dim(`Expires at: ${expiresAtSeconds}`));
+  console.log(import_chalk18.default.dim(`Settlement pubkey: ${sigFile.settlement_pubkey}`));
+  console.log(import_chalk18.default.dim(`Expires at: ${expiresAtSeconds}`));
   const result = await sendSettlementSignatureEnvelope({
     api,
     sender,
-    recipientDid,
+    recipientDid: recipient,
     content,
     ttlSeconds,
     verbose: opts.verbose,
@@ -4577,7 +4755,7 @@ async function sendSettlementSignatureEnvelope(args) {
     identitySecretKey: signer.identitySecretKey
   });
   if (args.verbose) {
-    console.log(import_chalk19.default.bold("\nEnvelope (pre-send):"));
+    console.log(import_chalk18.default.bold("\nEnvelope (pre-send):"));
     console.log(formatJson(envelope));
   }
   try {
@@ -4614,7 +4792,7 @@ async function sendReceiptEnvelope(args) {
     attachments: args.attachments
   });
   if (args.verbose) {
-    console.log(import_chalk19.default.bold("\nEnvelope (pre-send):"));
+    console.log(import_chalk18.default.bold("\nEnvelope (pre-send):"));
     console.log(formatJson(envelope));
   }
   try {
@@ -4673,12 +4851,12 @@ async function resolveCosignTargets(cmdName, api, signer, args) {
   };
 }
 function printIngestResult2(result) {
-  console.log(import_chalk19.default.green("\nDelivered."));
-  console.log(`${import_chalk19.default.bold("Event id")}: ${import_chalk19.default.cyan(result.eventId)}`);
-  console.log(`${import_chalk19.default.bold("Relationship id")}: ${import_chalk19.default.cyan(result.relationshipId)}`);
-  console.log(`${import_chalk19.default.bold("Chain index")}: ${import_chalk19.default.cyan(String(result.relationshipEventIndex))}`);
-  console.log(`${import_chalk19.default.bold("Server timestamp")}: ${import_chalk19.default.cyan(result.serverTimestamp)}`);
-  console.log(`${import_chalk19.default.bold("Server event hash")}: ${import_chalk19.default.cyan(result.serverEventHash)}`);
+  console.log(import_chalk18.default.green("\nDelivered."));
+  console.log(`${import_chalk18.default.bold("Event id")}: ${import_chalk18.default.cyan(result.eventId)}`);
+  console.log(`${import_chalk18.default.bold("Relationship id")}: ${import_chalk18.default.cyan(result.relationshipId)}`);
+  console.log(`${import_chalk18.default.bold("Chain index")}: ${import_chalk18.default.cyan(String(result.relationshipEventIndex))}`);
+  console.log(`${import_chalk18.default.bold("Server timestamp")}: ${import_chalk18.default.cyan(result.serverTimestamp)}`);
+  console.log(`${import_chalk18.default.bold("Server event hash")}: ${import_chalk18.default.cyan(result.serverEventHash)}`);
 }
 function parseVerdict(cmdName, raw) {
   if (raw === void 0 || raw === "") return "accepted";
@@ -4729,12 +4907,12 @@ function requireDid2(cmdName, did, label) {
     throw new Error(`${cmdName}: ${label} must look like 'did:arp:...' (got '${did}')`);
   }
 }
-var import_node_fs8, import_sdk11, import_chalk19, POST_COMMIT_ERROR_CODES2, VERDICT_VALUES, SHA256_RE;
+var import_node_fs7, import_sdk11, import_chalk18, POST_COMMIT_ERROR_CODES2, VERDICT_VALUES, SHA256_RE;
 var init_receipt = __esm({
   "src/commands/receipt.ts"() {
-    import_node_fs8 = require("fs");
+    import_node_fs7 = require("fs");
     import_sdk11 = require("@heyanon-arp/sdk");
-    import_chalk19 = __toESM(require("chalk"));
+    import_chalk18 = __toESM(require("chalk"));
     init_api();
     init_format();
     init_id_format();
@@ -4753,6 +4931,15 @@ var init_receipt = __esm({
       "RECEIPT_COSIGN_AGENT_MISMATCH",
       "RECEIPT_COSIGN_PURPOSE_INVALID",
       "RECEIPT_COSIGN_INVALID",
+      // M6 lock-at-accept: the receipt-propose handler's LOCKED gate emits
+      // `DELEGATION_PENDING_LOCK` (409) when the delegation is funded but
+      // the on-chain lock isn't confirmed yet (state
+      // `pending_lock_finalization`). It fires from the body handler AFTER
+      // the event row is committed — same lifecycle as
+      // `RECEIPT_DELEGATION_NOT_ACTIVE` — so the CLI must advance
+      // `lastSenderSequence`, otherwise a retry once the lock confirms
+      // reuses the consumed sequence and trips `ENV_SEQUENCE_BACKWARDS`.
+      "DELEGATION_PENDING_LOCK",
       // response_hash / request_hash / deliverable_hash content
       // verification. Server commits the receipt envelope row BEFORE
       // running the canonical-hash lookup, so a rejection here still
@@ -4842,7 +5029,7 @@ var import_simple_update_notifier = __toESM(require("simple-update-notifier"));
 // package.json
 var package_default = {
   name: "@heyanon-arp/cli",
-  version: "0.0.7",
+  version: "0.0.9",
   description: "Command-line client for the Agent Relationship Protocol \u2014 register agents, sign envelopes, run escrowed work cycles on Solana.",
   license: "MIT",
   keywords: ["arp", "agent-relationship-protocol", "did", "solana", "escrow", "ed25519", "agents", "a2a", "cli"],
@@ -4852,7 +5039,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  files: ["dist", "examples", "scripts/postinstall.mjs", "LICENSE", "README.md"],
+  files: ["dist", "scripts/postinstall.mjs", "LICENSE", "README.md"],
   engines: {
     node: ">=22"
   },
@@ -5077,9 +5264,9 @@ init_api();
 init_format();
 init_state();
 init_lifecycle();
-var ALLOWED_STATES = /* @__PURE__ */ new Set(["proposed", "accepted", "declined", "canceled"]);
+var ALLOWED_STATES = /* @__PURE__ */ new Set(["offered", "accepted", "declined", "canceled"]);
 function registerDelegationsCommand(root) {
-  root.command("delegations").description("List delegations for a relationship (one row per delegationId, oldest-first)").argument("<relationship-id>", "Relationship UUID").option("--server <url>", "Override ARP server base URL").option("--state <s>", "Filter by exact state (proposed|accepted|declined|canceled)").option("--after <id>", "Cursor: pass the previous page's last `id` to fetch the next page").option("--limit <n>", "Max rows to return (1..100)", "20").option("--from-did <did>", "Signer DID \u2014 required only if multiple agents are registered against this server").option(
+  root.command("delegations").description("List delegations for a relationship (one row per delegationId, oldest-first)").argument("<relationship-id>", "Relationship UUID").option("--server <url>", "Override ARP server base URL").option("--state <s>", "Filter by exact state (offered|accepted|declined|canceled)").option("--after <id>", "Cursor: pass the previous page's last `id` to fetch the next page").option("--limit <n>", "Max rows to return (1..100)", "20").option("--from-did <did>", "Signer DID \u2014 required only if multiple agents are registered against this server").option(
     "--verbose",
     'After the one-line summaries, print a framed "Full delegation payloads (N rows)" block \u2014 each row labelled with full delegationId (`delegation accept` / `delegation decline` / `work request` need it) and dumped as JSON. Mutually exclusive with --json.',
     false
@@ -5159,6 +5346,11 @@ function colorState(s) {
       return import_chalk7.default.yellow("pending_lock");
     case "accepted":
       return import_chalk7.default.green("accepted");
+    // M6 lock-at-accept: the on-chain escrow lock is confirmed.
+    // Distinct branch so a LOCKED row renders without hitting the
+    // defensive fallback (which would otherwise echo the raw state).
+    case "locked":
+      return import_chalk7.default.green("locked");
     case "declined":
       return import_chalk7.default.red("declined");
     case "canceled":
@@ -5193,7 +5385,7 @@ function truncate2(s, max) {
 function parseState(raw) {
   if (raw === void 0) return void 0;
   if (!ALLOWED_STATES.has(raw)) {
-    throw new Error(`delegations: --state must be one of proposed|accepted|declined|canceled (got '${raw}')`);
+    throw new Error(`delegations: --state must be one of offered|accepted|declined|canceled (got '${raw}')`);
   }
   return raw;
 }
@@ -5372,7 +5564,7 @@ function registerEscrowCommands(root) {
   });
   cmd.command("derive-condition-hash").description(
     "Compute canonical condition_hash (32-byte hex) for `heyarp wallet create-lock --condition-hash <hex>` from the DELEGATION terms. Projects the flags to the canonical subset and hashes via SDK deriveDelegationConditionHash \u2014 no server fetch. The SAME terms MUST go into `delegation offer` or the server rejects the lock (ESC_LOCK_CONDITION_HASH_MISMATCH)."
-  ).requiredOption("--delegation-id <id>", "Delegation UUID this lock binds (drives the on-chain lock_id + the condition_hash identity binding)").requiredOption("--scope <text>", "scope_summary \u2014 short prose describing the agreed work").requiredOption("--pricing-model <flat|usage_based>", "pricing_model (flat|usage_based)").requiredOption("--settlement-model <prepaid|escrow>", "settlement_model (prepaid|escrow)").option("--rate-amount <decimal>", 'rate_amount \u2014 decimal as string (e.g. "10.00"). Optional; binds the per-unit rate into the hash when present.').option("--rate-unit <task|thread|handoff>", "rate_unit (task|thread|handoff). Optional.").option(
+  ).requiredOption("--delegation-id <id>", "Delegation UUID this lock binds (drives the on-chain lock_id + the condition_hash identity binding)").requiredOption("--scope <text>", "scope_summary \u2014 short prose describing the agreed work").requiredOption("--pricing-model <flat|usage_based>", "pricing_model (flat|usage_based)").option(
     "--currency <s>",
     `Asset identifier bound into the hash: shorthand (${import_sdk7.WELL_KNOWN_ASSET_KEYS.join("|")}) OR raw CAIP-19 string. Optional but must match the offer's --currency.`
   ).option("--currency-decimals <n>", "Decimal places (0-18). Required only when --currency is raw CAIP-19.").option("--currency-symbol <s>", 'Optional UI hint ("USDC", "SOL"). Max 16 chars.').option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server").option("--json", "Machine-readable JSON: {delegation_id, condition_hash_hex, projected_subset}", false).action(async (opts) => {
@@ -5424,12 +5616,8 @@ function projectDelegationForHash(cmdName, opts, delegationId) {
   const out = {
     delegationId,
     scopeSummary: opts.scope,
-    pricingModel: parsePricingModel(cmdName, opts.pricingModel),
-    settlementModel: parseSettlementModel(cmdName, opts.settlementModel)
+    pricingModel: parsePricingModel(cmdName, opts.pricingModel)
   };
-  if (opts.rateAmount !== void 0 && opts.rateAmount !== "") out.rateAmount = opts.rateAmount;
-  const rateUnit = parseRateUnit(cmdName, opts.rateUnit);
-  if (rateUnit !== void 0) out.rateUnit = rateUnit;
   if (opts.currency !== void 0 && opts.currency !== "") {
     const currency = buildAssetIdentifier(cmdName, DELEGATION_CURRENCY_FLAGS, opts.currency, opts.currencyDecimals, opts.currencySymbol);
     out.currency = currency;
@@ -5463,9 +5651,6 @@ async function runDeriveConditionHash(opts) {
   console.log(import_chalk10.default.dim("Subset hashed:"));
   console.log(import_chalk10.default.dim(`  scopeSummary:           ${subset.scopeSummary ?? "(unset)"}`));
   console.log(import_chalk10.default.dim(`  pricingModel:           ${subset.pricingModel ?? "(unset)"}`));
-  console.log(import_chalk10.default.dim(`  settlementModel:        ${subset.settlementModel ?? "(unset)"}`));
-  if (subset.rateAmount !== void 0) console.log(import_chalk10.default.dim(`  rateAmount:             ${subset.rateAmount}`));
-  if (subset.rateUnit !== void 0) console.log(import_chalk10.default.dim(`  rateUnit:               ${subset.rateUnit}`));
   if (subset.currency !== void 0) console.log(import_chalk10.default.dim(`  currency.asset_id:      ${subset.currency.asset_id}`));
   console.log("");
   console.log(`${import_chalk10.default.bold("condition_hash:")} ${hex}`);
@@ -5674,92 +5859,30 @@ function parseSince(raw) {
   return n;
 }
 
-// src/commands/examples.ts
-var import_node_fs5 = require("fs");
-var import_node_path4 = require("path");
-var import_chalk12 = __toESM(require("chalk"));
-init_format();
-var EXAMPLES = [
-  {
-    name: "worker",
-    filename: "worker-template.py",
-    description: "Autonomous Python worker (handshake \u2192 delegation \u2192 work \u2192 receipt \u2192 settlement, all auto-mediated; fill in handle_work_request)"
-  }
-];
-var EXAMPLES_DIR = (0, import_node_path4.resolve)(__dirname, "..", "examples");
-function registerExamplesCommand(root) {
-  const examples = root.command("examples").description("Bundled reference templates (worker, etc.) \u2014 discover, print, or copy to disk. Templates ship inside the npm tarball; no GitHub round-trip required.");
-  examples.command("list").description("List bundled examples. Pair with `heyarp examples show <name>` or `heyarp examples copy <name>`.").option("--json", "JSON output (jq-pipeable)", false).action((opts, cmd) => {
-    try {
-      if (opts.json) {
-        console.log(formatJson(EXAMPLES));
-        return;
-      }
-      console.log(import_chalk12.default.bold("Bundled examples:"));
-      for (const e of EXAMPLES) {
-        console.log(`  ${import_chalk12.default.cyan(e.name).padEnd(20)} ${import_chalk12.default.dim(e.filename)}`);
-        console.log(`    ${e.description}`);
-      }
-      console.log(import_chalk12.default.dim("\nShow contents:   heyarp examples show <name>"));
-      console.log(import_chalk12.default.dim("Save to disk:    heyarp examples copy <name> --output ./<filename>"));
-    } catch (err) {
-      emitActionError(err, cmd);
-      process.exitCode = 1;
-    }
-  });
-  examples.command("show").description("Print the example's contents to stdout. Pipe-friendly \u2014 `heyarp examples show worker > my-worker.py` is the lowest-friction install path.").argument("<name>", `Example name (one of: ${EXAMPLES.map((e) => e.name).join(", ")})`).action((name, _opts, cmd) => {
-    try {
-      const entry = lookupOrThrow(name);
-      const contents = readExampleOrThrow(entry);
-      process.stdout.write(contents);
-    } catch (err) {
-      emitActionError(err, cmd);
-      process.exitCode = 1;
-    }
-  });
-  examples.command("copy").description("Copy the example to a path on disk. Creates parent directories as needed; refuses to overwrite an existing file unless `--force` is passed.").argument("<name>", `Example name (one of: ${EXAMPLES.map((e) => e.name).join(", ")})`).option("--output <path>", "Destination file path. Defaults to the bundled filename in the current working directory.").option("--force", "Overwrite the destination file if it already exists.", false).action((name, opts, cmd) => {
-    try {
-      const entry = lookupOrThrow(name);
-      const contents = readExampleOrThrow(entry);
-      const destPath = (0, import_node_path4.resolve)(process.cwd(), opts.output ?? entry.filename);
-      if ((0, import_node_fs5.existsSync)(destPath) && !opts.force) {
-        throw new Error(`refusing to overwrite ${destPath} (pass --force to override)`);
-      }
-      const parentDir = (0, import_node_path4.dirname)(destPath);
-      if (!(0, import_node_fs5.existsSync)(parentDir)) {
-        (0, import_node_fs5.mkdirSync)(parentDir, { recursive: true });
-      }
-      (0, import_node_fs5.writeFileSync)(destPath, contents);
-      console.log(`${import_chalk12.default.green("Wrote")} ${import_chalk12.default.cyan(destPath)} ${import_chalk12.default.dim(`(${contents.length} bytes)`)}`);
-    } catch (err) {
-      emitActionError(err, cmd);
-      process.exitCode = 1;
-    }
-  });
-}
-function lookupOrThrow(name) {
-  const entry = EXAMPLES.find((e) => e.name === name);
-  if (!entry) {
-    throw new Error(`unknown example '${name}'. Available: ${EXAMPLES.map((e) => e.name).join(", ")} (use \`heyarp examples list\` for descriptions)`);
-  }
-  return entry;
-}
-function readExampleOrThrow(entry) {
-  const filePath = (0, import_node_path4.join)(EXAMPLES_DIR, entry.filename);
-  if (!(0, import_node_fs5.existsSync)(filePath)) {
-    throw new Error(
-      `example '${entry.name}' is registered but the bundled file is missing at ${filePath} \u2014 your install may be incomplete. Try reinstalling: npm i -g @heyanon-arp/cli`
-    );
-  }
-  return (0, import_node_fs5.readFileSync)(filePath, "utf8");
-}
-
 // src/commands/guide.ts
-var import_chalk13 = __toESM(require("chalk"));
+var import_chalk12 = __toESM(require("chalk"));
 
 // src/guide/source.ts
 var GUIDE_TITLE = "HeyARP CLI \u2014 agent guide";
 var GUIDE_SECTIONS = [
+  {
+    id: "overview.which-role",
+    roles: ["worker", "buyer"],
+    title: "Which role am I? (decided per DEAL by the delegation offer, not your identity)",
+    body: [
+      "   The DELEGATION OFFER sets the roles \u2014 separately for each deal. The handshake",
+      '   is just "let us talk" and is role-neutral. The SAME agent is a BUYER in one',
+      "   deal and a WORKER in another; never assume a fixed role.",
+      "",
+      "     YOU send the delegation offer (you set the terms + pay)",
+      "        \u2192 BUYER  (aka offerer / payer)     heyarp guide --role buyer",
+      "     A delegation offer ARRIVES for you (you do the work, get paid)",
+      "        \u2192 WORKER (aka payee)               heyarp guide --role worker",
+      "",
+      "   Unsure on a live deal? `heyarp status <rel-id> --json` \u2192 if your DID matches",
+      "   .latestDelegation.offererDid you are BUYER, else WORKER (or follow .nextActionHint)."
+    ]
+  },
   {
     id: "worker.flow",
     roles: ["worker"],
@@ -5770,7 +5893,9 @@ var GUIDE_SECTIONS = [
       "",
       "     handshake          [recv] \u2192 send handshake_response (accept)",
       "     delegation.offer   [recv] \u2192 send delegation accept     \u2192 ACCEPTED",
-      "       (the offer carries the agreed terms inline + a funded create_lock)",
+      "       (the offer carries the agreed terms inline \u2014 NO lock yet)",
+      "     delegation.fund    [recv] \u2192 BUYER funds the escrow lock \u2192 wait for LOCKED",
+      "       (do not start work until the lock is confirmed on chain)",
       "     work_request       [recv] \u2192 send work respond (output | error)",
       "     (work finished)           \u2192 send receipt propose (verdict + body hashes)",
       "       \u2192 for an ESCROW delegation this SAME command also signs + delivers",
@@ -5781,12 +5906,16 @@ var GUIDE_SECTIONS = [
       { when: "a `handshake` arrives", then: "reply `heyarp send-handshake-response <buyer-did> --decision accept` (or `--decision decline --reason <code>`)" },
       {
         when: "a `delegation.offer` arrives",
-        then: "review the inline terms (scope / pricing / amount); accept ONLY if it carries a deadline you can meet: `heyarp delegation accept <rel-id> <del-id>`"
+        then: "review the inline terms (scope / pricing / amount); accept ONLY if it carries a deadline you can meet: `heyarp delegation accept <rel-id> <del-id>`. The offer carries NO lock yet \u2014 the buyer funds it after you accept."
+      },
+      {
+        when: "you have accepted",
+        then: "wait for the buyer to fund + the on-chain lock to confirm (delegation reaches LOCKED) before starting work: `heyarp status <rel-id> --wait --until delegation.locked`. Do NOT begin work on an unfunded delegation."
       },
       { when: "a `work_request` arrives", then: "do the task, then `heyarp work respond <rel-id> <del-id> <req-id> --output '<json>'`" },
       {
         when: "your `work respond` is sent",
-        then: "propose the receipt AND (for escrow) deliver your settlement signature in ONE command: `heyarp receipt propose <buyer-did> <del-id> --auto-hashes --rel-id <rel-id> --request-id <req-id> --verdict accepted --cluster-tag <0|1>`. For an escrow delegation --cluster-tag is REQUIRED and propose signs + delivers the payee settlement signature itself right after committing the receipt (with an RPC endpoint configured it reads the on-chain lock and resolves mint / amount / expiry / fee; otherwise native SOL, no fee). Prepaid delegations need no --cluster-tag and no settlement step. If propose reports the receipt was proposed but the settlement sig was NOT delivered (no RPC / lock not yet visible), recover with `heyarp receipt send-payee-sig <buyer-did> --delegation-id <del-id> --receipt-event-hash <hash> --sig-from-file <path> --expires-at <unix>` or re-run propose once the lock is reachable."
+        then: "propose the receipt AND deliver your settlement signature in ONE command: `heyarp receipt propose <buyer-did> <del-id> --auto-hashes --rel-id <rel-id> --request-id <req-id> --verdict accepted --cluster-tag <0|1>`. Every delegation is escrow-backed, so --cluster-tag is REQUIRED and propose signs + delivers the payee settlement signature itself right after committing the receipt (with an RPC endpoint configured it reads the on-chain lock and resolves mint / amount / expiry / fee; otherwise native SOL, no fee). If propose reports the receipt was proposed but the settlement sig was NOT delivered (e.g. the just-confirmed lock was not yet RPC-visible), recover AUTHORITATIVELY with `heyarp receipt send-payee-sig <buyer-did> --delegation-id <del-id> --auto --cluster-tag <0|1>` \u2014 it resolves condition_hash + the on-chain lock snapshot itself, so you hand-type NO hashes and supply NO sig file. Do NOT re-run `receipt propose` (the receipt already exists; a second propose is rejected as a duplicate)."
       },
       { when: "the buyer cosigns (cycle released)", then: "you are paid \u2014 the cycle is done; wait for the next offer" }
     ],
@@ -5796,9 +5925,48 @@ var GUIDE_SECTIONS = [
       "Do NOT build the escrow lock \u2014 the BUYER funds create_lock; for an escrow delegation `receipt propose --cluster-tag <0|1>` signs + delivers your settlement signature against it automatically.",
       "Do NOT omit --cluster-tag on an escrow `receipt propose` \u2014 it binds the cluster into the signed release digest and has no safe default (a wrong cluster fails at the buyer cosign); the command fails fast before committing the receipt."
     ],
-    crossRefs: [
-      "Skip manual control: the bundled Python reference worker auto-mediates the whole worker side \u2014 `heyarp examples show worker`. A policy-driven worker daemon is planned."
-    ]
+    crossRefs: ["Skip manual control: a policy-driven worker daemon that auto-mediates the whole worker side is planned."]
+  },
+  {
+    id: "worker.operating-modes",
+    roles: ["worker"],
+    title: "Running a worker: long-lived loop OR cron-poll the inbox",
+    body: [
+      "   ARP is asynchronous \u2014 offers + work_requests ARRIVE whenever the buyer",
+      "   acts. Pick whichever loop your runtime can actually sustain:",
+      "",
+      "   A) LONG-LIVED (a process that can hold a thread \u2014 e.g. a daemon):",
+      "      block on the next state:",
+      "        heyarp status <rel-id> --wait --until <state>   (exit 124 on timeout)",
+      "      or `heyarp inbox --tail` (SSE), or the SDK `pollUntil` helper. Lowest",
+      "      latency \u2014 but needs a process that stays alive.",
+      "",
+      "   B) CRON / STATELESS (cannot hold a thread \u2014 most ordinary agents):",
+      "      schedule `heyarp inbox` on an interval and REACT to what it returns \u2014",
+      "      no long-lived wait needed. Each tick is a fresh, short run:",
+      "        1. heyarp inbox --json --since <last-ts> --since-event-id <last-evt>",
+      "           (persist the newest {ts, eventId} as the cursor between ticks)",
+      "        2. for each NEW envelope, act per the worker FSM (handshake\u2192respond,",
+      "           delegation.offer\u2192accept, work_request\u2192respond, \u2026)",
+      '        3. nothing new \u2192 exit silently (never spam "still waiting")',
+      "      Simplest path for ordinary agents: poll \u2192 react \u2192 exit. Pick an",
+      "      interval your task tolerates (e.g. 1\u20132 min).",
+      "",
+      "      Example \u2014 run inline each tick (no script file). TS/EVT = your saved",
+      "      cursor (last serverTimestamp + eventId); persist them however you like:",
+      '        NEW=$(heyarp inbox --json ${TS:+--since "$TS" --since-event-id "$EVT"})',
+      '        [ "$(jq length <<<"$NEW")" -gt 0 ] || exit 0    # nothing new \u2192 stay silent',
+      '        jq -c ".[]" <<<"$NEW" | while read -r ev; do',
+      '          : # act on $(jq -r .body.type <<<"$ev"): handshake\u2192respond, delegation.offer\u2192accept, work_request\u2192respond',
+      "        done",
+      "        # new cursor = newest (last) row; persist these two for next tick:",
+      '        echo "$(jq -r ".[-1].serverTimestamp" <<<"$NEW") $(jq -r ".[-1].eventId" <<<"$NEW")"'
+    ],
+    commonErrors: [
+      'Do NOT promise "I will check later" then drop it \u2014 either hold a --wait loop (mode A) or schedule the inbox cron (mode B). A worker that never polls never gets paid.',
+      "Cron mode: ALWAYS advance the cursor (--since / --since-event-id) between ticks, or you reprocess the same event forever."
+    ],
+    crossRefs: ['Long-lived pattern details: see "Live tail vs polling \u2014 the FSM-wait pattern".']
   },
   {
     id: "buyer.flow",
@@ -5810,30 +5978,40 @@ var GUIDE_SECTIONS = [
       "",
       "     send handshake             \u2192 worker replies handshake_response",
       "     send delegation offer      \u2192 worker accepts              \u2192 ACCEPTED",
-      "       (the offer carries the agreed terms inline + a funded create_lock blob)",
+      "       (the offer carries the agreed terms inline \u2014 NO lock yet)",
+      "     send delegation fund       \u2192 worker waits for LOCKED, then works",
+      "       (fund the escrow lock AFTER the worker accepts)",
       "     send work request          \u2192 worker responds (output | error)",
-      "     worker proposes receipt [recv] \u2192 send receipt cosign     \u2192 COSIGNED \u2713 released"
+      "     worker proposes receipt [recv] \u2192 send receipt cosign     \u2192 COSIGNED \u2713 released",
+      "       (REVIEW the deliverable + get your user OK FIRST \u2014 cosign RELEASES the",
+      '        escrow and is irreversible; to refuse, do NOT cosign \u2014 see "Saying no")'
     ],
     transitions: [
       { when: "you need a task done", then: "find a worker `heyarp agents --tag <tag>`, then open contact `heyarp send-handshake <worker-did>`" },
       {
         when: "the worker accepts the handshake",
-        then: "derive the condition_hash `heyarp escrow derive-condition-hash --delegation-id <new-uuid> --scope \u2026 --pricing-model flat --settlement-model escrow --currency USDC:solana-devnet`, then fund escrow `heyarp wallet create-lock --delegation-id <same-uuid> --condition-hash <hex> ...`"
+        then: "offer the work (terms only, NO lock) `heyarp delegation offer <worker-did> --delegation-id <new-uuid> --title \u2026 --scope \u2026 --pricing-model flat --amount \u2026 --currency USDC:solana-devnet --deadline \u2026` then wait `--wait-until delegation.accepted`"
       },
       {
-        when: "escrow is funded",
-        then: "offer `heyarp delegation offer <worker-did> --delegation-id <same-uuid> --title \u2026 --scope \u2026 --pricing-model flat --settlement-model escrow --amount \u2026 --currency USDC:solana-devnet --escrow-lock-from-file <path>` (the inline terms MUST match the ones you hashed)"
+        when: "the worker accepts the delegation",
+        then: "NOW fund the escrow. Derive the condition_hash over the SAME terms you offered `heyarp escrow derive-condition-hash --delegation-id <same-uuid> --scope \u2026 --pricing-model flat --currency USDC:solana-devnet`, build the lock `heyarp wallet create-lock --delegation-id <same-uuid> --recipient-pubkey <worker-settlement-pubkey> --mint-pubkey <usdc-mint> --amount-base-units <n> --condition-hash <hex> --expiry-secs <unix> > lock.json` (recipient-pubkey = the worker\u2019s `#settlement` key from `heyarp did-doc <worker-did>`; for native SOL use `--amount-lamports <n>` instead of `--mint-pubkey/--amount-base-units`), then fund `heyarp delegation fund <same-uuid> --escrow-lock-from-file lock.json`"
+      },
+      {
+        when: "the lock is confirmed on chain (delegation reaches LOCKED)",
+        then: "send the task `heyarp work request <worker-did> <del-id> --params '<json>'`"
       },
-      { when: "the worker accepts the delegation", then: "send the task `heyarp work request <worker-did> <del-id> --params '<json>'`" },
       {
         when: "the worker proposes a receipt",
-        then: "cosign to release escrow `heyarp receipt cosign <rel-id> <del-id> --auto-hashes --auto-resolve-payee-sig --payer-sig-from-file <path>`"
+        then: "REVIEW the deliverable first (read the work_response / `heyarp work-list <rel-id> --full-ids`) and get the user OK \u2014 cosign RELEASES the escrow and is irreversible. THEN produce YOUR payer half of the 2-of-2 release: `heyarp wallet sign-settlement-release --delegation-id <del-id> --write-to payer-sig.json \u2026` (run `heyarp receipts <rel-id> --full-ids` for the receipt-event-hash, and `heyarp wallet sign-settlement-release --help` for the full digest flags \u2014 payer/payee settlement pubkeys, mint, lock-amount, condition-hash, deliverable-hash, expires-at, cluster-tag), THEN cosign to release escrow `heyarp receipt cosign <rel-id> <del-id> --auto-hashes --auto-resolve-payee-sig --payer-sig-from-file payer-sig.json`"
       }
     ],
     commonErrors: [
+      "Do NOT try to fund a lock on an empty wallet \u2014 the DEPOSIT (the lock amount) comes from YOUR settlement wallet (`heyarp whoami --local` \u2192 settlementPublicKeyB58); the relayer pays the on-chain tx fee, you only provide the deposit. Top it up first, or `wallet create-lock` fails.",
+      'The DEPOSIT equals the lock amount and LEAVES your wallet at `delegation fund`; you get it back ONLY via release (to the worker, when you cosign) or an expiry refund (to you, if the lock expires unspent). V1 has no "cancel lock" before expiry \u2014 never lock funds you are not ready to commit.',
+      "NEVER lock more than the agreed amount \u2014 confirm it with your user before `wallet create-lock`; the lock is the real on-chain money movement.",
       "Do NOT propose the receipt \u2014 the worker proposes; you COSIGN to release escrow.",
-      "Do NOT send delegation offer without a funded create_lock \u2014 the worker won't accept unfunded work.",
-      "Do NOT let the offer terms drift from the condition_hash \u2014 hash the SAME scope/pricing/settlement/rate/currency you put in the offer, or the lock is rejected (ESC_LOCK_CONDITION_HASH_MISMATCH).",
+      "Do NOT fund (`delegation fund`) before the worker has ACCEPTED \u2014 the server rejects a fund against a non-accepted delegation. Offer first, wait for accept, THEN fund.",
+      "Do NOT let the offer terms drift from the condition_hash \u2014 at fund time hash the SAME scope/pricing/currency you put in the offer, or the lock is rejected (ESC_LOCK_CONDITION_HASH_MISMATCH).",
       "Do NOT treat a catalog `active` row as ONLINE \u2014 probe liveness with `heyarp doctor <did>`."
     ],
     crossRefs: ["A one-shot buyer facade (`heyarp quick-job`) is planned. For now, drive the cycle with the per-transition commands below."]
@@ -5856,21 +6034,24 @@ var GUIDE_SECTIONS = [
     id: "overview.work-cycle",
     roles: ["worker", "buyer"],
     overview: true,
-    title: "The full work cycle (5 stages, in order)",
+    title: "The full work cycle (in order)",
     body: [
       "   Buyer (caller) and Worker (payee) take turns:",
       "",
       `     handshake               buyer  \u2192 worker     "let's talk"`,
       "     handshake_response      worker \u2192 buyer      accept | decline",
-      "     delegation offer        buyer  \u2192 worker     terms inline (scope, rate, amount) + funded lock",
+      "     delegation offer        buyer  \u2192 worker     terms inline (scope, pricing, amount), NO lock",
       "     delegation accept       worker \u2192 buyer      \u2192 state=accepted",
+      "     delegation fund         buyer  \u2192 worker     attaches the escrow lock \u2192 state=LOCKED",
       "     work request            buyer  \u2192 worker     params payload",
       "     work respond            worker \u2192 buyer      output OR error",
       "     receipt propose         worker \u2192 buyer      verdict + body hashes",
       "     receipt cosign          buyer  \u2192 worker     \u2192 state=cosigned \u2713 DONE",
       "",
       "   (There is no separate terms-agreement step \u2014 the delegation offer",
-      "   carries the agreed terms inline and the condition_hash binds them.)",
+      "   carries the agreed terms inline and the condition_hash binds them.",
+      "   M6 lock-at-accept: the escrow lock is funded AFTER acceptance via",
+      "   `delegation fund`, so an un-accepted offer never strands funds.)",
       "   Skipping any stage = the next stage rejects with a state-machine error.",
       "   `receipt cosign` is the closure \u2014 without it the work isn't paid for."
     ]
@@ -5881,13 +6062,16 @@ var GUIDE_SECTIONS = [
     overview: true,
     title: "Escrow (how funds actually move)",
     body: [
-      "   `delegation offer` attaches a signed Solana `create_lock` tx blob \u2014 the",
-      "   buyer FUNDS escrow up-front before the worker accepts. The worker ",
-      "   commits work knowing the cash is already locked.",
+      "   M6 lock-at-accept: the buyer funds escrow AFTER the worker accepts.",
+      "   `delegation offer` carries terms only (no lock). Once the worker",
+      "   accepts, `delegation fund` attaches the signed Solana `create_lock`",
+      "   tx blob; the worker waits for the lock to confirm (LOCKED) before",
+      "   starting work, knowing the cash is locked. An un-accepted offer has",
+      "   no lock to strand.",
       "   `receipt cosign` carries SETTLEMENT SIGNATURES (Ed25519 over a canonical",
       "   digest) from BOTH parties \u2014 these unlock `release_lock` on-chain.",
       "   Refund paths:",
-      "     \u2022 PayerCancellation  \u2014 buyer cancels within 10min of offer (1 sig)",
+      "     \u2022 PayerCancellation  \u2014 buyer cancels within 10min of the lock (1 sig)",
       "     \u2022 BothPartiesAgreed  \u2014 bilateral cooperative refund (2 sigs)",
       "     \u2022 Expired            \u2014 permissionless after lock.expiry passes (no sigs)",
       "     \u2022 DisputeResolution  \u2014 admin split via multisig (V1 backend-only)"
@@ -5901,8 +6085,9 @@ var GUIDE_SECTIONS = [
       "   `heyarp wallet create-lock --delegation-id <id> --condition-hash <hex>`",
       "   builds + signs a `create_lock` Solana tx. Output JSON: {signed_tx_blob,",
       "   lock_id (32-byte hex), amount, asset_id, expiry, delegation_id,",
-      "   program_id}. Pipe via `delegation offer",
-      "   --escrow-lock-from-file <path>` \u2014 delegation_id auto-aligns. Use",
+      "   program_id}. Run it AFTER the worker accepts, then fund via",
+      "   `delegation fund <delegation-id> --escrow-lock-from-file <path>` \u2014",
+      "   the file delegation_id is cross-checked against the argument. Use",
       "   `--expiry-secs $(($(date +%s) + 86400*3))` (\u22653d) \u2014 server enforces",
       "   lock.expiry \u2265 deadline + DISPUTE_BUFFER (1d).",
       "   Currency: native SOL by default (`--amount-lamports`). For an SPL",
@@ -5919,14 +6104,24 @@ var GUIDE_SECTIONS = [
       "   `config_pda` is the singleton program config; `event_authority_pda`",
       "   is the anchor `#[event_cpi]` self-CPI target.",
       "   `heyarp escrow derive-condition-hash --delegation-id <id> --scope \u2026",
-      "   --pricing-model flat --settlement-model escrow --currency USDC:solana-devnet`",
+      "   --pricing-model flat --currency USDC:solana-devnet`",
       "   computes the canonical condition_hash (over the delegation terms) for",
       "   `wallet create-lock --condition-hash`. Hash the SAME terms you put in",
       "   the `delegation offer` body or the lock is rejected.",
       "   `heyarp wallet sign-settlement-release` signs the release / partial",
       "   digest. Output `sig` is RAW base64 (NO `ed25519:` prefix). Pass",
       "   `--partial-payee-amount <lamports>` to switch the digest to",
-      "   `ARP-SOLANA-PARTIAL-RELEASE-v1.5`.",
+      "   `ARP-SOLANA-PARTIAL-RELEASE-v1.5`. WARNING: `--condition-hash` here is",
+      "   the SAME value `heyarp escrow derive-condition-hash` produces (the hash",
+      "   OVER THE TERMS) / the condition_hash on the on-chain lock \u2014 it is NOT",
+      "   the `lock_id` from `delegation.fund` attachments. lock_id",
+      '   (`sha256("arp-lock-v1"||delegation_id)`) and condition_hash',
+      "   (`sha256(terms)`) are DIFFERENT 32-byte values; the release digest binds",
+      "   condition_hash, so passing lock_id signs a digest the buyer cosign",
+      "   rejects (ESC_SETTLEMENT_SIG_INVALID). For the payee side, prefer",
+      "   `heyarp receipt send-payee-sig <buyer> --delegation-id <id> --auto`,",
+      "   which resolves condition_hash + the on-chain lock for you instead of",
+      "   hand-signing.",
       "   `heyarp receipt cosign` attaches both parties' signatures into",
       "   `attachments.settlement_signatures` via --settlement-purpose,",
       "   --settlement-expires-at, --payer-settlement-{pubkey,sig},",
@@ -6024,7 +6219,7 @@ var GUIDE_SECTIONS = [
     roles: ["buyer"],
     title: "Catalog vs live worker + autonomous worker latency",
     body: [
-      "   `heyarp agents` rows are LISTED (publicationStatus=active), not ONLINE.",
+      "   `heyarp agents` rows are LISTED (registered + discoverable), not ONLINE.",
       "   Probe with `heyarp doctor <did>` (LISTENING / DORMANT / UNKNOWN).",
       "   Autonomous LLM workers respond in 30s\u20138min typically; treat silence",
       '   > 15min as "try someone else". Parse inbox events as JSON:',
@@ -6042,6 +6237,90 @@ var GUIDE_SECTIONS = [
       "   status line for cycle-done \u2014 NOT the relationship row alone."
     ]
   },
+  {
+    id: "reference.terminal-states",
+    roles: ["worker", "buyer"],
+    title: "Am I done, dead, blocked, or up next? (drive off status --json)",
+    body: [
+      "   `heyarp status <rel-id> --json` tells you whose turn it is and whether the",
+      "   cycle ended. The fields that matter:",
+      '     .nextActionOwner  "me" = act now | "counterparty" = wait | "either" | "none"',
+      "     .nextActionHint   the exact next move, in words",
+      "     .cycleComplete    true once the cycle has settled (released)",
+      "     .latestDelegation.state   the PER-DEAL state (read THIS, not the relationship)",
+      "",
+      '   MY TURN \u2192 .nextActionOwner == "me"  \u2192 do .nextActionHint, then re-check.',
+      '   WAITING \u2192 .nextActionOwner == "counterparty"  \u2192 status --wait --until <phase>;',
+      "             silence past your timeout = counterparty unresponsive, move on.",
+      '   DONE    \u2192 .cycleComplete == true OR latestDelegation.state == "completed".',
+      '             The relationship STAYS "active" for the next deal \u2014 do not loop on it.',
+      "   DEAD    \u2192 latestDelegation.state in {declined, canceled, failed, refunded,",
+      "             dispute_resolved}: deal off / funds settled. Do NOT retry \u2014 make a",
+      "             fresh offer if you still want the work."
+    ]
+  },
+  {
+    id: "reference.json-reads",
+    roles: ["worker", "buyer"],
+    title: "Reading state as JSON (never scrape the human table)",
+    body: [
+      "   Always add `--json` and read the DOCUMENTED field \u2014 the pretty table is for",
+      "   humans and its columns will shift. Wire keys \u2260 table labels:",
+      "     turn / next move : status <rel> --json \u2192 .nextActionOwner, .nextActionHint",
+      "     relationship     : status <rel> --json \u2192 .relationshipState (NOT .state)",
+      "     delegation       : status <rel> --json \u2192 .latestDelegation.state",
+      "                        (or delegations <rel> --json \u2192 .[].state)",
+      "     receipt          : receipts <rel> --json \u2192 .[].state / .verdictFinal / .receiptEventHash",
+      "     incoming events  : inbox --json \u2192 .[].body.type / .eventId / .serverTimestamp /",
+      "                        .senderDid (NOT .signer)",
+      "     worker pay key   : did-doc <worker-did> --json \u2192 the #settlement",
+      "                        verificationMethod (NOT agents --json)"
+    ]
+  },
+  {
+    id: "reference.operating-rules",
+    roles: ["worker", "buyer"],
+    title: "Operating rules for autonomous agents",
+    body: ["   Four habits that prevent almost every mechanical failure:"],
+    commonErrors: [
+      "NEVER invent a flag, state, or value \u2014 run `<command> --help`; flag and state names are exact and the CLI rejects guesses.",
+      "NEVER scrape the human table \u2014 pass `--json` and read the documented fields (see the JSON read-map above).",
+      "NEVER truncate, edit, or re-case an ID or hash \u2014 copy it verbatim (use `--full-ids` for untruncated values); IDs are opaque tokens.",
+      "NEVER fire the next envelope optimistically \u2014 do ONE action, then WAIT for the state to advance (`status --wait --until <phase>`) before sending the next.",
+      "On a retry that returns a *_INVALID_STATE error, do NOT blindly resend \u2014 it usually means the action ALREADY landed; re-read `status --json` first to confirm the new state."
+    ]
+  },
+  {
+    id: "reference.saying-no",
+    roles: ["worker", "buyer"],
+    title: "Saying no (decline an offer / refuse to pay)",
+    body: [
+      "   WORKER \u2014 refuse an OFFER before doing any work:",
+      "     heyarp delegation decline <rel-id> <del-id> --reason <code>   (--help lists codes)",
+      "     You are not obligated to accept; declining ends that delegation cleanly.",
+      "   BUYER \u2014 unhappy with the DELIVERABLE:",
+      "     Do NOT cosign. Cosign = release/pay \u2014 it is NOT conditional on a verdict, and",
+      '     V1 has no "cosign-to-reject" and no --verdict flag. If you never cosign, the lock',
+      "     stays and AUTO-REFUNDS to you when it expires. (Disputes / partial settlement",
+      "     are post-V1.)",
+      "   BUYER \u2014 withdraw your OWN offer before the worker accepts:",
+      "     heyarp delegation cancel <rel-id> <del-id>   (offerer-only; OFFERED state only)"
+    ]
+  },
+  {
+    id: "setup.quickstart",
+    roles: ["setup"],
+    title: "Quickstart \u2014 install to first action",
+    body: [
+      "   1. heyarp register          create your DID + Ed25519 keys",
+      "   2. heyarp whoami            confirm your DID is set",
+      "   3. role for THIS deal: you SEND the offer \u2192 buyer; an offer ARRIVES \u2192 worker",
+      "   4. BUYER only \u2014 fund your settlement wallet: `whoami --local` \u2192",
+      "      settlementPublicKeyB58, send SOL/USDC there (the deposit comes from it)",
+      "   5. feed your role into your agent: heyarp guide --role <worker|buyer> --format prompt",
+      "   6. then act on ONE event at a time; after each: status --wait --until <phase>"
+    ]
+  },
   {
     id: "troubleshoot.stuck",
     roles: ["troubleshoot"],
@@ -6050,6 +6329,22 @@ var GUIDE_SECTIONS = [
       "   Every command supports `--help` \u2014 read structured `code` + `message`",
       "   error fields, they name the exact state-machine constraint violated.",
       "   `heyarp doctor <did>` probes a peer agent's endpoint (LISTED vs LIVE).",
+      "   Common blockers \u2192 fix:",
+      "   \u2022 `wallet create-lock` fails / insufficient balance \u2192 fund your settlement",
+      "     wallet (buyer side); `heyarp whoami --local` shows settlementPublicKeyB58.",
+      "   \u2022 `ATA does not exist` \u2192 use native SOL, or make sure the recipient token",
+      "     account for that mint exists.",
+      "   \u2022 handshake stuck `pending` / delegation stuck `offered` \u2192 the COUNTERPARTY",
+      "     has not acted; block on it with `heyarp status <rel-id> --wait --until <state>`.",
+      "   \u2022 `ESC_SETTLEMENT_SIG_INVALID` at `receipt cosign` \u2192 the payee signed the",
+      "     WRONG release digest \u2014 usually `--condition-hash` was set to the `lock_id`",
+      "     from a `delegation.fund` attachment (lock_id \u2260 condition_hash; the digest",
+      "     binds condition_hash). The payee re-delivers a correct sig with `heyarp",
+      "     receipt send-payee-sig <buyer> --delegation-id <id> --auto --cluster-tag",
+      "     <0|1>`, which resolves condition_hash from the on-chain lock (no manual",
+      "     hashes). Do NOT re-run `receipt propose` (the receipt already exists).",
+      '   \u2022 "wrong move for my role" \u2192 you mixed up buyer vs worker; role is',
+      '     PER-RELATIONSHIP \u2014 re-check with `heyarp guide` ("Which role am I?").',
       "   More: README at https://www.npmjs.com/package/@heyanon-arp/cli"
     ]
   }
@@ -6103,7 +6398,7 @@ function renderCommand(c) {
          ${c.description}`;
 }
 function renderSection(s) {
-  const lines = [import_chalk13.default.bold(s.title)];
+  const lines = [import_chalk12.default.bold(s.title)];
   if (s.body && s.body.length > 0) lines.push(...s.body);
   if (s.nextActions && s.nextActions.length > 0) {
     lines.push("   Commands:");
@@ -6122,29 +6417,29 @@ function modeHeader(mode) {
   switch (mode.kind) {
     case "overview":
       return [
-        "Pick your path:",
-        "   \u2022 Worker (you do tasks, get paid):   heyarp guide --role worker",
-        "   \u2022 Buyer  (you delegate tasks, pay):   heyarp guide --role buyer",
+        "Pick your path  (role is PER-DEAL \u2014 the same agent can be both):",
+        "   \u2022 WORKER \u2014 an OFFER comes to you; you do tasks, get paid:  heyarp guide --role worker",
+        "   \u2022 BUYER  \u2014 YOU send the OFFER; you set terms + pay:        heyarp guide --role buyer",
         "   \u2022 Setup / keys / multi-agent:         heyarp guide --setup",
         "   \u2022 Common errors \u2192 fixes:              heyarp guide --troubleshoot",
         ""
       ];
     case "role":
-      return [import_chalk13.default.dim(`(${mode.role} guide \u2014 your slice only; run \`heyarp guide\` for the overview)`), ""];
+      return [import_chalk12.default.dim(`(${mode.role} guide \u2014 your slice only; run \`heyarp guide\` for the overview)`), ""];
     case "setup":
-      return [import_chalk13.default.dim("(setup \u2014 role-agnostic; run `heyarp guide` for the overview)"), ""];
+      return [import_chalk12.default.dim("(setup \u2014 role-agnostic; run `heyarp guide` for the overview)"), ""];
     case "troubleshoot":
-      return [import_chalk13.default.dim("(troubleshooting \u2014 role-agnostic)"), ""];
+      return [import_chalk12.default.dim("(troubleshooting \u2014 role-agnostic)"), ""];
   }
 }
 function modeFooter(mode) {
   if (mode.kind === "overview") {
-    return ["", import_chalk13.default.dim("Full reference per role: `heyarp guide --role worker|buyer`. Docs: https://www.npmjs.com/package/@heyanon-arp/cli")];
+    return ["", import_chalk12.default.dim("Full reference per role: `heyarp guide --role worker|buyer`. Docs: https://www.npmjs.com/package/@heyanon-arp/cli")];
   }
   return [];
 }
 function renderGuide(mode = { kind: "overview" }) {
-  const blocks = [import_chalk13.default.bold(GUIDE_TITLE), "", ...modeHeader(mode)];
+  const blocks = [import_chalk12.default.bold(GUIDE_TITLE), "", ...modeHeader(mode)];
   for (const s of selectSections(mode)) {
     blocks.push(renderSection(s), "");
   }
@@ -6192,22 +6487,22 @@ function renderPrompt(mode, opts = { concise: false }) {
 }
 
 // src/commands/homes.ts
-var import_node_fs7 = require("fs");
-var import_node_path6 = require("path");
-var import_chalk14 = __toESM(require("chalk"));
+var import_node_fs6 = require("fs");
+var import_node_path5 = require("path");
+var import_chalk13 = __toESM(require("chalk"));
 var import_prompts = __toESM(require("prompts"));
 
 // src/homes.ts
-var import_node_fs6 = require("fs");
-var import_node_path5 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path4 = require("path");
 init_paths();
 var REGISTRY_WARNING = "DO NOT COMMIT \u2014 paths to home dirs may be sensitive (e.g. encrypted-volume mounts).";
 function readRegistry() {
   const path = homesRegistryPath();
-  if (!(0, import_node_fs6.existsSync)(path)) return { homes: [] };
+  if (!(0, import_node_fs5.existsSync)(path)) return { homes: [] };
   let raw;
   try {
-    raw = (0, import_node_fs6.readFileSync)(path, "utf8");
+    raw = (0, import_node_fs5.readFileSync)(path, "utf8");
   } catch (err) {
     throw new Error(`Failed to read homes registry at ${path}: ${err.message}`);
   }
@@ -6228,12 +6523,12 @@ function readRegistry() {
 }
 function writeRegistry(file) {
   const path = homesRegistryPath();
-  const dir = (0, import_node_path5.dirname)(path);
-  if (!(0, import_node_fs6.existsSync)(dir)) (0, import_node_fs6.mkdirSync)(dir, { recursive: true, mode: 448 });
+  const dir = (0, import_node_path4.dirname)(path);
+  if (!(0, import_node_fs5.existsSync)(dir)) (0, import_node_fs5.mkdirSync)(dir, { recursive: true, mode: 448 });
   const body = JSON.stringify({ _warning: REGISTRY_WARNING, homes: file.homes }, null, 2);
-  (0, import_node_fs6.writeFileSync)(path, body, { encoding: "utf8", mode: 384 });
+  (0, import_node_fs5.writeFileSync)(path, body, { encoding: "utf8", mode: 384 });
   try {
-    (0, import_node_fs6.chmodSync)(path, 384);
+    (0, import_node_fs5.chmodSync)(path, 384);
   } catch {
   }
 }
@@ -6261,7 +6556,7 @@ function forgetHome(homePath) {
   return true;
 }
 function homeStillExists(homePath) {
-  return (0, import_node_fs6.existsSync)(`${homePath}/agents.json`);
+  return (0, import_node_fs5.existsSync)(`${homePath}/agents.json`);
 }
 
 // src/commands/homes.ts
@@ -6288,27 +6583,27 @@ function runHomes(opts) {
     return;
   }
   if (rows.length === 0) {
-    console.log(import_chalk14.default.dim("(no HEYARP_HOME directories registered yet \u2014 run `heyarp register` once and the registry populates itself)"));
-    console.log(import_chalk14.default.dim(`   registry path: ${homesRegistryPath()}`));
+    console.log(import_chalk13.default.dim("(no HEYARP_HOME directories registered yet \u2014 run `heyarp register` once and the registry populates itself)"));
+    console.log(import_chalk13.default.dim(`   registry path: ${homesRegistryPath()}`));
     return;
   }
   const header = ["Path", "Agents", "Last seen", "Status"];
   const data = rows.map((r) => [
-    r.path + (r.isCurrent ? import_chalk14.default.green(" (current)") : ""),
+    r.path + (r.isCurrent ? import_chalk13.default.green(" (current)") : ""),
     String(r.agentCount),
     formatRelativeTime(r.lastSeenAt),
-    r.exists ? import_chalk14.default.green("ok") : import_chalk14.default.red("missing")
+    r.exists ? import_chalk13.default.green("ok") : import_chalk13.default.red("missing")
   ]);
   console.log("");
   console.log(formatTable(header, data));
-  console.log(import_chalk14.default.dim(`
+  console.log(import_chalk13.default.dim(`
 Registry path: ${homesRegistryPath()}`));
-  console.log(import_chalk14.default.dim(`Set HEYARP_HOME=<path> in a shell to switch between homes; run \`heyarp homes forget <path>\` to drop a stale entry.`));
+  console.log(import_chalk13.default.dim(`Set HEYARP_HOME=<path> in a shell to switch between homes; run \`heyarp homes forget <path>\` to drop a stale entry.`));
 }
 async function runForget(path, opts) {
   if (!opts.yes) {
-    console.log(import_chalk14.default.yellow(`About to remove '${path}' from the homes registry.`));
-    console.log(import_chalk14.default.dim("   Note: this only forgets the registry entry; the directory + its agents.json are NOT touched."));
+    console.log(import_chalk13.default.yellow(`About to remove '${path}' from the homes registry.`));
+    console.log(import_chalk13.default.dim("   Note: this only forgets the registry entry; the directory + its agents.json are NOT touched."));
     const answer = await (0, import_prompts.default)(
       {
         type: "confirm",
@@ -6318,28 +6613,28 @@ async function runForget(path, opts) {
       },
       {
         onCancel: () => {
-          console.log(import_chalk14.default.yellow("Aborted."));
+          console.log(import_chalk13.default.yellow("Aborted."));
           process.exit(130);
         }
       }
     );
     if (!answer.confirm) {
-      console.log(import_chalk14.default.dim("Aborted (no changes)."));
+      console.log(import_chalk13.default.dim("Aborted (no changes)."));
       return;
     }
   }
   const removed = forgetHome(path);
   if (removed) {
-    console.log(import_chalk14.default.green(`\u2713 forgot ${path}`));
+    console.log(import_chalk13.default.green(`\u2713 forgot ${path}`));
   } else {
-    console.log(import_chalk14.default.dim(`(no entry for ${path} in the registry \u2014 already absent)`));
+    console.log(import_chalk13.default.dim(`(no entry for ${path} in the registry \u2014 already absent)`));
   }
 }
 function countAgents(homePath) {
-  const file = (0, import_node_path6.join)(homePath, "agents.json");
-  if (!(0, import_node_fs7.existsSync)(file)) return 0;
+  const file = (0, import_node_path5.join)(homePath, "agents.json");
+  if (!(0, import_node_fs6.existsSync)(file)) return 0;
   try {
-    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(file, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(file, "utf8"));
     if (!parsed || typeof parsed !== "object" || !parsed.servers) return 0;
     let total = 0;
     for (const server of Object.values(parsed.servers)) {
@@ -6357,13 +6652,13 @@ function formatTable(header, data) {
     const padding = " ".repeat(Math.max(0, widths[i] - lengths[i]));
     return cell + padding;
   }).join("  ");
-  const headerLine = import_chalk14.default.bold(
+  const headerLine = import_chalk13.default.bold(
     pad(
       header,
       header.map((s) => s.length)
     )
   );
-  const sepLine = import_chalk14.default.dim(
+  const sepLine = import_chalk13.default.dim(
     pad(
       widths.map((w) => "-".repeat(w)),
       widths
@@ -6390,7 +6685,7 @@ function formatRelativeTime(iso) {
 }
 
 // src/commands/inbox.ts
-var import_chalk15 = __toESM(require("chalk"));
+var import_chalk14 = __toESM(require("chalk"));
 init_api();
 init_format();
 init_state();
@@ -6440,8 +6735,8 @@ async function runInbox(positionalDid, opts) {
   }
   const api = new ArpApiClient(opts.server);
   if (!opts.json) {
-    console.log(import_chalk15.default.dim(`Server: ${api.serverUrl}`));
-    console.log(import_chalk15.default.dim(`Signer: ${local.did}`));
+    console.log(import_chalk14.default.dim(`Server: ${api.serverUrl}`));
+    console.log(import_chalk14.default.dim(`Signer: ${local.did}`));
   }
   const query = { limit };
   if (opts.before) query.before = opts.before;
@@ -6455,7 +6750,7 @@ async function runInbox(positionalDid, opts) {
     return;
   }
   if (events.length === 0) {
-    console.log(import_chalk15.default.dim("\n(no events addressed to me \u2014 `heyarp events <relationship-id>` shows the chain-wide listing)"));
+    console.log(import_chalk14.default.dim("\n(no events addressed to me \u2014 `heyarp events <relationship-id>` shows the chain-wide listing)"));
     return;
   }
   console.log("");
@@ -6470,16 +6765,16 @@ async function runInbox(positionalDid, opts) {
       secondary: `eventId=${ev.eventId} serverEventHash=${ev.serverEventHash}`
     }));
   }
-  const addressedToMeHint = import_chalk15.default.dim(" (envelopes addressed to me \u2014 for the full chain see `heyarp events <relationship-id>`)");
+  const addressedToMeHint = import_chalk14.default.dim(" (envelopes addressed to me \u2014 for the full chain see `heyarp events <relationship-id>`)");
   if (opts.since && !opts.before) {
     console.log(
-      import_chalk15.default.dim(
+      import_chalk14.default.dim(
         `
 ${events.length} event(s) (oldest-first).${addressedToMeHint} Advance the forward cursor with --since <serverTimestamp> --since-event-id <eventId> using the LAST row above.`
       )
     );
   } else {
-    console.log(import_chalk15.default.dim(`
+    console.log(import_chalk14.default.dim(`
 ${events.length} event(s).${addressedToMeHint} Paginate with --before <serverTimestamp> --before-event-id <eventId> using the LAST row above.`));
   }
 }
@@ -6494,7 +6789,7 @@ async function runInboxTail(did, local, opts) {
     } else {
       warn(
         opts.json,
-        import_chalk15.default.yellow(
+        import_chalk14.default.yellow(
           "\u26A0 inbox --tail: stdout is piped but `process.stdout._handle.setBlocking` is unavailable in this Node runtime. Buffered writes may delay event delivery. Fall back to polling (`heyarp inbox --json`) if events stop arriving."
         )
       );
@@ -6504,9 +6799,9 @@ async function runInboxTail(did, local, opts) {
   if (opts.json) {
     console.log(formatTailStartedPing({ server: api.serverUrl, signer: local.did, stdoutBlockingApplied }));
   } else {
-    console.log(import_chalk15.default.dim(`Server: ${api.serverUrl}`));
-    console.log(import_chalk15.default.dim(`Signer: ${local.did}`));
-    console.log(import_chalk15.default.dim("Mode: --tail (live SSE, Ctrl-C to stop)"));
+    console.log(import_chalk14.default.dim(`Server: ${api.serverUrl}`));
+    console.log(import_chalk14.default.dim(`Signer: ${local.did}`));
+    console.log(import_chalk14.default.dim("Mode: --tail (live SSE, Ctrl-C to stop)"));
   }
   const controller = new AbortController();
   let userAborted = false;
@@ -6525,7 +6820,7 @@ async function runInboxTail(did, local, opts) {
       }
       if (event.type === "heartbeat") continue;
       if (event.type === "connected") {
-        console.log(import_chalk15.default.green("\u25CF stream open \u2014 listening for envelopes..."));
+        console.log(import_chalk14.default.green("\u25CF stream open \u2014 listening for envelopes..."));
         continue;
       }
       if (event.type === "envelope") {
@@ -6539,7 +6834,7 @@ async function runInboxTail(did, local, opts) {
         }
         continue;
       }
-      console.log(import_chalk15.default.dim(`(unknown event: ${event.type})`));
+      console.log(import_chalk14.default.dim(`(unknown event: ${event.type})`));
     }
     if (!userAborted) {
       throw new Error("inbox --tail: stream ended unexpectedly (server may have restarted, or change stream errored). Re-run to reconnect.");
@@ -6547,7 +6842,7 @@ async function runInboxTail(did, local, opts) {
   } catch (err) {
     const name = err.name;
     if (name === "AbortError" || userAborted) {
-      if (!opts.json) console.log(import_chalk15.default.dim("\nstream closed."));
+      if (!opts.json) console.log(import_chalk14.default.dim("\nstream closed."));
       return;
     }
     throw err;
@@ -6567,15 +6862,15 @@ function formatInboxTable(events, opts = {}) {
   ]);
   const widths = header.map((h, i) => Math.max(h.length, ...data.map((row) => row[i].length)));
   const pad = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join("  ");
-  const lines = [import_chalk15.default.bold(pad(header)), import_chalk15.default.dim(pad(widths.map((w) => "-".repeat(w)))), ...data.map((row) => pad(row))];
-  const detail = events.map((ev) => `  ${import_chalk15.default.dim("eventId:")} ${import_chalk15.default.cyan(ev.eventId)}  ${import_chalk15.default.dim("serverTimestamp:")} ${import_chalk15.default.cyan(ev.serverTimestamp)}`).join("\n");
+  const lines = [import_chalk14.default.bold(pad(header)), import_chalk14.default.dim(pad(widths.map((w) => "-".repeat(w)))), ...data.map((row) => pad(row))];
+  const detail = events.map((ev) => `  ${import_chalk14.default.dim("eventId:")} ${import_chalk14.default.cyan(ev.eventId)}  ${import_chalk14.default.dim("serverTimestamp:")} ${import_chalk14.default.cyan(ev.serverTimestamp)}`).join("\n");
   return `${lines.join("\n")}
 
-${import_chalk15.default.bold("Pagination cursors")} (last \u2192 first):
+${import_chalk14.default.bold("Pagination cursors")} (last \u2192 first):
 ${detail}`;
 }
 function hashHead2(hash) {
-  if (!hash) return import_chalk15.default.dim("(none)");
+  if (!hash) return import_chalk14.default.dim("(none)");
   if (hash.length <= 14) return hash;
   return `${hash.slice(0, 14)}...`;
 }
@@ -6590,35 +6885,35 @@ function parseLimit4(raw) {
 
 // src/commands/keys.ts
 var import_sdk8 = require("@heyanon-arp/sdk");
-var import_chalk16 = __toESM(require("chalk"));
+var import_chalk15 = __toESM(require("chalk"));
 function registerKeysCommand(root) {
   const keys = root.command("keys").description("Local key utilities");
   keys.command("gen").description("Generate a fresh identity + settlement keypair (no save by default)").option("--save", "Reserved for future scratch-key storage; currently a no-op with a notice", false).action((opts) => {
     const identity = (0, import_sdk8.generateKeyPair)();
     const settlement = (0, import_sdk8.generateKeyPair)();
     const out = [
-      import_chalk16.default.bold("Identity key (Ed25519)"),
-      `  public  (base58btc): ${import_chalk16.default.cyan((0, import_sdk8.base58btcEncode)(identity.publicKey))}`,
-      `  secret  (base64)   : ${import_chalk16.default.yellow(Buffer.from(identity.secretKey).toString("base64"))}`,
+      import_chalk15.default.bold("Identity key (Ed25519)"),
+      `  public  (base58btc): ${import_chalk15.default.cyan((0, import_sdk8.base58btcEncode)(identity.publicKey))}`,
+      `  secret  (base64)   : ${import_chalk15.default.yellow(Buffer.from(identity.secretKey).toString("base64"))}`,
       "",
-      import_chalk16.default.bold("Settlement key (Ed25519)"),
-      `  public  (base58btc): ${import_chalk16.default.cyan((0, import_sdk8.base58btcEncode)(settlement.publicKey))}`,
-      `  secret  (base64)   : ${import_chalk16.default.yellow(Buffer.from(settlement.secretKey).toString("base64"))}`,
+      import_chalk15.default.bold("Settlement key (Ed25519)"),
+      `  public  (base58btc): ${import_chalk15.default.cyan((0, import_sdk8.base58btcEncode)(settlement.publicKey))}`,
+      `  secret  (base64)   : ${import_chalk15.default.yellow(Buffer.from(settlement.secretKey).toString("base64"))}`,
       "",
-      import_chalk16.default.bold("Resulting DID"),
-      `  ${import_chalk16.default.cyan((0, import_sdk8.formatDid)(identity.publicKey))}`
+      import_chalk15.default.bold("Resulting DID"),
+      `  ${import_chalk15.default.cyan((0, import_sdk8.formatDid)(identity.publicKey))}`
     ];
     console.log(out.join("\n"));
     if (opts.save) {
-      console.log(import_chalk16.default.yellow("\nNote: --save is not yet implemented. Capture the secret keys above before they scroll off-screen."));
+      console.log(import_chalk15.default.yellow("\nNote: --save is not yet implemented. Capture the secret keys above before they scroll off-screen."));
     }
   });
   keys.command("whoami").description("Print the DID derived from a base64-encoded identity secret key").argument("<secret-key-b64>", "32-byte Ed25519 seed, base64").action((secretKeyB64) => {
     const seed = decodeSeed(secretKeyB64);
     const pub = (0, import_sdk8.getPublicKey)(seed);
     const did = (0, import_sdk8.formatDid)(pub);
-    console.log(`${import_chalk16.default.bold("DID")}: ${import_chalk16.default.cyan(did)}`);
-    console.log(`${import_chalk16.default.bold("Identity public key (base58btc)")}: ${import_chalk16.default.cyan((0, import_sdk8.base58btcEncode)(pub))}`);
+    console.log(`${import_chalk15.default.bold("DID")}: ${import_chalk15.default.cyan(did)}`);
+    console.log(`${import_chalk15.default.bold("Identity public key (base58btc)")}: ${import_chalk15.default.cyan((0, import_sdk8.base58btcEncode)(pub))}`);
   });
 }
 function decodeSeed(b64) {
@@ -6638,14 +6933,14 @@ function decodeSeed(b64) {
 init_lifecycle();
 
 // src/commands/list.ts
-var import_chalk17 = __toESM(require("chalk"));
+var import_chalk16 = __toESM(require("chalk"));
 init_format();
 init_state();
 function registerListCommand(root) {
   root.command("list").description("List agents registered locally (~/.arp/agents.json)").action(() => {
     const rows = listAgents();
     if (rows.length === 0) {
-      console.log(import_chalk17.default.dim(`No local agents. State file: ${stateFilePath()}`));
+      console.log(import_chalk16.default.dim(`No local agents. State file: ${stateFilePath()}`));
       return;
     }
     const grouped = /* @__PURE__ */ new Map();
@@ -6657,7 +6952,7 @@ function registerListCommand(root) {
     for (const [serverUrl, group] of grouped) {
       if (!first) console.log("");
       first = false;
-      console.log(import_chalk17.default.bold(`Server: ${serverUrl}`));
+      console.log(import_chalk16.default.bold(`Server: ${serverUrl}`));
       console.log(formatAgentsTable(group.map(({ agent }) => ({ did: agent.did, name: agent.name, tags: agent.tags, registeredAt: agent.registeredAt }))));
     }
   });
@@ -6667,7 +6962,7 @@ function registerListCommand(root) {
 init_receipt();
 
 // src/commands/receipts.ts
-var import_chalk20 = __toESM(require("chalk"));
+var import_chalk19 = __toESM(require("chalk"));
 init_api();
 init_format();
 init_state();
@@ -6699,9 +6994,9 @@ async function runReceipts(relationshipId, opts) {
   const api = new ArpApiClient(opts.server);
   const sender = resolveSenderAgent("receipts", opts.server, opts.fromDid);
   if (!opts.json) {
-    console.log(import_chalk20.default.dim(`Server: ${api.serverUrl}`));
-    console.log(import_chalk20.default.dim(`Signer: ${sender.did}`));
-    console.log(import_chalk20.default.dim(`Relationship: ${relationshipId}`));
+    console.log(import_chalk19.default.dim(`Server: ${api.serverUrl}`));
+    console.log(import_chalk19.default.dim(`Signer: ${sender.did}`));
+    console.log(import_chalk19.default.dim(`Relationship: ${relationshipId}`));
   }
   const query = { limit };
   if (state) query.state = state;
@@ -6714,7 +7009,7 @@ async function runReceipts(relationshipId, opts) {
     return;
   }
   if (rows.length === 0) {
-    console.log(import_chalk20.default.dim("\n(no receipts for this relationship)"));
+    console.log(import_chalk19.default.dim("\n(no receipts for this relationship)"));
     return;
   }
   console.log("");
@@ -6732,28 +7027,28 @@ async function runReceipts(relationshipId, opts) {
     }));
   }
   const lastId = rows[rows.length - 1].id;
-  console.log(import_chalk20.default.dim(`
+  console.log(import_chalk19.default.dim(`
 ${rows.length} receipt row(s). Paginate with --after ${lastId}.`));
 }
 function formatReceiptLine(r, selfDid, opts = {}) {
   const delegationPart = opts.fullIds ? r.delegationId : idHead2(r.delegationId);
   const requestHashPart = opts.fullIds ? r.requestHash : hashHead3(r.requestHash);
-  const id = import_chalk20.default.bold(`${delegationPart}/${requestHashPart}`);
+  const id = import_chalk19.default.bold(`${delegationPart}/${requestHashPart}`);
   const state = colorState2(r.state).padEnd(stateColumnWidth2());
   const callerHead = opts.fullIds ? r.callerDid : didHead3(r.callerDid);
   const payeeHead = opts.fullIds ? r.payeeDid : didHead3(r.payeeDid);
-  const direction = r.payeeDid === selfDid ? `${import_chalk20.default.bold("me")}(payee) \u2192 ${import_chalk20.default.dim(callerHead)}` : `${import_chalk20.default.dim(payeeHead)}(payee) \u2192 ${import_chalk20.default.bold("me")}`;
+  const direction = r.payeeDid === selfDid ? `${import_chalk19.default.bold("me")}(payee) \u2192 ${import_chalk19.default.dim(callerHead)}` : `${import_chalk19.default.dim(payeeHead)}(payee) \u2192 ${import_chalk19.default.bold("me")}`;
   const verdict = formatVerdict(r);
   const responseTail = opts.fullIds ? `
-  ${import_chalk20.default.dim("responseHash:")} ${import_chalk20.default.cyan(r.responseHash)}` : "";
+  ${import_chalk19.default.dim("responseHash:")} ${import_chalk19.default.cyan(r.responseHash)}` : "";
   return `${id}  ${state}  ${direction}  ${verdict}${responseTail}`;
 }
 function colorState2(s) {
   switch (s) {
     case "proposed":
-      return import_chalk20.default.yellow("proposed");
+      return import_chalk19.default.yellow("proposed");
     case "cosigned":
-      return import_chalk20.default.green("cosigned");
+      return import_chalk19.default.green("cosigned");
   }
 }
 function stateColumnWidth2() {
@@ -6763,11 +7058,11 @@ function formatVerdict(r) {
   const final = r.verdictFinal ?? r.verdictProposed;
   switch (final) {
     case "accepted":
-      return import_chalk20.default.green("accepted");
+      return import_chalk19.default.green("accepted");
     case "accepted_with_notes":
-      return import_chalk20.default.yellow("accepted_with_notes");
+      return import_chalk19.default.yellow("accepted_with_notes");
     case "rejected":
-      return import_chalk20.default.red("rejected");
+      return import_chalk19.default.red("rejected");
   }
 }
 function idHead2(id) {
@@ -6800,9 +7095,9 @@ function parseLimit5(raw) {
 
 // src/commands/register.ts
 var import_node_crypto = require("crypto");
-var import_node_fs9 = require("fs");
+var import_node_fs8 = require("fs");
 var import_sdk12 = require("@heyanon-arp/sdk");
-var import_chalk21 = __toESM(require("chalk"));
+var import_chalk20 = __toESM(require("chalk"));
 var import_prompts2 = __toESM(require("prompts"));
 init_api();
 init_format();
@@ -6835,22 +7130,15 @@ function registerRegisterCommand(root) {
     "--yes",
     "Strict non-interactive: fail if any required field is still missing after merging flags. With --yes, --password must be supplied explicitly (>= 8 chars).",
     false
-  ).option(
-    "--publication <state>",
-    "Post-register publication mode. 'active' (default) auto-publishes the agent into the discovery catalog so other agents can find it immediately via `heyarp agents`. 'draft' keeps it out of the catalog \u2014 curate the profile first, then run `heyarp publish <did>` manually.",
-    "active"
   ).option(
     "--json",
     // Emit a single JSON object instead of human-friendly
     // success prints. Output shape:
     // {did, settlementPublicKeyB58, identityPublicKeyB58,
-    //  keyMode, publication, didDocument}
+    //  localStatePath, didDocument}
     // (V1-alpha: `accountId` parked from the output.)
     // REQUIRES --yes (interactive prompts would corrupt the
-    // single-doc contract). The auto-publish branch reports
-    // its outcome under `.publication` ('published', 'draft',
-    // or 'failed:<reason>') instead of emitting human-readable
-    // lines.
+    // single-doc contract).
     "Machine-readable mode \u2014 emit `{did, settlementPublicKeyB58, \u2026, didDocument}` JSON instead of human prints. REQUIRES --yes (interactive prompts would corrupt the single-doc JSON output).",
     false
   ).action(async (opts) => {
@@ -6860,21 +7148,24 @@ function registerRegisterCommand(root) {
 function accumulate3(value, previous) {
   return [...previous, value];
 }
-async function runRegister(opts) {
-  const publication = parsePublicationMode(opts.publication ?? "active");
+var defaultRegisterDeps = {
+  makeApi: (serverOverride) => new ArpApiClient(serverOverride),
+  save: saveAgent
+};
+async function runRegister(opts, deps = defaultRegisterDeps) {
   assertJsonRequiresYes(opts);
-  const api = new ArpApiClient(opts.server);
-  if (!opts.json) console.log(import_chalk21.default.dim(`Server: ${api.serverUrl}`));
+  const api = deps.makeApi(opts.server);
+  if (!opts.json) console.log(import_chalk20.default.dim(`Server: ${api.serverUrl}`));
   if (!opts.json) {
     warnIfAgentsAlreadyRegistered(opts.server);
     warnIfOrphanHomesPresent();
   }
   const keys = opts.fromKeys ? loadKeysFromFile(opts.fromKeys) : freshKeys();
   const did = (0, import_sdk12.formatDid)(keys.identityPublicKey);
-  if (!opts.json) console.log(import_chalk21.default.dim(`DID will be: ${did}`));
+  if (!opts.json) console.log(import_chalk20.default.dim(`DID will be: ${did}`));
   const answers = await mergeAnswers(opts);
   const scryptSalt = (0, import_node_crypto.randomBytes)(16);
-  if (!opts.json) console.log(import_chalk21.default.dim("Deriving scrypt key, this may take a moment..."));
+  if (!opts.json) console.log(import_chalk20.default.dim("Deriving scrypt key, this may take a moment..."));
   const scryptKey = (0, import_sdk12.deriveScryptKey)(answers.password, new Uint8Array(scryptSalt));
   const challenge = await api.issueChallenge("register");
   const challengeBytes = base64UrlNoPadDecode(challenge.challengeB64);
@@ -6890,14 +7181,11 @@ async function runRegister(opts) {
   });
   const settlementPublicKeyB58 = (0, import_sdk12.base58btcEncode)(keys.settlementPublicKey);
   const scryptSaltId = (0, import_sdk12.uuidV4)();
-  const ownerId = (0, import_sdk12.uuidV4)();
   const payload = {
     purpose: "ARP-KEY-LINK-v1",
     agent_did: did,
     identity_public_key: identityPublicKeyB58,
     settlement_public_key: settlementPublicKeyB58,
-    key_mode: "separated_soft",
-    owner_id: ownerId,
     owner_signing_method: "scrypt_password_proof",
     link_method: "manual",
     created_at: (0, import_sdk12.rfc3339)(),
@@ -6910,7 +7198,6 @@ async function runRegister(opts) {
     // accountId: answers.accountId,
     identityPublicKey: identityPublicKeyB58,
     settlementPublicKey: settlementPublicKeyB58,
-    keyMode: "separated_soft",
     ownerAttestation: {
       payload: attestation.payload,
       sig: attestation.sig,
@@ -6922,9 +7209,8 @@ async function runRegister(opts) {
     description: answers.description ? answers.description : void 0,
     tags: answers.tags.length > 0 ? answers.tags : void 0
   };
-  const result = await api.register(body);
-  saveAgent(opts.server, {
-    did: result.did,
+  const durableState = {
+    did,
     identityPublicKeyB58,
     identitySecretKeyB64: Buffer.from(keys.identitySecretKey).toString("base64"),
     settlementPublicKeyB58,
@@ -6932,60 +7218,45 @@ async function runRegister(opts) {
     scryptKeyB64: Buffer.from(scryptKey).toString("base64"),
     scryptSaltB64: Buffer.from(scryptSalt).toString("base64"),
     scryptSaltId,
-    ownerId,
-    // `metadata.owner_attestation_id` is the canonical name in the
-    // DID document — same value as server's `currentAttestationId`
-    // at the moment of registration.
-    currentAttestationId: result.didDocument.metadata.owner_attestation_id,
+    // Placeholder until the server confirms registration and returns
+    // the canonical attestation id (finalized in Step 8 below).
+    currentAttestationId: "",
     // V1-alpha: accountId parked — local state file no longer
     // records the field. Existing state files written when the
     // field was required will still carry the value; readers
     // tolerate either shape.
     // accountId: answers.accountId,
-    keyMode: "separated_soft",
     name: answers.name,
     description: answers.description || void 0,
     tags: answers.tags.length > 0 ? answers.tags : void 0,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  deps.save(opts.server, durableState);
+  const result = await api.register(body);
+  if (result.did !== did) {
+    throw new Error(
+      `register: server returned DID ${result.did} but the locally-derived DID is ${did}. These must be identical (both base58btc of the identity public key). Refusing to finalize \u2014 the secret keys are already saved locally under ${did}.`
+    );
+  }
+  deps.save(opts.server, {
+    ...durableState,
+    currentAttestationId: result.didDocument.metadata.owner_attestation_id
   });
   try {
     recordHome(arpHomeDir());
   } catch (registryErr) {
-    if (!opts.json) console.log(import_chalk21.default.dim(`(homes registry write failed: ${registryErr.message})`));
+    if (!opts.json) console.log(import_chalk20.default.dim(`(homes registry write failed: ${registryErr.message})`));
   }
   if (!opts.json) {
-    console.log(import_chalk21.default.green("\nRegistered."));
-    console.log(`${import_chalk21.default.bold("DID")}: ${import_chalk21.default.cyan(result.did)}`);
-    console.log(`${import_chalk21.default.bold("Settlement pubkey")} ${import_chalk21.default.dim("(fund with SOL)")}: ${import_chalk21.default.cyan(settlementPublicKeyB58)}`);
-    console.log(import_chalk21.default.bold("DID document:"));
+    console.log(import_chalk20.default.green("\nRegistered."));
+    console.log(`${import_chalk20.default.bold("DID")}: ${import_chalk20.default.cyan(result.did)}`);
+    console.log(`${import_chalk20.default.bold("Settlement pubkey")} ${import_chalk20.default.dim("(fund with SOL)")}: ${import_chalk20.default.cyan(settlementPublicKeyB58)}`);
+    console.log(import_chalk20.default.bold("DID document:"));
     console.log(formatJson(result.didDocument));
   }
-  const decision = decideAutoPublish({ publication });
-  let publicationOutcome;
-  if (decision === "try") {
-    try {
-      const signer = makeSignerFromSecret(keys.identitySecretKey, result.did);
-      await api.publishAgent(result.did, signer);
-      publicationOutcome = "published";
-      if (!opts.json) console.log(import_chalk21.default.green(`
-\u2713 Published \u2014 discoverable now via \`heyarp agents\`.`));
-    } catch (err) {
-      publicationOutcome = `failed: ${err.message}`;
-      if (!opts.json)
-        console.log(
-          import_chalk21.default.yellow(`
-\u26A0 Auto-publish failed (${err.message}). Agent saved as DRAFT \u2014 run \`heyarp publish ${result.did}\` to make it discoverable.`)
-        );
-    }
-  } else {
-    publicationOutcome = "draft";
-    if (!opts.json) {
-      console.log(import_chalk21.default.dim(`
-Publication mode: DRAFT. Agent is registered but NOT discoverable via \`heyarp agents\`.`));
-      console.log(import_chalk21.default.dim(`Run \`heyarp publish ${result.did}\` when ready to appear in the catalog.`));
-    }
-  }
-  if (!opts.json) console.log(import_chalk21.default.dim(`
+  if (!opts.json) console.log(import_chalk20.default.green(`
+\u2713 Discoverable now via \`heyarp agents\`.`));
+  if (!opts.json) console.log(import_chalk20.default.dim(`
 Local state saved to ${arpHomeDir()}/agents.json (mode 0600).`));
   if (opts.json) {
     console.log(
@@ -6997,8 +7268,6 @@ Local state saved to ${arpHomeDir()}/agents.json (mode 0600).`));
           // V1-alpha: accountId parked — `--json` output no longer
           // includes it. Uncomment when launchpad↔ARP join lands.
           // accountId: answers.accountId,
-          keyMode: "separated_soft",
-          publication: publicationOutcome,
           localStatePath: `${arpHomeDir()}/agents.json`,
           didDocument: result.didDocument
         },
@@ -7065,7 +7334,7 @@ async function mergeAnswers(opts) {
   }
   const prompted = promptDefs.length > 0 ? await (0, import_prompts2.default)(promptDefs, {
     onCancel: () => {
-      console.log(import_chalk21.default.yellow("\nAborted."));
+      console.log(import_chalk20.default.yellow("\nAborted."));
       process.exit(130);
     }
   }) : {};
@@ -7087,16 +7356,16 @@ function warnIfOrphanHomesPresent() {
   try {
     others = listHomes().filter((h) => h.path !== current);
   } catch (registryErr) {
-    console.log(import_chalk21.default.dim(`(homes registry unreadable, skipping orphan-home check: ${registryErr.message})`));
+    console.log(import_chalk20.default.dim(`(homes registry unreadable, skipping orphan-home check: ${registryErr.message})`));
     return;
   }
   if (others.length === 0) return;
-  const list = others.map((h) => `   \u2022 ${import_chalk21.default.cyan(h.path)} ${import_chalk21.default.dim(`(last seen ${h.lastSeenAt})`)}`).join("\n");
-  console.log(import_chalk21.default.yellow(`
+  const list = others.map((h) => `   \u2022 ${import_chalk20.default.cyan(h.path)} ${import_chalk20.default.dim(`(last seen ${h.lastSeenAt})`)}`).join("\n");
+  console.log(import_chalk20.default.yellow(`
 \u26A0  HEYARP_HOME is unset, but other agent homes are registered on this machine:`));
   console.log(list);
   console.log(
-    import_chalk21.default.dim(
+    import_chalk20.default.dim(
       `   Registering will create a NEW agent under ${current}.
    If you meant to add to an existing home, abort (Ctrl-C) and re-run with:
      HEYARP_HOME=<path> heyarp register \u2026
@@ -7109,11 +7378,11 @@ function warnIfAgentsAlreadyRegistered(serverOverride) {
   const targetServer = resolveServerUrl(serverOverride);
   const existing = listAgents().filter((row) => row.serverUrl === targetServer);
   if (existing.length === 0) return;
-  const list = existing.map((row) => `   \u2022 ${import_chalk21.default.cyan(row.agent.did)}${row.agent.name ? import_chalk21.default.dim(` (${row.agent.name})`) : ""}`).join("\n");
-  console.log(import_chalk21.default.yellow("\n\u26A0  ~/.arp/agents.json already has agent(s) for this server:"));
+  const list = existing.map((row) => `   \u2022 ${import_chalk20.default.cyan(row.agent.did)}${row.agent.name ? import_chalk20.default.dim(` (${row.agent.name})`) : ""}`).join("\n");
+  console.log(import_chalk20.default.yellow("\n\u26A0  ~/.arp/agents.json already has agent(s) for this server:"));
   console.log(list);
   console.log(
-    import_chalk21.default.dim(
+    import_chalk20.default.dim(
       "   After this register completes, you will have multiple local DIDs sharing one state file.\n   To keep their state isolated, run with HEYARP_HOME pointing at a per-agent dir, e.g.\n     HEYARP_HOME=/tmp/agent-alice heyarp register \u2026\n   Otherwise, pass --from-did <did> explicitly on every signed command.\n"
     )
   );
@@ -7133,12 +7402,12 @@ function freshKeys() {
   };
 }
 function loadKeysFromFile(path) {
-  if (!(0, import_node_fs9.existsSync)(path)) {
+  if (!(0, import_node_fs8.existsSync)(path)) {
     throw new Error(`--from-keys: file not found at ${path}`);
   }
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs9.readFileSync)(path, "utf8"));
+    parsed = JSON.parse((0, import_node_fs8.readFileSync)(path, "utf8"));
   } catch (err) {
     throw new Error(`--from-keys: ${path} is not valid JSON: ${err.message}`);
   }
@@ -7166,20 +7435,9 @@ function assertJsonRequiresYes(opts) {
     throw new Error("register --json REQUIRES --yes (interactive prompts would corrupt the single-doc JSON output)");
   }
 }
-function parsePublicationMode(raw) {
-  if (raw === "active" || raw === "draft") return raw;
-  throw new Error(`register: --publication must be 'active' or 'draft' (got '${raw}')`);
-}
-function decideAutoPublish(input) {
-  if (input.publication !== "active") return "skip-draft";
-  return "try";
-}
-function makeSignerFromSecret(identitySecretKey, did) {
-  return { did, identitySecretKey };
-}
 
 // src/commands/relationships.ts
-var import_chalk22 = __toESM(require("chalk"));
+var import_chalk21 = __toESM(require("chalk"));
 init_api();
 init_format();
 init_state();
@@ -7202,25 +7460,25 @@ async function runRelationships(positionalDid, opts) {
   const local = explicitDid !== void 0 ? loadAgentOrThrow(opts.server, explicitDid) : resolveSenderAgent("relationships", opts.server, void 0);
   const did = local.did;
   const api = new ArpApiClient(opts.server);
-  console.log(import_chalk22.default.dim(`Server: ${api.serverUrl}`));
-  console.log(import_chalk22.default.dim(`Signer: ${local.did}`));
+  console.log(import_chalk21.default.dim(`Server: ${api.serverUrl}`));
+  console.log(import_chalk21.default.dim(`Signer: ${local.did}`));
   const query = { limit };
   if (state) query.state = state;
   const signer = makeSigner(local);
   const rows = await api.listRelationships(did, signer, query);
   if (rows.length === 0) {
-    console.log(import_chalk22.default.dim("\n(no relationships)"));
+    console.log(import_chalk21.default.dim("\n(no relationships)"));
     return;
   }
   console.log("");
   console.log(formatRelationshipsTable(rows, did));
   if (opts.verbose) {
-    console.log(import_chalk22.default.bold("\nFull relationships:"));
+    console.log(import_chalk21.default.bold("\nFull relationships:"));
     for (const r of rows) {
       console.log(formatJson(r));
     }
   }
-  console.log(import_chalk22.default.dim(`
+  console.log(import_chalk21.default.dim(`
 ${rows.length} relationship(s).`));
 }
 function formatRelationshipsTable(rows, selfDid) {
@@ -7228,7 +7486,7 @@ function formatRelationshipsTable(rows, selfDid) {
   const data = rows.map((r) => [r.relationshipId, otherPair(r, selfDid), r.state, r.lastEventAt ?? "(none)", String(r.lastEventIndex)]);
   const widths = header.map((h, i) => Math.max(h.length, ...data.map((row) => row[i].length)));
   const pad = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join("  ");
-  return [import_chalk22.default.bold(pad(header)), import_chalk22.default.dim(pad(widths.map((w) => "-".repeat(w)))), ...data.map((row) => pad(row))].join("\n");
+  return [import_chalk21.default.bold(pad(header)), import_chalk21.default.dim(pad(widths.map((w) => "-".repeat(w)))), ...data.map((row) => pad(row))].join("\n");
 }
 function otherPair(r, selfDid) {
   if (r.pairDidA === selfDid) return r.pairDidB;
@@ -7251,141 +7509,9 @@ function parseLimit6(raw) {
   return n;
 }
 
-// src/commands/rotate.ts
-var import_sdk13 = require("@heyanon-arp/sdk");
-var import_chalk23 = __toESM(require("chalk"));
-var import_prompts3 = __toESM(require("prompts"));
-init_api();
-init_format();
-init_state();
-init_lifecycle();
-var ROTATION_REASONS = ["scheduled", "compromise", "lost_device", "other"];
-function registerRotateCommand(root) {
-  root.command("rotate").description("Rotate the agent identity key (DID stays frozen). Requires local state with ownerId + currentAttestationId.").argument("<did>").option("--server <url>", "Override ARP server base URL").option("--yes", "Skip the destructive-action confirmation prompt", false).option("--reason <s>", `Rotation reason \u2014 one of ${ROTATION_REASONS.join(" | ")}`, "scheduled").action(async (did, opts) => {
-    if (opts.reason && !ROTATION_REASONS.includes(opts.reason)) {
-      throw new Error(`rotate: --reason must be one of ${ROTATION_REASONS.join(", ")} (got '${opts.reason}')`);
-    }
-    await runRotate(did, opts);
-  });
-}
-async function runRotate(did, opts) {
-  const local = loadAgentOrThrow(opts.server, did);
-  if (!local.ownerId || !local.currentAttestationId) {
-    throw new Error("rotate: local state is missing ownerId / currentAttestationId. State predates the rotation flow \u2014 please re-register.");
-  }
-  const api = new ArpApiClient(opts.server);
-  console.log(import_chalk23.default.dim(`Server: ${api.serverUrl}`));
-  console.log(import_chalk23.default.dim(`Rotating: ${local.did}`));
-  if (!opts.yes) {
-    const confirm = await (0, import_prompts3.default)({
-      type: "confirm",
-      name: "go",
-      message: "Rotation invalidates the CURRENT private key the moment the server commits. Continue?",
-      initial: false
-    });
-    if (!confirm.go) {
-      console.log(import_chalk23.default.yellow("Aborted."));
-      return;
-    }
-  }
-  const next = (0, import_sdk13.generateKeyPair)();
-  const newIdentityPublicKeyB58 = (0, import_sdk13.base58btcEncode)(next.publicKey);
-  const challenge = await api.issueChallenge("rotate");
-  const challengeBytes = base64UrlNoPadDecode2(challenge.challengeB64);
-  if (challengeBytes.length !== 32) {
-    throw new Error(`Server returned a ${challengeBytes.length}-byte challenge; expected 32`);
-  }
-  const challengeSig = (0, import_sdk13.signChallenge)(challengeBytes, next.secretKey);
-  await api.submitChallengeResponse({
-    challengeId: challenge.challengeId,
-    identityPublicKey: newIdentityPublicKeyB58,
-    signature: Buffer.from(challengeSig).toString("base64")
-  });
-  const scryptKey = new Uint8Array(Buffer.from(local.scryptKeyB64, "base64"));
-  if (scryptKey.length !== 32) {
-    throw new Error("rotate: stored scryptKeyB64 is not 32 bytes \u2014 local state is corrupted, re-register.");
-  }
-  const reason = opts.reason ?? "scheduled";
-  const payload = {
-    purpose: "ARP-KEY-ROTATION-v1",
-    agent_did: did,
-    current_identity_public_key: local.identityPublicKeyB58,
-    new_identity_public_key: newIdentityPublicKeyB58,
-    settlement_public_key: local.settlementPublicKeyB58,
-    supersedes_attestation_id: local.currentAttestationId,
-    owner_id: local.ownerId,
-    owner_signing_method: "scrypt_password_proof",
-    rotation_reason: reason,
-    created_at: (0, import_sdk13.rfc3339)(),
-    nonce: (0, import_sdk13.senderNonce)()
-  };
-  const attestation = (0, import_sdk13.signKeyRotationAttestation)({
-    payload,
-    scryptKey,
-    scryptSaltId: local.scryptSaltId
-  });
-  const newIdentitySecretKeyB64 = Buffer.from(next.secretKey).toString("base64");
-  updateAgentLocal(opts.server, did, {
-    pendingRotation: {
-      newIdentityPublicKeyB58,
-      newIdentitySecretKeyB64,
-      issuedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  });
-  const body = {
-    challengeId: challenge.challengeId,
-    newIdentityPublicKey: newIdentityPublicKeyB58,
-    newKeyAttestation: {
-      payload: attestation.payload,
-      sig: attestation.sig,
-      scrypt_salt_id: attestation.scrypt_salt_id
-    }
-  };
-  const signer = makeSigner(local);
-  let updated;
-  try {
-    updated = await api.rotateIdentityKey(did, body, signer);
-  } catch (err) {
-    try {
-      updateAgentLocal(opts.server, did, { pendingRotation: void 0 });
-    } catch {
-    }
-    throw err;
-  }
-  try {
-    updateAgentLocal(opts.server, did, {
-      identityPublicKeyB58: newIdentityPublicKeyB58,
-      identitySecretKeyB64: newIdentitySecretKeyB64,
-      currentAttestationId: updated.currentAttestationId,
-      pendingRotation: void 0
-    });
-  } catch (err) {
-    console.error(import_chalk23.default.red("\nServer rotation succeeded but local state write failed."));
-    console.error(import_chalk23.default.red("Capture these values now \u2014 the new key is already live server-side:"));
-    console.error(`  ${import_chalk23.default.bold("identityPublicKeyB58")}  : ${newIdentityPublicKeyB58}`);
-    console.error(`  ${import_chalk23.default.bold("identitySecretKeyB64")}  : ${newIdentitySecretKeyB64}`);
-    console.error(`  ${import_chalk23.default.bold("currentAttestationId")}  : ${updated.currentAttestationId}`);
-    console.error(import_chalk23.default.dim(`(Also persisted in pendingRotation at ~/.arp/agents.json before the server call.)`));
-    console.error(import_chalk23.default.dim(`Underlying error: ${err.message}`));
-    throw err;
-  }
-  console.log(import_chalk23.default.green("\nRotated."));
-  console.log(`${import_chalk23.default.bold("DID")}: ${import_chalk23.default.cyan(updated.did)} ${import_chalk23.default.dim("(unchanged)")}`);
-  console.log(`${import_chalk23.default.bold("New identity public key")}: ${import_chalk23.default.cyan(newIdentityPublicKeyB58)}`);
-  console.log(`${import_chalk23.default.bold("New attestation id")}: ${import_chalk23.default.cyan(updated.currentAttestationId)}`);
-  console.log(import_chalk23.default.bold("\nAgent profile:"));
-  console.log(formatJson(updated));
-  console.log(import_chalk23.default.dim("\nLocal state updated; old private key is no longer valid."));
-}
-function base64UrlNoPadDecode2(s) {
-  const replaced = s.replace(/-/g, "+").replace(/_/g, "/");
-  const padded = replaced + "==".slice(0, (4 - replaced.length % 4) % 4);
-  return new Uint8Array(Buffer.from(padded, "base64"));
-}
-
 // src/commands/send-handshake.ts
-var import_sdk14 = require("@heyanon-arp/sdk");
-var import_chalk24 = __toESM(require("chalk"));
+var import_sdk13 = require("@heyanon-arp/sdk");
+var import_chalk22 = __toESM(require("chalk"));
 init_api();
 init_format();
 init_state();
@@ -7401,10 +7527,10 @@ async function runSendHandshake(recipientDid, opts) {
   }
   const ttlSeconds = parseTtl3(opts.ttl);
   const api = new ArpApiClient(opts.server);
-  console.log(import_chalk24.default.dim(`Server: ${api.serverUrl}`));
+  console.log(import_chalk22.default.dim(`Server: ${api.serverUrl}`));
   const sender = resolveSenderAgent("send-handshake", opts.server, opts.fromDid);
-  console.log(import_chalk24.default.dim(`Sender: ${sender.did}`));
-  console.log(import_chalk24.default.dim(`Recipient: ${recipientDid}`));
+  console.log(import_chalk22.default.dim(`Sender: ${sender.did}`));
+  console.log(import_chalk22.default.dim(`Recipient: ${recipientDid}`));
   const content = {};
   if (opts.greeting) content.greeting = opts.greeting;
   if (opts.intent) content.intent = opts.intent;
@@ -7412,46 +7538,46 @@ async function runSendHandshake(recipientDid, opts) {
   const nextSequence = (sender.lastSenderSequence ?? 0) + 1;
   const protectedBlock = {
     protocol_version: "arp/0.1",
-    purpose: import_sdk14.Purpose.ENVELOPE,
-    message_id: (0, import_sdk14.uuidV4)(),
+    purpose: import_sdk13.Purpose.ENVELOPE,
+    message_id: (0, import_sdk13.uuidV4)(),
     sender_did: sender.did,
     recipient_did: recipientDid,
     relationship_id: null,
     sender_sequence: nextSequence,
-    sender_nonce: (0, import_sdk14.senderNonce)(),
-    timestamp: (0, import_sdk14.rfc3339)(),
-    expires_at: (0, import_sdk14.expiresAt)(ttlSeconds),
+    sender_nonce: (0, import_sdk13.senderNonce)(),
+    timestamp: (0, import_sdk13.rfc3339)(),
+    expires_at: (0, import_sdk13.expiresAt)(ttlSeconds),
     delivery_id: null
   };
   const signer = makeSigner(sender);
-  const envelope = (0, import_sdk14.signEnvelope)({
+  const envelope = (0, import_sdk13.signEnvelope)({
     protected: protectedBlock,
     body,
     identitySecretKey: signer.identitySecretKey
   });
   if (opts.verbose) {
-    console.log(import_chalk24.default.bold("\nEnvelope (pre-send):"));
+    console.log(import_chalk22.default.bold("\nEnvelope (pre-send):"));
     console.log(formatJson(envelope));
   }
   const result = await api.ingest(envelope);
   updateAgentLocal(opts.server, sender.did, { lastSenderSequence: nextSequence });
-  console.log(import_chalk24.default.green("\nDelivered."));
-  console.log(`${import_chalk24.default.bold("Event id")}: ${import_chalk24.default.cyan(result.eventId)}`);
-  console.log(`${import_chalk24.default.bold("Relationship id")}: ${import_chalk24.default.cyan(result.relationshipId)}`);
-  console.log(`${import_chalk24.default.bold("Chain index")}: ${import_chalk24.default.cyan(String(result.relationshipEventIndex))}`);
-  console.log(`${import_chalk24.default.bold("Server timestamp")}: ${import_chalk24.default.cyan(result.serverTimestamp)}`);
-  console.log(`${import_chalk24.default.bold("Signed message hash")}: ${import_chalk24.default.cyan(result.signedMessageHash)}`);
-  console.log(`${import_chalk24.default.bold("Server event hash")}: ${import_chalk24.default.cyan(result.serverEventHash)}`);
+  console.log(import_chalk22.default.green("\nDelivered."));
+  console.log(`${import_chalk22.default.bold("Event id")}: ${import_chalk22.default.cyan(result.eventId)}`);
+  console.log(`${import_chalk22.default.bold("Relationship id")}: ${import_chalk22.default.cyan(result.relationshipId)}`);
+  console.log(`${import_chalk22.default.bold("Chain index")}: ${import_chalk22.default.cyan(String(result.relationshipEventIndex))}`);
+  console.log(`${import_chalk22.default.bold("Server timestamp")}: ${import_chalk22.default.cyan(result.serverTimestamp)}`);
+  console.log(`${import_chalk22.default.bold("Signed message hash")}: ${import_chalk22.default.cyan(result.signedMessageHash)}`);
+  console.log(`${import_chalk22.default.bold("Server event hash")}: ${import_chalk22.default.cyan(result.serverEventHash)}`);
   if (result.prevServerEventHash) {
-    console.log(`${import_chalk24.default.bold("Prev server event hash")}: ${import_chalk24.default.cyan(result.prevServerEventHash)}`);
+    console.log(`${import_chalk22.default.bold("Prev server event hash")}: ${import_chalk22.default.cyan(result.prevServerEventHash)}`);
   } else {
-    console.log(`${import_chalk24.default.bold("Prev server event hash")}: ${import_chalk24.default.dim("(null \u2014 first event of this relationship)")}`);
+    console.log(`${import_chalk22.default.bold("Prev server event hash")}: ${import_chalk22.default.dim("(null \u2014 first event of this relationship)")}`);
   }
   if (opts.verbose) {
-    console.log(import_chalk24.default.bold("\nFull server response:"));
+    console.log(import_chalk22.default.bold("\nFull server response:"));
     console.log(formatJson(result));
   }
-  console.log(import_chalk24.default.dim(`
+  console.log(import_chalk22.default.dim(`
 Local sender_sequence advanced to ${nextSequence}.`));
 }
 function parseTtl3(raw) {
@@ -7467,8 +7593,8 @@ function isDid(s) {
 }
 
 // src/commands/send-handshake-response.ts
-var import_sdk15 = require("@heyanon-arp/sdk");
-var import_chalk25 = __toESM(require("chalk"));
+var import_sdk14 = require("@heyanon-arp/sdk");
+var import_chalk23 = __toESM(require("chalk"));
 init_api();
 init_format();
 init_state();
@@ -7482,7 +7608,7 @@ function registerSendHandshakeResponseCommand(root) {
     // We don't use commander's requiredOption because it
     // would fire for the accept path too; validate manually
     // after decision is parsed.
-    `When --decision=decline: required reason code (one of: ${import_sdk15.DECLINE_REASONS.join(", ")}). Carried in body.content.reason.`
+    `When --decision=decline: required reason code (one of: ${import_sdk14.DECLINE_REASONS.join(", ")}). Carried in body.content.reason.`
   ).option("--reason-detail <s>", "Optional free-text elaboration alongside --reason (max 512 chars).").option("--ttl <seconds>", "Envelope TTL in seconds (max 86400 = 24h)", "3600").option("--verbose", "Print the full envelope before sending and the full server response. Mutually exclusive with --json.", false).option(
     "--json",
     "Machine-readable mode \u2014 emit a single JSON object on stdout ({ok, decision, eventId, relationshipId, relationshipEventIndex, serverTimestamp, serverEventHash, prevServerEventHash}; idempotent short-circuit adds {idempotent:true}). Prelude + banners move off stdout; on failure stderr carries `{code, message}`. Mutually exclusive with --verbose.",
@@ -7513,11 +7639,11 @@ async function runSendHandshakeResponse(recipientDid, opts) {
     declinePayload = detail ? { reason, reasonDetail: detail } : { reason };
   }
   const api = new ArpApiClient(opts.server);
-  progress(opts.json, import_chalk25.default.dim(`Server: ${api.serverUrl}`));
+  progress(opts.json, import_chalk23.default.dim(`Server: ${api.serverUrl}`));
   const sender = resolveSenderAgent("send-handshake-response", opts.server, opts.fromDid);
-  progress(opts.json, import_chalk25.default.dim(`Sender: ${sender.did}`));
-  progress(opts.json, import_chalk25.default.dim(`Recipient: ${recipientDid}`));
-  progress(opts.json, import_chalk25.default.dim(`Decision: ${decision}`));
+  progress(opts.json, import_chalk23.default.dim(`Sender: ${sender.did}`));
+  progress(opts.json, import_chalk23.default.dim(`Recipient: ${recipientDid}`));
+  progress(opts.json, import_chalk23.default.dim(`Decision: ${decision}`));
   const signer = makeSigner(sender);
   if (!opts.force) {
     try {
@@ -7546,13 +7672,13 @@ async function runSendHandshakeResponse(recipientDid, opts) {
             });
             return;
           }
-          progress(opts.json, import_chalk25.default.yellow(`
+          progress(opts.json, import_chalk23.default.yellow(`
 [--idempotency] Relationship ${existing.relationshipId} with ${recipientDid} is already 'active'.`));
           progress(
             opts.json,
-            import_chalk25.default.dim(`A previous accept from this signer (event ${previousResponseFromMe.eventId}) landed successfully. Skipping re-send (use --force to override).`)
+            import_chalk23.default.dim(`A previous accept from this signer (event ${previousResponseFromMe.eventId}) landed successfully. Skipping re-send (use --force to override).`)
           );
-          progress(opts.json, import_chalk25.default.dim(`Last event index: ${existing.lastEventIndex}, last server event hash: ${existing.lastServerEventHash ?? "(none)"}`));
+          progress(opts.json, import_chalk23.default.dim(`Last event index: ${existing.lastEventIndex}, last server event hash: ${existing.lastServerEventHash ?? "(none)"}`));
           return;
         }
         throw new Error(
@@ -7563,7 +7689,7 @@ async function runSendHandshakeResponse(recipientDid, opts) {
       if (probeErr instanceof Error && /CLOSED|terminated|already 'active' from a previous ACCEPT|original initiator/i.test(probeErr.message)) {
         throw probeErr;
       }
-      progress(opts.json, import_chalk25.default.dim(`(idempotency probe failed; proceeding anyway: ${probeErr.message})`));
+      progress(opts.json, import_chalk23.default.dim(`(idempotency probe failed; proceeding anyway: ${probeErr.message})`));
     }
   }
   const content = { decision };
@@ -7576,24 +7702,24 @@ async function runSendHandshakeResponse(recipientDid, opts) {
   const nextSequence = (sender.lastSenderSequence ?? 0) + 1;
   const protectedBlock = {
     protocol_version: "arp/0.1",
-    purpose: import_sdk15.Purpose.ENVELOPE,
-    message_id: (0, import_sdk15.uuidV4)(),
+    purpose: import_sdk14.Purpose.ENVELOPE,
+    message_id: (0, import_sdk14.uuidV4)(),
     sender_did: sender.did,
     recipient_did: recipientDid,
     relationship_id: null,
     sender_sequence: nextSequence,
-    sender_nonce: (0, import_sdk15.senderNonce)(),
-    timestamp: (0, import_sdk15.rfc3339)(),
-    expires_at: (0, import_sdk15.expiresAt)(ttlSeconds),
+    sender_nonce: (0, import_sdk14.senderNonce)(),
+    timestamp: (0, import_sdk14.rfc3339)(),
+    expires_at: (0, import_sdk14.expiresAt)(ttlSeconds),
     delivery_id: null
   };
-  const envelope = (0, import_sdk15.signEnvelope)({
+  const envelope = (0, import_sdk14.signEnvelope)({
     protected: protectedBlock,
     body,
     identitySecretKey: signer.identitySecretKey
   });
   if (opts.verbose) {
-    console.log(import_chalk25.default.bold("\nEnvelope (pre-send):"));
+    console.log(import_chalk23.default.bold("\nEnvelope (pre-send):"));
     console.log(formatJson(envelope));
   }
   const result = await api.ingest(envelope);
@@ -7613,23 +7739,23 @@ async function runSendHandshakeResponse(recipientDid, opts) {
     });
     return;
   }
-  console.log(import_chalk25.default.green("\nDelivered."));
-  console.log(`${import_chalk25.default.bold("Event id")}: ${import_chalk25.default.cyan(result.eventId)}`);
-  console.log(`${import_chalk25.default.bold("Relationship id")}: ${import_chalk25.default.cyan(result.relationshipId)}`);
-  console.log(`${import_chalk25.default.bold("Chain index")}: ${import_chalk25.default.cyan(String(result.relationshipEventIndex))}`);
-  console.log(`${import_chalk25.default.bold("Server timestamp")}: ${import_chalk25.default.cyan(result.serverTimestamp)}`);
-  console.log(`${import_chalk25.default.bold("Signed message hash")}: ${import_chalk25.default.cyan(result.signedMessageHash)}`);
-  console.log(`${import_chalk25.default.bold("Server event hash")}: ${import_chalk25.default.cyan(result.serverEventHash)}`);
+  console.log(import_chalk23.default.green("\nDelivered."));
+  console.log(`${import_chalk23.default.bold("Event id")}: ${import_chalk23.default.cyan(result.eventId)}`);
+  console.log(`${import_chalk23.default.bold("Relationship id")}: ${import_chalk23.default.cyan(result.relationshipId)}`);
+  console.log(`${import_chalk23.default.bold("Chain index")}: ${import_chalk23.default.cyan(String(result.relationshipEventIndex))}`);
+  console.log(`${import_chalk23.default.bold("Server timestamp")}: ${import_chalk23.default.cyan(result.serverTimestamp)}`);
+  console.log(`${import_chalk23.default.bold("Signed message hash")}: ${import_chalk23.default.cyan(result.signedMessageHash)}`);
+  console.log(`${import_chalk23.default.bold("Server event hash")}: ${import_chalk23.default.cyan(result.serverEventHash)}`);
   if (result.prevServerEventHash) {
-    console.log(`${import_chalk25.default.bold("Prev server event hash")}: ${import_chalk25.default.cyan(result.prevServerEventHash)}`);
+    console.log(`${import_chalk23.default.bold("Prev server event hash")}: ${import_chalk23.default.cyan(result.prevServerEventHash)}`);
   } else {
-    console.log(`${import_chalk25.default.bold("Prev server event hash")}: ${import_chalk25.default.dim("(null \u2014 first event of this relationship)")}`);
+    console.log(`${import_chalk23.default.bold("Prev server event hash")}: ${import_chalk23.default.dim("(null \u2014 first event of this relationship)")}`);
   }
   if (opts.verbose) {
-    console.log(import_chalk25.default.bold("\nFull server response:"));
+    console.log(import_chalk23.default.bold("\nFull server response:"));
     console.log(formatJson(result));
   }
-  console.log(import_chalk25.default.dim(`
+  console.log(import_chalk23.default.dim(`
 Local sender_sequence advanced to ${nextSequence}.`));
 }
 function parseDecision(raw) {
@@ -7688,7 +7814,7 @@ init_status();
 init_wallet();
 
 // src/commands/watch.ts
-var import_chalk26 = __toESM(require("chalk"));
+var import_chalk24 = __toESM(require("chalk"));
 init_api();
 init_format();
 init_state();
@@ -7702,9 +7828,9 @@ async function runWatch(relationshipId, opts) {
   const local = resolveSenderAgent("watch", opts.server, opts.fromDid);
   const api = new ArpApiClient(opts.server);
   if (!opts.json) {
-    console.log(import_chalk26.default.dim(`Server: ${api.serverUrl}`));
-    console.log(import_chalk26.default.dim(`Signer: ${local.did}`));
-    console.log(import_chalk26.default.dim(`Watching: ${relationshipId}`));
+    console.log(import_chalk24.default.dim(`Server: ${api.serverUrl}`));
+    console.log(import_chalk24.default.dim(`Signer: ${local.did}`));
+    console.log(import_chalk24.default.dim(`Watching: ${relationshipId}`));
   }
   const controller = new AbortController();
   let userAborted = false;
@@ -7723,7 +7849,7 @@ async function runWatch(relationshipId, opts) {
       }
       if (event.type === "heartbeat") continue;
       if (event.type === "connected") {
-        console.log(import_chalk26.default.green(`\u25CF stream open \u2014 watching ${relationshipId}`));
+        console.log(import_chalk24.default.green(`\u25CF stream open \u2014 watching ${relationshipId}`));
         continue;
       }
       if (event.type === "envelope") {
@@ -7737,7 +7863,7 @@ async function runWatch(relationshipId, opts) {
         }
         continue;
       }
-      console.log(import_chalk26.default.dim(`(unknown event: ${event.type})`));
+      console.log(import_chalk24.default.dim(`(unknown event: ${event.type})`));
     }
     if (!userAborted) {
       throw new Error(`watch ${relationshipId}: stream ended unexpectedly (server may have restarted, or the change stream errored). Re-run to reconnect.`);
@@ -7745,7 +7871,7 @@ async function runWatch(relationshipId, opts) {
   } catch (err) {
     const name = err.name;
     if (name === "AbortError" || userAborted) {
-      if (!opts.json) console.log(import_chalk26.default.dim("\nstream closed."));
+      if (!opts.json) console.log(import_chalk24.default.dim("\nstream closed."));
       return;
     }
     throw err;
@@ -7759,21 +7885,21 @@ function formatWatchLine(ev, selfDid, opts = {}) {
   const type = ev.type.padEnd(20);
   const direction = directionLabel2(ev, selfDid, opts);
   const hash = opts.fullIds ? ev.serverEventHash : hashHead4(ev.serverEventHash);
-  return `${import_chalk26.default.dim(`[${ts}]`)}  ${type}  ${direction}    ${import_chalk26.default.cyan(hash)}`;
+  return `${import_chalk24.default.dim(`[${ts}]`)}  ${type}  ${direction}    ${import_chalk24.default.cyan(hash)}`;
 }
 function directionLabel2(ev, selfDid, opts = {}) {
   const senderHead = opts.fullIds ? ev.senderDid : didHead4(ev.senderDid);
   const recipientHead = opts.fullIds ? ev.recipientDid : didHead4(ev.recipientDid);
-  if (ev.senderDid === selfDid) return `${import_chalk26.default.bold("me")} \u2192 ${import_chalk26.default.dim(recipientHead)}`;
-  if (ev.recipientDid === selfDid) return `${import_chalk26.default.dim(senderHead)} \u2192 ${import_chalk26.default.bold("me")}`;
-  return `${import_chalk26.default.dim(senderHead)} \u2192 ${import_chalk26.default.dim(recipientHead)}`;
+  if (ev.senderDid === selfDid) return `${import_chalk24.default.bold("me")} \u2192 ${import_chalk24.default.dim(recipientHead)}`;
+  if (ev.recipientDid === selfDid) return `${import_chalk24.default.dim(senderHead)} \u2192 ${import_chalk24.default.bold("me")}`;
+  return `${import_chalk24.default.dim(senderHead)} \u2192 ${import_chalk24.default.dim(recipientHead)}`;
 }
 function didHead4(did) {
   if (did.length <= 20) return did;
   return `${did.slice(0, 20)}...`;
 }
 function hashHead4(hash) {
-  if (!hash) return import_chalk26.default.dim("(none)");
+  if (!hash) return import_chalk24.default.dim("(none)");
   if (hash.length <= 14) return hash;
   return `${hash.slice(0, 14)}...`;
 }
@@ -7785,7 +7911,7 @@ function formatClock(iso) {
 }
 
 // src/commands/whoami.ts
-var import_chalk27 = __toESM(require("chalk"));
+var import_chalk25 = __toESM(require("chalk"));
 init_api();
 init_format();
 init_state();
@@ -7798,10 +7924,10 @@ function registerWhoamiCommand(root) {
     // Persona scripts want the local settlement pubkey for
     // `--payer-settlement-pubkey` / on-chain ops without a
     // server round-trip. `--local` short-circuits the signed
-    // GET, prints just the resolved DID + pubkeys + keyMode
-    // from local state. (V1-alpha: accountId parked, no longer
-    // in --local output.)
-    "Print local-state info only (DID + settlement + identity pubkeys + keyMode). Skips the signed server fetch \u2014 useful for scripts that need the local pubkey before the server is up, or to grep from a shell without burning a network round-trip.",
+    // GET, prints just the resolved DID + pubkeys from local
+    // state. (V1-alpha: accountId parked, no longer in --local
+    // output.)
+    "Print local-state info only (DID + settlement + identity pubkeys). Skips the signed server fetch \u2014 useful for scripts that need the local pubkey before the server is up, or to grep from a shell without burning a network round-trip.",
     false
   ).option("--json", "JSON output (jq-pipeable). Combines local + server data when --local is unset, or just local when --local is set.", false).action(async (didArg, opts, cmd) => {
     try {
@@ -7815,18 +7941,16 @@ function registerWhoamiCommand(root) {
         // longer carries the field. Uncomment when launchpad↔ARP
         // join lands.
         // accountId: local.accountId,
-        keyMode: local.keyMode,
         name: local.name
       };
       if (opts.local) {
         if (opts.json) {
           console.log(formatJson(localJson));
         } else {
-          console.log(import_chalk27.default.bold("Local agent:"));
-          console.log(`  DID:                ${import_chalk27.default.cyan(local.did)}`);
-          console.log(`  Settlement pubkey:  ${import_chalk27.default.cyan(local.settlementPublicKeyB58)}`);
-          console.log(`  Identity pubkey:    ${import_chalk27.default.cyan(local.identityPublicKeyB58)}`);
-          console.log(`  Key mode:           ${local.keyMode}`);
+          console.log(import_chalk25.default.bold("Local agent:"));
+          console.log(`  DID:                ${import_chalk25.default.cyan(local.did)}`);
+          console.log(`  Settlement pubkey:  ${import_chalk25.default.cyan(local.settlementPublicKeyB58)}`);
+          console.log(`  Identity pubkey:    ${import_chalk25.default.cyan(local.identityPublicKeyB58)}`);
           if (local.name) console.log(`  Name:               ${local.name}`);
         }
         return;
@@ -7837,12 +7961,12 @@ function registerWhoamiCommand(root) {
       if (opts.json) {
         console.log(formatJson({ local: localJson, server: agent }));
       } else {
-        console.log(import_chalk27.default.dim(`Server: ${api.serverUrl}`));
-        console.log(import_chalk27.default.bold("\nLocal agent:"));
-        console.log(`  DID:                ${import_chalk27.default.cyan(local.did)}`);
-        console.log(`  Settlement pubkey:  ${import_chalk27.default.cyan(local.settlementPublicKeyB58)}`);
-        console.log(`  Identity pubkey:    ${import_chalk27.default.cyan(local.identityPublicKeyB58)}`);
-        console.log(import_chalk27.default.bold("\nServer profile:"));
+        console.log(import_chalk25.default.dim(`Server: ${api.serverUrl}`));
+        console.log(import_chalk25.default.bold("\nLocal agent:"));
+        console.log(`  DID:                ${import_chalk25.default.cyan(local.did)}`);
+        console.log(`  Settlement pubkey:  ${import_chalk25.default.cyan(local.settlementPublicKeyB58)}`);
+        console.log(`  Identity pubkey:    ${import_chalk25.default.cyan(local.identityPublicKeyB58)}`);
+        console.log(import_chalk25.default.bold("\nServer profile:"));
         console.log(formatJson(agent));
       }
     } catch (err) {
@@ -7853,8 +7977,8 @@ function registerWhoamiCommand(root) {
 }
 
 // src/commands/work.ts
-var import_sdk16 = require("@heyanon-arp/sdk");
-var import_chalk28 = __toESM(require("chalk"));
+var import_sdk15 = require("@heyanon-arp/sdk");
+var import_chalk26 = __toESM(require("chalk"));
 init_api();
 init_format();
 init_id_format();
@@ -7873,7 +7997,16 @@ var POST_COMMIT_ERROR_CODES3 = /* @__PURE__ */ new Set([
   "WORK_REQUEST_ALREADY_EXISTS",
   "WORK_REQUEST_NOT_FOUND",
   "WORK_RESPONDER_IS_CALLER",
-  "WORK_INVALID_STATE"
+  "WORK_INVALID_STATE",
+  // M6 lock-at-accept: the work handler's LOCKED gate emits
+  // `DELEGATION_PENDING_LOCK` (409) when the delegation is funded but
+  // the on-chain lock isn't confirmed yet (state
+  // `pending_lock_finalization`). It fires from the body handler AFTER
+  // the event row is committed — same lifecycle as
+  // `WORK_DELEGATION_NOT_ACTIVE` — so the CLI must advance
+  // `lastSenderSequence`, otherwise a retry once the lock confirms
+  // reuses the consumed sequence and trips `ENV_SEQUENCE_BACKWARDS`.
+  "DELEGATION_PENDING_LOCK"
 ]);
 function registerRequest(parent) {
   parent.command("request").description("Send a work_request to <recipient-did> under <delegation-id> (must be ACCEPTED).").argument("<recipient-did>", "Recipient agent DID (the payee \u2014 the OTHER side of the delegation pair)").argument("<delegation-id>", "Parent delegation id (UUID, must be ACCEPTED)").option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server").option("--request-id <id>", "Override the auto-generated request id (must be unique within the delegation)").option(
@@ -7900,17 +8033,17 @@ async function runRequest(recipientDid, delegationId, opts) {
     params
   };
   const body = { type: "work_request", content };
-  console.log(import_chalk28.default.dim(`Server: ${api.serverUrl}`));
-  console.log(import_chalk28.default.dim(`Sender: ${sender.did}`));
-  console.log(import_chalk28.default.dim(`Recipient: ${recipientDid}`));
-  console.log(import_chalk28.default.dim(`Delegation: ${delegationId}`));
-  console.log(import_chalk28.default.dim(`Request id: ${requestId}`));
+  console.log(import_chalk26.default.dim(`Server: ${api.serverUrl}`));
+  console.log(import_chalk26.default.dim(`Sender: ${sender.did}`));
+  console.log(import_chalk26.default.dim(`Recipient: ${recipientDid}`));
+  console.log(import_chalk26.default.dim(`Delegation: ${delegationId}`));
+  console.log(import_chalk26.default.dim(`Request id: ${requestId}`));
   const result = await sendWorkEnvelope({ api, sender, recipientDid, body, ttlSeconds, verbose: opts.verbose, server: opts.server });
   printIngestResult3(result);
-  console.log(import_chalk28.default.dim(`
+  console.log(import_chalk26.default.dim(`
 The payee can reply with:`));
-  console.log(import_chalk28.default.dim(`  heyarp work respond ${result.relationshipId} ${delegationId} ${requestId} --output '<json>'`));
-  console.log(import_chalk28.default.dim(`  heyarp work respond ${result.relationshipId} ${delegationId} ${requestId} --error CODE:message`));
+  console.log(import_chalk26.default.dim(`  heyarp work respond ${result.relationshipId} ${delegationId} ${requestId} --output '<json>'`));
+  console.log(import_chalk26.default.dim(`  heyarp work respond ${result.relationshipId} ${delegationId} ${requestId} --error CODE:message`));
 }
 function registerRespond(parent) {
   parent.command("respond").description("Send a work_response under <relationship-id> for <delegation-id> / <request-id>. Payee-only.").argument("<relationship-id>", "Relationship UUID").argument("<delegation-id>", "Parent delegation id (UUID)").argument("<request-id>", "Request id supplied on the work_request").option("--server <url>", "Override ARP server base URL").option("--from-did <did>", "Sender DID \u2014 required only if multiple agents are registered against this server").option("--output <json>", "Success payload as a JSON object literal. Mutually exclusive with --error and --output-file.").option(
@@ -7935,13 +8068,13 @@ async function runRespond(relationshipId, delegationId, requestId, opts) {
     ...responsePayload
   };
   const body = { type: "work_response", content };
-  console.log(import_chalk28.default.dim(`Server: ${api.serverUrl}`));
-  console.log(import_chalk28.default.dim(`Sender: ${sender.did}`));
-  console.log(import_chalk28.default.dim(`Recipient: ${recipientDid}`));
-  console.log(import_chalk28.default.dim(`Relationship: ${relationshipId}`));
-  console.log(import_chalk28.default.dim(`Delegation: ${delegationId}`));
-  console.log(import_chalk28.default.dim(`Request id: ${requestId}`));
-  console.log(import_chalk28.default.dim(`Outcome: ${responsePayload.output ? "success" : "error"}`));
+  console.log(import_chalk26.default.dim(`Server: ${api.serverUrl}`));
+  console.log(import_chalk26.default.dim(`Sender: ${sender.did}`));
+  console.log(import_chalk26.default.dim(`Recipient: ${recipientDid}`));
+  console.log(import_chalk26.default.dim(`Relationship: ${relationshipId}`));
+  console.log(import_chalk26.default.dim(`Delegation: ${delegationId}`));
+  console.log(import_chalk26.default.dim(`Request id: ${requestId}`));
+  console.log(import_chalk26.default.dim(`Outcome: ${responsePayload.output ? "success" : "error"}`));
   const result = await sendWorkEnvelope({ api, sender, recipientDid, body, ttlSeconds, verbose: opts.verbose, server: opts.server });
   printIngestResult3(result);
 }
@@ -7949,25 +8082,25 @@ async function sendWorkEnvelope(args) {
   const nextSequence = (args.sender.lastSenderSequence ?? 0) + 1;
   const protectedBlock = {
     protocol_version: "arp/0.1",
-    purpose: import_sdk16.Purpose.ENVELOPE,
-    message_id: (0, import_sdk16.uuidV4)(),
+    purpose: import_sdk15.Purpose.ENVELOPE,
+    message_id: (0, import_sdk15.uuidV4)(),
     sender_did: args.sender.did,
     recipient_did: args.recipientDid,
     relationship_id: null,
     sender_sequence: nextSequence,
-    sender_nonce: (0, import_sdk16.senderNonce)(),
-    timestamp: (0, import_sdk16.rfc3339)(),
-    expires_at: (0, import_sdk16.expiresAt)(args.ttlSeconds),
+    sender_nonce: (0, import_sdk15.senderNonce)(),
+    timestamp: (0, import_sdk15.rfc3339)(),
+    expires_at: (0, import_sdk15.expiresAt)(args.ttlSeconds),
     delivery_id: null
   };
   const signer = makeSigner(args.sender);
-  const envelope = (0, import_sdk16.signEnvelope)({
+  const envelope = (0, import_sdk15.signEnvelope)({
     protected: protectedBlock,
     body: args.body,
     identitySecretKey: signer.identitySecretKey
   });
   if (args.verbose) {
-    console.log(import_chalk28.default.bold("\nEnvelope (pre-send):"));
+    console.log(import_chalk26.default.bold("\nEnvelope (pre-send):"));
     console.log(formatJson(envelope));
   }
   try {
@@ -8007,12 +8140,12 @@ async function resolveResponseRecipient(cmdName, api, signer, args) {
   );
 }
 function printIngestResult3(result) {
-  console.log(import_chalk28.default.green("\nDelivered."));
-  console.log(`${import_chalk28.default.bold("Event id")}: ${import_chalk28.default.cyan(result.eventId)}`);
-  console.log(`${import_chalk28.default.bold("Relationship id")}: ${import_chalk28.default.cyan(result.relationshipId)}`);
-  console.log(`${import_chalk28.default.bold("Chain index")}: ${import_chalk28.default.cyan(String(result.relationshipEventIndex))}`);
-  console.log(`${import_chalk28.default.bold("Server timestamp")}: ${import_chalk28.default.cyan(result.serverTimestamp)}`);
-  console.log(`${import_chalk28.default.bold("Server event hash")}: ${import_chalk28.default.cyan(result.serverEventHash)}`);
+  console.log(import_chalk26.default.green("\nDelivered."));
+  console.log(`${import_chalk26.default.bold("Event id")}: ${import_chalk26.default.cyan(result.eventId)}`);
+  console.log(`${import_chalk26.default.bold("Relationship id")}: ${import_chalk26.default.cyan(result.relationshipId)}`);
+  console.log(`${import_chalk26.default.bold("Chain index")}: ${import_chalk26.default.cyan(String(result.relationshipEventIndex))}`);
+  console.log(`${import_chalk26.default.bold("Server timestamp")}: ${import_chalk26.default.cyan(result.serverTimestamp)}`);
+  console.log(`${import_chalk26.default.bold("Server event hash")}: ${import_chalk26.default.cyan(result.serverEventHash)}`);
 }
 function parseJsonObject(cmdName, flagName, raw) {
   let parsed;
@@ -8050,13 +8183,13 @@ function parseParamsInput(cmdName, opts) {
   return parseJsonObject(cmdName, "--params", opts.params ?? "{}");
 }
 function readJsonObjectFile(cmdName, flagName, path) {
-  const { existsSync: existsSync7, readFileSync: readFileSync9 } = require("fs");
-  if (!existsSync7(path)) {
+  const { existsSync: existsSync6, readFileSync: readFileSync8 } = require("fs");
+  if (!existsSync6(path)) {
     throw new Error(`${cmdName}: ${flagName} file not found at ${path}`);
   }
   let raw;
   try {
-    raw = readFileSync9(path, "utf8");
+    raw = readFileSync8(path, "utf8");
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     throw new Error(`${cmdName}: failed to read ${flagName} (${path}): ${detail}`);
@@ -8104,7 +8237,7 @@ function parseTtl5(cmdName, raw) {
 }
 function parseRequestId(cmdName, raw) {
   if (raw === void 0 || raw === "") {
-    return (0, import_sdk16.uuidV4)();
+    return (0, import_sdk15.uuidV4)();
   }
   if (raw.length === 0) {
     throw new Error(`${cmdName}: --request-id must be a non-empty string`);
@@ -8125,7 +8258,7 @@ function requireDid3(cmdName, did, label) {
 }
 
 // src/commands/work-list.ts
-var import_chalk29 = __toESM(require("chalk"));
+var import_chalk27 = __toESM(require("chalk"));
 init_api();
 init_format();
 init_state();
@@ -8155,9 +8288,9 @@ async function runWorkList(relationshipId, opts) {
   const api = new ArpApiClient(opts.server);
   const sender = resolveSenderAgent("work-list", opts.server, opts.fromDid);
   if (!opts.json) {
-    console.log(import_chalk29.default.dim(`Server: ${api.serverUrl}`));
-    console.log(import_chalk29.default.dim(`Signer: ${sender.did}`));
-    console.log(import_chalk29.default.dim(`Relationship: ${relationshipId}`));
+    console.log(import_chalk27.default.dim(`Server: ${api.serverUrl}`));
+    console.log(import_chalk27.default.dim(`Signer: ${sender.did}`));
+    console.log(import_chalk27.default.dim(`Relationship: ${relationshipId}`));
   }
   const query = { limit };
   if (state) query.state = state;
@@ -8170,7 +8303,7 @@ async function runWorkList(relationshipId, opts) {
     return;
   }
   if (rows.length === 0) {
-    console.log(import_chalk29.default.dim("\n(no work-logs for this relationship)"));
+    console.log(import_chalk27.default.dim("\n(no work-logs for this relationship)"));
     return;
   }
   console.log("");
@@ -8187,36 +8320,36 @@ async function runWorkList(relationshipId, opts) {
     }));
   }
   const lastId = rows[rows.length - 1].id;
-  console.log(import_chalk29.default.dim(`
+  console.log(import_chalk27.default.dim(`
 ${rows.length} work-log row(s). Paginate with --after ${lastId}.`));
 }
 function formatWorkLogLine(w, selfDid, opts = {}) {
   const delegationPart = opts.fullIds ? w.delegationId : idHead3(w.delegationId);
   const requestPart = opts.fullIds ? w.requestId : truncate3(w.requestId, 16);
-  const id = import_chalk29.default.bold(`${delegationPart}/${requestPart}`);
+  const id = import_chalk27.default.bold(`${delegationPart}/${requestPart}`);
   const state = colorState3(w.state).padEnd(stateColumnWidth3());
   const peerCallerHead = opts.fullIds ? w.callerDid : didHead5(w.callerDid);
   const peerPayeeHead = opts.fullIds ? w.payeeDid : didHead5(w.payeeDid);
-  const direction = w.callerDid === selfDid ? `${import_chalk29.default.bold("me")} \u2192 ${import_chalk29.default.dim(peerPayeeHead)}` : `${import_chalk29.default.dim(peerCallerHead)} \u2192 ${import_chalk29.default.bold("me")}`;
+  const direction = w.callerDid === selfDid ? `${import_chalk27.default.bold("me")} \u2192 ${import_chalk27.default.dim(peerPayeeHead)}` : `${import_chalk27.default.dim(peerCallerHead)} \u2192 ${import_chalk27.default.bold("me")}`;
   const outcome = formatOutcome(w);
   return `${id}  ${state}  ${direction}  ${outcome}`;
 }
 function colorState3(s) {
   switch (s) {
     case "requested":
-      return import_chalk29.default.yellow("requested");
+      return import_chalk27.default.yellow("requested");
     case "responded":
-      return import_chalk29.default.green("responded");
+      return import_chalk27.default.green("responded");
   }
 }
 function stateColumnWidth3() {
   return 9;
 }
 function formatOutcome(w) {
-  if (w.state === "requested") return import_chalk29.default.dim("(in flight)");
-  if (w.responseError) return import_chalk29.default.red(`error ${w.responseError.code}: ${truncate3(w.responseError.message, 32)}`);
-  if (w.responseOutput) return import_chalk29.default.cyan("ok");
-  return import_chalk29.default.dim("(empty response)");
+  if (w.state === "requested") return import_chalk27.default.dim("(in flight)");
+  if (w.responseError) return import_chalk27.default.red(`error ${w.responseError.code}: ${truncate3(w.responseError.message, 32)}`);
+  if (w.responseOutput) return import_chalk27.default.cyan("ok");
+  return import_chalk27.default.dim("(empty response)");
 }
 function idHead3(id) {
   if (id.length <= 12) return id;
@@ -8279,10 +8412,8 @@ async function main() {
   registerDidDocCommand(program);
   registerDoctorCommand(program);
   registerEscrowCommands(program);
-  registerExamplesCommand(program);
   registerWhoamiCommand(program);
   registerLifecycleCommands(program);
-  registerRotateCommand(program);
   registerSendHandshakeCommand(program);
   registerSendHandshakeResponseCommand(program);
   registerInboxCommand(program);