"note": "Heuristic false-green LEADS, not findings. A finding requires a demonstrated reproduction (surviving mutation via mutation-runner). Do not treat a candidate as a confirmed false green. Coverage-theater leads may include tests that delegate their assertion to a custom helper the classifier does not recognise; verify before acting.",

  "sourceDigest": "sha256:dd810dd48c5bdbc9becd7fcc01dd41a4ca2abf0b2d6f6a545907247f6e3e8361",

  "summary": {

    "filesScanned": 2476,

    "filesScanned": 2478,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:1d9036ecce5eea778b592bc94744162f06c5593790e4f7735114cec9f5d19c3a",

  "sourceDigest": "sha256:d8cd295762f49628cb5b8f0b739a7c2f863cfa6b021515152743307a3736f13c",

  "surfaces": [

    {

      "id": "app:@openagentsinc/acceptance-runner",

      "oracles": [

        {

          "type": "test",

          "ref": "packages/openagents-cli (71 tracked test files)"

          "ref": "packages/openagents-cli (73 tracked test files)"

        },

        {

          "type": "behavior-contract",

import { runGitCredentialHelper } from "./git-credential-helper.js";

import { Output, type OutputMode } from "./output.js";

import { ProjectClient } from "./project-client.js";

import { makeProviderCommand } from "./provider-command.js";

import { parseRepositoryTarget, RepositoryClient } from "./repository-client.js";

import { RequestBodyInput } from "./request-body-input.js";

import { SecretInput } from "./secret-input.js";

const traceCommand = makeTraceCommand(rootCommand);

const providerCommand = makeProviderCommand(rootCommand);

// The deploy command group: named operator deployment commands over the

// operator-only fleet promotion API from OpenAgentsInc/openagents.com#57.

// It consumes only that API — never `/admin/forge`, SSH, or an internal RPC —

    identityCommand,

    issueCommand,

    projectCommand,

    providerCommand,

    repoCommand,

    traceCommand,

  ]),

/**

 * The `openagents provider` command family.

 *

 * This is the earning half of provider mode, revived at the one seam that can

 * be proven offline: the settlement decision. `provider settle` reads a lease

 * and, when one exists, the NIP-LBR closeout receipt that covers it, and says

 * what the job earned. Unverified work earns zero and says which gate stopped

 * it.

 *

 * What is deliberately not here: presence, the claim and lease transport, and

 * any payout. Presence needs a market transport the do-not-build register keeps

 * deferred (an open market lane later uses the relay/provider-daemon/skeptical-

 * client shape, not a NIP-90/DVM revival), and payout stays on the MDK/Nexus

 * bridge. So `settle` takes the receipt as a file at that seam rather than

 * pretending to fetch it, in the same spirit as `trace upload` naming the

 * server half it is waiting for.

 *

 * The family is defined through a factory taking the root command, so the

 * registration hunk in `cli.ts` stays a single import and a single list entry.

 */

import { readFileSync } from "node:fs";

import { resolve } from "node:path";

import { Effect, Option } from "effect";

import { Command, Flag } from "effect/unstable/cli";

import { InputError } from "./errors.js";

import { Output, type OutputMode } from "./output.js";

import {

  settleLease,

  type LaborCloseoutReceipt,

  type ProviderLease,

  type SettlementDecision,

} from "./provider-settlement.js";

/** The shared flags a provider handler reads back off the root command. */

interface SharedFlags {

  readonly json: boolean;

}

const outputMode = (json: boolean): OutputMode => (json ? "json" : "human");

const readJsonFile = (path: string, label: string) =>

  Effect.try({

    try: () => JSON.parse(readFileSync(resolve(path), "utf8")) as unknown,

    catch: () =>

      new InputError({ message: `The ${label} file at ${path} could not be read as JSON.` }),

  });

const asRecord = (value: unknown): Record<string, unknown> | undefined =>

  typeof value === "object" && value !== null && !Array.isArray(value)

    ? (value as Record<string, unknown>)

    : undefined;

const text = (value: unknown): string => (typeof value === "string" ? value : "");

const count = (value: unknown): number => (typeof value === "number" ? value : Number.NaN);

/**

 * Read a lease document.

 *

 * The four fields the gate needs are required; a lease missing one is a typo

 * the reader would rather hear about now than as a mysterious refusal.

 */

const decodeLease = (value: unknown, path: string) =>

  Effect.gen(function* () {

    const record = asRecord(value);

    if (record === undefined) {

      return yield* new InputError({ message: `The lease at ${path} is not a JSON object.` });

    }

    const missing = ["job_id", "lane", "provider", "expires_at"].filter((field) =>

      typeof record[field] === "string" ? record[field] === "" : true,

    );

    if (missing.length > 0) {

      return yield* new InputError({

        message: `The lease at ${path} is missing ${missing.join(", ")}.`,

      });

    }

    const lease: ProviderLease = {

      job_id: text(record["job_id"]),

      lane: text(record["lane"]),

      provider: text(record["provider"]),

      price_msats: count(record["price_msats"]),

      expires_at: text(record["expires_at"]),

    };

    return lease;

  });

/**

 * Read a closeout receipt.

 *

 * Absent or malformed fields become empty strings rather than an error: the

 * settlement gate already has a named refusal for each of them, and a receipt

 * that is missing its verification refs should be refused as unverified work,

 * not as a bad file.

 */

const decodeCloseout = (value: unknown, path: string) =>

  Effect.gen(function* () {

    const record = asRecord(value);

    if (record === undefined) {

      return yield* new InputError({ message: `The closeout at ${path} is not a JSON object.` });

    }

    const closeout: LaborCloseoutReceipt = {

      receiptRef: text(record["receiptRef"]),

      requestId: text(record["requestId"]),

      requesterPubkey: text(record["requesterPubkey"]),

      providerPubkey: text(record["providerPubkey"]),

      quotedAmountMsats: count(record["quotedAmountMsats"]),

      verificationCommandRef: text(record["verificationCommandRef"]),

      testRef: text(record["testRef"]),

      platformCloseoutRef: text(record["platformCloseoutRef"]),

      digest: text(record["digest"]),

      settled_at: text(record["settled_at"]),

    };

    return closeout;

  });

const decisionHuman = (decision: SettlementDecision): ReadonlyArray<string> => [

  `Job: ${decision.job_id}`,

  `Outcome: ${decision.state}`,

  `Earned: ${decision.earned_msats} msats`,

  ...(decision.refusal === undefined ? [] : [`Refused: ${decision.refusal}`]),

  ...(decision.receipt_ref === undefined ? [] : [`Receipt: ${decision.receipt_ref}`]),

  decision.reason,

  "Accrual only: this command holds no key, connects no payout rail, and moves nothing.",

];

export const makeProviderCommand = <R>(root: Effect.Effect<SharedFlags, never, R>) => {

  const leaseFlag = Flag.string("lease").pipe(

    Flag.withDescription("Path to the lease document the buyer granted for this job"),

  );

  const closeoutFlag = Flag.string("closeout").pipe(

    Flag.optional,

    Flag.withDescription(

      "Path to the NIP-LBR closeout receipt covering this job. Omit it to see what an unverified job earns.",

    ),

  );

  const settleCommand = Command.make(

    "settle",

    { lease: leaseFlag, closeout: closeoutFlag },

    ({ closeout: closeoutPath, lease: leasePath }) =>

      Effect.gen(function* () {

        const flags = yield* root;

        const output = yield* Output;

        const lease = yield* decodeLease(yield* readJsonFile(leasePath, "lease"), leasePath);

        const closeout = Option.isSome(closeoutPath)

          ? yield* decodeCloseout(

              yield* readJsonFile(closeoutPath.value, "closeout"),

              closeoutPath.value,

            )

          : undefined;

        const decision = settleLease(lease, closeout);

        yield* output.write(

          { value: decision, human: decisionHuman(decision) },

          outputMode(flags.json),

        );

      }),

  ).pipe(

    Command.withDescription(

      "Decide what one leased job earned. Payment follows a NIP-LBR closeout receipt that names a verification command, its evidence, and the platform's own closeout; a lease, a submission, or time spent online earns nothing. The decision accrues and never pays: no key is held and no payout rail is connected.",

    ),

  );

  return Command.make("provider").pipe(

    Command.withDescription(

      "Earn on verified work. The settlement gate is live; presence, the claim and lease transport, and payout are not wired, so this decides what work is owed rather than moving anything.",

    ),

    Command.withSubcommands([settleCommand]),

  );

};

/**

 * Provider mode: the settlement gate.

 *

 * ## What died, and what the corpse still teaches

 *

 * Pylon's provider loop -- NIP-89 announce, quote, execute on your own agent,

 * publish an output-only result, record a msat earning -- was deleted whole on

 * 2026-07-14 by VP-1 (`21e82ce8`, "retire money sites and wallet authority"),

 * along with `apps/pylon/src/provider-nip90.ts`, `labor-market.ts`, and

 * `multi-earning-ledger.ts`. It was not removed because it broke. It was

 * removed because payout and settlement were not part of the accepted MVP, and

 * `INVARIANTS.md` still says any revival needs a fresh design that does not

 * quietly restore custody.

 *

 * One piece survived the purge, uncalled, at

 * `apps/pylon/src/coordinator/labor-job-state.ts`. Its transition table reads:

 *

 *     accept: { quoted: "accepted" }

 *     start:  { accepted: "in_progress" }

 *     deliver:{ in_progress: "delivered" }

 *     settle: { delivered: "settled" }

 *

 * `settle` is legal straight out of `delivered`, and `delivered` is set by the

 * provider. That machine pays a claim. The doctrine the Pylon arc actually

 * earned -- a lease is not an earning claim, only a settlement receipt is --

 * cannot be expressed in it.

 *

 * ## What this is

 *

 * The corrected gate, on the surviving protocol substrate. `packages/nip90`

 * kept and grew the NIP-LBR lane through the purge: `lbr.ts` (request, quote,

 * acceptance, result), `lbr-bond.ts`, and `lbr-closeout.ts`, whose

 * `LbrLaborCloseout` is a content-addressed, public-safe receipt binding one

 * complete labor lifecycle. That receipt -- not the provider's own submission

 * -- is the thing this module will pay against.

 *

 * The closeout is read structurally rather than imported: `@openagentsinc/cli`

 * ships as a plain-tsc npm package with a deliberately small dependency set,

 * and `@openagentsinc/nip90` pulls a git-tarball dependency that does not

 * belong in it. {@link LaborCloseoutReceipt} mirrors only the public-safe

 * fields the gate reads, and every one of them is a field `lbr-closeout.ts`

 * already produces.

 *

 * ## What this refuses to be

 *

 * It moves no money and holds no key. A settled decision is an accrual record:

 * `payout_rail` is `not_connected` and `custody` is `none`. Outbound payout

 * stays on the MDK/Nexus bridge, and settlement authority stays in the platform

 * receipt systems, exactly as `docs/nips/LBR.md` says. The number here is what

 * a verified job is owed, recorded so a ledger can accrue while the rail stays

 * a separate, explicit owner decision.

 *

 * Presence is not an input. `settleLease` takes a lease and a closeout receipt.

 * Being online, advertising capacity, or holding a live lease reaches neither

 * argument, so a provider that never earns a closeout earns zero no matter how

 * long it is up.

 */

/**

 * A lease: the buyer's grant of one job to one provider at one price.

 *

 * `price_msats` is what the job is worth once it verifies. Holding the lease

 * earns none of it. `provider` is the provider's public key; deriving it is the

 * identity seam's job, not this module's.

 */

export interface ProviderLease {

  readonly job_id: string;

  readonly lane: string;

  readonly provider: string;

  readonly price_msats: number;

  readonly expires_at: string;

}

/**

 * The public-safe fields of a NIP-LBR closeout receipt this gate reads.

 *

 * A structural mirror of `LbrLaborCloseout` from

 * `packages/nip90/src/lbr-closeout.ts`; the names are that module's names so a

 * receipt produced there is accepted here without translation.

 */

export interface LaborCloseoutReceipt {

  /** `lbr-closeout:<requestId>:<digest>`. */

  readonly receiptRef: string;

  readonly requestId: string;

  readonly requesterPubkey: string;

  readonly providerPubkey: string;

  readonly quotedAmountMsats: number;

  /** What was run to check the work. Empty means nothing checked it. */

  readonly verificationCommandRef: string;

  /** The evidence that check produced. */

  readonly testRef: string;

  /** The platform's own closeout. Settlement authority lives there, not here. */

  readonly platformCloseoutRef: string;

  /** SHA-256 over the canonical projection, making the receipt dereferenceable. */

  readonly digest: string;

  readonly settled_at: string;

}

/** Why a settlement did not happen. Each one is a distinct, nameable failure. */

export type SettlementRefusal =

  | "price_not_payable"

  | "no_closeout"

  | "closeout_job_mismatch"

  | "closeout_provider_mismatch"

  | "self_dealt"

  | "work_not_verified"

  | "no_settlement_authority"

  | "receipt_not_addressable"

  | "lease_expired"

  | "price_mismatch";

export interface SettlementDecision {

  readonly schema: "openagents.provider_settlement.v1";

  readonly job_id: string;

  readonly state: "settled" | "unsettled";

  /** What the verified job is owed. Zero on every path but a clean receipt. */

  readonly earned_msats: number;

  readonly reason: string;

  readonly refusal?: SettlementRefusal;

  /** No rail is wired. A settled decision accrues; it does not pay. */

  readonly payout_rail: "not_connected";

  readonly custody: "none";

  readonly receipt_ref?: string;

}

const DIGEST_PATTERN = /^[a-f0-9]{64}$/i;

const unsettled = (

  job_id: string,

  refusal: SettlementRefusal,

  reason: string,

): SettlementDecision => ({

  schema: "openagents.provider_settlement.v1",

  job_id,

  state: "unsettled",

  earned_msats: 0,

  reason,

  refusal,

  payout_rail: "not_connected",

  custody: "none",

});

const blank = (value: string | undefined): boolean =>

  typeof value !== "string" || value.trim().length === 0;

const parsedTime = (value: string): number | undefined => {

  const at = Date.parse(value);

  return Number.isNaN(at) ? undefined : at;

};

/**

 * Decide what one leased job earns.

 *

 * The gates run in the order a reader would check them by hand, so a refusal

 * names the first thing that is actually wrong rather than the last. Only the

 * final branch returns a non-zero amount, and reaching it needs a closeout

 * receipt that exists, names this job and this provider, was not issued by the

 * provider to itself, carries both a verification command and the evidence it

 * produced, carries the platform's own closeout, is content-addressable, landed

 * inside the lease window, and prices the job exactly as the lease did.

 */

export const settleLease = (

  lease: ProviderLease,

  closeout?: LaborCloseoutReceipt,

): SettlementDecision => {

  if (!Number.isFinite(lease.price_msats) || lease.price_msats <= 0) {

    return unsettled(

      lease.job_id,

      "price_not_payable",

      `The lease prices this job at ${lease.price_msats} msats, so there is nothing to settle.`,

    );

  }

  if (closeout === undefined) {

    return unsettled(

      lease.job_id,

      "no_closeout",

      "No closeout receipt covers this job. A lease is not an earning claim and a submission is not a receipt, so this earns nothing.",

    );

  }

  if (closeout.requestId !== lease.job_id) {

    return unsettled(

      lease.job_id,

      "closeout_job_mismatch",

      `The receipt closes out job ${closeout.requestId}, not the leased job ${lease.job_id}.`,

    );

  }

  if (closeout.providerPubkey !== lease.provider) {

    return unsettled(

      lease.job_id,

      "closeout_provider_mismatch",

      `The receipt credits provider ${closeout.providerPubkey}, but the lease is held by ${lease.provider}.`,

    );

  }

  if (closeout.requesterPubkey === closeout.providerPubkey) {

    return unsettled(

      lease.job_id,

      "self_dealt",

      "The receipt names the same key as requester and provider. A provider cannot buy its own work into an earning.",

    );

  }

  if (blank(closeout.verificationCommandRef) || blank(closeout.testRef)) {

    return unsettled(

      lease.job_id,

      "work_not_verified",

      "The receipt carries no verification command and evidence pair, so nothing checked this work. Unverified work earns nothing.",

    );

  }

  if (blank(closeout.platformCloseoutRef)) {

    return unsettled(

      lease.job_id,

      "no_settlement_authority",

      "The receipt carries no platform closeout ref. Settlement authority stays in the platform receipt systems; the relay is only transport.",

    );

  }

  if (!DIGEST_PATTERN.test(closeout.digest)) {

    return unsettled(

      lease.job_id,

      "receipt_not_addressable",

      "The receipt digest is not a 32-byte hex hash, so the receipt cannot be dereferenced and re-verified.",

    );

  }

  const expiresAt = parsedTime(lease.expires_at);

  const settledAt = parsedTime(closeout.settled_at);

  if (expiresAt === undefined || settledAt === undefined) {

    return unsettled(

      lease.job_id,

      "lease_expired",

      "The lease window could not be read, so the closeout cannot be placed inside it.",

    );

  }

  if (settledAt > expiresAt) {

    return unsettled(

      lease.job_id,

      "lease_expired",

      `The job closed out at ${closeout.settled_at}, after the lease expired at ${lease.expires_at}.`,

    );

  }

  if (closeout.quotedAmountMsats !== lease.price_msats) {

    return unsettled(

      lease.job_id,

      "price_mismatch",

      `The receipt quotes ${closeout.quotedAmountMsats} msats but the lease priced the job at ${lease.price_msats} msats.`,

    );

  }

  return {

    schema: "openagents.provider_settlement.v1",

    job_id: lease.job_id,

    state: "settled",

    earned_msats: closeout.quotedAmountMsats,

    reason: `Verified by ${closeout.verificationCommandRef} with evidence ${closeout.testRef}, closed out by ${closeout.platformCloseoutRef}. Accrued, not paid: no payout rail is connected.`,

    payout_rail: "not_connected",

    custody: "none",

    receipt_ref: closeout.receiptRef,

  };

};

import { mkdtempSync, writeFileSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import * as NodeServices from "@effect/platform-node/NodeServices";

import { Effect, Layer } from "effect";

import { describe, expect, it } from "vitest";

import { runCliWith } from "../src/cli.js";

import { credentialStoreUnavailableLayer } from "../src/credential-store.js";

import { environmentLayerFromValues } from "../src/environment.js";

import { outputTestLayer, type OutputDocument, type OutputMode } from "../src/output.js";

import { persistedConfigurationTestLayer } from "../src/persisted-configuration.js";

import { terminalSessionTestLayer } from "../src/terminal-session.js";

interface Written {

  readonly document: OutputDocument;

  readonly mode: OutputMode;

}

const harness = () => {

  const written: Array<Written> = [];

  const layer = Layer.mergeAll(

    NodeServices.layer,

    environmentLayerFromValues({}),

    persistedConfigurationTestLayer({}),

    terminalSessionTestLayer(false),

    credentialStoreUnavailableLayer,

    outputTestLayer((document, mode) =>

      Effect.sync(() => {

        written.push({ document, mode });

      }),

    ),

  );

  const run = (argv: ReadonlyArray<string>) =>

    Effect.runPromise(

      runCliWith([...argv]).pipe(Effect.provide(layer)) as Effect.Effect<void, unknown>,

    );

  const fail = (argv: ReadonlyArray<string>) =>

    Effect.runPromise(

      runCliWith([...argv]).pipe(Effect.provide(layer), Effect.flip) as Effect.Effect<

        unknown,

        unknown

      >,

    );

  return { run, fail, written };

};

const DIGEST = "b".repeat(64);

const PROVIDER = "npub-provider-0000000000000000000000000000";

const workspace = () => {

  const root = mkdtempSync(join(tmpdir(), "openagents-provider-"));

  const write = (name: string, value: unknown) => {

    const path = join(root, name);

    writeFileSync(path, JSON.stringify(value, undefined, 2), "utf8");

    return path;

  };

  const leasePath = write("lease.json", {

    job_id: "job-9f2c",

    lane: "validator_replay",

    provider: PROVIDER,

    price_msats: 1_000,

    expires_at: "2026-08-25T18:00:00.000Z",

  });

  const closeoutPath = write("closeout.json", {

    receiptRef: `lbr-closeout:job-9f2c:${DIGEST}`,

    requestId: "job-9f2c",

    requesterPubkey: "npub-requester-1111111111111111111111111111",

    providerPubkey: PROVIDER,

    quotedAmountMsats: 1_000,

    verificationCommandRef: "verify:pnpm-run-check-fast",

    testRef: "test:run-4471-passed",

    platformCloseoutRef: "platform-closeout:2026-08-25/job-9f2c",

    digest: DIGEST,

    settled_at: "2026-08-25T17:30:00.000Z",

  });

  const unverifiedPath = write("unverified.json", {

    receiptRef: `lbr-closeout:job-9f2c:${DIGEST}`,

    requestId: "job-9f2c",

    requesterPubkey: "npub-requester-1111111111111111111111111111",

    providerPubkey: PROVIDER,

    quotedAmountMsats: 1_000,

    verificationCommandRef: "",

    testRef: "",

    platformCloseoutRef: "platform-closeout:2026-08-25/job-9f2c",

    digest: DIGEST,

    settled_at: "2026-08-25T17:30:00.000Z",

  });

  return { root, leasePath, closeoutPath, unverifiedPath, write };

};

describe("openagents provider settle", () => {

  it("settles a job whose closeout receipt proves the work", async () => {

    const { closeoutPath, leasePath } = workspace();

    const { run, written } = harness();

    await run(["--json", "provider", "settle", "--lease", leasePath, "--closeout", closeoutPath]);

    const value = written[0]?.document.value as Record<string, unknown>;

    expect(value["schema"]).toBe("openagents.provider_settlement.v1");

    expect(value["state"]).toBe("settled");

    expect(value["earned_msats"]).toBe(1_000);

  });

  it("earns nothing when the run offers no closeout receipt", async () => {

    const { leasePath } = workspace();

    const { run, written } = harness();

    await run(["--json", "provider", "settle", "--lease", leasePath]);

    const value = written[0]?.document.value as Record<string, unknown>;

    expect(value["state"]).toBe("unsettled");

    expect(value["earned_msats"]).toBe(0);

    expect(value["refusal"]).toBe("no_closeout");

  });

  it("earns nothing when the receipt shows nothing verified the work", async () => {

    const { leasePath, unverifiedPath } = workspace();

    const { run, written } = harness();

    await run(["--json", "provider", "settle", "--lease", leasePath, "--closeout", unverifiedPath]);

    const value = written[0]?.document.value as Record<string, unknown>;

    expect(value["earned_msats"]).toBe(0);

    expect(value["refusal"]).toBe("work_not_verified");

  });

  it("never claims a payout rail or custody", async () => {

    const { closeoutPath, leasePath } = workspace();

    const { run, written } = harness();

    await run(["--json", "provider", "settle", "--lease", leasePath, "--closeout", closeoutPath]);

    const value = written[0]?.document.value as Record<string, unknown>;

    expect(value["payout_rail"]).toBe("not_connected");

    expect(value["custody"]).toBe("none");

  });

  it("refuses a lease file that is missing the fields the gate needs", async () => {

    const { write } = workspace();

    const broken = write("broken.json", { job_id: "job-9f2c", price_msats: 1_000 });

    const { fail } = harness();

    const error = await fail(["provider", "settle", "--lease", broken]);

    expect(String((error as { message?: string }).message)).toContain("missing");

  });

  it("refuses a lease path that does not parse as JSON", async () => {

    const { fail } = harness();

    const error = await fail([

      "provider",

      "settle",

      "--lease",

      join(tmpdir(), "openagents-provider-absent.json"),

    ]);

    expect(String((error as { message?: string }).message)).toContain("could not be read as JSON");

  });

});

import { describe, expect, it } from "vitest";

import {

  settleLease,

  type LaborCloseoutReceipt,

  type ProviderLease,

} from "../src/provider-settlement.js";

const PROVIDER = "npub-provider-0000000000000000000000000000";

const REQUESTER = "npub-requester-1111111111111111111111111111";

const DIGEST = "a".repeat(64);

const lease = (overrides: Partial<ProviderLease> = {}): ProviderLease => ({

  job_id: "job-9f2c",

  lane: "validator_replay",

  provider: PROVIDER,

  price_msats: 1_000,

  expires_at: "2026-08-25T18:00:00.000Z",

  ...overrides,

});

/** A receipt that clears every gate, so each test can break exactly one. */

const closeout = (overrides: Partial<LaborCloseoutReceipt> = {}): LaborCloseoutReceipt => ({

  receiptRef: `lbr-closeout:job-9f2c:${DIGEST}`,

  requestId: "job-9f2c",

  requesterPubkey: REQUESTER,

  providerPubkey: PROVIDER,

  quotedAmountMsats: 1_000,

  verificationCommandRef: "verify:pnpm-run-check-fast",

  testRef: "test:run-4471-passed",

  platformCloseoutRef: "platform-closeout:2026-08-25/job-9f2c",

  digest: DIGEST,

  settled_at: "2026-08-25T17:30:00.000Z",

  ...overrides,

});

describe("provider settlement: payment follows a proof", () => {

  it("pays a job whose closeout receipt carries verification, evidence, and platform closeout", () => {

    const decision = settleLease(lease(), closeout());

    expect(decision.state).toBe("settled");

    expect(decision.earned_msats).toBe(1_000);

    expect(decision.refusal).toBeUndefined();

    expect(decision.receipt_ref).toBe(`lbr-closeout:job-9f2c:${DIGEST}`);

  });

  // The headline gate. Everything else in this file is a way of getting here

  // by a different road: without a receipt that proves the work, there is no

  // amount to be owed.

  it("earns nothing when no closeout receipt covers the job", () => {

    const decision = settleLease(lease());

    expect(decision.state).toBe("unsettled");

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("no_closeout");

  });

  it("earns nothing when the receipt names no verification command", () => {

    const decision = settleLease(lease(), closeout({ verificationCommandRef: "" }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("work_not_verified");

  });

  it("earns nothing when the verification produced no evidence", () => {

    const decision = settleLease(lease(), closeout({ testRef: "   " }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("work_not_verified");

  });

  it("earns nothing when no platform closeout backs the receipt", () => {

    const decision = settleLease(lease(), closeout({ platformCloseoutRef: "" }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("no_settlement_authority");

  });

  it("earns nothing when the provider is also the requester", () => {

    const decision = settleLease(lease(), closeout({ requesterPubkey: PROVIDER }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("self_dealt");

  });

  it("earns nothing when the receipt closes out a different job", () => {

    const decision = settleLease(lease(), closeout({ requestId: "job-other" }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("closeout_job_mismatch");

  });

  it("earns nothing when the receipt credits a different provider", () => {

    const decision = settleLease(lease(), closeout({ providerPubkey: "npub-somebody-else" }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("closeout_provider_mismatch");

  });

  it("earns nothing when the receipt is not content-addressable", () => {

    const decision = settleLease(lease(), closeout({ digest: "not-a-sha256" }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("receipt_not_addressable");

  });

  it("earns nothing when the work closed out after the lease expired", () => {

    const decision = settleLease(lease(), closeout({ settled_at: "2026-08-25T18:00:01.000Z" }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("lease_expired");

  });

  it("cannot be inflated by a receipt that quotes more than the lease priced", () => {

    const decision = settleLease(lease(), closeout({ quotedAmountMsats: 5_000_000 }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("price_mismatch");

  });

  it("earns nothing on an unpriced lease even with a clean receipt", () => {

    const decision = settleLease(lease({ price_msats: 0 }), closeout({ quotedAmountMsats: 0 }));

    expect(decision.earned_msats).toBe(0);

    expect(decision.refusal).toBe("price_not_payable");

  });

});

describe("provider settlement: presence is never paid", () => {

  // The lesson VP-1's deleted loop and the do-not-build register both carry:

  // being online is not work. There is no argument to `settleLease` that

  // uptime, advertised capacity, or a live lease could reach, and this pins

  // that shape so a later refactor cannot quietly add one.

  it("takes only a lease and a receipt, so uptime has nowhere to enter", () => {

    expect(settleLease.length).toBe(2);

  });

  it("pays a provider that held a live lease all day but never closed out nothing", () => {

    const allDay = lease({ expires_at: "2026-12-31T23:59:59.000Z" });

    expect(settleLease(allDay).earned_msats).toBe(0);

    expect(settleLease(allDay).refusal).toBe("no_closeout");

  });

});

describe("provider settlement: accrual, not custody", () => {

  it("reports no connected payout rail and no custody on a settled job", () => {

    const decision = settleLease(lease(), closeout());

    expect(decision.payout_rail).toBe("not_connected");

    expect(decision.custody).toBe("none");

  });

  it("reports no connected payout rail and no custody on a refusal too", () => {

    const decision = settleLease(lease());

    expect(decision.payout_rail).toBe("not_connected");

    expect(decision.custody).toBe("none");

  });

});