@opengeni/contracts 0.28.1 → 0.30.0

package/dist/google-drive.js

@@ -1,6 +1,6 @@
 import {
   ConnectionMetadata
-} from "./chunk-3Q5FLMOD.js";
+} from "./chunk-YWKPXSLB.js";
 import "./chunk-KGL5BVGF.js";
 
 // src/google-drive.ts

package/dist/index.d.ts

@@ -2395,6 +2395,42 @@ export declare const McpServerConnectionRef: z.ZodObject<{
     }>>;
 }, z.core.$strict>;
 export type McpServerConnectionRef = z.infer<typeof McpServerConnectionRef>;
+/** Internal frozen authority for one personal MCP connection. */
+export declare const McpPersonalConnectionDelegation: z.ZodObject<{
+    serverId: z.ZodString;
+    connectionId: z.ZodString;
+    ownerSubjectId: z.ZodString;
+    providerDomain: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+        api_key: "api_key";
+        app_install: "app_install";
+        delegated: "delegated";
+        oauth2: "oauth2";
+    }>>;
+}, z.core.$strict>;
+export type McpPersonalConnectionDelegation = z.infer<typeof McpPersonalConnectionDelegation>;
+/**
+ * Exact personal MCP authority frozen on one causal turn or scheduled task.
+ * One server can have at most one grant; bounded validation keeps corrupt JSON
+ * from becoming executable credential authority at a DB read boundary.
+ */
+export declare const McpPersonalConnectionDelegations: z.ZodArray<z.ZodObject<{
+    serverId: z.ZodString;
+    connectionId: z.ZodString;
+    ownerSubjectId: z.ZodString;
+    providerDomain: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+        api_key: "api_key";
+        app_install: "app_install";
+        delegated: "delegated";
+        oauth2: "oauth2";
+    }>>;
+}, z.core.$strict>>;
+export declare const McpPersonalConnectionSummary: z.ZodObject<{
+    serverId: z.ZodString;
+    providerDomain: z.ZodString;
+}, z.core.$strict>;
+export type McpPersonalConnectionSummary = z.infer<typeof McpPersonalConnectionSummary>;
 export type McpCredentialsRequest = {
     accountId: string;
     workspaceId: string;
@@ -2419,7 +2455,7 @@ export type McpCredentialsRequest = {
     connectionRef: McpServerConnectionRef;
     forceRefresh: boolean;
 };
-export type McpCredentialAuthNeededReason = CredentialAuthNeededReason | "unsupported_auth" | "resource_scope_unavailable";
+export type McpCredentialAuthNeededReason = CredentialAuthNeededReason | "personal_authority_unavailable" | "unsupported_auth" | "resource_scope_unavailable";
 export type McpCredentialResolution = {
     status: "ok";
     /** Scope echoes are mandatory and verified before any header is used. */
@@ -4017,6 +4053,10 @@ export declare const SessionTurn: z.ZodObject<{
         }>;
     }, z.core.$strip>;
     initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    personalConnections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        serverId: z.ZodString;
+        providerDomain: z.ZodString;
+    }, z.core.$strict>>>;
     cancelledBy: z.ZodNullable<z.ZodString>;
     cancelReason: z.ZodNullable<z.ZodString>;
     startedAt: z.ZodNullable<z.ZodString>;
@@ -5197,6 +5237,10 @@ export declare const SessionQueueSnapshot: z.ZodObject<{
             quiescencePendingCount: z.ZodNumber;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+    activePersonalConnections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        serverId: z.ZodString;
+        providerDomain: z.ZodString;
+    }, z.core.$strict>>>;
     stoppingPreviousAttempt: z.ZodBoolean;
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -5305,6 +5349,10 @@ export declare const SessionQueueSnapshot: z.ZodObject<{
             }>;
         }, z.core.$strip>;
         initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        personalConnections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            serverId: z.ZodString;
+            providerDomain: z.ZodString;
+        }, z.core.$strict>>>;
         cancelledBy: z.ZodNullable<z.ZodString>;
         cancelReason: z.ZodNullable<z.ZodString>;
         startedAt: z.ZodNullable<z.ZodString>;
@@ -5859,6 +5907,19 @@ export declare const ScheduledTask: z.ZodObject<{
         }, z.core.$strip>>;
         maxNestedAgentDepth: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
+    createdBy: z.ZodDefault<z.ZodObject<{
+        subjectId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            service: "service";
+            subject: "subject";
+        }>;
+    }, z.core.$strip>>;
+    createdByContext: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    personalConnections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        serverId: z.ZodString;
+        providerDomain: z.ZodString;
+    }, z.core.$strict>>>;
     reusableSessionId: z.ZodNullable<z.ZodString>;
     variableSetId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     environmentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -6732,6 +6793,11 @@ export declare function comparePersonalSlackCanonicalConnections(left: PersonalS
 export declare function selectCanonicalPersonalSlackConnection<T extends PersonalSlackCanonicalConnection>(connections: readonly T[]): T | null;
 export declare const ConnectionCredentialBundle: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 export type ConnectionCredentialBundle = z.infer<typeof ConnectionCredentialBundle>;
+export declare const ConnectionOwnership: z.ZodEnum<{
+    personal: "personal";
+    workspace: "workspace";
+}>;
+export type ConnectionOwnership = z.infer<typeof ConnectionOwnership>;
 export declare const CreateConnectionRequest: z.ZodObject<{
     providerDomain: z.ZodString;
     kind: z.ZodEnum<{
@@ -6740,6 +6806,10 @@ export declare const CreateConnectionRequest: z.ZodObject<{
         delegated: "delegated";
         oauth2: "oauth2";
     }>;
+    ownership: z.ZodOptional<z.ZodEnum<{
+        personal: "personal";
+        workspace: "workspace";
+    }>>;
     subjectId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     credential: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     grantedScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -6854,6 +6924,10 @@ export declare const OAuthStartRequest: z.ZodObject<{
     requestedScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
     returnPath: z.ZodOptional<z.ZodString>;
     connectionId: z.ZodOptional<z.ZodString>;
+    ownership: z.ZodOptional<z.ZodEnum<{
+        personal: "personal";
+        workspace: "workspace";
+    }>>;
     oauthClient: z.ZodOptional<z.ZodObject<{
         clientId: z.ZodString;
         clientSecret: z.ZodOptional<z.ZodString>;
@@ -9566,6 +9640,7 @@ export declare const ToolAuthNeededPayload: z.ZodObject<{
         expired: "expired";
         insufficient_scope: "insufficient_scope";
         missing_connection: "missing_connection";
+        personal_authority_unavailable: "personal_authority_unavailable";
         refresh_failed: "refresh_failed";
         resource_scope_unavailable: "resource_scope_unavailable";
         unsupported_auth: "unsupported_auth";
@@ -11305,6 +11380,10 @@ export declare const SessionQueueMutationResponse: z.ZodObject<{
                 quiescencePendingCount: z.ZodNumber;
             }, z.core.$strip>>;
         }, z.core.$strip>;
+        activePersonalConnections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            serverId: z.ZodString;
+            providerDomain: z.ZodString;
+        }, z.core.$strict>>>;
         stoppingPreviousAttempt: z.ZodBoolean;
         items: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -11413,6 +11492,10 @@ export declare const SessionQueueMutationResponse: z.ZodObject<{
                 }>;
             }, z.core.$strip>;
             initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            personalConnections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                serverId: z.ZodString;
+                providerDomain: z.ZodString;
+            }, z.core.$strict>>>;
             cancelledBy: z.ZodNullable<z.ZodString>;
             cancelReason: z.ZodNullable<z.ZodString>;
             startedAt: z.ZodNullable<z.ZodString>;
@@ -12368,6 +12451,10 @@ export declare const SteerSessionMessageResponse: z.ZodObject<{
             }>;
         }, z.core.$strip>;
         initiatorContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        personalConnections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            serverId: z.ZodString;
+            providerDomain: z.ZodString;
+        }, z.core.$strict>>>;
         cancelledBy: z.ZodNullable<z.ZodString>;
         cancelReason: z.ZodNullable<z.ZodString>;
         startedAt: z.ZodNullable<z.ZodString>;
@@ -14605,3 +14692,4 @@ export * from "./secret-redaction";
 export * from "./workspace-instruction-policies";
 export * from "./workspace-state";
 export * from "./preference-registry";
+export * from "./scoped-knowledge";

package/dist/index.js

@@ -53,6 +53,7 @@ import {
   ConnectionCredentialBundle,
   ConnectionKind,
   ConnectionMetadata,
+  ConnectionOwnership,
   ConnectionResponse,
   ConnectionStatus,
   CorrectPreferenceRegistryRequest,
@@ -215,12 +216,21 @@ import {
   InsightsSpendDriver,
   InsightsWarmGroupRow,
   IntegrationClientMetadata,
+  KnowledgeChangeProposalTargetKind,
+  KnowledgeClaimEvidencePolarity,
+  KnowledgeClaimOrigin,
+  KnowledgeClaimRelationType,
+  KnowledgeClaimReviewState,
+  KnowledgeFactObjectKind,
+  KnowledgeLifecycleEventType,
+  KnowledgeLifecycleState,
   KnowledgeMemory,
   KnowledgeMemoryKind,
   KnowledgeMemorySearchRequest,
   KnowledgeMemoryStatus,
   KnowledgeSourceKind,
   KnowledgeSourceRef,
+  KnowledgeSyncRunState,
   LatencyMode,
   LimitAction,
   LimitDecision,
@@ -237,6 +247,9 @@ import {
   ManagedAccount,
   MarketingDailyAnalysisTaskRequest,
   McpConnectionResourceScope,
+  McpPersonalConnectionDelegation,
+  McpPersonalConnectionDelegations,
+  McpPersonalConnectionSummary,
   McpServerConnectionRef,
   MetricSample,
   MintEnrollTokenRequest,
@@ -383,6 +396,8 @@ import {
   ScheduledTaskScheduleSpec,
   ScheduledTaskStatus,
   ScheduledTaskTriggerType,
+  ScopedKnowledgeActorKind,
+  ScopedKnowledgeScopeKind,
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
   Session,
@@ -688,7 +703,7 @@ import {
   verifyRelayToken,
   verifyStreamToken,
   workspaceControlUtf8Bytes
-} from "./chunk-3Q5FLMOD.js";
+} from "./chunk-YWKPXSLB.js";
 import {
   OPENGENI_SLACK_BOT_FORBIDDEN_SCOPES,
   OPENGENI_SLACK_BOT_REQUIRED_SCOPES,
@@ -751,6 +766,7 @@ export {
   ConnectionCredentialBundle,
   ConnectionKind,
   ConnectionMetadata,
+  ConnectionOwnership,
   ConnectionResponse,
   ConnectionStatus,
   CorrectPreferenceRegistryRequest,
@@ -913,12 +929,21 @@ export {
   InsightsSpendDriver,
   InsightsWarmGroupRow,
   IntegrationClientMetadata,
+  KnowledgeChangeProposalTargetKind,
+  KnowledgeClaimEvidencePolarity,
+  KnowledgeClaimOrigin,
+  KnowledgeClaimRelationType,
+  KnowledgeClaimReviewState,
+  KnowledgeFactObjectKind,
+  KnowledgeLifecycleEventType,
+  KnowledgeLifecycleState,
   KnowledgeMemory,
   KnowledgeMemoryKind,
   KnowledgeMemorySearchRequest,
   KnowledgeMemoryStatus,
   KnowledgeSourceKind,
   KnowledgeSourceRef,
+  KnowledgeSyncRunState,
   LatencyMode,
   LimitAction,
   LimitDecision,
@@ -935,6 +960,9 @@ export {
   ManagedAccount,
   MarketingDailyAnalysisTaskRequest,
   McpConnectionResourceScope,
+  McpPersonalConnectionDelegation,
+  McpPersonalConnectionDelegations,
+  McpPersonalConnectionSummary,
   McpServerConnectionRef,
   MetricSample,
   MintEnrollTokenRequest,
@@ -1084,6 +1112,8 @@ export {
   ScheduledTaskScheduleSpec,
   ScheduledTaskStatus,
   ScheduledTaskTriggerType,
+  ScopedKnowledgeActorKind,
+  ScopedKnowledgeScopeKind,
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
   Session,

package/dist/scoped-knowledge.d.ts

@@ -0,0 +1,233 @@
+import { z } from "zod";
+/** Tenant scope for normalized knowledge and source provenance. */
+export declare const ScopedKnowledgeScopeKind: z.ZodEnum<{
+    organization: "organization";
+    personal: "personal";
+    workspace: "workspace";
+}>;
+export type ScopedKnowledgeScopeKind = z.infer<typeof ScopedKnowledgeScopeKind>;
+export type ScopedKnowledgeScope = {
+    kind: "organization";
+    workspaceId: null;
+    subjectId: null;
+} | {
+    kind: "workspace";
+    workspaceId: string;
+    subjectId: null;
+} | {
+    kind: "personal";
+    workspaceId: string | null;
+    subjectId: string;
+};
+export declare const ScopedKnowledgeActorKind: z.ZodEnum<{
+    human: "human";
+    service: "service";
+}>;
+export type ScopedKnowledgeActorKind = z.infer<typeof ScopedKnowledgeActorKind>;
+/**
+ * Immutable write provenance. A service actor may retain a causal human, but
+ * the service identity never substitutes for that human on personal reads.
+ */
+export type ScopedKnowledgeActor = {
+    kind: ScopedKnowledgeActorKind;
+    subjectId: string;
+    initiatingHumanSubjectId: string | null;
+};
+export declare const KnowledgeLifecycleState: z.ZodEnum<{
+    active: "active";
+    deleted: "deleted";
+    revoked: "revoked";
+}>;
+export type KnowledgeLifecycleState = z.infer<typeof KnowledgeLifecycleState>;
+export declare const KnowledgeLifecycleEventType: z.ZodEnum<{
+    acl_changed: "acl_changed";
+    deleted: "deleted";
+    object_version_added: "object_version_added";
+    restored: "restored";
+    revoked: "revoked";
+    sync_failed: "sync_failed";
+    sync_succeeded: "sync_succeeded";
+}>;
+export type KnowledgeLifecycleEventType = z.infer<typeof KnowledgeLifecycleEventType>;
+export declare const KnowledgeSyncRunState: z.ZodEnum<{
+    failed: "failed";
+    started: "started";
+    succeeded: "succeeded";
+}>;
+export type KnowledgeSyncRunState = z.infer<typeof KnowledgeSyncRunState>;
+export declare const KnowledgeClaimOrigin: z.ZodEnum<{
+    explicit: "explicit";
+    inferred: "inferred";
+}>;
+export type KnowledgeClaimOrigin = z.infer<typeof KnowledgeClaimOrigin>;
+export declare const KnowledgeClaimRelationType: z.ZodEnum<{
+    conflicts_with: "conflicts_with";
+    supersedes: "supersedes";
+}>;
+export type KnowledgeClaimRelationType = z.infer<typeof KnowledgeClaimRelationType>;
+export declare const KnowledgeClaimEvidencePolarity: z.ZodEnum<{
+    contradicts: "contradicts";
+    supports: "supports";
+}>;
+export type KnowledgeClaimEvidencePolarity = z.infer<typeof KnowledgeClaimEvidencePolarity>;
+export declare const KnowledgeClaimReviewState: z.ZodEnum<{
+    approved: "approved";
+    proposed: "proposed";
+    rejected: "rejected";
+    revoked: "revoked";
+}>;
+export type KnowledgeClaimReviewState = z.infer<typeof KnowledgeClaimReviewState>;
+export declare const KnowledgeFactObjectKind: z.ZodEnum<{
+    boolean: "boolean";
+    entity: "entity";
+    json: "json";
+    number: "number";
+    text: "text";
+    timestamp: "timestamp";
+}>;
+export type KnowledgeFactObjectKind = z.infer<typeof KnowledgeFactObjectKind>;
+export declare const KnowledgeChangeProposalTargetKind: z.ZodEnum<{
+    instruction_policy: "instruction_policy";
+    preference: "preference";
+}>;
+export type KnowledgeChangeProposalTargetKind = z.infer<typeof KnowledgeChangeProposalTargetKind>;
+export type KnowledgeProviderRecord = {
+    id: string;
+    accountId: string;
+    scope: ScopedKnowledgeScope;
+    providerKey: string;
+    externalTenantId: string;
+    lifecycleState: KnowledgeLifecycleState;
+    lifecycleGeneration: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type KnowledgeSourceRecord = {
+    id: string;
+    accountId: string;
+    providerId: string;
+    scope: ScopedKnowledgeScope;
+    externalSourceId: string;
+    sourceKind: string;
+    sourceUri: string | null;
+    currentAclGeneration: number | null;
+    syncGeneration: number;
+    syncCursor: string | null;
+    lifecycleState: KnowledgeLifecycleState;
+    lifecycleGeneration: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type KnowledgeSourceAclVersionRecord = {
+    id: string;
+    accountId: string;
+    sourceId: string;
+    generation: number;
+    aclVersion: string | null;
+    aclHash: string;
+    audience: ScopedKnowledgeScope;
+    agentAccess: boolean;
+    createdAt: string;
+};
+export type KnowledgeSyncRunRecord = {
+    id: string;
+    accountId: string;
+    sourceId: string;
+    operationId: string;
+    state: KnowledgeSyncRunState;
+    inputSyncGeneration: number;
+    inputLifecycleGeneration: number;
+    inputCursor: string | null;
+    outputCursor: string | null;
+    watermark: string | null;
+    metadata: Record<string, unknown>;
+    errorCode: string | null;
+    startedAt: string;
+    completedAt: string | null;
+};
+export type KnowledgeSourceObjectRecord = {
+    id: string;
+    accountId: string;
+    sourceId: string;
+    scope: ScopedKnowledgeScope;
+    externalObjectId: string;
+    documentId: string | null;
+    lifecycleState: KnowledgeLifecycleState;
+    lifecycleGeneration: number;
+    versionGeneration: number;
+    currentVersionId: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type KnowledgeDocumentVersionRecord = {
+    id: string;
+    accountId: string;
+    sourceId: string;
+    objectId: string;
+    scope: ScopedKnowledgeScope;
+    versionGeneration: number;
+    externalVersionId: string;
+    contentSha256: string;
+    ingestionKey: string;
+    aclVersionId: string;
+    aclGeneration: number;
+    documentId: string | null;
+    fileId: string | null;
+    createdAt: string;
+};
+export type KnowledgeEntityRecord = {
+    id: string;
+    accountId: string;
+    scope: ScopedKnowledgeScope;
+    entityType: string;
+    normalizedKey: string;
+    displayName: string;
+    createdAt: string;
+};
+export type KnowledgeFactRecord = {
+    id: string;
+    accountId: string;
+    scope: ScopedKnowledgeScope;
+    subjectEntityId: string;
+    predicateKey: string;
+    objectKind: KnowledgeFactObjectKind;
+    objectEntityId: string | null;
+    objectValue: unknown | null;
+    objectHash: string;
+    createdAt: string;
+};
+export type KnowledgeClaimRecord = {
+    id: string;
+    accountId: string;
+    scope: ScopedKnowledgeScope;
+    factId: string;
+    origin: KnowledgeClaimOrigin;
+    confidenceBps: number;
+    effectiveAt: string;
+    expiresAt: string | null;
+    extractionMethod: string;
+    modelProvider: string | null;
+    modelName: string | null;
+    modelVersion: string | null;
+    createdAt: string;
+};
+export type EligibleKnowledgeClaim = {
+    claim: KnowledgeClaimRecord;
+    fact: KnowledgeFactRecord;
+    reviewState: "approved";
+    supportingEvidenceCount: number;
+};
+export type KnowledgeChangeProposalRecord = {
+    id: string;
+    accountId: string;
+    scope: ScopedKnowledgeScope;
+    targetKind: KnowledgeChangeProposalTargetKind;
+    targetScope: string;
+    targetKey: string | null;
+    content: string;
+    contentHash: string;
+    claimId: string;
+    evidenceId: string;
+    status: "proposed";
+    createdAt: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/contracts",
-  "version": "0.28.1",
+  "version": "0.30.0",
   "description": "Shared zod schemas and wire-contract types for the OpenGeni API.",
   "license": "Apache-2.0",
   "repository": {

package/src/index.ts

@@ -2548,6 +2548,46 @@ export const McpServerConnectionRef = z
   });
 export type McpServerConnectionRef = z.infer<typeof McpServerConnectionRef>;
 
+/** Internal frozen authority for one personal MCP connection. */
+export const McpPersonalConnectionDelegation = z
+  .object({
+    serverId: z.string().min(1).max(256),
+    connectionId: z.string().uuid(),
+    ownerSubjectId: z.string().min(1).max(512),
+    providerDomain: z.string().min(1).max(2048),
+    kind: z.enum(["oauth2", "api_key", "app_install", "delegated"]).optional(),
+  })
+  .strict();
+export type McpPersonalConnectionDelegation = z.infer<typeof McpPersonalConnectionDelegation>;
+
+/**
+ * Exact personal MCP authority frozen on one causal turn or scheduled task.
+ * One server can have at most one grant; bounded validation keeps corrupt JSON
+ * from becoming executable credential authority at a DB read boundary.
+ */
+export const McpPersonalConnectionDelegations = z
+  .array(McpPersonalConnectionDelegation)
+  .max(128)
+  .superRefine((delegations, context) => {
+    const seen = new Set<string>();
+    for (const [index, delegation] of delegations.entries()) {
+      if (seen.has(delegation.serverId)) {
+        context.addIssue({
+          code: "custom",
+          message: "personal MCP delegations must be unique by serverId",
+          path: [index, "serverId"],
+        });
+      }
+      seen.add(delegation.serverId);
+    }
+  });
+
+export const McpPersonalConnectionSummary = McpPersonalConnectionDelegation.pick({
+  serverId: true,
+  providerDomain: true,
+});
+export type McpPersonalConnectionSummary = z.infer<typeof McpPersonalConnectionSummary>;
+
 export type McpCredentialsRequest = {
   accountId: string;
   workspaceId: string;
@@ -2575,6 +2615,7 @@ export type McpCredentialsRequest = {
 
 export type McpCredentialAuthNeededReason =
   | CredentialAuthNeededReason
+  | "personal_authority_unavailable"
   | "unsupported_auth"
   | "resource_scope_unavailable";
 
@@ -4021,6 +4062,8 @@ export const SessionTurn = z.object({
   lineage: z.record(z.string(), z.unknown()),
   initiator: TurnInitiator,
   initiatorContext: TurnInitiatorContext,
+  /** Secret-safe projection of the exact personal authority frozen on this turn. */
+  personalConnections: z.array(McpPersonalConnectionSummary).default([]),
   cancelledBy: z.string().nullable(),
   cancelReason: z.string().nullable(),
   startedAt: z.string().nullable(),
@@ -4508,6 +4551,8 @@ export type SessionPendingInputPreview = z.infer<typeof SessionPendingInputPrevi
 export const SessionQueueSnapshot = z.object({
   version: z.number().int().nonnegative(),
   effectiveControl: EffectiveSessionControl,
+  /** Secret-safe personal MCP summaries frozen on the exact active turn. */
+  activePersonalConnections: z.array(McpPersonalConnectionSummary).default([]),
   /**
    * True while the latest attempt is interrupted but has not durably proved
    * quiescence: no more inference, user-visible output, or workspace-persistence
@@ -4875,6 +4920,9 @@ export const ScheduledTask = z.object({
   runMode: ScheduledTaskRunMode,
   overlapPolicy: ScheduledTaskOverlapPolicy,
   agentConfig: ScheduledTaskAgentConfig,
+  createdBy: TurnInitiator.default({ kind: "service", subjectId: "unattributed-legacy" }),
+  createdByContext: TurnInitiatorContext.default({}),
+  personalConnections: z.array(McpPersonalConnectionSummary).default([]),
   reusableSessionId: z.string().uuid().nullable(),
   variableSetId: z.string().uuid().nullable().default(null),
   /** @deprecated use variableSetId */
@@ -5397,9 +5445,14 @@ function compareDescending(left: number | string, right: number | string): numbe
 export const ConnectionCredentialBundle = z.record(z.string(), z.unknown());
 export type ConnectionCredentialBundle = z.infer<typeof ConnectionCredentialBundle>;
 
+export const ConnectionOwnership = z.enum(["workspace", "personal"]);
+export type ConnectionOwnership = z.infer<typeof ConnectionOwnership>;
+
 export const CreateConnectionRequest = z.object({
   providerDomain: z.string().min(1),
   kind: ConnectionKind,
+  ownership: ConnectionOwnership.optional(),
+  /** @deprecated use ownership */
   subjectId: z.string().min(1).nullable().optional(),
   credential: ConnectionCredentialBundle,
   grantedScopes: z.array(z.string().min(1)).default([]),
@@ -5449,6 +5502,7 @@ export const OAuthStartRequest = z
     requestedScopes: z.array(z.string().min(1)).default([]),
     returnPath: z.string().min(1).optional(),
     connectionId: z.string().uuid().optional(),
+    ownership: ConnectionOwnership.optional(),
     oauthClient: z
       .object({
         clientId: z.string().min(1),
@@ -6243,6 +6297,7 @@ export const ToolAuthNeededPayload = z.object({
     "expired",
     "insufficient_scope",
     "refresh_failed",
+    "personal_authority_unavailable",
     "unsupported_auth",
     "resource_scope_unavailable",
   ]),
@@ -9539,3 +9594,4 @@ export * from "./secret-redaction";
 export * from "./workspace-instruction-policies";
 export * from "./workspace-state";
 export * from "./preference-registry";
+export * from "./scoped-knowledge";