@opengeni/contracts 0.50.0 → 1.0.0

package/dist/product-lifecycle-facts.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Content-free per-person product lifecycle facts.
+ *
+ * Migration `0532_product_lifecycle_fact_export.sql` captures one fact per
+ * product change with row triggers and writes it to the durable host export as
+ * the `lifecycle_fact` kind; `0565_usage_analytics_presence_and_facts.sql` adds
+ * `user.active`, `credits.granted` and `connection.revoked`. Every value is drawn from a fixed list; the
+ * database function `opengeni_private.product_lifecycle_fact_valid` enforces
+ * the same lists and a test keeps the two copies identical.
+ */
+/**
+ * Closed class of a positive credit grant (`grant` or `manual_credit_grant`
+ * ledger row). `opengeni_private.credit_grant_class` mirrors this mapping:
+ * - `signup_trial`: the one-time verified-signup trial (source `verified_signup_trial`).
+ * - `coupon`: a fully discounted Stripe checkout (source `stripe_checkout_coupon`).
+ * - `manual`: an operator grant (`manual_credit_grant` or source `operator_adjustment`).
+ * - `other`: any other grant source.
+ */
+export declare const CREDIT_GRANT_CLASSES: readonly ["signup_trial", "coupon", "manual", "other"];
+export type CreditGrantClass = (typeof CREDIT_GRANT_CLASSES)[number];
+/** Each fact type and the fixed values its `attribute` may carry. */
+export declare const PRODUCT_LIFECYCLE_FACT_ATTRIBUTES: {
+    /** A managed account was created. Attribute: first sign-in method. */
+    readonly "auth.sign_up": readonly ["email", "google", "github", "other"];
+    /**
+     * The account email became verified: by the verification link, or at
+     * creation when a social provider already verified it.
+     */
+    readonly "auth.email_verified": readonly [];
+    /** A live sign-in session was created. Attribute: method of that session. */
+    readonly "auth.sign_in": readonly ["email", "google", "github", "other"];
+    /** An organization was created by self-service setup or as an additional one. */
+    readonly "organization.setup": readonly ["created", "additional"];
+    /** A model subscription or organization model provider was connected. */
+    readonly "model.connected": readonly ["codex", "supergrok", "vercel_gateway", "openrouter", "anthropic", "claude_subscription"];
+    /** A credit top-up payment was granted. */
+    readonly "credits.purchased": readonly [];
+    /** Credits were granted without a purchase. Attribute: grant class. */
+    readonly "credits.granted": readonly ["signup_trial", "coupon", "manual", "other"];
+    /** An integration connection was created. Attribute: provider class. */
+    readonly "connection.created": readonly ["slack", "github", "gitlab", "azure_devops", "bitbucket", "google", "microsoft", "linear", "atlassian", "notion", "supabase", "datadog", "posthog", "openai", "x", "other"];
+    /**
+     * An integration connection was revoked, or deleted while still live.
+     * Attribute: provider class, the same list as `connection.created`.
+     */
+    readonly "connection.revoked": readonly ["slack", "github", "gitlab", "azure_devops", "bitbucket", "google", "microsoft", "linear", "atlassian", "notion", "supabase", "datadog", "posthog", "openai", "x", "other"];
+    readonly "scheduled_task.created": readonly [];
+    /** A catalog Skill was installed into a workspace. */
+    readonly "skill.installed": readonly [];
+    /** A Slack user was linked to an OpenGeni user. */
+    readonly "slack.user_linked": readonly [];
+    /** A new Connected Machine was enrolled. */
+    readonly "machine.enrolled": readonly [];
+    /** A person became an active member of an organization that already had one. */
+    readonly "member.joined": readonly [];
+    /**
+     * A managed person was active in an authenticated browser session on a new
+     * UTC day: at most one fact per person per UTC day, with no organization.
+     */
+    readonly "user.active": readonly [];
+};
+export type ProductLifecycleFactType = keyof typeof PRODUCT_LIFECYCLE_FACT_ATTRIBUTES;
+export declare const PRODUCT_LIFECYCLE_FACT_TYPES: ProductLifecycleFactType[];
+/**
+ * What kind of subject caused the fact. Only `user` and `api_key` facts carry
+ * their opaque subject id; every other subject string is reduced to its kind
+ * because embedded hosts may put their own identifiers in it.
+ */
+export declare const PRODUCT_LIFECYCLE_SUBJECT_KINDS: readonly ["user", "api_key", "service", "other", "none"];
+export type ProductLifecycleSubjectKind = (typeof PRODUCT_LIFECYCLE_SUBJECT_KINDS)[number];
+/** Pseudonymous subject ids that may leave the database. */
+export declare const PRODUCT_LIFECYCLE_SUBJECT_ID_PATTERN: RegExp;
+export declare function isProductLifecycleFact(type: string, attribute: string | null): boolean;

package/dist/remember.d.ts

@@ -0,0 +1,350 @@
+import { z } from "zod";
+/**
+ * Explicit user-directed durable write ("remember X for this workspace").
+ *
+ * The lane is the Agent Knowledge area the content belongs to:
+ * - `preference`: a Ways-of-working preference (how agents should act);
+ * - `instruction_policy`: a mandatory workspace rule ("always"/"never");
+ * - `knowledge`: a company/product/people fact.
+ *
+ * v1 supports the workspace scope only. Personal and organization scopes are
+ * separate authorities that are not yet active for governed writes.
+ */
+export declare const RememberLane: z.ZodEnum<{
+    instruction_policy: "instruction_policy";
+    knowledge: "knowledge";
+    preference: "preference";
+}>;
+export type RememberLane = z.infer<typeof RememberLane>;
+export declare const RememberScope: z.ZodEnum<{
+    workspace: "workspace";
+}>;
+export type RememberScope = z.infer<typeof RememberScope>;
+/**
+ * Ceiling for the Knowledge lane, which is retrieval evidence rather than
+ * always-composed prompt text. Other lanes have their own destination bounds:
+ * see `AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_MAX_CHARS` and
+ * `AGENT_AUTHORED_PREFERENCE_CONTENT_MAX_CHARS`.
+ */
+export declare const REMEMBER_CONTENT_MAX_CHARS = 4000;
+export declare const RememberRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operationId: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        workspace: "workspace";
+    }>>;
+    reason: z.ZodString;
+    lane: z.ZodLiteral<"preference">;
+    content: z.ZodString;
+    stableKey: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operationId: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        workspace: "workspace";
+    }>>;
+    reason: z.ZodString;
+    lane: z.ZodLiteral<"instruction_policy">;
+    content: z.ZodString;
+    target: z.ZodDefault<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    operationId: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        workspace: "workspace";
+    }>>;
+    content: z.ZodString;
+    reason: z.ZodString;
+    lane: z.ZodLiteral<"knowledge">;
+    subject: z.ZodString;
+}, z.core.$strict>], "lane">;
+export type RememberRequest = z.infer<typeof RememberRequest>;
+/**
+ * Bound structured human-input question that authorizes a confirmed remember.
+ * The question id binds the exact confirmation target: the
+ * `knowledge_change_proposals` id for Ways-of-working lanes, or the
+ * `knowledge_claims` id for the Knowledge lane.
+ */
+export declare const REMEMBER_HUMAN_INPUT_SAVE_OPTION: "save";
+export declare const REMEMBER_HUMAN_INPUT_SKIP_OPTION: "skip";
+export declare function rememberHumanInputQuestionId(targetId: string): string;
+export declare const RememberHumanInputPrompt: z.ZodObject<{
+    questions: z.ZodArray<z.ZodLazy<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            multi_select: "multi_select";
+            single_select: "single_select";
+            text: "text";
+        }>;
+        prompt: z.ZodString;
+        label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        helpText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        skillReview: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            removalOperationId: z.ZodOptional<z.ZodUUID>;
+            sourceOperationId: z.ZodUUID;
+            skillId: z.ZodUUID;
+            revisionId: z.ZodUUID;
+            expectedRevisionId: z.ZodNullable<z.ZodUUID>;
+            expectedScopeVersion: z.ZodNumber;
+        }, z.core.$strip>>>;
+        options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        allowOther: z.ZodDefault<z.ZodBoolean>;
+        validation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            minSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            maxSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    allowSkip: z.ZodLiteral<false>;
+}, z.core.$strip>;
+export type RememberHumanInputPrompt = z.infer<typeof RememberHumanInputPrompt>;
+export declare const RememberActivationSummary: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    destination: z.ZodEnum<{
+        instruction_policy: "instruction_policy";
+        preference: "preference";
+    }>;
+    receiptId: z.ZodString;
+    destinationRevisionId: z.ZodNullable<z.ZodString>;
+    effectiveAt: z.ZodNullable<z.ZodString>;
+    authorityKind: z.ZodEnum<{
+        automatic: "automatic";
+        human_confirmed: "human_confirmed";
+    }>;
+    undo: z.ZodLiteral<"learning_history">;
+}, z.core.$strip>, z.ZodObject<{
+    destination: z.ZodLiteral<"knowledge">;
+    receiptId: z.ZodString;
+    claimId: z.ZodString;
+    memoryId: z.ZodString;
+    approvalReviewId: z.ZodString;
+    effectiveAt: z.ZodNullable<z.ZodString>;
+    authorityKind: z.ZodLiteral<"human_confirmed">;
+    undo: z.ZodLiteral<"memory_management">;
+}, z.core.$strip>], "destination">;
+export type RememberActivationSummary = z.infer<typeof RememberActivationSummary>;
+export declare const RememberReceipt: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"blocked">;
+    operationId: z.ZodString;
+    lane: z.ZodEnum<{
+        instruction_policy: "instruction_policy";
+        knowledge: "knowledge";
+        preference: "preference";
+    }>;
+    scope: z.ZodEnum<{
+        workspace: "workspace";
+    }>;
+    reason: z.ZodLiteral<"learning_policy_off">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"proposed_for_review">;
+    operationId: z.ZodString;
+    lane: z.ZodEnum<{
+        instruction_policy: "instruction_policy";
+        knowledge: "knowledge";
+        preference: "preference";
+    }>;
+    scope: z.ZodEnum<{
+        workspace: "workspace";
+    }>;
+    noteId: z.ZodString;
+    claimId: z.ZodString;
+    evidenceId: z.ZodString;
+    reviewId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"activated">;
+    operationId: z.ZodString;
+    lane: z.ZodEnum<{
+        instruction_policy: "instruction_policy";
+        knowledge: "knowledge";
+        preference: "preference";
+    }>;
+    scope: z.ZodEnum<{
+        workspace: "workspace";
+    }>;
+    noteId: z.ZodString;
+    proposalId: z.ZodString;
+    learning: z.ZodNullable<z.ZodObject<{
+        receiptId: z.ZodString;
+        outcome: z.ZodEnum<{
+            automatic: "automatic";
+            confidence: "confidence";
+            conflict: "conflict";
+            off: "off";
+            revoked: "revoked";
+            stale: "stale";
+            suggest: "suggest";
+        }>;
+        automaticEligible: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodEnum<{
+            confidence_below_floor: "confidence_below_floor";
+            evidence_conflict: "evidence_conflict";
+            evidence_revoked: "evidence_revoked";
+            policy_automatic: "policy_automatic";
+            policy_off: "policy_off";
+            policy_suggest: "policy_suggest";
+            proposal_stale: "proposal_stale";
+        }>>;
+    }, z.core.$strip>>;
+    activation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        destination: z.ZodEnum<{
+            instruction_policy: "instruction_policy";
+            preference: "preference";
+        }>;
+        receiptId: z.ZodString;
+        destinationRevisionId: z.ZodNullable<z.ZodString>;
+        effectiveAt: z.ZodNullable<z.ZodString>;
+        authorityKind: z.ZodEnum<{
+            automatic: "automatic";
+            human_confirmed: "human_confirmed";
+        }>;
+        undo: z.ZodLiteral<"learning_history">;
+    }, z.core.$strip>, z.ZodObject<{
+        destination: z.ZodLiteral<"knowledge">;
+        receiptId: z.ZodString;
+        claimId: z.ZodString;
+        memoryId: z.ZodString;
+        approvalReviewId: z.ZodString;
+        effectiveAt: z.ZodNullable<z.ZodString>;
+        authorityKind: z.ZodLiteral<"human_confirmed">;
+        undo: z.ZodLiteral<"memory_management">;
+    }, z.core.$strip>], "destination">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"confirmation_required">;
+    operationId: z.ZodString;
+    lane: z.ZodEnum<{
+        instruction_policy: "instruction_policy";
+        knowledge: "knowledge";
+        preference: "preference";
+    }>;
+    scope: z.ZodEnum<{
+        workspace: "workspace";
+    }>;
+    noteId: z.ZodString;
+    proposalId: z.ZodNullable<z.ZodString>;
+    claimId: z.ZodString;
+    learning: z.ZodNullable<z.ZodObject<{
+        receiptId: z.ZodString;
+        outcome: z.ZodEnum<{
+            automatic: "automatic";
+            confidence: "confidence";
+            conflict: "conflict";
+            off: "off";
+            revoked: "revoked";
+            stale: "stale";
+            suggest: "suggest";
+        }>;
+        automaticEligible: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodEnum<{
+            confidence_below_floor: "confidence_below_floor";
+            evidence_conflict: "evidence_conflict";
+            evidence_revoked: "evidence_revoked";
+            policy_automatic: "policy_automatic";
+            policy_off: "policy_off";
+            policy_suggest: "policy_suggest";
+            proposal_stale: "proposal_stale";
+        }>>;
+    }, z.core.$strip>>;
+    learningFailure: z.ZodNullable<z.ZodObject<{
+        stage: z.ZodEnum<{
+            activation: "activation";
+            evaluation: "evaluation";
+        }>;
+        code: z.ZodEnum<{
+            authority: "authority";
+            conflict: "conflict";
+            invalid_operation: "invalid_operation";
+            unavailable: "unavailable";
+        }>;
+    }, z.core.$strip>>;
+    humanInput: z.ZodObject<{
+        questions: z.ZodArray<z.ZodLazy<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                multi_select: "multi_select";
+                single_select: "single_select";
+                text: "text";
+            }>;
+            prompt: z.ZodString;
+            label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            helpText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            skillReview: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                removalOperationId: z.ZodOptional<z.ZodUUID>;
+                sourceOperationId: z.ZodUUID;
+                skillId: z.ZodUUID;
+                revisionId: z.ZodUUID;
+                expectedRevisionId: z.ZodNullable<z.ZodUUID>;
+                expectedScopeVersion: z.ZodNumber;
+            }, z.core.$strip>>>;
+            options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            allowOther: z.ZodDefault<z.ZodBoolean>;
+            validation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                minSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                maxSelections: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        allowSkip: z.ZodLiteral<false>;
+    }, z.core.$strip>;
+    confirmWith: z.ZodLiteral<"remember_confirm">;
+}, z.core.$strip>], "status">;
+export type RememberReceipt = z.infer<typeof RememberReceipt>;
+export declare const RememberConfirmRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    target: z.ZodLiteral<"proposal">;
+    operationId: z.ZodString;
+    proposalId: z.ZodString;
+    decisionReceiptId: z.ZodString;
+    humanInputRequestId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    target: z.ZodLiteral<"knowledge_claim">;
+    operationId: z.ZodString;
+    claimId: z.ZodString;
+    humanInputRequestId: z.ZodString;
+}, z.core.$strict>], "target">;
+export type RememberConfirmRequest = z.infer<typeof RememberConfirmRequest>;
+export declare const RememberConfirmReceipt: z.ZodObject<{
+    status: z.ZodLiteral<"activated">;
+    operationId: z.ZodString;
+    proposalId: z.ZodNullable<z.ZodString>;
+    claimId: z.ZodString;
+    decisionReceiptId: z.ZodNullable<z.ZodString>;
+    activation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        destination: z.ZodEnum<{
+            instruction_policy: "instruction_policy";
+            preference: "preference";
+        }>;
+        receiptId: z.ZodString;
+        destinationRevisionId: z.ZodNullable<z.ZodString>;
+        effectiveAt: z.ZodNullable<z.ZodString>;
+        authorityKind: z.ZodEnum<{
+            automatic: "automatic";
+            human_confirmed: "human_confirmed";
+        }>;
+        undo: z.ZodLiteral<"learning_history">;
+    }, z.core.$strip>, z.ZodObject<{
+        destination: z.ZodLiteral<"knowledge">;
+        receiptId: z.ZodString;
+        claimId: z.ZodString;
+        memoryId: z.ZodString;
+        approvalReviewId: z.ZodString;
+        effectiveAt: z.ZodNullable<z.ZodString>;
+        authorityKind: z.ZodLiteral<"human_confirmed">;
+        undo: z.ZodLiteral<"memory_management">;
+    }, z.core.$strip>], "destination">;
+}, z.core.$strip>;
+export type RememberConfirmReceipt = z.infer<typeof RememberConfirmReceipt>;

package/dist/retained-output.d.ts

@@ -19,6 +19,7 @@ export declare const GENERATED_IMAGE_MAX_BYTES: number;
 export declare const GENERATED_VIDEO_MAX_BYTES: number;
 export declare const RetainedOutputKind: z.ZodEnum<{
     assistant_completion: "assistant_completion";
+    browser_screenshot: "browser_screenshot";
     computer_screenshot: "computer_screenshot";
     event_media: "event_media";
     file: "file";
@@ -47,6 +48,7 @@ export declare const RetainedArtifactReferenceSchema: z.ZodObject<{
     artifactId: z.ZodString;
     kind: z.ZodEnum<{
         assistant_completion: "assistant_completion";
+        browser_screenshot: "browser_screenshot";
         computer_screenshot: "computer_screenshot";
         event_media: "event_media";
         file: "file";
@@ -104,6 +106,7 @@ export declare const RetainedOutputEvidenceSchema: z.ZodDiscriminatedUnion<[z.Zo
     artifactId: z.ZodString;
     kind: z.ZodEnum<{
         assistant_completion: "assistant_completion";
+        browser_screenshot: "browser_screenshot";
         computer_screenshot: "computer_screenshot";
         event_media: "event_media";
         file: "file";
@@ -162,6 +165,7 @@ export declare const RetainedArtifactMetadataSchema: z.ZodUnion<readonly [z.ZodO
     artifactId: z.ZodString;
     kind: z.ZodEnum<{
         assistant_completion: "assistant_completion";
+        browser_screenshot: "browser_screenshot";
         computer_screenshot: "computer_screenshot";
         event_media: "event_media";
         file: "file";
@@ -223,7 +227,11 @@ export type RetainedScreenshotArtifactInput = RetainedArtifactFileInput & {
     width: number;
     height: number;
     expiresAt: string;
+    kind?: "computer_screenshot" | "browser_screenshot";
 };
+export type RetainedSessionScreenshotKind = "computer_screenshot" | "browser_screenshot";
+/** The persisted, server-authored storage key distinguishes browser captures from legacy computer captures. */
+export declare function retainedSessionScreenshotKindFromObjectKey(objectKey: string): RetainedSessionScreenshotKind | null;
 export type RetainedGeneratedImageArtifactInput = RetainedArtifactFileInput & {
     width: number;
     height: number;

package/dist/sandbox-file-artifacts.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+/**
+ * Channel-A currently returns one bounded binary-safe read. Keep publication
+ * below that ceiling so an extra sentinel byte can distinguish an exact file
+ * from a truncated prefix.
+ */
+export declare const SANDBOX_FILE_ARTIFACT_MAX_BYTES: number;
+export declare const PublishSandboxFileArtifactRequest: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
+export type PublishSandboxFileArtifactRequest = z.infer<typeof PublishSandboxFileArtifactRequest>;
+/**
+ * Closed model/UI receipt for one exact sandbox-file publication. Storage
+ * locators and signed URLs never cross this boundary.
+ */
+export declare const SandboxFileArtifactReceipt: z.ZodObject<{
+    type: z.ZodLiteral<"sandbox_file">;
+    sandboxPath: z.ZodString;
+    filename: z.ZodString;
+    artifact: z.ZodObject<{
+        available: z.ZodLiteral<true>;
+        artifactId: z.ZodString;
+        kind: z.ZodEnum<{
+            assistant_completion: "assistant_completion";
+            browser_screenshot: "browser_screenshot";
+            computer_screenshot: "computer_screenshot";
+            event_media: "event_media";
+            file: "file";
+            generated_image: "generated_image";
+            generated_video: "generated_video";
+            internal_update: "internal_update";
+            tool_result: "tool_result";
+        }>;
+        contentType: z.ZodString;
+        originalBytes: z.ZodNumber;
+        sha256: z.ZodString;
+        retainedAt: z.ZodString;
+        dimensions: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strict>>;
+        retention: z.ZodUnion<readonly [z.ZodObject<{
+            policy: z.ZodLiteral<"workspace_file">;
+            expiresAt: z.ZodNull;
+        }, z.core.$strict>, z.ZodObject<{
+            policy: z.ZodLiteral<"session_screenshot">;
+            expiresAt: z.ZodString;
+        }, z.core.$strict>]>;
+        retrieval: z.ZodObject<{
+            method: z.ZodLiteral<"GET">;
+            path: z.ZodString;
+            acceptRanges: z.ZodLiteral<"bytes">;
+            maxRangeBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SandboxFileArtifactReceipt = z.infer<typeof SandboxFileArtifactReceipt>;

package/dist/sandbox-provider-command.d.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+/** Provider-owned execution identity and acknowledged output cursors. These
+ * values are retained by the control plane, never recovered from sandbox files. */
+export declare const ModalLegacyProviderCommand: z.ZodObject<{
+    kind: z.ZodLiteral<"modal-control-v1">;
+    sandboxId: z.ZodString;
+    taskId: z.ZodString;
+    execId: z.ZodString;
+    pty: z.ZodOptional<z.ZodBoolean>;
+    streams: z.ZodObject<{
+        stdout: z.ZodObject<{
+            batchIndex: z.ZodNumber;
+            utf8Remainder: z.ZodString;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        stderr: z.ZodObject<{
+            batchIndex: z.ZodNumber;
+            utf8Remainder: z.ZodString;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ModalLegacyProviderCommand = z.infer<typeof ModalLegacyProviderCommand>;
+export declare const CommandSupervisionDescriptor: z.ZodObject<{
+    protocol: z.ZodLiteral<"native-subreaper-v1">;
+    invocationId: z.ZodString;
+    nonce: z.ZodString;
+    controlPath: z.ZodString;
+}, z.core.$strict>;
+export type CommandSupervisionDescriptor = z.infer<typeof CommandSupervisionDescriptor>;
+export declare const CommandSupervisionReceipt: z.ZodObject<{
+    protocol: z.ZodLiteral<"native-subreaper-v1">;
+    invocationId: z.ZodString;
+    receiptId: z.ZodString;
+    leaderExitCode: z.ZodNumber;
+}, z.core.$strict>;
+export type CommandSupervisionReceipt = z.infer<typeof CommandSupervisionReceipt>;
+export declare const ModalRouterProviderCommand: z.ZodObject<{
+    kind: z.ZodLiteral<"modal-router-v1">;
+    sandboxId: z.ZodString;
+    taskId: z.ZodString;
+    execId: z.ZodString;
+    pty: z.ZodOptional<z.ZodBoolean>;
+    supervision: z.ZodOptional<z.ZodObject<{
+        protocol: z.ZodLiteral<"native-subreaper-v1">;
+        invocationId: z.ZodString;
+        nonce: z.ZodString;
+        controlPath: z.ZodString;
+    }, z.core.$strict>>;
+    streams: z.ZodObject<{
+        stdout: z.ZodObject<{
+            byteOffset: z.ZodNumber;
+            utf8Remainder: z.ZodString;
+            eof: z.ZodBoolean;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        stderr: z.ZodObject<{
+            byteOffset: z.ZodNumber;
+            utf8Remainder: z.ZodString;
+            eof: z.ZodBoolean;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ModalRouterProviderCommand = z.infer<typeof ModalRouterProviderCommand>;
+/** Legacy locators are read-only compatibility for already launched commands;
+ * new starts use authenticated task-router byte offsets, never batch indices. */
+export declare const SandboxProviderCommand: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"modal-control-v1">;
+    sandboxId: z.ZodString;
+    taskId: z.ZodString;
+    execId: z.ZodString;
+    pty: z.ZodOptional<z.ZodBoolean>;
+    streams: z.ZodObject<{
+        stdout: z.ZodObject<{
+            batchIndex: z.ZodNumber;
+            utf8Remainder: z.ZodString;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        stderr: z.ZodObject<{
+            batchIndex: z.ZodNumber;
+            utf8Remainder: z.ZodString;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"modal-router-v1">;
+    sandboxId: z.ZodString;
+    taskId: z.ZodString;
+    execId: z.ZodString;
+    pty: z.ZodOptional<z.ZodBoolean>;
+    supervision: z.ZodOptional<z.ZodObject<{
+        protocol: z.ZodLiteral<"native-subreaper-v1">;
+        invocationId: z.ZodString;
+        nonce: z.ZodString;
+        controlPath: z.ZodString;
+    }, z.core.$strict>>;
+    streams: z.ZodObject<{
+        stdout: z.ZodObject<{
+            byteOffset: z.ZodNumber;
+            utf8Remainder: z.ZodString;
+            eof: z.ZodBoolean;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        stderr: z.ZodObject<{
+            byteOffset: z.ZodNumber;
+            utf8Remainder: z.ZodString;
+            eof: z.ZodBoolean;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+export type SandboxProviderCommand = z.infer<typeof SandboxProviderCommand>;