@opengeni/contracts 0.50.0 → 2.2.0-canary.0

package/dist/remember.d.ts

@@ -0,0 +1,331 @@
+import { z } from "zod";
+/**
+ * Explicit user-directed durable write ("remember X for this workspace").
+ *
+ * The lane is the Company Brain 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. The prompt-composed lanes are bounded far more
+ * tightly: 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>>;
+        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;
+    approvalReviewId: z.ZodString;
+    effectiveAt: z.ZodNullable<z.ZodString>;
+    authorityKind: z.ZodLiteral<"human_confirmed">;
+    undo: z.ZodLiteral<"knowledge_review">;
+}, 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;
+        approvalReviewId: z.ZodString;
+        effectiveAt: z.ZodNullable<z.ZodString>;
+        authorityKind: z.ZodLiteral<"human_confirmed">;
+        undo: z.ZodLiteral<"knowledge_review">;
+    }, 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>>;
+            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;
+        approvalReviewId: z.ZodString;
+        effectiveAt: z.ZodNullable<z.ZodString>;
+        authorityKind: z.ZodLiteral<"human_confirmed">;
+        undo: z.ZodLiteral<"knowledge_review">;
+    }, z.core.$strip>], "destination">;
+}, z.core.$strip>;
+export type RememberConfirmReceipt = z.infer<typeof RememberConfirmReceipt>;

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

@@ -0,0 +1,56 @@
+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";
+            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-snapshots.d.ts

@@ -40,6 +40,27 @@ export type NativeSnapshotDescriptor = {
     workspacePersistence?: string;
 };
 export type WorkspaceArchiveDescriptor = TarWorkspaceArchiveDescriptor | NativeSnapshotDescriptor;
+export declare const WORKSPACE_ARCHIVE_OBJECT_REF_SCHEMA: "sandbox_archive_object_v1";
+/** Compact object-storage locator for portable tar bytes. The SHA-256/size in
+ * `workspaceArchiveMeta` remain the verification authority. */
+export type WorkspaceArchiveObjectRef = {
+    schema: typeof WORKSPACE_ARCHIVE_OBJECT_REF_SCHEMA;
+    key: string;
+    sha256: string;
+    bytes: number;
+    backend: string;
+};
+export declare function parseWorkspaceArchiveObjectRef(value: unknown): WorkspaceArchiveObjectRef | null;
+export declare function workspaceArchiveObjectKey(input: {
+    accountId: string;
+    workspaceId: string;
+    sandboxGroupId: string;
+    revision: string;
+}): string;
+export declare function workspaceArchivePayloadPresent(sessionState: Record<string, unknown> | null | undefined): boolean;
+/** Restore may inline object bytes in memory for hydrate. That copy must never
+ *  be published onto a lease when a durable object-storage ref exists. */
+export declare function omitInlineWorkspaceArchiveWhenObjectRefPresent(sessionState: Record<string, unknown>): Record<string, unknown>;
 export declare const NATIVE_SNAPSHOT_PREFIXES: ReadonlyArray<{
     provider: NativeSnapshotProvider;
     prefix: string;

package/dist/slack-bot-scopes.d.ts

@@ -1,31 +1,50 @@
 export declare const OPENGENI_SLACK_BOT_REQUIRED_SCOPES: readonly ["app_mentions:read", "canvases:read", "channels:history", "channels:read", "chat:write", "commands", "files:read", "groups:history", "groups:read", "im:history", "im:read", "im:write", "mpim:history", "mpim:read", "users:read"];
 /** Read-only scope needed only for the optional emoji-reaction summon surface. */
 export declare const OPENGENI_SLACK_REACTION_REQUIRED_SCOPE: "reactions:read";
+/**
+ * Bot-token search scopes for Slack's Real-time Search API
+ * (`assistant.search.context`). Slack accepts these as BOT scopes, so
+ * workspace-wide public search runs under the bot identity and never needs a
+ * human proxy token. Private-channel, DM, and MPIM search remain user-token
+ * only and belong exclusively to the personal hosted-MCP grant.
+ */
+export declare const OPENGENI_SLACK_BOT_SEARCH_SCOPES: readonly ["search:read.public", "search:read.files", "search:read.users"];
 /**
  * Scopes requested by the managed and generated self-hosted manifests.
  *
- * `reactions:read` is deliberately not part of the base eligibility contract:
- * legacy installations may continue using existing Slack interactions and
- * tools while the reaction setting stays disabled and the UI asks an admin to
- * reinstall.
+ * `reactions:read` and the bot search scopes are deliberately not part of the
+ * base eligibility contract: legacy installations may continue using existing
+ * Slack interactions and tools while the reaction setting stays disabled, bot
+ * search stays unavailable, and the UI asks an admin to reinstall.
  */
-export declare const OPENGENI_SLACK_BOT_REQUESTED_SCOPES: readonly ["app_mentions:read", "canvases:read", "channels:history", "channels:read", "chat:write", "commands", "files:read", "groups:history", "groups:read", "im:history", "im:read", "im:write", "mpim:history", "mpim:read", "users:read", "reactions:read"];
-export declare const OPENGENI_SLACK_BOT_EVENTS: readonly ["app_mention", "message.channels", "message.groups", "message.im", "message.mpim", "reaction_added"];
+export declare const OPENGENI_SLACK_BOT_REQUESTED_SCOPES: readonly ["app_mentions:read", "canvases:read", "channels:history", "channels:read", "chat:write", "commands", "files:read", "groups:history", "groups:read", "im:history", "im:read", "im:write", "mpim:history", "mpim:read", "users:read", "reactions:read", "search:read.public", "search:read.files", "search:read.users"];
+export declare const OPENGENI_SLACK_BOT_EVENTS: readonly ["app_home_opened", "app_mention", "message.channels", "message.groups", "message.im", "message.mpim", "reaction_added"];
 /** Full user-token scope set for every tool currently exposed by Slack's hosted MCP server. */
 export declare const OPENGENI_SLACK_MCP_USER_SCOPES: readonly ["search:read.public", "search:read.private", "search:read.mpim", "search:read.im", "search:read.files", "files:read", "emoji:read", "search:read.users", "chat:write", "channels:history", "groups:history", "mpim:history", "im:history", "channels:write", "groups:write", "im:write", "mpim:write", "reactions:write", "canvases:read", "canvases:write", "users:read", "users:read.email", "channels:read", "groups:read", "mpim:read"];
 export declare const OPENGENI_MANAGED_PUBLIC_BASE_URL: "https://app.opengeni.ai";
+export type OpenGeniSlackBotManifestOptions = Readonly<{
+    appName?: string;
+    botDisplayName?: string;
+    slashCommand?: string;
+    shortcutName?: string;
+}>;
 /** Canonical managed/self-hosted Slack app manifest. Slack accepts JSON manifests. */
-export declare function buildOpenGeniSlackBotManifest(publicBaseUrl: string): {
+export declare function buildOpenGeniSlackBotManifest(publicBaseUrl: string, options?: OpenGeniSlackBotManifestOptions): {
     readonly display_information: {
-        readonly name: "OpenGeni";
+        readonly name: string;
     };
     readonly features: {
+        readonly app_home: {
+            readonly home_tab_enabled: true;
+            readonly messages_tab_enabled: true;
+            readonly messages_tab_read_only_enabled: false;
+        };
         readonly bot_user: {
-            readonly display_name: "OpenGeni";
+            readonly display_name: string;
             readonly always_online: false;
         };
         readonly slash_commands: readonly [{
-            readonly command: "/opengeni";
+            readonly command: string;
             readonly description: "Start an OpenGeni task in this channel";
             readonly should_escape: false;
             readonly url: `${string}/v1/integrations/slack/commands`;
@@ -33,20 +52,20 @@ export declare function buildOpenGeniSlackBotManifest(publicBaseUrl: string): {
         readonly shortcuts: readonly [{
             readonly callback_id: "opengeni_message";
             readonly description: "Start an OpenGeni task from this Slack message";
-            readonly name: "Open in OpenGeni";
+            readonly name: string;
             readonly type: "message";
         }];
     };
     readonly oauth_config: {
         readonly redirect_urls: readonly [`${string}/v1/integrations/oauth/callback`, `${string}/v1/integrations/slack/callback`];
         readonly scopes: {
-            readonly bot: readonly ["app_mentions:read", "canvases:read", "channels:history", "channels:read", "chat:write", "commands", "files:read", "groups:history", "groups:read", "im:history", "im:read", "im:write", "mpim:history", "mpim:read", "users:read", "reactions:read"];
+            readonly bot: readonly ["app_mentions:read", "canvases:read", "channels:history", "channels:read", "chat:write", "commands", "files:read", "groups:history", "groups:read", "im:history", "im:read", "im:write", "mpim:history", "mpim:read", "users:read", "reactions:read", "search:read.public", "search:read.files", "search:read.users"];
             readonly user: readonly ["search:read.public", "search:read.private", "search:read.mpim", "search:read.im", "search:read.files", "files:read", "emoji:read", "search:read.users", "chat:write", "channels:history", "groups:history", "mpim:history", "im:history", "channels:write", "groups:write", "im:write", "mpim:write", "reactions:write", "canvases:read", "canvases:write", "users:read", "users:read.email", "channels:read", "groups:read", "mpim:read"];
         };
     };
     readonly settings: {
         readonly event_subscriptions: {
-            readonly bot_events: readonly ["app_mention", "message.channels", "message.groups", "message.im", "message.mpim", "reaction_added"];
+            readonly bot_events: readonly ["app_home_opened", "app_mention", "message.channels", "message.groups", "message.im", "message.mpim", "reaction_added"];
             readonly request_url: `${string}/v1/integrations/slack/events`;
         };
         readonly interactivity: {
@@ -64,7 +83,8 @@ export declare function buildOpenGeniSlackBotManifest(publicBaseUrl: string): {
  * boundary. Every other unrequired scope fails closed, including unknown future
  * Slack scopes, so verification, core routing, and UI eligibility cannot drift.
  */
-export declare const OPENGENI_SLACK_BOT_SAFE_OPTIONAL_SCOPES: readonly ["team:read", "reactions:read"];
+export declare const OPENGENI_SLACK_BOT_SAFE_OPTIONAL_SCOPES: readonly ["team:read", "reactions:read", "search:read.public", "search:read.files", "search:read.users"];
+export declare function hasOpenGeniSlackBotSearchScopes(grantedScopes: readonly string[]): boolean;
 /** @deprecated Use evaluateOpenGeniSlackBotScopes; an allowlist is the policy. */
 export declare const OPENGENI_SLACK_BOT_FORBIDDEN_SCOPES: readonly ["channels:join", "chat:write.public"];
 export type OpenGeniSlackBotScopePolicy = {

package/dist/slack-bot-scopes.js

@@ -5,13 +5,15 @@ import {
   OPENGENI_SLACK_BOT_REQUESTED_SCOPES,
   OPENGENI_SLACK_BOT_REQUIRED_SCOPES,
   OPENGENI_SLACK_BOT_SAFE_OPTIONAL_SCOPES,
+  OPENGENI_SLACK_BOT_SEARCH_SCOPES,
   OPENGENI_SLACK_MCP_USER_SCOPES,
   OPENGENI_SLACK_REACTION_REQUIRED_SCOPE,
   areOpenGeniSlackBotScopesAccepted,
   buildOpenGeniSlackBotManifest,
   evaluateOpenGeniSlackBotScopes,
+  hasOpenGeniSlackBotSearchScopes,
   hasOpenGeniSlackReactionScope
-} from "./chunk-5UDNP7AO.js";
+} from "./chunk-MRWYRAS5.js";
 export {
   OPENGENI_MANAGED_PUBLIC_BASE_URL,
   OPENGENI_SLACK_BOT_EVENTS,
@@ -19,11 +21,13 @@ export {
   OPENGENI_SLACK_BOT_REQUESTED_SCOPES,
   OPENGENI_SLACK_BOT_REQUIRED_SCOPES,
   OPENGENI_SLACK_BOT_SAFE_OPTIONAL_SCOPES,
+  OPENGENI_SLACK_BOT_SEARCH_SCOPES,
   OPENGENI_SLACK_MCP_USER_SCOPES,
   OPENGENI_SLACK_REACTION_REQUIRED_SCOPE,
   areOpenGeniSlackBotScopesAccepted,
   buildOpenGeniSlackBotManifest,
   evaluateOpenGeniSlackBotScopes,
+  hasOpenGeniSlackBotSearchScopes,
   hasOpenGeniSlackReactionScope
 };
 //# sourceMappingURL=slack-bot-scopes.js.map

package/dist/spreadsheet-artifact-commands.d.ts

@@ -1,10 +1,11 @@
+import { SPREADSHEET_ARTIFACT_COMMAND_VERSION } from "./editable-artifact-versions.js";
 /**
  * Canonical, identity-free spreadsheet mutation commands nested inside
  * `OGATX001`. Artifact, actor, transaction, delivery, and causal identity must
  * never be added here: the outer authored-intent envelope is their sole wire
  * authority.
  */
-export declare const SPREADSHEET_ARTIFACT_COMMAND_VERSION: 1;
+export { SPREADSHEET_ARTIFACT_COMMAND_VERSION } from "./editable-artifact-versions.js";
 export declare const SPREADSHEET_ARTIFACT_COMMAND_MAX_BYTES: number;
 export declare const SPREADSHEET_ARTIFACT_COMMAND_MAX_COMMANDS = 4096;
 export declare const SPREADSHEET_ARTIFACT_COMMAND_MAX_CELLS = 1000000;
@@ -53,7 +54,6 @@ export type SpreadsheetDateValue = Readonly<{
 export type SpreadsheetCellScalar = null | boolean | number | string | SpreadsheetDateValue | SpreadsheetFormulaError;
 export type SpreadsheetFormulaCell = Readonly<{
     formula: string;
-    cached: SpreadsheetCellScalar;
 }>;
 export type SpreadsheetCellInput = SpreadsheetCellScalar | SpreadsheetFormulaCell;
 export type SpreadsheetCreateSheetCommand = Readonly<{
@@ -98,4 +98,3 @@ export declare function encodeSpreadsheetArtifactCommandBatch(input: Spreadsheet
 export declare function decodeSpreadsheetArtifactCommandBatch(bytes: Uint8Array): SpreadsheetArtifactCommandBatch;
 /** Decodes, re-encodes, and proves byte-for-byte canonicality. */
 export declare function assertCanonicalSpreadsheetArtifactCommandBytes(bytes: Uint8Array): Uint8Array;
-export {};

package/dist/spreadsheet-artifact-commands.js

@@ -3,14 +3,16 @@ import {
   SPREADSHEET_ARTIFACT_COMMAND_MAX_CELLS,
   SPREADSHEET_ARTIFACT_COMMAND_MAX_COMMANDS,
   SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES,
-  SPREADSHEET_ARTIFACT_COMMAND_VERSION,
   SPREADSHEET_ARTIFACT_SHEET_NAME_MAX_UTF16_UNITS,
   assertCanonicalSpreadsheetArtifactCommandBytes,
   decodeSpreadsheetArtifactCommandBatch,
   editableArtifactStableId,
   encodeSpreadsheetArtifactCommandBatch,
   spreadsheetSheetId
-} from "./chunk-LSB7GRLG.js";
+} from "./chunk-TXTQIYCV.js";
+import {
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION
+} from "./chunk-PX3VCKAU.js";
 export {
   SPREADSHEET_ARTIFACT_COMMAND_MAX_BYTES,
   SPREADSHEET_ARTIFACT_COMMAND_MAX_CELLS,

package/dist/spreadsheet-artifact-query.js

@@ -20,8 +20,9 @@ import {
   encodeSpreadsheetMetadataKernelQuery,
   encodeSpreadsheetViewportKernelProjection,
   encodeSpreadsheetViewportKernelQuery
-} from "./chunk-CADSX6UN.js";
-import "./chunk-LSB7GRLG.js";
+} from "./chunk-Y3KNXVTD.js";
+import "./chunk-TXTQIYCV.js";
+import "./chunk-PX3VCKAU.js";
 export {
   SPREADSHEET_ARTIFACT_METADATA_MAX_SHEETS,
   SPREADSHEET_ARTIFACT_METADATA_MIN_RESPONSE_BYTES,

package/dist/task-notes.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 export declare const TASK_NOTE_TEXT_MAX_BYTES = 4096;
 export declare const TASK_NOTE_REASON_MAX_BYTES = 2048;
-export declare const TASK_NOTE_MAX_LIFETIME_DAYS = 30;
+export declare const TASK_NOTE_MAX_LIFETIME_DAYS = 90;
 export declare const TASK_NOTE_ACTIVE_RECORD_CAP = 500;
 export declare const TASK_NOTE_LIST_DEFAULT_LIMIT = 10;
 export declare const TASK_NOTE_LIST_MAX_LIMIT = 20;
@@ -93,6 +93,47 @@ export declare const TaskNoteMutationResult: z.ZodObject<{
     replayed: z.ZodBoolean;
 }, z.core.$strip>;
 export type TaskNoteMutationResult = z.infer<typeof TaskNoteMutationResult>;
+/** Atomic correction lineage: archive one exact v1 note and create one v1 replacement. */
+export declare const TaskNoteReplacementResult: z.ZodObject<{
+    operationId: z.ZodString;
+    inputHash: z.ZodString;
+    replaces: z.ZodObject<{
+        noteId: z.ZodString;
+        archivedVersion: z.ZodLiteral<2>;
+    }, z.core.$strip>;
+    replacement: z.ZodObject<{
+        id: z.ZodString;
+        rootSessionId: z.ZodString;
+        kind: z.ZodEnum<{
+            artifact: "artifact";
+            blocker: "blocker";
+            decision: "decision";
+            finding: "finding";
+            handoff: "handoff";
+            ownership: "ownership";
+        }>;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            archived: "archived";
+        }>;
+        version: z.ZodNumber;
+        expiresAt: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        archivedAt: z.ZodNullable<z.ZodString>;
+        provenance: z.ZodObject<{
+            actorKind: z.ZodEnum<{
+                human: "human";
+                service: "service";
+            }>;
+            sourceSessionId: z.ZodString;
+            sourceTurnId: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    replayed: z.ZodBoolean;
+}, z.core.$strip>;
+export type TaskNoteReplacementResult = z.infer<typeof TaskNoteReplacementResult>;
 export declare const TaskNoteListResponse: z.ZodObject<{
     notes: z.ZodArray<z.ZodObject<{
         id: z.ZodString;