@skrr-ai/cli 0.1.35 → 0.1.36

package/dist/commands/tasks/export.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const promises_1 = require("node:fs/promises");
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const list_1 = require("./list");
 const tasks_1 = require("../../lib/tasks");
 const task_transfer_1 = require("../../lib/task-transfer");
+const artifact_export_1 = require("../../lib/artifact-export");
 /** The list filter vocabulary is intentionally mirrored here; request construction stays shared. */
 const FILTER_FLAGS = {
     space: core_1.Flags.string({ description: 'Filter by space ID' }),
@@ -49,26 +49,24 @@ const FILTER_FLAGS = {
 class TasksExport extends base_command_1.BaseCommand {
     static description = 'Export a filtered task forest as portable JSON or flat CSV';
     static examples = [
+        '<%= config.bin %> tasks export --space <space-id> --summary',
         '<%= config.bin %> tasks export --space <space-id> --output tasks.json',
         '<%= config.bin %> tasks export --space <space-id> --format csv --output tasks.csv',
-        '<%= config.bin %> tasks export --space <space-id> --with-comments > tasks.json',
+        '<%= config.bin %> tasks export --space <space-id> --output - | jq .',
     ];
     static flags = {
         ...FILTER_FLAGS,
+        ...(0, artifact_export_1.paginatedExportFlags)({ defaultMaxItems: 1000 }),
         format: core_1.Flags.string({
             description: 'Portable output format',
             options: ['json', 'csv'],
             default: 'json',
         }),
-        output: core_1.Flags.string({
-            description: 'Write to this path instead of stdout (use "-" for stdout)',
-        }),
         'with-comments': core_1.Flags.boolean({
             description: 'Include comment bodies. Imported comments are newly authored by the importing principal.',
         }),
         max: core_1.Flags.integer({
-            description: 'Safety cap for exported tasks',
-            default: 10000,
+            description: 'Deprecated alias for --max-items',
             min: 1,
             max: 100000,
         }),
@@ -76,6 +74,29 @@ class TasksExport extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { flags } = await this.parse(TasksExport);
+        let selection;
+        try {
+            selection = (0, artifact_export_1.resolveExportSelection)(flags);
+        }
+        catch (err) {
+            if (err instanceof artifact_export_1.ExportContractError) {
+                this.failWithCliError({
+                    message: err.message,
+                    code: err.code,
+                    exit: 2,
+                    retryable: false,
+                });
+            }
+            throw err;
+        }
+        if (flags.max !== undefined && flags['max-items'] !== undefined) {
+            this.failWithCliError({
+                message: '--max and --max-items cannot be used together.',
+                code: 'TASK_EXPORT_MAX_FLAG_CONFLICT',
+                exit: 2,
+                retryable: false,
+            });
+        }
         if (flags.mine && flags['assignee-user']) {
             this.failWithCliError({
                 message: '--mine and --assignee-user are mutually exclusive.',
@@ -97,9 +118,9 @@ class TasksExport extends base_command_1.BaseCommand {
         const assigneeUserId = flags.mine || flags['assignee-user']?.trim().toLowerCase() === 'me'
             ? await this.resolveCurrentUserId()
             : flags['assignee-user'];
-        const max = flags.max ?? 10000;
+        const max = flags.max ?? flags['max-items'] ?? 1000;
         const all = [];
-        let cursor;
+        let cursor = flags.cursor;
         let hasMore = false;
         do {
             let response;
@@ -119,14 +140,6 @@ class TasksExport extends base_command_1.BaseCommand {
             cursor = response.next_cursor ?? undefined;
             hasMore = Boolean(response.has_more && cursor);
         } while (hasMore && all.length < max);
-        if (hasMore) {
-            this.failWithCliError({
-                message: `Export reached the --max safety cap (${max}). Narrow filters or pass a larger --max.`,
-                code: 'TASK_EXPORT_MAX_REACHED',
-                exit: 2,
-                retryable: false,
-            });
-        }
         const commentsByTaskId = new Map();
         if (flags['with-comments']) {
             for (const task of all) {
@@ -158,16 +171,51 @@ class TasksExport extends base_command_1.BaseCommand {
                     commentsByTaskId.set(taskId, comments);
             }
         }
+        const commentCount = [...commentsByTaskId.values()].reduce((sum, comments) => sum + comments.length, 0);
+        if (selection.summary) {
+            const summary = (0, artifact_export_1.contentFreeSummary)({
+                command: 'tasks export',
+                artifactSchemaVersion: 1,
+                itemCount: all.length,
+                counts: { tasks: all.length, comments: commentCount },
+                truncated: hasMore,
+                nextCursor: cursor,
+            });
+            this.log(selection.json ? JSON.stringify(summary, null, 2) : (0, artifact_export_1.humanExportSummary)(summary));
+            return;
+        }
         const exported = (0, task_transfer_1.buildPortableTaskExport)(all, commentsByTaskId);
         const content = flags.format === 'csv'
             ? (0, task_transfer_1.portableTaskExportToCsv)(exported)
             : JSON.stringify(exported, null, 2);
-        if (flags.output && flags.output !== '-') {
-            await (0, promises_1.writeFile)(flags.output, `${content}\n`, 'utf8');
-            this.log(`Exported ${all.length} task(s) to ${flags.output}.`);
+        const artifact = content.endsWith('\n') ? content : `${content}\n`;
+        if (selection.output === '-') {
+            this.log(content);
             return;
         }
-        this.log(content);
+        let receipt;
+        try {
+            receipt = await (0, artifact_export_1.writeExportArtifact)({
+                command: 'tasks export',
+                artifactSchemaVersion: exported.version,
+                format: flags.format ?? 'json',
+                output: selection.output,
+                content: artifact,
+                itemCount: all.length,
+                truncated: hasMore,
+                nextCursor: cursor,
+            });
+        }
+        catch (err) {
+            this.failWithCliError({
+                message: `Could not write ${selection.output}: ${err.message}`,
+                code: 'TASK_EXPORT_WRITE_FAILED',
+                exit: 1,
+                retryable: false,
+                details: { path: selection.output },
+            });
+        }
+        this.log(selection.json ? JSON.stringify(receipt, null, 2) : (0, artifact_export_1.humanExportReceipt)(receipt));
     }
 }
 exports.default = TasksExport;

package/dist/commands/tones/export.d.ts

@@ -20,9 +20,11 @@ export default class TonesExport extends BaseCommand {
         id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
-        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         mine: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         out: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        summary: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/tones/export.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TONE_BUNDLE_VERSION = void 0;
 const core_1 = require("@oclif/core");
-const promises_1 = require("node:fs/promises");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const tone_input_1 = require("../../lib/tone-input");
+const artifact_export_1 = require("../../lib/artifact-export");
 /** Shape written by `export` and accepted by `import`. */
 exports.TONE_BUNDLE_VERSION = 1;
 /**
@@ -23,9 +23,10 @@ exports.TONE_BUNDLE_VERSION = 1;
 class TonesExport extends base_command_1.BaseCommand {
     static description = 'Export tones as JSON (round-trips with `tones import`)';
     static examples = [
-        '<%= config.bin %> tones export',
-        '<%= config.bin %> tones export --mine --out tones.json',
-        '<%= config.bin %> tones export brief --out brief.json',
+        '<%= config.bin %> tones export --summary',
+        '<%= config.bin %> tones export --mine --output tones.json',
+        '<%= config.bin %> tones export brief --output brief.json',
+        '<%= config.bin %> tones export --output - | jq .',
     ];
     static args = {
         id: core_1.Args.string({
@@ -35,15 +36,28 @@ class TonesExport extends base_command_1.BaseCommand {
         }),
     };
     static flags = {
-        json: core_1.Flags.boolean({
-            description: 'Print the bundle to stdout even when --out wrote it to a file',
-        }),
+        ...(0, artifact_export_1.standardExportFlags)(),
         mine: core_1.Flags.boolean({ description: 'Export only tones you authored' }),
-        out: core_1.Flags.string({ description: 'Write to this file instead of stdout' }),
+        out: core_1.Flags.string({ description: 'Deprecated alias for --output' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TonesExport);
+        let selection;
+        try {
+            selection = (0, artifact_export_1.resolveExportSelection)(flags);
+        }
+        catch (err) {
+            if (err instanceof artifact_export_1.ExportContractError) {
+                this.failWithCliError({
+                    message: err.message,
+                    code: err.code,
+                    exit: 2,
+                    retryable: false,
+                });
+            }
+            throw err;
+        }
         let library;
         try {
             library = await data_provider_1.dataService.listTones();
@@ -79,6 +93,19 @@ class TonesExport extends base_command_1.BaseCommand {
         else {
             selected = flags.mine ? [...library.custom] : [...library.presets, ...library.custom];
         }
+        if (selection.summary) {
+            const summary = (0, artifact_export_1.contentFreeSummary)({
+                command: 'tones export',
+                artifactSchemaVersion: exports.TONE_BUNDLE_VERSION,
+                itemCount: selected.length,
+                counts: {
+                    presets: selected.filter((tone) => !(0, tone_input_1.isCustomTone)(tone)).length,
+                    custom: selected.filter((tone) => (0, tone_input_1.isCustomTone)(tone)).length,
+                },
+            });
+            this.log(selection.json ? JSON.stringify(summary, null, 2) : (0, artifact_export_1.humanExportSummary)(summary));
+            return;
+        }
         const bundle = {
             object: 'sky.tone.bundle',
             version: exports.TONE_BUNDLE_VERSION,
@@ -97,30 +124,32 @@ class TonesExport extends base_command_1.BaseCommand {
                 visibility: (0, tone_input_1.isCustomTone)(tone) ? tone.visibility : 'private',
             })),
         };
-        const serialized = `${JSON.stringify(bundle, null, 2)}\n`;
-        if (!flags.out) {
-            // stdout IS the bundle here — `skrr tones export > tones.json` and
-            // `… | jq` both work without a flag, so --json is a no-op on this path.
+        const serialized = (0, artifact_export_1.serializedArtifact)(bundle);
+        if (selection.output === '-') {
             this.log(serialized.trimEnd());
             return;
         }
+        let receipt;
         try {
-            await (0, promises_1.writeFile)(flags.out, serialized, 'utf8');
+            receipt = await (0, artifact_export_1.writeExportArtifact)({
+                command: 'tones export',
+                artifactSchemaVersion: exports.TONE_BUNDLE_VERSION,
+                format: 'json',
+                output: selection.output,
+                content: serialized,
+                itemCount: selected.length,
+            });
         }
         catch (err) {
             this.failWithCliError({
-                message: `Could not write ${flags.out}: ${err.message}`,
+                message: `Could not write ${selection.output}: ${err.message}`,
                 code: 'TONE_BUNDLE_WRITE_FAILED',
                 exit: 1,
-                retryable: true,
-                details: { path: flags.out },
+                retryable: false,
+                details: { path: selection.output },
             });
         }
-        if (flags.json) {
-            this.log(serialized.trimEnd());
-            return;
-        }
-        this.log(`Wrote ${bundle.tones.length} tone(s) to ${flags.out}.`);
+        this.log(selection.json ? JSON.stringify(receipt, null, 2) : (0, artifact_export_1.humanExportReceipt)(receipt));
     }
 }
 exports.default = TonesExport;

package/dist/lib/artifact-export.d.ts

@@ -0,0 +1,84 @@
+export declare const EXPORT_RECEIPT_SCHEMA_VERSION = 1;
+export type ExportSelection = {
+    output?: string;
+    summary: boolean;
+    json: boolean;
+};
+export type ExportReceipt = {
+    object: 'skrr.export.receipt';
+    schemaVersion: typeof EXPORT_RECEIPT_SCHEMA_VERSION;
+    command: string;
+    artifactSchemaVersion: string | number;
+    format: string;
+    output: string;
+    contentDigest: string;
+    bytes: number;
+    lines: number;
+    itemCount: number;
+    truncated: boolean;
+    nextCursor: string | null;
+};
+export declare class ExportContractError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare function standardExportFlags(): {
+    summary: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export declare function paginatedExportFlags(options?: {
+    defaultMaxItems?: number;
+}): {
+    'max-items': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    summary: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export declare function resolveExportSelection(flags: {
+    output?: string;
+    out?: string;
+    summary?: boolean;
+    json?: boolean;
+}): ExportSelection;
+export declare function serializedArtifact(value: unknown): string;
+export declare function buildExportReceipt(input: {
+    command: string;
+    artifactSchemaVersion: string | number;
+    format: string;
+    output: string;
+    content: string;
+    itemCount: number;
+    truncated?: boolean;
+    nextCursor?: string | null;
+}): ExportReceipt;
+export declare function writeExportArtifact(input: {
+    command: string;
+    artifactSchemaVersion: string | number;
+    format: string;
+    output: string;
+    content: string;
+    itemCount: number;
+    truncated?: boolean;
+    nextCursor?: string | null;
+}): Promise<ExportReceipt>;
+export declare function humanExportReceipt(receipt: ExportReceipt): string;
+export declare function contentFreeSummary(input: {
+    command: string;
+    artifactSchemaVersion: string | number;
+    itemCount: number;
+    truncated?: boolean;
+    nextCursor?: string | null;
+    counts?: Record<string, number>;
+}): {
+    object: "skrr.export.summary";
+    schemaVersion: number;
+    command: string;
+    artifactSchemaVersion: string | number;
+    itemCount: number;
+    counts: Record<string, number>;
+    truncated: boolean;
+    nextCursor: string | null;
+};
+export declare function humanExportSummary(summary: ReturnType<typeof contentFreeSummary>): string;

package/dist/lib/artifact-export.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportContractError = exports.EXPORT_RECEIPT_SCHEMA_VERSION = void 0;
+exports.standardExportFlags = standardExportFlags;
+exports.paginatedExportFlags = paginatedExportFlags;
+exports.resolveExportSelection = resolveExportSelection;
+exports.serializedArtifact = serializedArtifact;
+exports.buildExportReceipt = buildExportReceipt;
+exports.writeExportArtifact = writeExportArtifact;
+exports.humanExportReceipt = humanExportReceipt;
+exports.contentFreeSummary = contentFreeSummary;
+exports.humanExportSummary = humanExportSummary;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const core_1 = require("@oclif/core");
+exports.EXPORT_RECEIPT_SCHEMA_VERSION = 1;
+class ExportContractError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.ExportContractError = ExportContractError;
+function standardExportFlags() {
+    return {
+        summary: core_1.Flags.boolean({
+            description: 'Print a content-free summary instead of the full artifact',
+        }),
+        output: core_1.Flags.string({
+            char: 'o',
+            description: 'Write the full artifact to this path; use "-" for deliberate stdout',
+        }),
+        json: core_1.Flags.boolean({
+            description: 'Print summary or file receipt as machine-readable JSON',
+        }),
+    };
+}
+function paginatedExportFlags(options = {}) {
+    return {
+        ...standardExportFlags(),
+        'max-items': core_1.Flags.integer({
+            description: `Maximum records in this export chunk (default ${options.defaultMaxItems ?? 1000})`,
+            min: 1,
+            max: 100000,
+        }),
+        cursor: core_1.Flags.string({
+            description: 'Opaque cursor returned by a previous export chunk',
+        }),
+    };
+}
+function resolveExportSelection(flags) {
+    if (flags.output && flags.out) {
+        throw new ExportContractError('--output and the deprecated --out alias cannot be used together.', 'EXPORT_OUTPUT_FLAG_CONFLICT');
+    }
+    const output = flags.output ?? flags.out;
+    const summary = Boolean(flags.summary);
+    if (!output && !summary) {
+        throw new ExportContractError('Choose --summary, --output <path>, or --output - for deliberate stdout.', 'EXPORT_DESTINATION_REQUIRED');
+    }
+    if (output && summary) {
+        throw new ExportContractError('--summary and --output are mutually exclusive.', 'EXPORT_MODE_CONFLICT');
+    }
+    return { output, summary, json: Boolean(flags.json) };
+}
+function serializedArtifact(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function buildExportReceipt(input) {
+    return {
+        object: 'skrr.export.receipt',
+        schemaVersion: exports.EXPORT_RECEIPT_SCHEMA_VERSION,
+        command: input.command,
+        artifactSchemaVersion: input.artifactSchemaVersion,
+        format: input.format,
+        output: input.output,
+        contentDigest: (0, node_crypto_1.createHash)('sha256').update(input.content).digest('hex'),
+        bytes: Buffer.byteLength(input.content),
+        lines: input.content.length ? input.content.split('\n').length - 1 : 0,
+        itemCount: input.itemCount,
+        truncated: Boolean(input.truncated),
+        nextCursor: input.nextCursor ?? null,
+    };
+}
+async function writeExportArtifact(input) {
+    const receipt = buildExportReceipt(input);
+    if (input.output === '-')
+        return receipt;
+    await (0, promises_1.writeFile)(input.output, input.content, {
+        encoding: 'utf8',
+        flag: 'wx',
+        mode: 0o600,
+    });
+    return receipt;
+}
+function humanExportReceipt(receipt) {
+    const continuation = receipt.truncated && receipt.nextCursor ? ` Next cursor: ${receipt.nextCursor}.` : '';
+    return (`Wrote ${receipt.itemCount} item(s) to ${receipt.output} ` +
+        `(${receipt.bytes} bytes, sha256:${receipt.contentDigest}, schema ` +
+        `${receipt.artifactSchemaVersion}).${continuation}`);
+}
+function contentFreeSummary(input) {
+    return {
+        object: 'skrr.export.summary',
+        schemaVersion: exports.EXPORT_RECEIPT_SCHEMA_VERSION,
+        command: input.command,
+        artifactSchemaVersion: input.artifactSchemaVersion,
+        itemCount: input.itemCount,
+        counts: input.counts ?? {},
+        truncated: Boolean(input.truncated),
+        nextCursor: input.nextCursor ?? null,
+    };
+}
+function humanExportSummary(summary) {
+    const counts = Object.entries(summary.counts)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(', ');
+    const continuation = summary.truncated && summary.nextCursor ? `; next cursor=${summary.nextCursor}` : '';
+    return (`${summary.command}: ${summary.itemCount} item(s)` +
+        (counts ? ` (${counts})` : '') +
+        `; schema ${summary.artifactSchemaVersion}${continuation}`);
+}

package/dist/lib/balance.d.ts

@@ -1,4 +1,4 @@
-import type { TSkyCodeUsageSnapshot } from '@skrr-ai/data-provider';
+import type { TSubscription, TSkyCodeUsageEvents, TSkyCodeUsageSnapshot } from '@skrr-ai/data-provider';
 /**
  * balance.ts — request client for `/api/balance`.
  *
@@ -79,6 +79,18 @@ export interface BalanceHistory {
 /** The account's current credits, limit and period usage. */
 export declare function getBalance(): Promise<BalanceStatus>;
 export declare function getSkyCodeUsage(workspaceId?: string): Promise<TSkyCodeUsageSnapshot>;
+/** The personal Sky Code subscription, distinct from published agent-service subscriptions. */
+export declare function getSkyCodeSubscription(): Promise<TSubscription>;
+/** Explicit personal consent to use stored balance after included Sky Code allowance. */
+export declare function setSkyCodeOverageConsent(enabled: boolean): Promise<{
+    enabled: boolean;
+}>;
+export declare function getSkyCodeUsageEvents(workspaceId: string | undefined, params?: {
+    from?: string;
+    to?: string;
+    cursor?: string;
+    limit?: number;
+}): Promise<TSkyCodeUsageEvents>;
 /** Recent token transactions, newest first. Cursor is an ISO createdAt. */
 export declare function getBalanceHistory(limit: number, cursor?: string): Promise<BalanceHistory>;
 /**

package/dist/lib/balance.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CREDITS_PER_USD = void 0;
 exports.getBalance = getBalance;
 exports.getSkyCodeUsage = getSkyCodeUsage;
+exports.getSkyCodeSubscription = getSkyCodeSubscription;
+exports.setSkyCodeOverageConsent = setSkyCodeOverageConsent;
+exports.getSkyCodeUsageEvents = getSkyCodeUsageEvents;
 exports.getBalanceHistory = getBalanceHistory;
 exports.formatCredits = formatCredits;
 exports.getWorkspaceBalance = getWorkspaceBalance;
@@ -27,6 +30,33 @@ async function getSkyCodeUsage(workspaceId) {
         : '/api/balance/usage/sky-code';
     return (0, api_fetch_1.apiFetch)(path);
 }
+/** The personal Sky Code subscription, distinct from published agent-service subscriptions. */
+async function getSkyCodeSubscription() {
+    return (0, api_fetch_1.apiFetch)('/api/stripe/subscription');
+}
+/** Explicit personal consent to use stored balance after included Sky Code allowance. */
+async function setSkyCodeOverageConsent(enabled) {
+    return (0, api_fetch_1.apiFetch)('/api/balance/usage/sky-code/overage', {
+        method: 'PUT',
+        body: { enabled },
+    });
+}
+async function getSkyCodeUsageEvents(workspaceId, params = {}) {
+    const query = new URLSearchParams();
+    if (params.from)
+        query.set('from', params.from);
+    if (params.to)
+        query.set('to', params.to);
+    if (params.cursor)
+        query.set('cursor', params.cursor);
+    if (params.limit !== undefined)
+        query.set('limit', String(params.limit));
+    const base = workspaceId
+        ? `/api/balance/usage/sky-code/workspace/${encodeURIComponent(workspaceId)}/events`
+        : '/api/balance/usage/sky-code/events';
+    const suffix = query.toString();
+    return (0, api_fetch_1.apiFetch)(suffix ? `${base}?${suffix}` : base);
+}
 /** Recent token transactions, newest first. Cursor is an ISO createdAt. */
 async function getBalanceHistory(limit, cursor) {
     const query = new URLSearchParams({ limit: String(limit) });

package/dist/lib/web-url.d.ts

@@ -16,6 +16,8 @@
  * and the `api.` subdomain are distinct origins in skrr's topology).
  */
 export type WebUrlRef = {
+    kind: 'billing';
+} | {
     kind: 'task';
     taskId: string;
     spaceId?: string | null;

package/dist/lib/web-url.js

@@ -51,6 +51,8 @@ const publicEndpoints_generated_1 = require("./publicEndpoints.generated");
  */
 function webPath(ref) {
     switch (ref.kind) {
+        case 'billing':
+            return '/d/settings/balance';
         case 'task': {
             const taskId = encodeId(ref.taskId);
             if (!taskId)

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/firstPartyHarness.d.ts

@@ -19,7 +19,9 @@
  *
  *   1. set `displayName` and `provider`;
  *   2. move the old `provider` to the front of `aliases`;
- *   3. leave `wireProvider` on the spelling installed daemons still speak;
+ *   3. set `wireProvider` to the old spelling as a literal — installed daemons
+ *      still speak it — and derive it from `provider` again only in the wire
+ *      phase, once every peer accepts the new one;
  *   4. regenerate `first-party-harness.json`
  *      (`node --import tsx scripts/emit-first-party-harness-json.mjs`);
  *   5. ship the data migration, which is generic over `aliases`.
@@ -33,9 +35,11 @@
  *                canonical at the edge. Nothing new is ever written with one.
  * `wireProvider` What the server and a daemon say to EACH OTHER — the
  *                capability a daemon advertises, `daemon:<p>:request|response`,
- *                the `provider` of a session RPC. It moves LAST, because a
- *                daemon on a user's machine may be any version and the server
- *                cannot tell which one sent a request.
+ *                the `provider` of a session RPC. It moves after the flip and
+ *                BEFORE contract, because a daemon on a user's machine may be
+ *                any version and the server cannot tell which one sent a
+ *                request: only a released daemon that already advertises the
+ *                canonical capability lets the old one age out of the fleet.
  *
  * The old code treated those three as one string, which is why no single
  * change could rename it safely. See
@@ -63,18 +67,19 @@ export interface FirstPartyHarnessIdentity {
 /**
  * THE identity — the only literal product name in the codebase.
  *
- * Phase: FLIPPED. `skrr-code` is canonical — stored, returned and rendered.
- * `sky-code` is still accepted on every ingress, and it is still the WIRE
- * spelling: daemons on users' machines may predate the rename, so the server
- * and a daemon keep exchanging `sky-code` until contract (OSK-8663) empties
- * `aliases` and moves `wireProvider`.
+ * Phase: WIRE MOVED. `skrr-code` is canonical — stored, returned, rendered — and
+ * it is now also what the server and a daemon say to each other. `sky-code` is
+ * still accepted on every ingress, so a daemon released before this change
+ * (which advertises and answers on `sky-code`) keeps working against a server
+ * that speaks `skrr-code`, and the reverse. Contract (OSK-8663) empties
+ * `aliases` once no connected daemon still advertises the old capability.
  */
 declare const IDENTITY: {
     readonly displayName: "skrr Code";
     readonly command: "skrr code";
     readonly provider: "skrr-code";
     readonly aliases: readonly ["sky-code"];
-    readonly wireProvider: "sky-code";
+    readonly wireProvider: "skrr-code";
 };
 /** The canonical slug, as a literal type. */
 export type FirstPartyHarnessCanonicalProvider = typeof IDENTITY.provider;