@hasna/skills 0.7.3 → 0.8.1

package/dist/lib/canonical-json.d.ts

@@ -0,0 +1,8 @@
+/** Bounded canonical JSON for portable integrity checks, not an authority token.
+ * Object keys use JavaScript code-unit order. Values that JSON would silently
+ * drop or transform are refused, including accessors and sparse array slots. */
+export declare function canonicalJson(value: unknown, maximumBytes?: number): string;
+/** Internal parser bound: response wrappers consume depth independently of the
+ * immutable payload. The public canonical helpers retain their 64-level bound. */
+export declare function canonicalJsonAtDepth(value: unknown, maximumBytes: number, maximumDepth: number): string;
+export declare function canonicalJsonSha256(value: unknown, maximumBytes?: number): string;

package/dist/lib/cli-mcp-parity.d.ts

@@ -1,4 +1,4 @@
-export type SkillsCliMcpParityDomain = "discovery" | "portable-skills" | "runtime" | "tool-primitives" | "validation";
+export type SkillsCliMcpParityDomain = "recurring-consent" | "discovery" | "portable-skills" | "runtime" | "tool-primitives" | "validation";
 export interface SkillsCliMcpParityEntry {
     domain: SkillsCliMcpParityDomain;
     operation: string;

package/dist/lib/config.d.ts

@@ -4,7 +4,6 @@
  * Loads configuration from:
  *   1. Project-local: ./skills.config.json (highest priority)
  *   2. Global: ~/.hasna/skills/config.json (JSON format, lowest priority)
- *      (backward compat: also checks ~/.skillsrc)
  *
  * Values from the project config override global config.
  */
@@ -83,35 +82,16 @@ export declare function isOwnerLayoutMigrated(appDir: string): boolean;
 /**
  * Get the data directory for skills global config/data.
  * Default: ~/.hasna/skills/, overridable with $HASNA_SKILLS_DIR.
- * Auto-migrates from ~/.skills/ and ~/.skillsrc without deleting legacy data.
+ * Legacy directories and configuration are never imported during resolution.
  */
 export declare function getDataDir(): string;
-/**
- * Write-free data-dir resolution for read-only paths (e.g. `sync --dry-run`).
- *
- * getDataDir() itself writes: it mkdirs the app folder, merges legacy ~/.skills
- * content and copies the legacy config file. A dry run must resolve the SAME
- * directory a real run would use without performing any of that — the app-home
- * resolver (getDataRoot) is already write-free, so this mirrors it directly.
- */
+/** Resolve the same app data root without creating directories. */
 export declare function getDataDirReadOnly(): string;
 /**
  * Get the config file path for a given scope, write-free (see getDataDirReadOnly).
  */
 export declare function getConfigPathReadOnly(scope: ConfigScope): string;
-/**
- * Load merged config (project-local overrides global) without the writes
- * getDataDir() performs on the write path.
- *
- * The write path folds the legacy ~/.skillsrc into canonical config.json as part of
- * getDataDir()'s migration — copied ONLY when canonical config.json is absent, and
- * the legacy migration is skipped entirely when a data-directory override is active.
- * This mirrors that FILE-LEVEL precedence, never field-level merging: canonical
- * config.json, when present, is the whole global config; legacy ~/.skillsrc is read
- * only in the exact situation the write path would copy it (no canonical file, no
- * override). Field-level merging would inherit stale legacy values beneath a
- * canonical config that omits them, so the two paths must agree exactly.
- */
+/** Read only the canonical global and explicitly selected project configuration. */
 export declare function loadConfigReadOnly(): SkillsConfig;
 /**
  * Get the config file path for a given scope

package/dist/lib/installer.d.ts

@@ -48,7 +48,7 @@ interface MetaFile {
     disabled?: string[];
 }
 /**
- * Get the path to a bundled skill in the package.
+ * Resolve a skill only inside the owned cache or an explicit authoring source.
  */
 export declare function getSkillPath(name: string): string;
 /**

package/dist/lib/mcp-contracts.d.ts

@@ -21,7 +21,7 @@ export interface JsonSchemaObject {
     oneOf?: JsonSchemaObject[];
 }
 export type McpToolCategory = "agent-session" | "discovery" | "execution" | "feedback" | "metadata" | "pinning" | "scaffolding" | "scheduling" | "storage" | "validation";
-export type McpToolSideEffect = "filesystem" | "local-process-or-remote-run" | "none" | "schedule-state";
+export type McpToolSideEffect = "filesystem" | "remote-state" | "remote-state-and-filesystem" | "local-process-or-remote-run" | "none" | "schedule-state";
 export interface McpToolContract {
     name: string;
     title: string;

package/dist/lib/portable-skills.d.ts

@@ -20,7 +20,7 @@ export * from "./portable-skills-types.js";
  *      exists there (the record is the authority; a skills/ directory someone
  *      created by hand is not the corpus)
  *   3. `getDataDir()`         - <app folder>/installed (pre-migration corpus,
- *      with the legacy auto-copy migration), where the app folder is
+ *      without importing any legacy directories), where the app folder is
  *      $HASNA_SKILLS_DIR, else ~/.hasna/skills
  *
  * The app folder holds app data (config.json, skills.db, auth.json); the corpus

package/dist/lib/recurring-customer.d.ts

@@ -0,0 +1,29 @@
+import { type RemoteWorkspaceContext } from "./remote-workspace-selection.js";
+import { type RecurringAction, type RecurringInputs, type RecurringResults } from "./remote-recurring.js";
+type Env = Record<string, string | undefined>;
+export declare class RecurringCustomerError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface RecurringCustomer {
+    readonly apiOrigin: string;
+    readonly profile: string | null;
+    readonly context: RemoteWorkspaceContext | undefined;
+    /** Present only after actual fresh session and selected-workspace verification. */
+    readonly organizationId: string | undefined;
+    assertCurrent(): Promise<void>;
+    call<A extends RecurringAction>(action: A, input: RecurringInputs[A]): Promise<RecurringResults[A]>;
+    requestCode(email: string): Promise<void>;
+    fresh(email: string, code: string): Promise<RecurringCustomer>;
+}
+/** Capture before prompting. Fresh authority comes only from the existing OTP and
+ * workspace session verifier; a profile/context never grants that authority. */
+export declare function prepareRecurringCustomer(requested?: RemoteWorkspaceContext, source?: Env): Promise<RecurringCustomer>;
+/** Never echo authentication/transport bodies or caller-supplied credentials. */
+export declare function recurringCustomerError(error: unknown): {
+    status?: number | undefined;
+    code: string;
+    error: string;
+    outcomeUnknown: boolean;
+};
+export {};

package/dist/lib/recurring-recovery.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod/v4";
+import { type RecurringActivation, type RecurringPreview, type RecurringConsentView } from "./remote-recurring.js";
+import { type RecurringCustomer } from "./recurring-customer.js";
+declare const intentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    contractVersion: z.ZodLiteral<1>;
+    apiOrigin: z.ZodString;
+    profile: z.ZodNullable<z.ZodString>;
+    organizationId: z.ZodString;
+    userId: z.ZodString;
+    membershipId: z.ZodString;
+    operation: z.ZodLiteral<"activate">;
+    draftId: z.ZodString;
+    termsSha256: z.ZodString;
+    approvalDeadline: z.ZodString;
+    approval: z.ZodObject<{
+        contractVersion: z.ZodLiteral<1>;
+        acceptedTermsSha256: z.ZodString;
+        acceptance: z.ZodLiteral<"authorize-recurring-credit-use">;
+        idempotencyKey: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    contractVersion: z.ZodLiteral<1>;
+    apiOrigin: z.ZodString;
+    profile: z.ZodNullable<z.ZodString>;
+    organizationId: z.ZodString;
+    userId: z.ZodString;
+    membershipId: z.ZodString;
+    operation: z.ZodLiteral<"revoke">;
+    consentId: z.ZodString;
+}, z.core.$strict>], "operation">;
+type Intent = z.infer<typeof intentSchema>;
+/** Refuse a substituted target before displaying saved terms or requesting OTP.
+ * The recovery executor repeats this fence while holding the original record. */
+export declare function bindRecurringRecovery(customer: RecurringCustomer, intent: Intent): void;
+export declare function prepareRecurringActivation(customer: RecurringCustomer, directory: string, draftId: string, approval: RecurringActivation): Promise<RecurringPreview>;
+export declare function prepareRecurringRevocation(customer: RecurringCustomer, directory: string, consentId: string): Promise<RecurringConsentView>;
+export declare function readRecurringRecovery(directory: string): {
+    intent: {
+        contractVersion: 1;
+        apiOrigin: string;
+        profile: string | null;
+        organizationId: string;
+        userId: string;
+        membershipId: string;
+        operation: "activate";
+        draftId: string;
+        termsSha256: string;
+        approvalDeadline: string;
+        approval: {
+            contractVersion: 1;
+            acceptedTermsSha256: string;
+            acceptance: "authorize-recurring-credit-use";
+            idempotencyKey: string;
+        };
+    } | {
+        contractVersion: 1;
+        apiOrigin: string;
+        profile: string | null;
+        organizationId: string;
+        userId: string;
+        membershipId: string;
+        operation: "revoke";
+        consentId: string;
+    };
+    phase: "pending" | "prepared" | "observed";
+    consentId: string | null;
+};
+export interface RecurringRecoveryOptions {
+    confirm: boolean;
+    email?: string;
+    code?: string;
+}
+/** One explicit action, never an internal POST retry. Pending remains uncertain
+ * even when later verification, local persistence or custody checks fail. */
+export declare function continueRecurringRecovery(customer: RecurringCustomer, directory: string, options: RecurringRecoveryOptions): Promise<{
+    recoveryDirectory: string;
+    operation: "activate" | "revoke";
+    outcomeUnknown: boolean;
+    phase: "pending" | "prepared" | "observed";
+    result: unknown;
+}>;
+export {};

package/dist/lib/recurring-surface.d.ts

@@ -0,0 +1,252 @@
+import { z } from "zod/v4";
+import { type RecurringPreview } from "./remote-recurring.js";
+export declare const recurringSurfaceSchemas: {
+    preview: z.ZodObject<{
+        request: z.ZodObject<{
+            contractVersion: z.ZodLiteral<1>;
+            skill: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            args: z.ZodArray<z.ZodString>;
+            runtime: z.ZodObject<{
+                timeoutMs: z.ZodNumber;
+                maxOutputBytes: z.ZodNumber;
+                maxAttempts: z.ZodNumber;
+                connectorOperations: z.ZodArray<z.ZodObject<{
+                    connectorSlug: z.ZodString;
+                    operationName: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            everyMinutes: z.ZodNumber;
+            startsAt: z.ZodString;
+            expiresAt: z.ZodString;
+            dispatchGraceSeconds: z.ZodNumber;
+            period: z.ZodLiteral<"utc-day">;
+            inFlightPolicy: z.ZodLiteral<"finish-authorized-attempt">;
+            maxCreditsPerRun: z.ZodNumber;
+            maxCreditsPerPeriod: z.ZodNumber;
+            maxCreditsTotal: z.ZodNumber;
+            maxOccurrencesPerPeriod: z.ZodNumber;
+            maxOccurrencesTotal: z.ZodNumber;
+        }, z.core.$strict>;
+        userId: z.ZodOptional<z.ZodString>;
+        membershipId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    draft: z.ZodObject<{
+        draftId: z.ZodString;
+        userId: z.ZodOptional<z.ZodString>;
+        membershipId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    activate: z.ZodObject<{
+        draftId: z.ZodString;
+        approval: z.ZodObject<{
+            contractVersion: z.ZodLiteral<1>;
+            acceptedTermsSha256: z.ZodString;
+            acceptance: z.ZodLiteral<"authorize-recurring-credit-use">;
+            idempotencyKey: z.ZodString;
+        }, z.core.$strict>;
+        recoveryDirectory: z.ZodString;
+        email: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+        confirm: z.ZodOptional<z.ZodBoolean>;
+        userId: z.ZodOptional<z.ZodString>;
+        membershipId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    list: z.ZodObject<{
+        limit: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        membershipId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    get: z.ZodObject<{
+        consentId: z.ZodString;
+        userId: z.ZodOptional<z.ZodString>;
+        membershipId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    occurrences: z.ZodObject<{
+        consentId: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        membershipId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    revoke: z.ZodObject<{
+        consentId: z.ZodString;
+        recoveryDirectory: z.ZodString;
+        confirm: z.ZodLiteral<true>;
+        userId: z.ZodOptional<z.ZodString>;
+        membershipId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    recover: z.ZodObject<{
+        recoveryDirectory: z.ZodString;
+        confirm: z.ZodOptional<z.ZodBoolean>;
+        email: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        membershipId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    verification: z.ZodObject<{
+        draftId: z.ZodString;
+        email: z.ZodString;
+        confirm: z.ZodLiteral<true>;
+        userId: z.ZodOptional<z.ZodString>;
+        membershipId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+};
+export type RecurringSurfaceAction = keyof typeof recurringSurfaceSchemas;
+export declare const recurringSurfaceOperations: readonly [{
+    readonly action: "preview";
+    readonly name: "preview_recurring_consent";
+    readonly title: "Preview recurring consent";
+    readonly cli: "preview";
+    readonly read: false;
+    readonly recovery: false;
+}, {
+    readonly action: "draft";
+    readonly name: "get_recurring_draft";
+    readonly title: "Read original recurring draft";
+    readonly cli: "draft";
+    readonly read: true;
+    readonly recovery: false;
+}, {
+    readonly action: "activate";
+    readonly name: "activate_recurring_consent";
+    readonly title: "Authorize recurring credit use";
+    readonly cli: "activate";
+    readonly read: false;
+    readonly recovery: true;
+}, {
+    readonly action: "list";
+    readonly name: "list_recurring_consents";
+    readonly title: "List recurring consents";
+    readonly cli: "list";
+    readonly read: true;
+    readonly recovery: false;
+}, {
+    readonly action: "get";
+    readonly name: "get_recurring_consent";
+    readonly title: "Inspect recurring consent and budgets";
+    readonly cli: "get";
+    readonly read: true;
+    readonly recovery: false;
+}, {
+    readonly action: "occurrences";
+    readonly name: "list_recurring_occurrences";
+    readonly title: "Inspect recurring occurrence history";
+    readonly cli: "occurrences";
+    readonly read: true;
+    readonly recovery: false;
+}, {
+    readonly action: "revoke";
+    readonly name: "revoke_recurring_consent";
+    readonly title: "Revoke recurring authority";
+    readonly cli: "revoke";
+    readonly read: false;
+    readonly recovery: true;
+}, {
+    readonly action: "recover";
+    readonly name: "recover_recurring_consent";
+    readonly title: "Reconcile original recurring request";
+    readonly cli: "recover";
+    readonly read: false;
+    readonly recovery: true;
+}, {
+    readonly action: "verification";
+    readonly name: "request_recurring_verification";
+    readonly title: "Request recurring approval verification";
+    readonly cli: "verification";
+    readonly read: false;
+    readonly recovery: false;
+}];
+/** The host must obtain explicit acceptance and a real human OTP. A boolean alone
+ * never grants recurring authority. Host request history may retain supplied OTPs. */
+export declare function recurringMcpSchema(action: RecurringSurfaceAction): z.ZodObject<{
+    request: z.ZodObject<{
+        contractVersion: z.ZodLiteral<1>;
+        skill: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        args: z.ZodArray<z.ZodString>;
+        runtime: z.ZodObject<{
+            timeoutMs: z.ZodNumber;
+            maxOutputBytes: z.ZodNumber;
+            maxAttempts: z.ZodNumber;
+            connectorOperations: z.ZodArray<z.ZodObject<{
+                connectorSlug: z.ZodString;
+                operationName: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        everyMinutes: z.ZodNumber;
+        startsAt: z.ZodString;
+        expiresAt: z.ZodString;
+        dispatchGraceSeconds: z.ZodNumber;
+        period: z.ZodLiteral<"utc-day">;
+        inFlightPolicy: z.ZodLiteral<"finish-authorized-attempt">;
+        maxCreditsPerRun: z.ZodNumber;
+        maxCreditsPerPeriod: z.ZodNumber;
+        maxCreditsTotal: z.ZodNumber;
+        maxOccurrencesPerPeriod: z.ZodNumber;
+        maxOccurrencesTotal: z.ZodNumber;
+    }, z.core.$strict>;
+    userId: z.ZodOptional<z.ZodString>;
+    membershipId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict> | z.ZodObject<{
+    draftId: z.ZodString;
+    userId: z.ZodOptional<z.ZodString>;
+    membershipId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict> | z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    membershipId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict> | z.ZodObject<{
+    consentId: z.ZodString;
+    userId: z.ZodOptional<z.ZodString>;
+    membershipId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict> | z.ZodObject<{
+    recoveryDirectory: z.ZodString;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+    email: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    membershipId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export interface RecurringInteraction {
+    accept(draft: RecurringPreview): Promise<boolean>;
+    verification(email: string, requestCode: () => Promise<void>): Promise<string | null>;
+}
+/** Shared CLI/MCP orchestration only. The SDK owns wire validation/transport; the
+ * selected server owns grants, freshness, prices, financial state and execution. */
+export declare function executeRecurringSurface(action: RecurringSurfaceAction, raw: unknown, env?: Record<string, string | undefined>, interaction?: RecurringInteraction): Promise<RecurringPreview | import("./remote-recurring-contract.js").RecurringConsentView | import("./remote-recurring-contract.js").RecurringPage<import("./remote-recurring-contract.js").RecurringConsentView> | import("./remote-recurring-contract.js").RecurringPage<import("./remote-recurring-contract.js").RecurringOccurrenceView> | {
+    recoveryDirectory: string;
+    operation: "activate" | "revoke";
+    outcomeUnknown: boolean;
+    phase: "pending" | "prepared" | "observed";
+    result: unknown;
+} | {
+    cancelled: boolean;
+    activated: boolean;
+} | {
+    verificationRequested: boolean;
+    deliveryConfirmed: boolean;
+    draftId: string;
+    activated: boolean;
+    cancelled?: undefined;
+    outcomeUnknown?: undefined;
+    recoveryDirectory?: undefined;
+} | {
+    recoveryDirectory: string;
+    phase: string;
+    outcomeUnknown: boolean;
+    cancelled: boolean;
+    activated: boolean;
+    verificationRequested?: undefined;
+    deliveryConfirmed?: undefined;
+    draftId?: undefined;
+} | {
+    cancelled: boolean;
+    outcomeUnknown: boolean;
+    recoveryDirectory: string;
+    verificationRequested?: undefined;
+    deliveryConfirmed?: undefined;
+    draftId?: undefined;
+    activated?: undefined;
+} | null>;

package/dist/lib/registry-data/index.d.ts

@@ -1,2 +1,3 @@
 import type { SkillMeta } from "../registry-types.js";
+/** @deprecated Skills are loaded from an account or an explicitly selected local source. */
 export declare const SKILLS: SkillMeta[];

package/dist/lib/registry-types.d.ts

@@ -38,5 +38,6 @@ export interface SkillAvailabilityMetadata {
 }
 export declare const CATEGORIES: readonly ["Development Tools", "Business & Marketing", "Productivity & Organization", "Project Management", "Content Generation", "Finance & Compliance", "Data & Analysis", "Media Processing", "Design & Branding", "Web & Browser", "Research & Writing", "Science & Academic", "Education & Learning", "Communication", "Health & Wellness", "Travel & Lifestyle", "Event Management"];
 export type Category = (typeof CATEGORIES)[number];
-export declare const BASIC_SKILL_NAMES: readonly ["blog-article", "ad-creative-pack", "email-sequence", "seo-content-pack", "social-content-calendar", "pitch-deck", "proposal-pack", "market-research-report"];
+/** @deprecated There is no software-owned default selection. Use an account profile. */
+export declare const BASIC_SKILL_NAMES: readonly string[];
 export type SkillRegistryProfile = "basic" | "all";

package/dist/lib/registry.d.ts

@@ -7,19 +7,9 @@ export { BASIC_SKILL_NAMES, CATEGORIES, SKILLS };
 export type { Category, SkillMeta, SkillRegistryProfile };
 export declare function isBasicSkillName(name: string): boolean;
 export declare function findExtensionSkillPath(name: string): string | null;
-/**
- * Load the full registry: official skills merged with a configured private
- * extension checkout and global custom skills from the canonical local corpus
- * — <app folder>/installed/<name>/ before the owner-layout migration, <app
- * folder>/skills/<name>/ after it (resolveCorpusRoot(), the one resolution
- * every discovery path shares) — plus the legacy ~/.hasna/skills/custom/<name>/
- * migration safety net.
- *
- * Custom skills take precedence over extensions, which take precedence over
- * official skills. Extension skills are read in place and never copied into the
- * corpus. Results are cached for 5 seconds.
- */
+/** Discover the Skills-owned cache and explicitly configured authoring sources. */
 export declare function loadRegistry(cwd?: string): SkillMeta[];
+/** Compatibility name for the caller's own catalog; no baked-in default selection. */
 export declare function loadBasicRegistry(cwd?: string): SkillMeta[];
 export declare function loadRegistryProfile(profile?: SkillRegistryProfile, cwd?: string): SkillMeta[];
 /** Invalidate the registry cache (e.g. after installing a custom skill). */

package/dist/lib/release-dependencies.d.ts

@@ -1,3 +1,4 @@
+type Context = Record<string, string | null>;
 /** Verifies installed resolution against the selected standalone frozen lock.
  * This is a graph/version check; the separate frozen installer receipt binds
  * registry integrity. Package payload attestation is not inferred from version. */
@@ -17,6 +18,7 @@ export declare function verifyProducerDependencies(packageRoot: string): {
         version: string;
         manifestSha256: string;
         relativePath: string;
+        context: Context;
     }[];
     edges: {
         from: string;
@@ -25,3 +27,4 @@ export declare function verifyProducerDependencies(packageRoot: string): {
         optionalAbsent?: boolean;
     }[];
 };
+export {};

package/dist/lib/remote-client.d.ts

@@ -1,3 +1,4 @@
+import { type RecurringRequest, type RecurringActivation, type RecurringListOptions, type RecurringCapability, type RecurringConsentView, type RecurringOccurrenceView, type RecurringPage } from "./remote-recurring.js";
 import { type ListRemoteWorkspaceInvitations, type IssueRemoteWorkspaceInvitation, type ResendRemoteWorkspaceInvitation, type RevokeRemoteWorkspaceInvitation, type AcceptRemoteWorkspaceInvitation } from "./remote-invitations.js";
 import { type LeaveRemoteWorkspace, type RemoteWorkspaceLeaveResult } from "./remote-workspace-leave.js";
 import { type RemoteWorkspaceContext, type RemoteAccountWorkspaces, type RemoteWorkspaceSession, type RemoteWorkspaceSelectionErrorCode } from "./remote-workspace-selection.js";
@@ -130,6 +131,7 @@ export declare class RemoteSkillsClient {
             boundedRunApproval?: boolean;
             unit?: string;
         };
+        recurringConsents?: RecurringCapability;
     }>;
     /** Quote first and fail closed when the caller has not approved the required credits. */
     submitQuotedRun(slug: string, input?: Record<string, unknown>, args?: string[], approval?: RemoteRunApproval): Promise<RemoteSkillRunContract>;
@@ -167,6 +169,17 @@ export declare class RemoteSkillsClient {
     /** One bounded operation, bound to the observed current incarnation. No retries,
      * key/session persistence or post-acceptance selection of another workspace. */
     private requestWorkspaceInvitation;
+    previewRecurringConsent(request: RecurringRequest, context?: RemoteWorkspaceContext): Promise<import("./remote-recurring-contract.js").RecurringPreview>;
+    getRecurringDraft(draftId: string, context?: RemoteWorkspaceContext): Promise<import("./remote-recurring-contract.js").RecurringPreview | null>;
+    activateRecurringConsent(draftId: string, approval: RecurringActivation, context?: RemoteWorkspaceContext): Promise<import("./remote-recurring-contract.js").RecurringActivationResult>;
+    listRecurringConsents(options?: RecurringListOptions, context?: RemoteWorkspaceContext): Promise<RecurringPage<RecurringConsentView>>;
+    getRecurringConsent(consentId: string, context?: RemoteWorkspaceContext): Promise<RecurringConsentView | null>;
+    listRecurringOccurrences(consentId: string, options?: RecurringListOptions, context?: RemoteWorkspaceContext): Promise<RecurringPage<RecurringOccurrenceView>>;
+    revokeRecurringConsent(consentId: string, context?: RemoteWorkspaceContext): Promise<import("./remote-recurring-contract.js").RecurringRevocation>;
+    /** One explicit operation on a captured connection. No policy inference,
+     * credential persistence, POST retries or replacement idempotency keys. */
+    private requestRecurring;
+    private dispatchRecurring;
     listApiKeys(): Promise<Record<string, unknown>[]>;
     createApiKey(name: string, scopes?: string[]): Promise<{
         key: string;

package/dist/lib/remote-customer-operations.d.ts

@@ -19,6 +19,7 @@ export declare const REMOTE_CUSTOMER_OPERATIONS: readonly [{
             boundedRunApproval?: boolean;
             unit?: string;
         };
+        recurringConsents?: import("./remote-recurring.js").RecurringCapability;
     }>;
 }, {
     readonly name: "list_remote_skills";

package/dist/lib/remote-invitations.d.ts

@@ -84,7 +84,7 @@ export declare class RemoteWorkspaceInvitationReadError extends Error {
     readonly code = "INVITATION_READ_FAILED";
     constructor();
 }
-export declare function invitationFailure(value: unknown, status: number): "INVALID_REQUEST" | "ACCOUNT_UNAVAILABLE" | "INTERACTIVE_SESSION_REQUIRED" | "WORKSPACE_ADMIN_REQUIRED" | "INVITATION_FORBIDDEN" | "INVITATION_UNAVAILABLE" | "INVITATION_CHANGED" | "INVITATION_EXISTS" | "ALREADY_MEMBER" | "IDEMPOTENCY_CONFLICT" | "INVITATION_LIMIT" | "INVITATION_BUSY" | "INVITATION_DELIVERY_UNAVAILABLE" | null;
+export declare function invitationFailure(value: unknown, status: number): "ACCOUNT_UNAVAILABLE" | "INTERACTIVE_SESSION_REQUIRED" | "INVALID_REQUEST" | "WORKSPACE_ADMIN_REQUIRED" | "INVITATION_FORBIDDEN" | "INVITATION_UNAVAILABLE" | "INVITATION_CHANGED" | "INVITATION_EXISTS" | "ALREADY_MEMBER" | "IDEMPOTENCY_CONFLICT" | "INVITATION_LIMIT" | "INVITATION_BUSY" | "INVITATION_DELIVERY_UNAVAILABLE" | null;
 export type InvitationAction = "list" | "get" | "issue" | "resend" | "revoke" | "accept";
 export type InvitationInputs = {
     list: ListRemoteWorkspaceInvitations;