@skrr-ai/cli 0.1.60 → 0.1.62

package/dist/lib/agent-evals.js

@@ -0,0 +1,359 @@
+"use strict";
+/**
+ * `skrr agents eval` — the pure half (OSK-12303): reading a case file, choosing
+ * the release, and rendering what the platform reports back.
+ *
+ * The CLI never grades anything. It uploads the cases once, then asks the API
+ * to run each planned trial; the API executes, grades and prices every trial
+ * itself, so nothing printed here is a number the CLI computed from its own
+ * observations.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVAL_TRIAL_OBSERVE_LIMIT_MS = exports.EvalTrialFailedError = exports.EVAL_BASELINE_FLAG_VALUES = void 0;
+exports.readEvalCases = readEvalCases;
+exports.pickRelease = pickRelease;
+exports.pendingTrials = pendingTrials;
+exports.describeTrialLine = describeTrialLine;
+exports.describeEvalHeader = describeEvalHeader;
+exports.describeEvalReport = describeEvalReport;
+exports.isTrialStillRunningError = isTrialStillRunningError;
+exports.runEvalTrial = runEvalTrial;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const data_provider_1 = require("@skrr-ai/data-provider");
+const http_error_1 = require("./http-error");
+/** CLI spelling → API spelling. */
+exports.EVAL_BASELINE_FLAG_VALUES = {
+    'no-agent': 'no_agent',
+    'previous-release': 'previous_release',
+};
+function caseFromRaw(raw, where) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(`${where}: a case must be an object`);
+    }
+    const expected = raw.expected;
+    let assertions;
+    if (Array.isArray(raw.assertions))
+        assertions = raw.assertions;
+    else if (expected && Array.isArray(expected.assertions))
+        assertions = expected.assertions;
+    // Only what the server grades travels. A golden fixture's recorded output,
+    // judge scores and frozen agent config stay on this machine.
+    return {
+        id: raw.id,
+        prompt: raw.prompt,
+        assertions: (assertions ?? []),
+    };
+}
+function casesFromJson(value, where, fallbackId) {
+    if (Array.isArray(value))
+        return value.map((entry, i) => caseFromRaw(entry, `${where}[${i}]`));
+    if (value && typeof value === 'object') {
+        const record = value;
+        if (Array.isArray(record.cases)) {
+            return record.cases.map((entry, i) => caseFromRaw(entry, `${where} cases[${i}]`));
+        }
+        // One WS-1.6 golden fixture per file: its id defaults to the file name.
+        const single = caseFromRaw(record, where);
+        if (!single.id && fallbackId)
+            single.id = fallbackId;
+        return [single];
+    }
+    throw new Error(`${where}: expected a list of cases, {"cases": [...]}, or one case`);
+}
+/**
+ * Read `--cases`: a JSON file (a list, `{cases: [...]}`, or one case) or a
+ * directory of such files, read in name order — so the repo's golden set
+ * directory is a valid argument as-is.
+ */
+function readEvalCases(casesPath) {
+    const resolved = path.resolve(casesPath);
+    const stat = fs.statSync(resolved);
+    const files = stat.isDirectory()
+        ? fs
+            .readdirSync(resolved)
+            .filter((name) => name.endsWith('.json'))
+            .sort()
+            .map((name) => path.join(resolved, name))
+        : [resolved];
+    if (files.length === 0)
+        throw new Error(`${casesPath}: no .json case files found`);
+    const cases = files.flatMap((file) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        }
+        catch (error) {
+            throw new Error(`${file}: not valid JSON (${error.message})`);
+        }
+        return casesFromJson(parsed, path.basename(file), path.basename(file, '.json'));
+    });
+    if (cases.length > data_provider_1.RELEASE_EVAL_LIMITS.maxCases) {
+        throw new Error(`${cases.length} cases found; an evaluation takes at most ${data_provider_1.RELEASE_EVAL_LIMITS.maxCases}`);
+    }
+    return cases;
+}
+/**
+ * `--release`: an id, a version label (`1.2` or `v1.2`), or omitted for the
+ * newest release. Releases arrive newest first.
+ */
+function pickRelease(releases, wanted) {
+    if (!wanted) {
+        return [...releases].sort((a, b) => (b.releaseNumber ?? 0) - (a.releaseNumber ?? 0))[0];
+    }
+    const label = wanted.replace(/^v/i, '');
+    return releases.find((release) => release.id === wanted || release.versionLabel === label);
+}
+/** The planned trials that have no graded result yet, in run order. */
+function pendingTrials(evaluation) {
+    const done = new Set((evaluation.trials ?? []).filter((t) => t.state === 'completed').map((t) => t.key));
+    return (0, data_provider_1.releaseEvalTrialPlan)({
+        cases: evaluation.cases,
+        trialsPerCase: evaluation.trialsPerCase,
+    }).filter((entry) => !done.has(entry.key));
+}
+function armLabel(evaluation, arm) {
+    return arm === 'candidate'
+        ? `v${evaluation.versionLabel ?? '?'}`
+        : (0, data_provider_1.describeReleaseEvalBaseline)(evaluation.baseline);
+}
+function describeTrialLine(evaluation, trial, position, total, replayed = false) {
+    let verdict = 'RUNNING';
+    if (trial.state === 'completed')
+        verdict = trial.passed ? 'PASS' : 'FAIL';
+    const failed = (trial.assertions ?? []).filter((a) => !a.passed).map((a) => a.id);
+    return [
+        `  [${position}/${total}]`,
+        armLabel(evaluation, trial.arm).padEnd(14),
+        `${trial.caseId} #${trial.trialIndex}`.padEnd(28),
+        verdict.padEnd(4),
+        (0, data_provider_1.formatReleaseEvalCostMicros)(trial.costMicros).padStart(9),
+        replayed ? '(already graded)' : '',
+        failed.length ? `failed: ${failed.join(', ')}` : '',
+    ]
+        .filter(Boolean)
+        .join('  ');
+}
+function armRow(label, arm) {
+    const unpriced = arm.unpricedTrials ?? 0;
+    return [
+        `  ${label.padEnd(18)}`,
+        `${(0, data_provider_1.formatReleaseEvalPassRate)(arm.passRate)} (${arm.passed}/${arm.trials})`.padEnd(16),
+        (0, data_provider_1.formatReleaseEvalCostMicros)(arm.meanCostMicros).padStart(10),
+        (0, data_provider_1.formatReleaseEvalCostMicros)(arm.totalCostMicros).padStart(12),
+        // An unpriced trial is left out of both cost figures, not priced at $0.
+        unpriced > 0 ? `(${unpriced} unpriced, not in cost)` : '',
+    ]
+        .filter(Boolean)
+        .join('  ');
+}
+function describeEvalHeader(evaluation) {
+    const baseline = evaluation.baseline.kind === 'no_agent'
+        ? `no agent — the default assistant on ${evaluation.baseline.model || 'the release model'}`
+        : (0, data_provider_1.describeReleaseEvalBaseline)(evaluation.baseline);
+    return [
+        `Evaluation ${evaluation.id}`,
+        `  Release:   v${evaluation.versionLabel ?? '?'} (${evaluation.releaseId})`,
+        `  Baseline:  ${baseline}`,
+        `  Cases:     ${evaluation.cases.length} × ${evaluation.trialsPerCase} trial(s) on each side`,
+        `  Listed:    ${evaluation.listed
+            ? 'yes — shown on the store listing now, with a result once every trial is graded'
+            : 'no — visible only to you'}`,
+    ];
+}
+/** The comparison, the per-case table, and the provenance lines. */
+function describeEvalReport(evaluation) {
+    const { summary } = evaluation;
+    const provenance = (0, data_provider_1.describeReleaseEvalProvenance)(evaluation);
+    const lines = [
+        ...describeEvalHeader(evaluation),
+        `  Status:    ${evaluation.status}${evaluation.status === 'running'
+            ? ` — ${summary.recordedTrials} of ${summary.expectedTrials} trials graded`
+            : ''}`,
+        '',
+        `  ${''.padEnd(18)}  ${'pass rate'.padEnd(16)}  ${'cost/run'.padStart(10)}  ${'total cost'.padStart(12)}`,
+        armRow(armLabel(evaluation, 'candidate'), summary.candidate),
+        armRow(armLabel(evaluation, 'baseline'), summary.baseline),
+        `  ${'delta'.padEnd(18)}  ${summary.passRateDelta == null
+            ? 'n/a'
+            : `${summary.passRateDelta >= 0 ? '+' : ''}${Math.round(summary.passRateDelta * 100)} pts`}`,
+        '',
+        '  Per case (passed/trials):',
+        ...summary.perCase.map((row) => `    ${row.caseId.padEnd(28)}  ${armLabel(evaluation, 'candidate')} ${row.candidate.passed}/${row.candidate.trials}   ${armLabel(evaluation, 'baseline')} ${row.baseline.passed}/${row.baseline.trials}`),
+        '',
+        `  ${provenance.runner} · ${provenance.casesAuthor}`,
+        '  Cost is model usage at the price billed to your account.',
+    ];
+    if (evaluation.erroredAttempts > 0) {
+        lines.push(`  ${evaluation.erroredAttempts} trial attempt(s) errored before a result (recorded on the evaluation).`);
+    }
+    return lines;
+}
+/** A trial that ended without a result; `message` is the server's reason. */
+class EvalTrialFailedError extends Error {
+    key;
+    constructor(key, message) {
+        super(message);
+        this.key = key;
+        this.name = 'EvalTrialFailedError';
+    }
+}
+exports.EvalTrialFailedError = EvalTrialFailedError;
+/** How long one trial is observed before the CLI gives up and says how to resume. */
+exports.EVAL_TRIAL_OBSERVE_LIMIT_MS = 15 * 60 * 1000;
+const OBSERVE_WAIT_MS = Math.min(20_000, data_provider_1.RELEASE_EVAL_OBSERVE_MAX_WAIT_MS);
+const MAX_CONSECUTIVE_OBSERVE_ERRORS = 3;
+/**
+ * Whether a failed START may still have started the trial, or found it
+ * running: an edge timeout or dropped connection (the request may have landed),
+ * or the server saying another run holds it. Either way the answer is to
+ * observe the trial, not to give up — or to start a second run.
+ */
+function isTrialStillRunningError(error) {
+    const status = (0, http_error_1.httpStatusOf)(error);
+    if (status === undefined)
+        return true;
+    if (status === 502 || status === 503 || status === 504)
+        return true;
+    return status === 409 && (0, http_error_1.httpBodyOf)(error)?.code === 'RELEASE_EVAL_TRIAL_IN_PROGRESS';
+}
+function attemptErrorCount(evaluation, key) {
+    return (evaluation?.attemptErrors ?? []).filter((entry) => entry.key === key).length;
+}
+function latestAttemptError(evaluation, key) {
+    const mine = (evaluation.attemptErrors ?? []).filter((entry) => entry.key === key);
+    return mine.length ? mine[mine.length - 1].message : undefined;
+}
+/**
+ * Run ONE planned trial to a graded result: start it, then observe it with
+ * bounded reads until it is graded. No request waits on the run itself.
+ *
+ * - A trial already graded comes back at once (`replayed`).
+ * - A start that fails in a way that may have started it (an edge 504, a
+ *   dropped connection) or that finds it running elsewhere is observed.
+ * - A run that errors is recorded by the server; that reason is thrown as an
+ *   `EvalTrialFailedError`, and a re-run is the caller's choice (`--resume`).
+ * - A claim whose run is gone (`stale`) is started again, which retakes it.
+ */
+async function runEvalTrial(client, entry) {
+    const sleep = client.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const now = client.now ?? (() => Date.now());
+    const deadline = now() + exports.EVAL_TRIAL_OBSERVE_LIMIT_MS;
+    let started;
+    try {
+        started = await client.start(entry);
+    }
+    catch (error) {
+        if (!isTrialStillRunningError(error))
+            throw error;
+    }
+    if (started?.trial.state === 'completed') {
+        return { trial: started.trial, evaluation: started.evaluation, replayed: started.replayed };
+    }
+    // A failure recorded AFTER this point is this run's; one recorded before
+    // belongs to an earlier attempt.
+    let knownErrors = attemptErrorCount(started?.evaluation, entry.key);
+    let baselineKnown = started !== undefined;
+    let consecutiveErrors = 0;
+    let restartedLostStart = false;
+    while (now() < deadline) {
+        let evaluation;
+        try {
+            evaluation = await client.observe({ trial: entry.key, waitMs: OBSERVE_WAIT_MS });
+            consecutiveErrors = 0;
+        }
+        catch (error) {
+            consecutiveErrors += 1;
+            if (consecutiveErrors >= MAX_CONSECUTIVE_OBSERVE_ERRORS)
+                throw error;
+            await sleep(2_000);
+            continue;
+        }
+        const trial = (evaluation.trials ?? []).find((t) => t.key === entry.key);
+        if (trial?.state === 'completed') {
+            return { trial, evaluation, replayed: false };
+        }
+        const errors = attemptErrorCount(evaluation, entry.key);
+        if (!baselineKnown) {
+            // The start's answer never arrived. If nothing holds the trial, the
+            // start never landed: start it once more rather than wait on nothing.
+            if (!trial && !restartedLostStart) {
+                restartedLostStart = true;
+                try {
+                    const restarted = await client.start(entry);
+                    if (restarted.trial.state === 'completed') {
+                        return {
+                            trial: restarted.trial,
+                            evaluation: restarted.evaluation,
+                            replayed: restarted.replayed,
+                        };
+                    }
+                    knownErrors = attemptErrorCount(restarted.evaluation, entry.key);
+                    baselineKnown = true;
+                }
+                catch (error) {
+                    if (!isTrialStillRunningError(error))
+                        throw error;
+                }
+                continue;
+            }
+            knownErrors = errors;
+            baselineKnown = true;
+        }
+        if (errors > knownErrors || !trial) {
+            throw new EvalTrialFailedError(entry.key, latestAttemptError(evaluation, entry.key) ?? `Trial ${entry.key} did not produce a result`);
+        }
+        if (trial.stale) {
+            // The run behind the claim is gone; starting again retakes it.
+            try {
+                const retaken = await client.start(entry);
+                if (retaken.trial.state === 'completed') {
+                    return {
+                        trial: retaken.trial,
+                        evaluation: retaken.evaluation,
+                        replayed: retaken.replayed,
+                    };
+                }
+                knownErrors = attemptErrorCount(retaken.evaluation, entry.key);
+            }
+            catch (error) {
+                if (!isTrialStillRunningError(error))
+                    throw error;
+            }
+        }
+    }
+    throw new EvalTrialFailedError(entry.key, `Trial ${entry.key} was still running after ${Math.round(exports.EVAL_TRIAL_OBSERVE_LIMIT_MS / 60_000)} minutes`);
+}

package/dist/lib/agent-spec.d.ts

@@ -0,0 +1,28 @@
+import { type AgentSpecDocument, type AgentSpecIssue, type AgentSpecValidation } from '@skrr-ai/data-provider';
+/**
+ * Shared plumbing for `skrr agents pull | push | validate | import`.
+ *
+ * The rules themselves are not here — they live in `@skrr-ai/data-provider`
+ * (`agents/agentSpec`) and the server reads the same module, so an offline
+ * `validate` and a server-side push refusal cannot disagree about a field.
+ */
+/** Serialize a document the way `pull` writes it: stable, reviewable in a diff. */
+export declare function serializeAgentSpecDocument(document: AgentSpecDocument): string;
+/** Read a file, or stdin for `-`. */
+export declare function readSpecSource(source: string): Promise<string>;
+export type ParsedSpecSource = {
+    ok: true;
+    validation: AgentSpecValidation;
+} | {
+    ok: false;
+    message: string;
+};
+/** Parse JSON text and validate it as an agent spec document, with no network. */
+export declare function parseAndValidateAgentSpec(raw: string, source: string): ParsedSpecSource;
+/** The issue list a server refusal carried, when it carried one. */
+export declare function refusalIssues(err: unknown): {
+    code?: string;
+    issues: AgentSpecIssue[];
+} | null;
+/** Issue lines indented under a heading, for a terminal. */
+export declare function issueBlock(heading: string, issues: readonly AgentSpecIssue[]): string;

package/dist/lib/agent-spec.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeAgentSpecDocument = serializeAgentSpecDocument;
+exports.readSpecSource = readSpecSource;
+exports.parseAndValidateAgentSpec = parseAndValidateAgentSpec;
+exports.refusalIssues = refusalIssues;
+exports.issueBlock = issueBlock;
+const promises_1 = require("node:fs/promises");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const prompt_1 = require("./prompt");
+/**
+ * Shared plumbing for `skrr agents pull | push | validate | import`.
+ *
+ * The rules themselves are not here — they live in `@skrr-ai/data-provider`
+ * (`agents/agentSpec`) and the server reads the same module, so an offline
+ * `validate` and a server-side push refusal cannot disagree about a field.
+ */
+/** Serialize a document the way `pull` writes it: stable, reviewable in a diff. */
+function serializeAgentSpecDocument(document) {
+    return `${JSON.stringify(document, null, 2)}\n`;
+}
+/** Read a file, or stdin for `-`. */
+async function readSpecSource(source) {
+    return source === '-' ? (0, prompt_1.readStdin)() : (0, promises_1.readFile)(source, 'utf8');
+}
+/** Parse JSON text and validate it as an agent spec document, with no network. */
+function parseAndValidateAgentSpec(raw, source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        return { ok: false, message: `${source} is not valid JSON: ${err.message}` };
+    }
+    return { ok: true, validation: (0, data_provider_1.validateAgentSpecDocument)(parsed) };
+}
+/** The issue list a server refusal carried, when it carried one. */
+function refusalIssues(err) {
+    const body = err?.body;
+    if (typeof body !== 'string')
+        return null;
+    try {
+        const parsed = JSON.parse(body);
+        if (!Array.isArray(parsed.issues))
+            return null;
+        return {
+            code: typeof parsed.code === 'string' ? parsed.code : undefined,
+            issues: parsed.issues,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Issue lines indented under a heading, for a terminal. */
+function issueBlock(heading, issues) {
+    return [heading, ...(0, data_provider_1.formatAgentSpecIssues)(issues).map((line) => `  - ${line}`)].join('\n');
+}

package/dist/lib/auth-storage.d.ts

@@ -113,6 +113,18 @@ export declare function readFromBackend(expectedServerOrigin?: string): ReadResu
  * that explain an absent sign-in (BaseCommand, `skrr doctor`).
  */
 export declare function describeForeignCredential(result: ReadResult): string | null;
+/**
+ * Persist a token bundle to the preferred backend.
+ *
+ * Writes to keychain when available, file otherwise. If keychain writes
+ * fail mid-flight (e.g., user canceled the unlock prompt), we fall back
+ * to the file backend so the CLI remains functional.
+ *
+ * Returns the backend that actually accepted the write. Callers wanting
+ * a specific backend (bare mode, store-mode overrides) should call the
+ * lower-level write helpers directly — not exported here to keep the
+ * default path honest.
+ */
 export declare function writeToBackend(bundle: AuthBundle, options?: WriteOptions): AuthBackend;
 /**
  * Clear both backends. Called on `skrr logout` (and internally during

package/dist/lib/auth-storage.js

@@ -760,37 +760,6 @@ function describeForeignCredential(result) {
  * lower-level write helpers directly — not exported here to keep the
  * default path honest.
  */
-/**
- * Clear the DAEMON's needs-reauth latch as well as the CLI's own.
- *
- * `clearReauthState()` resolves `getAuthConfigDir()`, and the two binaries wire
- * that differently: the CLI points auth-core at the machine root (`~/.skrr`),
- * the daemon at its PROFILE dir (`~/.skrr/profiles/<profile>`). So the daemon
- * latched at one path while `skrr login` cleared another — a file that on most
- * machines does not exist at all, which made the clear a silent no-op.
- *
- * The visible cost was a loop with no exit: `skrr daemon status` reported
- * "Cause: TOKEN_INVALID · Remedy: run `skrr login`", the login succeeded, and
- * the flag never moved, so the daemon's realtime channel stayed down and it
- * could not execute tasks. `auth-core-init.ts` states the intent — "share the
- * daemon's config root so auth.lock and the needs-reauth flag are coordinated
- * across binaries" — which stopped being true when the daemon became
- * profile-scoped.
- *
- * The ACTIVE profile only, deliberately: a per-profile latch is correct because
- * different profiles can hold different credentials, and a login re-authorises
- * exactly the one it just wrote.
- */
-function clearDaemonProfileReauthState() {
-    try {
-        const target = path.join(os.homedir(), '.skrr', 'profiles', keychain.getActiveProfile(), 'needs-reauth.json');
-        fs.rmSync(target, { force: true });
-    }
-    catch {
-        // Best effort: the CLI's own latch is already cleared, and failing to
-        // remove the daemon's must not fail a login that otherwise succeeded.
-    }
-}
 function writeToBackend(bundle, options = {}) {
     const requestedOrigin = options.serverOrigin ?? bundle.serverOrigin;
     let persistedBundle = bundle;
@@ -822,7 +791,6 @@ function writeToBackend(bundle, options = {}) {
             backend = 'keychain';
             if (options.clearReauth) {
                 (0, auth_core_1.clearReauthState)();
-                clearDaemonProfileReauthState();
             }
             return backend;
         }
@@ -837,7 +805,6 @@ function writeToBackend(bundle, options = {}) {
     backend = 'file';
     if (options.clearReauth) {
         (0, auth_core_1.clearReauthState)();
-        clearDaemonProfileReauthState();
     }
     return backend;
 }

package/dist/lib/commerce.d.ts

@@ -1,3 +1,4 @@
+import type { TMarketplaceFeeSchedule } from '@skrr-ai/data-provider';
 /**
  * `/api/commerce` — marketplace terms, the offer governance pipeline, trials,
  * promotions, and the incident queue behind fulfillment and integrity.
@@ -38,6 +39,13 @@ export declare function getMarketplaceTerms(scope: MarketplaceTermsScope): Promi
  * may default, because the whole value of the receipt is that somebody said so.
  */
 export declare function acceptMarketplaceTerms(scope: MarketplaceTermsScope): Promise<unknown>;
+/**
+ * `GET /marketplace/fee-schedule` — the seller share, hold and payout minimum
+ * every surface quotes, under the publisher terms in force (OSK-12271). The
+ * shape is `@skrr-ai/data-provider`'s, the one the web client reads too.
+ * `version` names a past schedule version for audit reads (OSK-12539).
+ */
+export declare function getMarketplaceFeeSchedule(version?: string): Promise<TMarketplaceFeeSchedule>;
 /** `GET /admin/marketplace/incidents/:kind` — the queue. */
 export declare function listMarketplaceIncidents(kind: string, params?: {
     status?: string;

package/dist/lib/commerce.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketplaceTerms = getMarketplaceTerms;
 exports.acceptMarketplaceTerms = acceptMarketplaceTerms;
+exports.getMarketplaceFeeSchedule = getMarketplaceFeeSchedule;
 exports.listMarketplaceIncidents = listMarketplaceIncidents;
 exports.getMarketplaceIncident = getMarketplaceIncident;
 exports.listMarketplaceIncidentAudit = listMarketplaceIncidentAudit;
@@ -44,6 +45,15 @@ async function acceptMarketplaceTerms(scope) {
         body: { scope, accepted: true },
     });
 }
+/**
+ * `GET /marketplace/fee-schedule` — the seller share, hold and payout minimum
+ * every surface quotes, under the publisher terms in force (OSK-12271). The
+ * shape is `@skrr-ai/data-provider`'s, the one the web client reads too.
+ * `version` names a past schedule version for audit reads (OSK-12539).
+ */
+async function getMarketplaceFeeSchedule(version) {
+    return (0, api_fetch_1.apiFetch)((0, triggers_1.withQuery)('/api/commerce/marketplace/fee-schedule', { version }));
+}
 /** `GET /admin/marketplace/incidents/:kind` — the queue. */
 async function listMarketplaceIncidents(kind, params = {}) {
     return (0, api_fetch_1.apiFetch)((0, triggers_1.withQuery)(`/api/commerce/admin/marketplace/incidents/${encodeURIComponent(kind)}`, params));

package/dist/lib/earnings.d.ts

@@ -0,0 +1,36 @@
+import { type TConnectAutoPayout, type TConnectEarnings, type TConnectPayoutHistoryResponse, type TConnectStatement, type TConnectStatementsResponse } from '@skrr-ai/data-provider';
+/**
+ * earnings.ts — the read-only publisher payout surface (OSK-12272).
+ *
+ * `skrr earnings` reads a publisher's balance, automatic-payout state, monthly
+ * statements and payout history from `/api/connect/*`. It is read-only on
+ * purpose: requesting a payout and switching automatic payouts on move money,
+ * and those routes refuse a daemon credential (`refuseDaemonScope`), so they
+ * stay in the web Earnings page where a signed-in person does them.
+ *
+ * Every read goes through `dataService`, so the path a command reaches is the
+ * same one the web page reads, and copy for server vocabularies comes from
+ * `@skrr-ai/data-provider` (`connectPayouts.ts`), shared with that page.
+ */
+export declare const readEarnings: () => Promise<TConnectEarnings>;
+export declare const readAutoPayout: () => Promise<TConnectAutoPayout>;
+export declare const readStatements: (params: {
+    limit?: number;
+    cursor?: string;
+}) => Promise<TConnectStatementsResponse>;
+export declare const readStatement: (period: string) => Promise<TConnectStatement>;
+export declare const readPayouts: (params: {
+    limit?: number;
+    cursor?: string;
+}) => Promise<TConnectPayoutHistoryResponse>;
+export declare const PERIOD_PATTERN: RegExp;
+type Log = (line: string) => void;
+/** `skrr earnings`: the balance, then how and when it is paid out. */
+export declare function renderEarningsSummary(earnings: TConnectEarnings, autoPayout: TConnectAutoPayout | null, log: Log): void;
+/** `skrr earnings statements`: one row per month, newest first. */
+export declare function renderStatementList(result: TConnectStatementsResponse, log: Log): void;
+/** `skrr earnings statements <YYYY-MM>`: the whole statement, opening to closing. */
+export declare function renderStatement(statement: TConnectStatement, log: Log): void;
+/** `skrr earnings payouts`: the payout ledger, newest first. */
+export declare function renderPayoutHistory(result: TConnectPayoutHistoryResponse, log: Log): void;
+export {};