@onesi/genesis 0.1.13 → 0.2.1

package/dist/iam.js

@@ -0,0 +1,92 @@
+import { GenesisError } from './errors.js';
+import { idempotencyHeaders } from './idempotency.js';
+const key = (operationId, idempotencyKey) => ({ headers: idempotencyHeaders(operationId, idempotencyKey) });
+const ENROLLMENT_KEY = /^mek_[A-Za-z0-9_-]{16,512}$/;
+/**
+ * IAM v4 tenant operations at /v1/iam/... (iam.l1fe.ai). Use a One account login or an organization API key with iam:read
+ * (reads) or iam:write (changes). The gateway exchanges either at Auth for a short-lived IAM token and forwards only that;
+ * IAM decides authority (owner or manager for most changes). `org_id` must be your own organization.
+ *
+ * Inviting members, changing member roles, removing members, Mind API keys and enterprise settings are not here: they stay
+ * with a person in the Console. Projects and workspaces are `genesis.projects` and `genesis.workspaces`.
+ */
+export function iamModule(client) {
+    return {
+        orgs: {
+            list: (query = {}) => client.request('iam_listOrgs', query),
+            get: (org_id) => client.request('iam_getOrg', { org_id }),
+            update: (org_id, body) => client.request('iam_updateOrg', { org_id, body }),
+            members: (org_id, query = {}) => client.request('iam_listMembers', { org_id, ...query }),
+            entitlements: (org_id, environment_id) => client.request('iam_listEntitlements', { org_id, ...(environment_id ? { environment_id } : {}) }),
+        },
+        fleets: {
+            list: (org_id) => client.request('iam_listFleets', { org_id }),
+            get: (org_id, fleet_id) => client.request('iam_getFleet', { org_id, fleet_id }),
+            /** Reuse the same idempotencyKey to replay an uncertain create instead of making a second fleet. */
+            create: (org_id, body, idempotencyKey) => client.request('iam_createFleet', { org_id, body }, key('iam_createFleet', idempotencyKey)),
+            update: (org_id, fleet_id, body) => client.request('iam_updateFleet', { org_id, fleet_id, body }),
+            /** Permanent; IAM refuses while grants reference the fleet. */
+            delete: (org_id, fleet_id) => client.request('iam_deleteFleet', { org_id, fleet_id }),
+        },
+        agents: {
+            list: (org_id) => client.request('iam_listAgents', { org_id }),
+            get: (org_id, agent_did) => client.request('iam_getAgent', { org_id, agent_did }),
+            /** Without `publicKey` IAM generates a key pair and returns `privateKey` once. */
+            create: (org_id, body) => client.request('iam_createAgent', { org_id, body }),
+            /** Revokes the agent (status `revoked`); the record stays. */
+            delete: (org_id, agent_did) => client.request('iam_deleteAgent', { org_id, agent_did }),
+            suspend: (org_id, agent_did) => client.request('iam_suspendAgent', { org_id, agent_did }),
+            resume: (org_id, agent_did) => client.request('iam_resumeAgent', { org_id, agent_did }),
+            rotate: (org_id, agent_did, body = {}) => client.request('iam_rotateAgentKey', { org_id, agent_did, body }),
+            acts: {
+                list: (org_id, agent_did) => client.request('iam_listAgentActs', { org_id, agent_did }),
+                issue: (org_id, agent_did, body) => client.request('iam_issueAgentAct', { org_id, agent_did, body }),
+            },
+            publication: (org_id, agent_id) => client.request('iam_getAgentPublication', { org_id, agent_id }),
+            orbitMsgsGrant: (org_id, agent_id) => client.request('iam_getOrbitMsgsProductGrant', { org_id, agent_id }),
+            /** A published agent's public card (anonymous). */
+            publicCard: (agent_id) => client.request('iam_getPublicAgent', { agent_id }),
+            /** Agents enrolled for a Mind with a currently valid credential. */
+            forMind: (org_id, mind_id) => client.request('iam_listMindAgents', { org_id, mind_id }),
+            enrollmentGrants: (org_id) => client.request('iam_listAgentEnrollmentGrants', { org_id }),
+            /**
+             * Enroll an agent under an agent enrollment grant. Only the grant's enrollment key (`mek_...`) is sent, as the bearer;
+             * this client's own Genesis credential is not. The credential secret in the answer is returned once.
+             */
+            enroll: (enrollmentKey, body) => {
+                if (typeof enrollmentKey !== 'string' || !ENROLLMENT_KEY.test(enrollmentKey))
+                    throw new GenesisError({ status: 0, type: 'invalid_request', operationId: 'iam_enrollAgent', message: 'Agent enrollment needs the grant\'s enrollment key (mek_...).' });
+                return client.request('iam_enrollAgent', { body }, { headers: { authorization: `Bearer ${enrollmentKey}` } });
+            },
+        },
+        roles: {
+            list: (org_id) => client.request('iam_listRoles', { org_id }),
+            get: (org_id, role_id) => client.request('iam_getRole', { org_id, role_id }),
+            create: (org_id, body) => client.request('iam_createRole', { org_id, body }),
+            update: (org_id, role_id, body) => client.request('iam_updateRole', { org_id, role_id, body }),
+            delete: (org_id, role_id) => client.request('iam_deleteRole', { org_id, role_id }),
+        },
+        grants: {
+            list: (query = {}) => client.request('iam_listGrants', query),
+            get: (grant_id) => client.request('iam_getGrant', { grant_id }),
+            /** `organization_id` must be your organization. With an idempotencyKey a retry returns the original grant. */
+            create: (body, idempotencyKey) => client.request('iam_createGrant', { body }, key('iam_createGrant', idempotencyKey)),
+            update: (grant_id, body) => client.request('iam_updateGrant', { grant_id, body }),
+            delete: (grant_id) => client.request('iam_deleteGrant', { grant_id }),
+        },
+        capabilities: {
+            get: (capability_id) => client.request('iam_getCapability', { capability_id }),
+            /** You are always the issuer; `organization_id` must be your organization. */
+            create: (body, idempotencyKey) => client.request('iam_createCapability', { body }, key('iam_createCapability', idempotencyKey)),
+            update: (capability_id, body) => client.request('iam_updateCapability', { capability_id, body }),
+            /** Revoke (issuer only), with an optional recorded reason. */
+            delete: (capability_id, reason) => client.request('iam_deleteCapability', { capability_id, body: reason === undefined ? {} : { reason } }),
+            verify: (body) => client.request('iam_verifyCapability', { body }),
+        },
+        platforms: () => client.request('iam_listPlatforms'),
+        tenantContext: () => client.request('iam_getTenantContext'),
+        checkPermission: (body) => client.request('iam_checkPermission', { body }),
+        requirePermission: (body) => client.request('iam_requirePermission', { body }),
+        checkEntitlement: (body) => client.request('iam_checkEntitlement', { body }),
+    };
+}

package/dist/idempotency.d.ts

@@ -2,3 +2,6 @@ import { type OperationId } from './generated/operations.js';
 /** The Idempotency-Key header an operation's spec declares. A required key is refused locally when missing
  * or malformed, before any request is sent; reuse the same key to replay instead of acting twice. */
 export declare function idempotencyHeaders(operationId: OperationId, key: string | undefined): Record<string, string>;
+/** The If-Match header an operation's spec requires (Auto's optimistic concurrency): the resource `version`
+ * you read, or its ETag. A missing or malformed version is refused locally, before anything is sent. */
+export declare function ifMatchHeaders(operationId: OperationId, version: string | number | undefined): Record<string, string>;

package/dist/idempotency.js

@@ -2,6 +2,8 @@ import { GenesisError } from './errors.js';
 import { operationTable } from './generated/operations.js';
 const REQUIRED = /^[\x21-\x7e]{8,128}$/;
 const OPTIONAL = /^[\x21-\x7e]{1,256}$/;
+/** Auto's Idempotency-Key grammar (l1felabs/auto src/operating.ts IDEMPOTENCY_KEY). */
+const AUTO_KEY = /^[A-Za-z0-9_.:-]{8,128}$/;
 /** The Idempotency-Key header an operation's spec declares. A required key is refused locally when missing
  * or malformed, before any request is sent; reuse the same key to replay instead of acting twice. */
 export function idempotencyHeaders(operationId, key) {
@@ -13,5 +15,30 @@ export function idempotencyHeaders(operationId, key) {
             message: need === 'required' ? `${operationId} needs a stable idempotency key (8-128 printable ASCII characters)`
                 : need ? `${operationId} idempotency key must be 1-256 printable ASCII characters` : `${operationId} does not take an idempotency key` });
     }
+    // Zaps (spec IdempotencyKey, gateway key lane) admits only 8-128 printable characters, required or optional.
+    if (operationTable[operationId].service === 'zaps' && !REQUIRED.test(key)) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId,
+            message: `${operationId} idempotency key must be 8-128 printable ASCII characters` });
+    }
+    // Auto takes 8-128 characters of [A-Za-z0-9_.:-] (its authority check); refuse anything it would 422 before sending.
+    if (operationTable[operationId].service === 'auto' && !AUTO_KEY.test(key)) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId,
+            message: `${operationId} idempotency key must be 8-128 characters of A-Z a-z 0-9 _ . : -` });
+    }
     return { 'idempotency-key': key };
 }
+/** The If-Match header an operation's spec requires (Auto's optimistic concurrency): the resource `version`
+ * you read, or its ETag. A missing or malformed version is refused locally, before anything is sent. */
+export function ifMatchHeaders(operationId, version) {
+    const need = operationTable[operationId].ifMatch;
+    if (!need) {
+        if (version === undefined)
+            return {};
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId, message: `${operationId} does not take If-Match` });
+    }
+    const v = typeof version === 'number' ? String(version) : version;
+    if (typeof v !== 'string' || !/^(?:W\/)?"?[1-9][0-9]{0,8}"?$/.test(v)) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId, message: `${operationId} needs the version you read (If-Match, e.g. 3)` });
+    }
+    return { 'if-match': `"${v.replace(/^W\//, '').replace(/"/g, '')}"` };
+}

package/dist/index.d.ts

@@ -1,6 +1,9 @@
 export { Genesis, type ChatMessage } from './genesis.js';
 export { GenesisClient, DEFAULT_BASE_URL, type GenesisOptions, type CredentialProvider } from './client.js';
-export { GenesisError, errorCatalog, errorToken, errorOutcome } from './errors.js';
+export { iamDirectoryOperations, isIamDirectoryOperation, iamDirectoryFailure } from './iam-directory.js';
+export { iamModule } from './iam.js';
+export { GenesisError, errorCatalog, errorBody, errorToken, errorOutcome } from './errors.js';
+export { ERROR_BODY_LIMITS, cardNumber, redactErrorBody, redactErrorText, secretField } from './redact.js';
 export { requireSecureUrl } from './urls.js';
 export { operationTable, services, type OperationId } from './generated/operations.js';
 export type { OperationInput, OperationOutput, OperationMeta, ServiceMeta } from './types.js';
@@ -10,24 +13,37 @@ export { validateHivesInvocation, hivesFunctionResponseHeaders, HivesOperationEr
 export { hivesResponseBytes } from './hives-response.js';
 export { runnerModule, type RunnerStartInput, type RunnerSnapshot, type RunnerCatalog, type RunnerEvent, type RunnerProviderResult, type RunnerRequestOptions } from './runner.js';
 export type { RunnerSelfExecutionGrantInput, RunnerSelfExecutionGrant } from './runner-grant.js';
-export { beaconsModule } from './beacons.js';
+export { beaconsModule, BEACONS_RESOURCE_FAMILIES, BEACONS_CLIENT_PLATFORMS, type BeaconsResourceFamily } from './beacons.js';
+export type { BeaconsClientPlatform } from './beacons.js';
 export { rigsModule, panesModule, shellsModule } from './instances.js';
 export { gearsModule } from './gears.js';
+export { tapsModule } from './taps.js';
 export { lanesModule } from './lanes.js';
 export { flaresModule } from './flares.js';
-export { idempotencyHeaders } from './idempotency.js';
+export { idempotencyHeaders, ifMatchHeaders } from './idempotency.js';
+export type { FlocksWriteOptions, WaitForJobOptions, FlocksJob, FlocksRun } from './flocks.js';
+export { autoModule } from './auto.js';
+export { gardenModule } from './garden.js';
+export { orgsEntitiesModule, type OrgsDocumentContent } from './orgs.js';
+export { scopesModule } from './scopes.js';
+export { billingModule, gatewayModule, orgsModule } from './gateway.js';
+export { boxesModule } from './boxes.js';
 export { dialsModule, dialsEmergencyAddressFeedback, type DialsEmergencyAddressFeedback, type DialsScope, type DialsOutboundCall, type DialsCallControl, type DialsEmergencyAddress, type DialsCallListItem, type DialsCallDispatchState, type DialsMessage, type DialsMessageTemplate, type DialsMessagingBrand, type DialsMessagingCampaign, type DialsWorkflowDocument, type DialsRoutingAction, type DialsRoutingRule, type DialsRoutingRuleReceipt, type DialsOutboundCallReceipt, type DialsRecoveredOutboundCallReceipt } from './dials.js';
 export { hivesObjectKey, type HivesBucket, type HivesObject, type HivesObjectAcknowledgement, type HivesObjectList, type HivesCorsRule, type HivesCreateBucket, type HivesPresign, type HivesPresignedUrl } from './hives-cells.js';
+export { hivesSseEvents, hivesSseReader, type HivesLogStreamEvent, type HivesLogStreamQuery, type HivesLogWindow, type HivesLogWindowOptions } from './hives-platform.js';
 export { hivesQueueBody, type HivesQueue, type HivesQueueConfig, type HivesQueueCreate, type HivesQueueSend, type HivesQueueDelivery, type HivesDeadLetter, type HivesDeadLetterStats } from './hives-queues.js';
 export type { HivesRuntime, HivesRuntimeSelection } from './hives-runtimes.js';
 export type { HivesVolume, HivesVolumeCreate, HivesVolumeMount, HivesVolumePage } from './hives-volumes.js';
-export { HIVES_OBJECT_BYTES, HIVES_QUEUE_BYTES, type HivesResourceOptions } from './hives-resources-transport.js';
+export { HIVES_OBJECT_BYTES, HIVES_QUEUE_BYTES, type HivesResourceOptions, type HivesFundedWriteOptions } from './hives-resources-transport.js';
 export type { HivesMarketplacePackage, HivesMarketplaceVersion, HivesMarketplaceInstallation, HivesMarketplaceCategory, HivesMarketplacePage, HivesMarketplacePublish, HivesMarketplaceInstall, HivesMarketplaceSearch, HivesMarketplaceDetail } from './hives-marketplace.js';
 export type { HivesQueueConsumerConfig, HivesQueueConsumerBinding, HivesQueueConsumerAttempt, HivesQueueConsumerStatus } from './hives-queue-consumer.js';
 export { foundryBillingOperations, isFoundryBillingOperation } from './foundry-billing.js';
 export type { HivesTopic, HivesTopicSubscription, HivesTopicPublish, HivesTopicPublication } from './hives-topics.js';
-export { mindsModule, mindsOperations, isMindsOperation, type MindsCreateOptions, type MindsResumeOptions, type MindsStopOptions, type MindsWakeReason, type MindsRequestOptions, type MindsUsage, type MindsEventInput } from './minds.js';
-export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation, type MindsAgentOptions, type MindsAgentEventInput } from './minds-agent.js';
+export { mindsModule, mindsOperations, isMindsOperation, mindsServices, type MindsService, type MindsDeleteOptions, type MindsResizeOptions, type MindsCreateOptions, type MindsResumeOptions, type MindsStopOptions, type MindsWakeReason, type MindsRequestOptions, type MindsUsage, type MindsEventInput, type MindsWebhookDelivery, type MindsWebhookDeliveryReceipt } from './minds.js';
+export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation, mindsAgentCreateOperations, isMindsAgentCreateOperation, type MindsAgentOptions, type MindsAgentEventInput, type MindsAgentCreateInput, type MindsAgentCreateOptions } from './minds-agent.js';
+export { mindsEngineModule, mindsEngineOperations, isMindsEngineOperation, mindsEngineCommands, type MindsEngineOperation, type MindsEngineOptions } from './minds-engine.js';
 export { MindsOwnerError, mindsOwnerOperations, isMindsOwnerOperation, type MindsOwnerOptions, type MindsOwnerVersion, type MindsAttachmentSubject, type MindsAttachInput } from './minds-owner.js';
 export { selectGenesisContext, checkedGenesisContextSession, type GenesisContextSelection, type GenesisContextSession } from './context.js';
 export { HivesQueueOperationError, hivesQueueOperationId, type HivesQueueOperation, type HivesQueueSendOptions } from './hives-queue-funding.js';
+export { foldHenryTurns, type HenryRun, type HenryRunEvent, type HenryRunEventMessage, type HenryRunStreamStatus, type HenryMessageDelivery, type HenryStreamEvent, type HenryStreamOptions, type HenryTurn, type HenryReplay } from './henry.js';
+export { hivesSseWindow, type HivesSseEvent, type HivesSseWindow, type HivesSseWindowOptions } from './hives-sse.js';

package/dist/index.js

@@ -1,25 +1,39 @@
 export { Genesis } from './genesis.js';
 export { GenesisClient, DEFAULT_BASE_URL } from './client.js';
-export { GenesisError, errorCatalog, errorToken, errorOutcome } from './errors.js';
+export { iamDirectoryOperations, isIamDirectoryOperation, iamDirectoryFailure } from './iam-directory.js';
+export { iamModule } from './iam.js';
+export { GenesisError, errorCatalog, errorBody, errorToken, errorOutcome } from './errors.js';
+export { ERROR_BODY_LIMITS, cardNumber, redactErrorBody, redactErrorText, secretField } from './redact.js';
 export { requireSecureUrl } from './urls.js';
 export { operationTable, services } from './generated/operations.js';
 export { hivesUploadBody, MAX_WASM_BYTES } from './hives-upload.js';
 export { validateHivesInvocation, hivesFunctionResponseHeaders, HivesOperationError, MAX_FUNCTION_BODY_BYTES, MAX_FUNCTION_JSON_BYTES } from './hives-functions.js';
 export { hivesResponseBytes } from './hives-response.js';
 export { runnerModule } from './runner.js';
-export { beaconsModule } from './beacons.js';
+export { beaconsModule, BEACONS_RESOURCE_FAMILIES, BEACONS_CLIENT_PLATFORMS } from './beacons.js';
 export { rigsModule, panesModule, shellsModule } from './instances.js';
 export { gearsModule } from './gears.js';
+export { tapsModule } from './taps.js';
 export { lanesModule } from './lanes.js';
 export { flaresModule } from './flares.js';
-export { idempotencyHeaders } from './idempotency.js';
+export { idempotencyHeaders, ifMatchHeaders } from './idempotency.js';
+export { autoModule } from './auto.js';
+export { gardenModule } from './garden.js';
+export { orgsEntitiesModule } from './orgs.js';
+export { scopesModule } from './scopes.js';
+export { billingModule, gatewayModule, orgsModule } from './gateway.js';
+export { boxesModule } from './boxes.js';
 export { dialsModule, dialsEmergencyAddressFeedback } from './dials.js';
 export { hivesObjectKey } from './hives-cells.js';
+export { hivesSseEvents, hivesSseReader } from './hives-platform.js';
 export { hivesQueueBody } from './hives-queues.js';
 export { HIVES_OBJECT_BYTES, HIVES_QUEUE_BYTES } from './hives-resources-transport.js';
 export { foundryBillingOperations, isFoundryBillingOperation } from './foundry-billing.js';
-export { mindsModule, mindsOperations, isMindsOperation } from './minds.js';
-export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation } from './minds-agent.js';
+export { mindsModule, mindsOperations, isMindsOperation, mindsServices } from './minds.js';
+export { MindsAgentError, mindsAgentOperations, isMindsAgentOperation, mindsAgentCreateOperations, isMindsAgentCreateOperation } from './minds-agent.js';
+export { mindsEngineModule, mindsEngineOperations, isMindsEngineOperation, mindsEngineCommands } from './minds-engine.js';
 export { MindsOwnerError, mindsOwnerOperations, isMindsOwnerOperation } from './minds-owner.js';
 export { selectGenesisContext, checkedGenesisContextSession } from './context.js';
 export { HivesQueueOperationError, hivesQueueOperationId } from './hives-queue-funding.js';
+export { foldHenryTurns } from './henry.js';
+export { hivesSseWindow } from './hives-sse.js';

package/dist/instances.d.ts

@@ -1,11 +1,63 @@
 import type { GenesisClient } from './client.js';
-/** Read-only instance inventories. Each needs an interactive One account login with a selected
- * organization and project; the gateway admits nothing else on these products. */
+import type { OperationInput } from './types.js';
+/** Instance inventory and lifecycle. Each needs a One account login with a selected organization
+ * and project, or an org API key whose binding selects them. `create` needs a stable idempotency
+ * key (8-128 printable ASCII characters): reuse it to retry and the same instance is returned.
+ * `delete` runs the instance's stop action (an optional key makes the stop one replayable
+ * operation); Omega's native stop deletes the deployment. Ids are Omega deployment UUIDs. */
 export declare function rigsModule(client: GenesisClient): {
     list: () => Promise<{
         product: "rigs";
         instances: import("./index.js").components["schemas"]["Rigs.Instance"][];
     }>;
+    get: (id: string) => Promise<{
+        product: "rigs";
+        instance: import("./index.js").components["schemas"]["Rigs.Instance"];
+    }>;
+    create: (body: NonNullable<OperationInput<"rigs_createRig">["body"]>, idempotencyKey: string) => Promise<{
+        product: "rigs";
+        instance: import("./index.js").components["schemas"]["Rigs.Instance"];
+    }>;
+    delete: (id: string, idempotencyKey?: string) => Promise<{
+        ok: true;
+        product: "rigs";
+        id: string;
+        capability: "stop";
+        result: {
+            ok?: boolean;
+            capability?: string;
+            status?: string;
+            completed?: boolean;
+            pending?: boolean;
+            bridge?: boolean;
+        };
+    }>;
+    /** `{capability, args}`; the key is required for every capability but `stop`. */
+    action: (id: string, body: NonNullable<OperationInput<"rigs_actOnRig">["body"]>, idempotencyKey?: string) => Promise<{
+        ok: boolean;
+        product: string;
+        id: string;
+        capability: string;
+        result?: {
+            [key: string]: unknown;
+        } | null;
+    } & {
+        [key: string]: unknown;
+    }>;
+    term: (id: string) => Promise<{
+        product: string;
+        id: string;
+        kind?: string;
+        credentials: {
+            url?: string;
+            token?: string;
+            expires_in?: number | string;
+        } & {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    }>;
 };
 export declare function panesModule(client: GenesisClient): {
     list: () => Promise<{
@@ -14,6 +66,61 @@ export declare function panesModule(client: GenesisClient): {
     } & {
         [key: string]: unknown;
     }>;
+    get: (id: string) => Promise<{
+        product: "panes";
+        instance: import("./index.js").components["schemas"]["Panes.Instance"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    create: (body: NonNullable<OperationInput<"panes_createPane">["body"]>, idempotencyKey: string) => Promise<{
+        product: "panes";
+        instance: import("./index.js").components["schemas"]["Panes.Instance"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    delete: (id: string, idempotencyKey?: string) => Promise<{
+        ok: true;
+        product: "panes";
+        id: string;
+        capability: "stop";
+        result?: {
+            [key: string]: unknown;
+        };
+        accepted?: boolean;
+        completed?: boolean;
+        pending?: boolean;
+        status?: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** `{capability, args}`; the key is required for every capability but `stop`. */
+    action: (id: string, body: NonNullable<OperationInput<"panes_actOnPane">["body"]>, idempotencyKey?: string) => Promise<{
+        ok: boolean;
+        product: string;
+        id: string;
+        capability: string;
+        result?: {
+            [key: string]: unknown;
+        } | null;
+    } & {
+        [key: string]: unknown;
+    }>;
+    term: (id: string) => Promise<{
+        product: string;
+        id: string;
+        kind?: string;
+        credentials: {
+            url?: string;
+            token?: string;
+            expires_in?: number | string;
+        } & {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** The screenshot image as a raw Response (PNG or JPEG). */
+    screenshot: (id: string, artifactId: string) => Promise<unknown>;
 };
 export declare function shellsModule(client: GenesisClient): {
     list: () => Promise<{
@@ -22,4 +129,72 @@ export declare function shellsModule(client: GenesisClient): {
     } & {
         [key: string]: unknown;
     }>;
+    get: (id: string) => Promise<{
+        product: "shells";
+        instance: import("./index.js").components["schemas"]["Shells.Instance"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    create: (body: NonNullable<OperationInput<"shells_createShell">["body"]>, idempotencyKey: string) => Promise<{
+        product: "shells";
+        instance: import("./index.js").components["schemas"]["Shells.Instance"];
+    } & {
+        [key: string]: unknown;
+    }>;
+    delete: (id: string, idempotencyKey?: string) => Promise<{
+        ok: true;
+        product: "shells";
+        id: string;
+        capability: "stop";
+        result?: {
+            [key: string]: unknown;
+        };
+        cambium?: unknown;
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** `{capability, args}`; the key is required for every capability but `stop`. */
+    action: (id: string, body: NonNullable<OperationInput<"shells_actOnShell">["body"]>, idempotencyKey?: string) => Promise<{
+        ok: boolean;
+        product: string;
+        id: string;
+        capability: string;
+        result?: {
+            [key: string]: unknown;
+        } | null;
+    } & {
+        [key: string]: unknown;
+    }>;
+    term: (id: string) => Promise<{
+        product: string;
+        id: string;
+        kind?: string;
+        credentials: {
+            url?: string;
+            token?: string;
+            expires_in?: number | string;
+        } & {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    }>;
+    /** One-shot exec; a repeat with the same key and body replays the stored result. */
+    exec: (id: string, body: NonNullable<OperationInput<"shells_execShell">["body"]>, idempotencyKey: string) => Promise<{
+        ok: true;
+        product: "shells";
+        id: string;
+        result: {
+            exitCode: number | null;
+            encoding: "base64";
+            stdout: string;
+            stderr: string;
+            truncated: {
+                stdout?: boolean;
+                stderr?: boolean;
+            };
+            timedOut: boolean;
+            durationMs: number;
+        };
+    }>;
 };

package/dist/instances.js

@@ -1,11 +1,43 @@
-/** Read-only instance inventories. Each needs an interactive One account login with a selected
- * organization and project; the gateway admits nothing else on these products. */
+import { idempotencyHeaders } from './idempotency.js';
+/** Instance inventory and lifecycle. Each needs a One account login with a selected organization
+ * and project, or an org API key whose binding selects them. `create` needs a stable idempotency
+ * key (8-128 printable ASCII characters): reuse it to retry and the same instance is returned.
+ * `delete` runs the instance's stop action (an optional key makes the stop one replayable
+ * operation); Omega's native stop deletes the deployment. Ids are Omega deployment UUIDs. */
 export function rigsModule(client) {
-    return { list: () => client.request('rigs_listRigs') };
+    return {
+        list: () => client.request('rigs_listRigs'),
+        get: (id) => client.request('rigs_getRig', { id }),
+        create: (body, idempotencyKey) => client.request('rigs_createRig', { body }, { headers: idempotencyHeaders('rigs_createRig', idempotencyKey) }),
+        delete: (id, idempotencyKey) => client.request('rigs_deleteRig', { id }, { headers: idempotencyHeaders('rigs_deleteRig', idempotencyKey) }),
+        /** `{capability, args}`; the key is required for every capability but `stop`. */
+        action: (id, body, idempotencyKey) => client.request('rigs_actOnRig', { id, body }, { headers: idempotencyHeaders('rigs_actOnRig', idempotencyKey) }),
+        term: (id) => client.request('rigs_openRigTerm', { id }),
+    };
 }
 export function panesModule(client) {
-    return { list: () => client.request('panes_listPanes') };
+    return {
+        list: () => client.request('panes_listPanes'),
+        get: (id) => client.request('panes_getPane', { id }),
+        create: (body, idempotencyKey) => client.request('panes_createPane', { body }, { headers: idempotencyHeaders('panes_createPane', idempotencyKey) }),
+        delete: (id, idempotencyKey) => client.request('panes_deletePane', { id }, { headers: idempotencyHeaders('panes_deletePane', idempotencyKey) }),
+        /** `{capability, args}`; the key is required for every capability but `stop`. */
+        action: (id, body, idempotencyKey) => client.request('panes_actOnPane', { id, body }, { headers: idempotencyHeaders('panes_actOnPane', idempotencyKey) }),
+        term: (id) => client.request('panes_openPaneTerm', { id }),
+        /** The screenshot image as a raw Response (PNG or JPEG). */
+        screenshot: (id, artifactId) => client.request('panes_getPaneScreenshotData', { id, artifactId }),
+    };
 }
 export function shellsModule(client) {
-    return { list: () => client.request('shells_listShells') };
+    return {
+        list: () => client.request('shells_listShells'),
+        get: (id) => client.request('shells_getShell', { id }),
+        create: (body, idempotencyKey) => client.request('shells_createShell', { body }, { headers: idempotencyHeaders('shells_createShell', idempotencyKey) }),
+        delete: (id, idempotencyKey) => client.request('shells_deleteShell', { id }, { headers: idempotencyHeaders('shells_deleteShell', idempotencyKey) }),
+        /** `{capability, args}`; the key is required for every capability but `stop`. */
+        action: (id, body, idempotencyKey) => client.request('shells_actOnShell', { id, body }, { headers: idempotencyHeaders('shells_actOnShell', idempotencyKey) }),
+        term: (id) => client.request('shells_openShellTerm', { id }),
+        /** One-shot exec; a repeat with the same key and body replays the stored result. */
+        exec: (id, body, idempotencyKey) => client.request('shells_execShell', { id, body }, { headers: idempotencyHeaders('shells_execShell', idempotencyKey) }),
+    };
 }

package/dist/minds-agent.d.ts

@@ -1,6 +1,9 @@
 import type { GenesisClient } from './client.js';
 import { GenesisError } from './errors.js';
 export declare const mindsAgentOperations: readonly ["minds_agentInsertEpisodicMemory", "minds_agentGetEpisodicMemory", "minds_agentSearchMemory"];
+/** Agent Mind creation: an approved agent-create token with DPoP, default-off at the gateway (MINDS_AGENT_CREATE_ENABLED). */
+export declare const mindsAgentCreateOperations: readonly ["minds_agentCreateMind", "minds_agentGetCreateOperation"];
+export declare const isMindsAgentCreateOperation: (id: string) => boolean;
 export declare const isMindsAgentOperation: (id: string) => boolean;
 declare const EVENT_TYPES: readonly ["Conversation", "Command", "Query", "Document", "Error", "Success", "Learning", "Decision", "Action", "Context", "Knowledge"];
 type Row = Record<string, unknown>;
@@ -12,6 +15,18 @@ export interface MindsAgentEventInput {
     summary?: string | null;
     tags?: string[];
 }
+export interface MindsAgentCreateInput {
+    /** "Sandbox" or "Sandbox <label>", at most 80 characters. */
+    name: string;
+    approvalId: string;
+    approvalVersion: number;
+    /** Persisted UUID4 for this creation; also the idempotency key and the status lookup id. */
+    operationId: string;
+}
+export interface MindsAgentCreateOptions {
+    dpopProof: string;
+    signal?: AbortSignal;
+}
 export interface MindsAgentOptions {
     /** Omit for the agent's private namespace; group authority is checked by the controller. */
     group?: string;
@@ -38,6 +53,19 @@ export declare function mindsAgentTransport(options: {
     signal?: AbortSignal;
 }): Promise<Response>;
 export declare function mindsAgentModule(client: GenesisClient): {
+    /** Free/F1 Sandbox only; the fixed spec is the only shape the gateway admits. */
+    create: (input: MindsAgentCreateInput, options: MindsAgentCreateOptions) => Promise<{
+        mind_id: string;
+        status: string;
+    } & {
+        [key: string]: unknown;
+    }>;
+    createStatus: (operation_id: string, options: MindsAgentCreateOptions) => Promise<{
+        mind_id: string;
+        status: string;
+    } & {
+        [key: string]: unknown;
+    }>;
     memory: {
         insert: (mind: string, event: MindsAgentEventInput, options?: MindsAgentOptions) => Promise<{
             id: string;