@hasna/skills 0.8.0 → 0.8.2

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/execution-secrets.d.ts

@@ -0,0 +1,40 @@
+import type { ResolvedSkillSelection } from "../types/skill-selection.js";
+export interface SelectedSecretBindings {
+    schema: "hasna.skills-secret-bindings.v1";
+    selection: Pick<ResolvedSkillSelection, "authority" | "workspaceId" | "profileRevision" | "slug" | "version" | "bundleDigest"> & {
+        profileId: string;
+    };
+    consumer: {
+        stationId: string;
+        workspaceDirectory: string;
+    };
+    /** Exact canonical /v1 authority of the independently configured Secrets client. */
+    secretsAuthority: string;
+    /** Declared environment name -> vault key. Values are resolved freshly for each run. */
+    bindings: Record<string, string>;
+}
+export interface SelectedSecretsClient {
+    readonly baseUrl: string;
+    getSecret(query: {
+        key: string;
+    }, init?: RequestInit): Promise<{
+        key: string;
+        value: string;
+        expires_at?: string | null;
+    }>;
+}
+export interface SelectedSecretScope {
+    selection: ResolvedSkillSelection;
+    profileId: string;
+    cwd: string;
+}
+export declare function selectedSecretBindingsTemplate(scope: SelectedSecretScope, names: string[], createClient?: () => SelectedSecretsClient): SelectedSecretBindings;
+/** Runtime controls must not be supplied as credentials, even by a reviewed binding. */
+export declare function declaredSecretNames(value: unknown): string[];
+/** Reading is bounded and rejects symlinks/devices. Parsing errors never echo file contents. */
+export declare function readSelectedSecretBindings(path: string): SelectedSecretBindings;
+/** Validate every grant before constructing a client or reading any secret. */
+export declare function validateSelectedSecretBindings(value: unknown, scope: SelectedSecretScope, names: string[]): SelectedSecretBindings;
+export declare function resolveSelectedSecrets(bindings: SelectedSecretBindings, createClient?: () => SelectedSecretsClient): Promise<Record<string, string>>;
+/** Limit accidental disclosure in child output. This is not a sandbox for hostile code. */
+export declare function redactExecutionSecrets(text: string, env: Record<string, 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/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/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;

package/dist/lib/remote-recurring-contract.d.ts

@@ -0,0 +1,165 @@
+import { z } from "zod/v4";
+/** Portable versioned wire values only. Eligibility, repricing, freshness, budgets
+ * and execution authority are verified by the configured server. */
+export declare const RECURRING_CONTRACT_VERSION: 1;
+export declare const MAX_RECURRING_CREDITS = 2147483647;
+export declare const recurringRequestSchema: 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>;
+export type RecurringRequest = z.infer<typeof recurringRequestSchema>;
+export interface RecurringTerms extends RecurringRequest {
+    deploymentId: string;
+    organizationId: string;
+    approvedByUserId: string;
+    approvedMembershipId: string;
+    policyId: string;
+    policyRevision: number;
+    skillId: string;
+    skillVersionId: string;
+    runtimeApprovalDigest: string;
+    payloadSha256: string;
+}
+export declare const recurringTermsSchema: 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;
+    deploymentId: z.ZodString;
+    organizationId: z.ZodUUID;
+    approvedByUserId: z.ZodUUID;
+    approvedMembershipId: z.ZodUUID;
+    policyId: z.ZodUUID;
+    policyRevision: z.ZodNumber;
+    skillId: z.ZodUUID;
+    skillVersionId: z.ZodUUID;
+    runtimeApprovalDigest: z.ZodString;
+    payloadSha256: z.ZodString;
+}, z.core.$strict>;
+export interface RecurringQuote {
+    costCredits: number;
+    quotedAt: string;
+    /** Quote is informational: admission always reprices under authority locks. */
+    admissionReprices: true;
+}
+export interface RecurringPreview {
+    contractVersion: typeof RECURRING_CONTRACT_VERSION;
+    draftId: string;
+    terms: RecurringTerms;
+    termsSha256: string;
+    quote: RecurringQuote;
+    approvalDeadline: string;
+    firstDueInstants: string[];
+    firstPeriod: {
+        startsAt: string;
+        endsAt: string;
+    };
+    additionalBudget: true;
+}
+export declare const recurringActivationSchema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<1>;
+    acceptedTermsSha256: z.ZodString;
+    acceptance: z.ZodLiteral<"authorize-recurring-credit-use">;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type RecurringActivation = z.infer<typeof recurringActivationSchema>;
+export interface RecurringBudget {
+    reservedCredits: number;
+    settledCredits: number;
+    admittedOccurrences: number;
+}
+export interface RecurringConsentView {
+    contractVersion: typeof RECURRING_CONTRACT_VERSION;
+    consentId: string;
+    scheduleId: string;
+    terms: RecurringTerms;
+    termsSha256: string;
+    state: "active" | "revoked" | "expired";
+    activatedAt: string;
+    revokedAt: string | null;
+    total: RecurringBudget;
+    currentPeriod: (RecurringBudget & {
+        startsAt: string;
+        endsAt: string;
+    }) | null;
+    nextDueAt: string | null;
+}
+export interface RecurringActivationResult {
+    replayed: boolean;
+    consent: RecurringConsentView;
+}
+export interface RecurringPage<T> {
+    contractVersion: typeof RECURRING_CONTRACT_VERSION;
+    items: T[];
+    nextCursor: string | null;
+}
+export type RecurringRefusal = "consent-inactive" | "authority-revoked" | "policy-disabled" | "policy-changed" | "skill-changed" | "quote-unavailable" | "per-run-ceiling" | "period-ceiling" | "total-ceiling" | "period-count" | "total-count" | "insufficient-credits" | "input-quota" | "runtime-unavailable";
+export interface RecurringOccurrenceView {
+    occurrenceId: string;
+    scheduleId: string;
+    dueAt: string;
+    periodStartsAt: string;
+    periodEndsAt: string;
+    outcome: "admitted" | "skipped" | "refused";
+    reason: RecurringRefusal | "dispatch-grace-elapsed" | null;
+    runId: string | null;
+    quotedCredits: number | null;
+    allocationState: "reserved" | "captured" | "released" | null;
+}
+export interface RecurringRevocation {
+    contractVersion: typeof RECURRING_CONTRACT_VERSION;
+    consentId: string;
+    revokedAt: string;
+    /** Bounded snapshot; separate paginated occurrences contains every run. */
+    authorizedRuns: {
+        runId: string;
+        attempt: number;
+        reservedCredits: number;
+    }[];
+    authorizedRunCount: number;
+    residualReservedCredits: number;
+    inFlightPolicy: "finish-authorized-attempt";
+    cancellationIsSeparate: true;
+}