@opengeni/contracts 0.50.0 → 2.2.0-canary.0

package/dist/tool-result-spill.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+/** Model-visible overflow of one tool result. Exact bytes live on a workspace File. */
+export declare const TOOL_RESULT_SPILLED_TYPE: "tool_result_spilled";
+export declare const TOOL_RESULT_SPILL_MEDIA_TYPE: "application/json";
+export declare const TOOL_RESULT_SPILL_MOUNT_PATH: "tool-results";
+export declare const ToolResultSpilledReceipt: z.ZodObject<{
+    type: z.ZodLiteral<"tool_result_spilled">;
+    sandboxPath: z.ZodNullable<z.ZodString>;
+    fileId: z.ZodString;
+    byteSize: z.ZodNumber;
+    mediaType: z.ZodLiteral<"application/json">;
+}, z.core.$strict>;
+export type ToolResultSpilledReceipt = z.infer<typeof ToolResultSpilledReceipt>;
+export declare function isToolResultSpilledReceipt(value: unknown): value is ToolResultSpilledReceipt;
+export declare function toolResultSpillSandboxPath(filename: string): string;
+export declare function toolResultSpillFilename(operationId: string): string;

package/dist/workspace-instruction-policies.d.ts

@@ -126,6 +126,21 @@ export declare const WorkspaceInstructionPolicyHead: z.ZodObject<{
     activatedAt: z.ZodString;
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyHead = z.infer<typeof WorkspaceInstructionPolicyHead>;
+export declare const WorkspaceInstructionPolicyInactiveHead: z.ZodObject<{
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodNullable<z.ZodString>;
+    workspaceId: z.ZodString;
+    activationVersion: z.ZodNumber;
+    deactivatedAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyInactiveHead = z.infer<typeof WorkspaceInstructionPolicyInactiveHead>;
 export declare const WorkspaceInstructionPolicySnapshotProvenance: z.ZodObject<{
     source: z.ZodEnum<{
         human: "human";
@@ -310,6 +325,32 @@ export declare const WorkspaceInstructionPolicyActivationEvent: z.ZodObject<{
     createdAt: z.ZodString;
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyActivationEvent = z.infer<typeof WorkspaceInstructionPolicyActivationEvent>;
+export declare const WorkspaceInstructionPolicyDeactivationEvent: z.ZodObject<{
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    operationId: z.ZodString;
+    accountId: z.ZodString;
+    workspaceId: z.ZodString;
+    type: z.ZodLiteral<"automatic_deactivate">;
+    activationVersion: z.ZodNumber;
+    oldRevision: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strip>;
+    actorSubjectId: z.ZodString;
+    reason: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyDeactivationEvent = z.infer<typeof WorkspaceInstructionPolicyDeactivationEvent>;
 export declare const CreateWorkspaceInstructionPolicyDraftRequest: z.ZodObject<{
     operationId: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<{
@@ -398,6 +439,21 @@ export declare const WorkspaceInstructionPolicyListResponse: z.ZodObject<{
         activationVersion: z.ZodNumber;
         activatedAt: z.ZodString;
     }, z.core.$strip>>;
+    inactiveHeads: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodString;
+        activationVersion: z.ZodNumber;
+        deactivatedAt: z.ZodString;
+    }, z.core.$strip>>>;
+    inactiveHeadsTruncated: z.ZodDefault<z.ZodBoolean>;
     activationEvents: z.ZodArray<z.ZodObject<{
         kind: z.ZodEnum<{
             charter: "charter";
@@ -431,6 +487,31 @@ export declare const WorkspaceInstructionPolicyListResponse: z.ZodObject<{
         reason: z.ZodString;
         createdAt: z.ZodString;
     }, z.core.$strip>>;
+    deactivationEvents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        id: z.ZodString;
+        operationId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        type: z.ZodLiteral<"automatic_deactivate">;
+        activationVersion: z.ZodNumber;
+        oldRevision: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strip>;
+        actorSubjectId: z.ZodString;
+        reason: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>>;
     nextAfterRevision: z.ZodNullable<z.ZodNumber>;
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyListResponse = z.infer<typeof WorkspaceInstructionPolicyListResponse>;

package/dist/workspace-learning-administration.d.ts

@@ -0,0 +1,289 @@
+import { z } from "zod";
+export declare const WORKSPACE_LEARNING_HISTORY_MAX_ITEMS = 100;
+export declare const WorkspaceLearningPolicyHistoryQuery: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type WorkspaceLearningPolicyHistoryQuery = z.infer<typeof WorkspaceLearningPolicyHistoryQuery>;
+export declare const CreateWorkspaceLearningPolicyRevisionRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
+    workspaceMode: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        suggest: "suggest";
+    }>;
+    sourceOverrides: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+        id: z.ZodString;
+        mode: z.ZodEnum<{
+            automatic: "automatic";
+            inherit: "inherit";
+            off: "off";
+            suggest: "suggest";
+        }>;
+    }, z.core.$strip>>>>;
+    supersedesRevisionId: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+}, z.core.$strict>;
+export type CreateWorkspaceLearningPolicyRevisionRequest = z.infer<typeof CreateWorkspaceLearningPolicyRevisionRequest>;
+export declare const ActivateWorkspaceLearningPolicyRevisionRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
+    expectedCurrentRevisionId: z.ZodNullable<z.ZodString>;
+    expectedActivationVersion: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type ActivateWorkspaceLearningPolicyRevisionRequest = z.infer<typeof ActivateWorkspaceLearningPolicyRevisionRequest>;
+export declare const RollbackWorkspaceLearningPolicyRevisionRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
+    expectedActivationVersion: z.ZodNumber;
+    reason: z.ZodString;
+    targetRevisionId: z.ZodString;
+    expectedCurrentRevisionId: z.ZodString;
+}, z.core.$strict>;
+export type RollbackWorkspaceLearningPolicyRevisionRequest = z.infer<typeof RollbackWorkspaceLearningPolicyRevisionRequest>;
+export declare const WorkspaceLearningPolicyMutationResponse: z.ZodObject<{
+    head: z.ZodObject<{
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        policyHash: z.ZodString;
+        activationVersion: z.ZodNumber;
+        activatedAt: z.ZodString;
+    }, z.core.$strip>;
+    event: z.ZodObject<{
+        id: z.ZodString;
+        operationId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        type: z.ZodEnum<{
+            activate: "activate";
+            rollback: "rollback";
+        }>;
+        activationVersion: z.ZodNumber;
+        oldRevision: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            policyHash: z.ZodString;
+        }, z.core.$strip>>;
+        newRevision: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            policyHash: z.ZodString;
+        }, z.core.$strip>;
+        actorSubjectId: z.ZodString;
+        reason: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type WorkspaceLearningPolicyMutationResponse = z.infer<typeof WorkspaceLearningPolicyMutationResponse>;
+export declare const UndoGovernedLearningActivationHttpRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type UndoGovernedLearningActivationHttpRequest = z.infer<typeof UndoGovernedLearningActivationHttpRequest>;
+export declare const WorkspaceLearningHistoryResponse: z.ZodObject<{
+    head: z.ZodNullable<z.ZodObject<{
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        policyHash: z.ZodString;
+        activationVersion: z.ZodNumber;
+        activatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    revisions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policyHash: z.ZodString;
+        operationId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        workspaceMode: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            suggest: "suggest";
+        }>;
+        sourceOverrides: z.ZodArray<z.ZodObject<{
+            kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+            id: z.ZodString;
+            mode: z.ZodEnum<{
+                automatic: "automatic";
+                off: "off";
+                suggest: "suggest";
+            }>;
+        }, z.core.$strip>>;
+        supersedesRevisionId: z.ZodNullable<z.ZodString>;
+        createdBySubjectId: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    policyEvents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        operationId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        type: z.ZodEnum<{
+            activate: "activate";
+            rollback: "rollback";
+        }>;
+        activationVersion: z.ZodNumber;
+        oldRevision: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            policyHash: z.ZodString;
+        }, z.core.$strip>>;
+        newRevision: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            policyHash: z.ZodString;
+        }, z.core.$strip>;
+        actorSubjectId: z.ZodString;
+        reason: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    decisions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        operationId: z.ZodString;
+        inputHash: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        attemptId: z.ZodString;
+        executionGeneration: z.ZodNumber;
+        initiatingHumanSubjectId: z.ZodString;
+        policySnapshotId: z.ZodString;
+        policySnapshotHash: z.ZodString;
+        policyRevisionId: z.ZodNullable<z.ZodString>;
+        policyActivationVersion: z.ZodNumber;
+        sourceKind: z.ZodEnum<{
+            "scoped-knowledge-evidence": "scoped-knowledge-evidence";
+            "task-note": "task-note";
+        }>;
+        sourceId: z.ZodString;
+        proposalId: z.ZodString;
+        proposalInputHash: z.ZodString;
+        proposalContentHash: z.ZodString;
+        claimId: z.ZodString;
+        claimInputHash: z.ZodString;
+        evidenceId: z.ZodString;
+        evidenceInputHash: z.ZodString;
+        evidenceContentHash: z.ZodString;
+        evidenceAuthorityHash: z.ZodString;
+        reviewRevision: z.ZodNumber;
+        reviewState: z.ZodEnum<{
+            approved: "approved";
+            proposed: "proposed";
+            rejected: "rejected";
+            revoked: "revoked";
+        }>;
+        effectiveMode: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            suggest: "suggest";
+        }>;
+        confidenceBps: z.ZodNumber;
+        conflictCount: z.ZodNumber;
+        outcome: z.ZodEnum<{
+            automatic: "automatic";
+            confidence: "confidence";
+            conflict: "conflict";
+            off: "off";
+            revoked: "revoked";
+            stale: "stale";
+            suggest: "suggest";
+        }>;
+        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";
+        }>>;
+        automaticEligible: z.ZodBoolean;
+        confidenceFloorBps: z.ZodLiteral<8500>;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+    activations: z.ZodArray<z.ZodObject<{
+        destination: z.ZodEnum<{
+            instruction_policy: "instruction_policy";
+            preference: "preference";
+        }>;
+        destinationProposalId: z.ZodString;
+        destinationRevisionId: z.ZodString;
+        destinationOldRevisionId: z.ZodNullable<z.ZodString>;
+        destinationOldContentHash: z.ZodNullable<z.ZodString>;
+        destinationOldVersion: z.ZodNumber;
+        destinationNewContentHash: z.ZodString;
+        destinationNewVersion: z.ZodNumber;
+        destinationEventId: z.ZodString;
+        id: z.ZodString;
+        operationId: z.ZodString;
+        inputHash: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        decisionReceiptId: z.ZodString;
+        initiatingHumanSubjectId: z.ZodString;
+        serviceActorSubjectId: z.ZodString;
+        policyRevisionId: z.ZodString;
+        policyHash: z.ZodString;
+        policyActivationVersion: z.ZodNumber;
+        sourceKind: z.ZodEnum<{
+            "scoped-knowledge-evidence": "scoped-knowledge-evidence";
+            "task-note": "task-note";
+        }>;
+        sourceId: z.ZodString;
+        sourceAuthorityHash: z.ZodString;
+        proposalId: z.ZodString;
+        claimId: z.ZodString;
+        evidenceId: z.ZodString;
+        knowledgePreviousReviewId: z.ZodString;
+        knowledgePreviousReviewRevision: z.ZodNumber;
+        knowledgeApprovalReviewId: z.ZodString;
+        knowledgeApprovalReviewRevision: z.ZodNumber;
+        knowledgeApprovalInputHash: z.ZodString;
+        outcome: z.ZodLiteral<"activated">;
+        effectiveAt: z.ZodString;
+        authorityKind: z.ZodEnum<{
+            automatic: "automatic";
+            human_confirmed: "human_confirmed";
+        }>;
+        humanInputRequestId: z.ZodNullable<z.ZodString>;
+        rollback: z.ZodObject<{
+            supported: z.ZodLiteral<true>;
+            mechanism: z.ZodLiteral<"exact_head_and_latest_review">;
+        }, z.core.$strict>;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+    undos: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        operationId: z.ZodString;
+        inputHash: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        activationReceiptId: z.ZodString;
+        initiatingHumanSubjectId: z.ZodString;
+        serviceActorSubjectId: z.ZodString;
+        destination: z.ZodEnum<{
+            instruction_policy: "instruction_policy";
+            preference: "preference";
+        }>;
+        knowledgeApprovalReviewId: z.ZodString;
+        knowledgeRevocationReviewId: z.ZodString;
+        knowledgeRevocationReviewRevision: z.ZodNumber;
+        knowledgeRevocationInputHash: z.ZodString;
+        destinationActivatedRevisionId: z.ZodString;
+        destinationRestoredRevisionId: z.ZodNullable<z.ZodString>;
+        destinationActivatedContentHash: z.ZodString;
+        destinationRestoredContentHash: z.ZodNullable<z.ZodString>;
+        destinationOldVersion: z.ZodNumber;
+        destinationNewVersion: z.ZodNumber;
+        destinationEventId: z.ZodString;
+        outcome: z.ZodLiteral<"undone">;
+        superseded: z.ZodLiteral<false>;
+        effectiveAt: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+    truncated: z.ZodBoolean;
+    effectiveBoundary: z.ZodLiteral<"next_accepted_attempt">;
+}, z.core.$strict>;
+export type WorkspaceLearningHistoryResponse = z.infer<typeof WorkspaceLearningHistoryResponse>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/contracts",
-  "version": "0.50.0",
+  "version": "2.2.0-canary.0",
   "description": "Shared zod schemas and wire-contract types for the OpenGeni API.",
   "license": "Apache-2.0",
   "repository": {
@@ -30,6 +30,10 @@
       "types": "./dist/google-drive.d.ts",
       "import": "./dist/google-drive.js"
     },
+    "./personal-github": {
+      "types": "./dist/personal-github.d.ts",
+      "import": "./dist/personal-github.js"
+    },
     "./atlassian": {
       "types": "./dist/atlassian.d.ts",
       "import": "./dist/atlassian.js"
@@ -38,6 +42,14 @@
       "types": "./dist/connector-destinations.d.ts",
       "import": "./dist/connector-destinations.js"
     },
+    "./connector-attachments": {
+      "types": "./dist/connector-attachments.d.ts",
+      "import": "./dist/connector-attachments.js"
+    },
+    "./connection-authority": {
+      "types": "./dist/connection-authority.d.ts",
+      "import": "./dist/connection-authority.js"
+    },
     "./video-generation": {
       "types": "./dist/video-generation.d.ts",
       "import": "./dist/video-generation.js"

package/src/agent-authored-durable-text.ts

@@ -0,0 +1,105 @@
+/**
+ * Budgets and authoring style for durable text an **agent** writes on a user's
+ * behalf.
+ *
+ * The budget follows the cost, and the cost differs per destination:
+ *
+ * - A workspace instruction policy is composed verbatim into the prompt of
+ *   every session it applies to, for as long as it stays active. A global
+ *   charter or global policy applies to every session in the workspace; a role
+ *   policy applies to every session bound to that role. At most three entries
+ *   compose at once (charter, global policy, matching role policy), so the
+ *   standing ceiling this budget implies is three times the per-entry cap.
+ * - A preference is cheaper and in a different way: only its short title and
+ *   description descriptors are prompt-composed, while the full content is
+ *   retrieved on demand behind the exact attempt's retrieval handle. Its length
+ *   is therefore retrieval cost, not standing prompt cost, which is why it gets
+ *   more room rather than less.
+ * - A company profile is the largest always-on surface: every field is
+ *   mandatory prompt context in every session across the whole organization.
+ * - Knowledge is retrieval evidence and never joins the always-composed prefix.
+ *
+ * These caps deliberately bind only agent-authored writes. The human-facing
+ * limits (`WORKSPACE_INSTRUCTION_POLICY_CONTENT_MAX_CHARS`,
+ * `PREFERENCE_REGISTRY_CONTENT_MAX_CHARS`, `COMPANY_PROFILE_SCALAR_MAX_CHARS`,
+ * `COMPANY_PROFILE_ENTRY_MAX_CHARS`, `COMPANY_PROFILE_CONTENT_MAX_UTF8_BYTES`)
+ * are unchanged: a person editing in the UI is making a deliberate, visible
+ * choice, and lowering their limit would reject text they already typed.
+ * Existing stored revisions are never rewritten; only new agent writes are
+ * bounded.
+ */
+
+/** One imperative rule, in 1-3 sentences, fits comfortably under this. */
+export const AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_MAX_CHARS = 600;
+
+/** Retrieved on demand rather than always composed, so a little more room. */
+export const AGENT_AUTHORED_PREFERENCE_CONTENT_MAX_CHARS = 1_200;
+
+/** `identity` and `mission`: a couple of sentences, not a positioning document. */
+export const AGENT_AUTHORED_COMPANY_PROFILE_SCALAR_MAX_CHARS = 400;
+
+/** One product, customer, goal, or constraint: a phrase or a single sentence. */
+export const AGENT_AUTHORED_COMPANY_PROFILE_ENTRY_MAX_CHARS = 200;
+
+/** Whole canonical profile, mandatory in every session across the organization. */
+export const AGENT_AUTHORED_COMPANY_PROFILE_CONTENT_MAX_UTF8_BYTES = 4_096;
+
+export const AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_TOO_LONG_MESSAGE =
+  "A workspace rule is composed verbatim into the prompt of every session it applies to (every session " +
+  "for a global charter or policy, every session bound to the role for a role policy), for as long as it " +
+  `stays active. Keep it under ${AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_MAX_CHARS} characters: one rule, ` +
+  "imperative, no numbered procedure. Split unrelated rules into separate entries.";
+
+export const AGENT_AUTHORED_PREFERENCE_CONTENT_TOO_LONG_MESSAGE =
+  "A workspace preference is durable Company Brain content that agents retrieve on demand, so its length is " +
+  "retrieval cost rather than standing prompt cost: only its short title and description are composed into " +
+  `every session prompt. Keep it under ${AGENT_AUTHORED_PREFERENCE_CONTENT_MAX_CHARS} characters: state the ` +
+  "preference plainly, no numbered procedure and no examples. Put procedure in a Document or Skill and " +
+  "reference it instead.";
+
+export const AGENT_AUTHORED_COMPANY_PROFILE_TOO_LONG_MESSAGE =
+  "Every company-profile field is mandatory prompt context in every session across the organization. Keep " +
+  `identity and mission under ${AGENT_AUTHORED_COMPANY_PROFILE_SCALAR_MAX_CHARS} characters each, each list ` +
+  `entry under ${AGENT_AUTHORED_COMPANY_PROFILE_ENTRY_MAX_CHARS}, and the whole profile under ` +
+  `${AGENT_AUTHORED_COMPANY_PROFILE_CONTENT_MAX_UTF8_BYTES} UTF-8 bytes: one concise statement per field, no ` +
+  "numbered procedure and no marketing copy. Longer source material belongs in organization Documents and is " +
+  "retrieved as evidence.";
+
+/**
+ * Lane-agnostic guidance for the one `remember` content field, whose schema
+ * bound has to admit the widest lane. Without it an over-long rule would be
+ * refused with a generic "expected length <= 4000" that points at the wrong
+ * number entirely.
+ */
+export const AGENT_AUTHORED_REMEMBER_CONTENT_TOO_LONG_MESSAGE =
+  "Remembered content is bounded by where it lands: a mandatory workspace rule at most " +
+  `${AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_MAX_CHARS} characters because it is composed into every ` +
+  `session prompt it applies to, a preference at most ${AGENT_AUTHORED_PREFERENCE_CONTENT_MAX_CHARS}, a ` +
+  "Knowledge fact at most 4000. Write one imperative statement in 1-3 sentences, split unrelated entries, and " +
+  "keep procedure in a Document or Skill that the entry references.";
+
+/**
+ * The shape rule the model reads on every tool that authors a durable *rule or
+ * preference*. Deliberately not reused for the company profile, which is a
+ * descriptive profile rather than an instruction and needs its own wording.
+ */
+export const AGENT_AUTHORED_DURABLE_TEXT_STYLE =
+  "Durable text is prompt cost, not a place to be thorough: write one imperative statement in 1-3 sentences, " +
+  "with no numbered steps, no examples, no rationale and no restating of defaults. Prefer several small entries " +
+  "over one long one, and keep procedure in a Document or Skill that the rule references instead of inlining it.";
+
+/**
+ * Actionable over-budget message including the text the caller actually sent,
+ * so the model can see how far over it is instead of guessing.
+ */
+export function agentAuthoredDurableTextTooLongMessage(input: {
+  kind: "instruction_policy" | "preference";
+  actualChars: number;
+}): string {
+  const subject = input.kind === "instruction_policy" ? "This rule is" : "This preference is";
+  const limit =
+    input.kind === "instruction_policy"
+      ? AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_TOO_LONG_MESSAGE
+      : AGENT_AUTHORED_PREFERENCE_CONTENT_TOO_LONG_MESSAGE;
+  return `${subject} ${input.actualChars} characters. ${limit}`;
+}