@lssm/lib.contracts-spec 17.3.2

package/dist/capabilities/validation.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Capability validation utilities for ensuring bidirectional consistency.
+ *
+ * Validates that:
+ * 1. All `provides` surface references point to existing specs
+ * 2. All specs with `capability` fields are listed in their capability's `provides`
+ *
+ * @module capabilities/validation
+ */
+import type { EventRegistry } from '../events.js';
+import type { OperationSpecRegistry } from '../operations/registry.js';
+import type { PresentationRegistry } from '../presentations/index.js';
+import type { CapabilityRegistry, CapabilitySurface } from './capabilities.js';
+/** Single validation error describing an inconsistency. */
+export interface CapabilityValidationError {
+    /** Type of validation error. */
+    type: 'missing_surface_spec' | 'orphan_spec' | 'capability_not_found' | 'surface_not_in_provides';
+    /** Human-readable error message. */
+    message: string;
+    /** Capability key involved (if applicable). */
+    capabilityKey?: string;
+    /** Surface type involved (if applicable). */
+    surface?: CapabilitySurface;
+    /** Spec key involved (if applicable). */
+    specKey?: string;
+}
+/** Result of capability consistency validation. */
+export interface CapabilityValidationResult {
+    /** Whether validation passed with no errors. */
+    valid: boolean;
+    /** List of validation errors found. */
+    errors: CapabilityValidationError[];
+    /** List of warnings (non-blocking issues). */
+    warnings: CapabilityValidationError[];
+}
+/** Registries needed for full bidirectional validation. */
+export interface CapabilityValidationDeps {
+    capabilities: CapabilityRegistry;
+    operations?: OperationSpecRegistry;
+    events?: EventRegistry;
+    presentations?: PresentationRegistry;
+}
+/**
+ * Validates bidirectional consistency between capabilities and their surfaces.
+ *
+ * Checks:
+ * 1. Forward validation: Every surface ref in capability `provides` exists
+ * 2. Reverse validation: Every spec with `capability` field is in that capability's `provides`
+ *
+ * @param deps - Registries to validate against
+ * @returns Validation result with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const result = validateCapabilityConsistency({
+ *   capabilities: capabilityRegistry,
+ *   operations: operationRegistry,
+ *   events: eventRegistry,
+ * });
+ *
+ * if (!result.valid) {
+ *   console.error('Capability validation failed:', result.errors);
+ * }
+ * ```
+ */
+export declare function validateCapabilityConsistency(deps: CapabilityValidationDeps): CapabilityValidationResult;
+/**
+ * Finds specs that have no capability assignment (orphan specs).
+ * This is informational - orphan specs are allowed but may indicate
+ * incomplete capability modeling.
+ *
+ * @param deps - Registries to check
+ * @returns List of spec keys without capability assignment
+ */
+export declare function findOrphanSpecs(deps: CapabilityValidationDeps): {
+    operations: string[];
+    events: string[];
+    presentations: string[];
+};

package/dist/capabilities/validation.js

@@ -0,0 +1 @@
+export function validateCapabilityConsistency(e){const a=[],t=[];for(const i of e.capabilities.list()){const s=`${i.meta.key}.v${i.meta.version}`;for(const n of i.provides??[])if(!o(e,n.surface,n.key))a.push({type:"missing_surface_spec",message:`Capability "${s}" provides ${n.surface} "${n.key}" but spec not found`,capabilityKey:s,surface:n.surface,specKey:n.key})}if(e.operations){for(const i of e.operations.list())if(i.capability){const s=e.capabilities.get(i.capability.key,i.capability.version);if(!s)a.push({type:"capability_not_found",message:`Operation "${i.meta.key}" references capability "${i.capability.key}.v${i.capability.version}" but capability not found`,specKey:i.meta.key,capabilityKey:`${i.capability.key}.v${i.capability.version}`,surface:"operation"});else if(!s.provides?.some((r)=>r.surface==="operation"&&r.key===i.meta.key))a.push({type:"surface_not_in_provides",message:`Operation "${i.meta.key}" claims capability "${i.capability.key}.v${i.capability.version}" but not in capability's provides`,specKey:i.meta.key,capabilityKey:`${i.capability.key}.v${i.capability.version}`,surface:"operation"})}}if(e.events){for(const i of e.events.list())if(i.capability){const s=e.capabilities.get(i.capability.key,i.capability.version);if(!s)a.push({type:"capability_not_found",message:`Event "${i.meta.key}" references capability "${i.capability.key}.v${i.capability.version}" but capability not found`,specKey:i.meta.key,capabilityKey:`${i.capability.key}.v${i.capability.version}`,surface:"event"});else if(!s.provides?.some((r)=>r.surface==="event"&&r.key===i.meta.key))a.push({type:"surface_not_in_provides",message:`Event "${i.meta.key}" claims capability "${i.capability.key}.v${i.capability.version}" but not in capability's provides`,specKey:i.meta.key,capabilityKey:`${i.capability.key}.v${i.capability.version}`,surface:"event"})}}if(e.presentations){for(const i of e.presentations.list())if(i.capability){const s=e.capabilities.get(i.capability.key,i.capability.version);if(!s)a.push({type:"capability_not_found",message:`Presentation "${i.meta.key}" references capability "${i.capability.key}.v${i.capability.version}" but capability not found`,specKey:i.meta.key,capabilityKey:`${i.capability.key}.v${i.capability.version}`,surface:"presentation"});else if(!s.provides?.some((r)=>r.surface==="presentation"&&r.key===i.meta.key))a.push({type:"surface_not_in_provides",message:`Presentation "${i.meta.key}" claims capability "${i.capability.key}.v${i.capability.version}" but not in capability's provides`,specKey:i.meta.key,capabilityKey:`${i.capability.key}.v${i.capability.version}`,surface:"presentation"})}}return{valid:a.length===0,errors:a,warnings:t}}function o(e,a,t){switch(a){case"operation":return e.operations?.has(t)??!0;case"event":return e.events?.has(t)??!0;case"presentation":return e.presentations?.has(t)??!0;case"workflow":case"resource":return!0;default:return!0}}export function findOrphanSpecs(e){const a={operations:[],events:[],presentations:[]};if(e.operations){for(const t of e.operations.list())if(!t.capability)a.operations.push(t.meta.key)}if(e.events){for(const t of e.events.list())if(!t.capability)a.events.push(t.meta.key)}if(e.presentations){for(const t of e.presentations.list())if(!t.capability)a.presentations.push(t.meta.key)}return a}

package/dist/cli/command-pack.d.ts

@@ -0,0 +1,37 @@
+import * as z from 'zod';
+export declare const CLI_COMMAND_PACK_SCHEMA_VERSION: 1;
+export declare const CliCommandNameSchema: z.ZodString;
+export declare const CliCommandPackSpecSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    version: z.ZodString;
+    commands: z.ZodArray<z.ZodString>;
+    extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type CliCommandPackSpec = z.infer<typeof CliCommandPackSpecSchema>;
+export declare const CliCommandPackMetadataSchema: z.ZodObject<{
+    entry: z.ZodString;
+    spec: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        version: z.ZodString;
+        commands: z.ZodArray<z.ZodString>;
+        extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CliCommandPackMetadata = z.infer<typeof CliCommandPackMetadataSchema>;
+export declare const CliCommandPackDiscoveryConfigSchema: z.ZodObject<{
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type CliCommandPackDiscoveryConfig = z.infer<typeof CliCommandPackDiscoveryConfigSchema>;
+export declare const CliCommandPackDocBlock: {
+    id: string;
+    title: string;
+    summary: string;
+    kind: "reference";
+    visibility: "public";
+    route: string;
+    tags: string[];
+    body: string;
+};

package/dist/cli/command-pack.js

@@ -0,0 +1,16 @@
+import*as a from"zod";export const CLI_COMMAND_PACK_SCHEMA_VERSION=1;export const CliCommandNameSchema=a.string().trim().min(1).regex(/^[a-z0-9][a-z0-9:-]*$/);export const CliCommandPackSpecSchema=a.object({schemaVersion:a.literal(CLI_COMMAND_PACK_SCHEMA_VERSION),id:a.string().trim().min(1),version:a.string().trim().min(1),commands:a.array(CliCommandNameSchema).min(1),extends:a.array(CliCommandNameSchema).optional()});export const CliCommandPackMetadataSchema=a.object({entry:a.string().trim().min(1),spec:CliCommandPackSpecSchema});export const CliCommandPackDiscoveryConfigSchema=a.object({include:a.array(a.string().trim().min(1)).optional(),exclude:a.array(a.string().trim().min(1)).optional()});export const CliCommandPackDocBlock={id:"docs.tech.contracts.cli-command-packs",title:"CLI command packs",summary:"Portable metadata and consumer discovery controls for ContractSpec CLI command packs.",kind:"reference",visibility:"public",route:"/docs/tech/contracts/cli-command-packs",tags:["cli","command-pack","configuration"],body:`## CLI command packs
+
+Published command packs expose \`contractspec.commandPack\` metadata containing a module entry and a \`CliCommandPackSpec\`. The CLI discovers only direct consumer dependencies with that metadata.
+
+Consumers can constrain discovery with \`.contractsrc.json\`:
+
+\`\`\`json
+{
+  "commandPacks": {
+    "include": ["@lssm/integration.cli-contractspec-ai"],
+    "exclude": ["@lssm/integration.cli-contractspec-examples"]
+  }
+}
+\`\`\`
+
+Exclusion wins when a package appears in both lists. Runtime registration and conflict handling are owned by \`@lssm/lib.cli-runtime\`.`};

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export * from './command-pack.js';

package/dist/cli/index.js

@@ -0,0 +1 @@
+export*from"./command-pack.js";

package/dist/companyos/auth-production-topology.d.ts

@@ -0,0 +1,24 @@
+/** Canonical production origins shared by CompanyOS web and auth runtimes. */
+export declare const COMPANYOS_PRODUCTION_AUTH_TOPOLOGY: {
+    readonly webOrigin: 'https://www.companyos.run';
+    readonly apiOrigin: 'https://api.companyos.run';
+    readonly cookieDomain: '.companyos.run';
+    readonly defaultPostLoginPath: '/companyos';
+};
+/** Resolves a sanitized same-site path onto the canonical web origin. */
+export declare function resolveCompanyOsPostLoginUrl(path: string): string;
+/** Additive preview topology; deployment qualification must prove data/secret isolation. */
+export interface CompanyOsPreviewAuthTopologyV1 {
+    readonly schemaVersion: '1';
+    readonly profile: 'preview-v1';
+    readonly webOrigin: string;
+    readonly upstreamApiOrigin: string;
+    readonly authOrigin: string;
+    readonly cookiePrefix: 'companyos-preview';
+    readonly crossSubDomainCookies: false;
+}
+/** Auth is served through the web origin; cookies never use a shared parent domain. */
+export declare function defineCompanyOsPreviewAuthTopology(input: {
+    readonly webOrigin: string;
+    readonly upstreamApiOrigin: string;
+}): CompanyOsPreviewAuthTopologyV1;

package/dist/companyos/auth-production-topology.js

@@ -0,0 +1 @@
+export const COMPANYOS_PRODUCTION_AUTH_TOPOLOGY={webOrigin:"https://www.companyos.run",apiOrigin:"https://api.companyos.run",cookieDomain:".companyos.run",defaultPostLoginPath:"/companyos"};export function resolveCompanyOsPostLoginUrl(n){if(!n.startsWith("/")||n.startsWith("//")||/[\\\u0000-\u001f\u007f]/.test(n))throw Error("companyos_post_login_path_invalid");const i=new URL(n,COMPANYOS_PRODUCTION_AUTH_TOPOLOGY.webOrigin);if(i.origin!==COMPANYOS_PRODUCTION_AUTH_TOPOLOGY.webOrigin)throw Error("companyos_post_login_path_invalid");return i.toString()}export function defineCompanyOsPreviewAuthTopology(n){const i=(e)=>{const o=new URL(e);if(o.protocol!=="https:"||o.username||o.password||o.pathname!=="/"||o.search||o.hash||e!==o.origin||o.hostname==="companyos.run"||o.hostname.endsWith(".companyos.run")||o.hostname==="lssm.co"||o.hostname.endsWith(".lssm.co")||o.hostname==="lssm.tech"||o.hostname.endsWith(".lssm.tech"))throw Error("companyos_preview_origin_invalid");return o.origin},r=i(n.webOrigin);return Object.freeze({schemaVersion:"1",profile:"preview-v1",webOrigin:r,upstreamApiOrigin:i(n.upstreamApiOrigin),authOrigin:r,cookiePrefix:"companyos-preview",crossSubDomainCookies:!1})}

package/dist/companyos/booking-surfaces.d.ts

@@ -0,0 +1,50 @@
+export declare const COMPANYOS_REQUIRED_BOOKING_SURFACES: readonly [Readonly<{
+    kind: "organization";
+    organizationSlug: "lssm";
+    handle: "lssm";
+    displayName: "LSSM";
+    email: "tboutron@lssm.co";
+}>, Readonly<{
+    kind: "organization";
+    organizationSlug: "companyos";
+    handle: "companyos";
+    displayName: "CompanyOS";
+    email: "tboutron@lssm.co";
+}>, Readonly<{
+    kind: "organization";
+    organizationSlug: "hirly";
+    handle: "hirly";
+    displayName: "Hirly";
+    email: "theo@tryhirly.com";
+}>, Readonly<{
+    kind: "individual";
+    organizationSlug: "lssm";
+    handle: "theo";
+    displayName: "Théo Boutron";
+    email: "tboutron@lssm.co";
+}>, Readonly<{
+    kind: "individual";
+    organizationSlug: "hirly";
+    handle: "antoine";
+    displayName: "Antoine";
+    email: "antoine@tryhirly.com";
+}>, Readonly<{
+    kind: "individual";
+    organizationSlug: "hirly";
+    handle: "younes";
+    displayName: "Younes";
+    email: "younes@tryhirly.com";
+}>];
+export type CompanyOsRequiredBookingSurface = (typeof COMPANYOS_REQUIRED_BOOKING_SURFACES)[number];
+export declare const COMPANYOS_BOOKING_SURFACE_POLICY: Readonly<{
+    readonly personalSurfaceCount: 3;
+    readonly organizationSurfaceCount: 3;
+    readonly destination: 'owned_live';
+    readonly sharedWorkspaceCalendarForMembers: true;
+    readonly canonicalEmbedOrigins: readonly ["https://www.companyos.run"];
+    readonly publicProfilePath: '/u/:handle';
+    readonly publicBookingPath: '/book/:token';
+    readonly activationPath: '/api/companyos/operator/booking-surfaces/activate';
+    readonly activationAuthentication: 'dedicated_bearer';
+    readonly activationReplay: 'idempotent';
+}>;

package/dist/companyos/booking-surfaces.js

@@ -0,0 +1 @@
+export const COMPANYOS_REQUIRED_BOOKING_SURFACES=Object.freeze([Object.freeze({kind:"organization",organizationSlug:"lssm",handle:"lssm",displayName:"LSSM",email:"tboutron@lssm.co"}),Object.freeze({kind:"organization",organizationSlug:"companyos",handle:"companyos",displayName:"CompanyOS",email:"tboutron@lssm.co"}),Object.freeze({kind:"organization",organizationSlug:"hirly",handle:"hirly",displayName:"Hirly",email:"theo@tryhirly.com"}),Object.freeze({kind:"individual",organizationSlug:"lssm",handle:"theo",displayName:"Th\xE9o Boutron",email:"tboutron@lssm.co"}),Object.freeze({kind:"individual",organizationSlug:"hirly",handle:"antoine",displayName:"Antoine",email:"antoine@tryhirly.com"}),Object.freeze({kind:"individual",organizationSlug:"hirly",handle:"younes",displayName:"Younes",email:"younes@tryhirly.com"})]);export const COMPANYOS_BOOKING_SURFACE_POLICY=Object.freeze({personalSurfaceCount:3,organizationSurfaceCount:3,destination:"owned_live",sharedWorkspaceCalendarForMembers:!0,canonicalEmbedOrigins:Object.freeze(["https://www.companyos.run"]),publicProfilePath:"/u/:handle",publicBookingPath:"/book/:token",activationPath:"/api/companyos/operator/booking-surfaces/activate",activationAuthentication:"dedicated_bearer",activationReplay:"idempotent"});

package/dist/companyos/calendar-intelligence.d.ts

@@ -0,0 +1,129 @@
+export declare const COMPANYOS_CALENDAR_INTELLIGENCE_VERSION = "2.5.0";
+export declare const COMPANYOS_CALENDAR_INTELLIGENCE_GOOGLE_SCOPES: readonly ["https://www.googleapis.com/auth/calendar.events.freebusy", "https://www.googleapis.com/auth/calendar.events.owned", "https://www.googleapis.com/auth/calendar.calendarlist.readonly", "https://www.googleapis.com/auth/calendar.events.readonly"];
+export declare const COMPANYOS_CALENDAR_INTELLIGENCE_COMPATIBILITY: Readonly<{
+    readonly intent: 'additive-minor';
+    readonly priorWorkspacePreferences: 'unsupported';
+    readonly workspaceBookingCalendars: 'permanently-excluded';
+    readonly unconfiguredRecipients: 'setup-required-no-delivery';
+    readonly oauthConsent: 'personal-reauthorization-required';
+    readonly omnichannelPreferences: 'email-default-with-durable-in-app-fallback';
+    readonly providerAcceptance: 'not-delivery-confirmation';
+    readonly queueAdmission: 'not-provider-acceptance';
+}>;
+export declare const COMPANYOS_CALENDAR_INTELLIGENCE_POLICY: Readonly<{
+    readonly defaultTimezone: 'Europe/Paris';
+    readonly defaultLocale: 'en';
+    readonly morningRecapLocalTime: '07:00';
+    readonly morningRecapCatchUpMinutes: 180;
+    readonly meetingPreparationLeadMinutes: 60;
+    readonly eventReadWindowHours: 36;
+    readonly maximumEventsPerPerson: 40;
+    readonly maximumGraphFactsPerWorkspace: 8;
+    readonly durableContentRetention: 'P90D-policy-overridable';
+    readonly durableEvidence: 'digest-delivery-model-evidence-refs-only';
+    readonly declinedEvents: 'excluded';
+    readonly allDayEvents: 'recap-only';
+    readonly operatorReplayPath: '/api/companyos/operator/calendar-intelligence/run';
+}>;
+export type CalendarIntelligenceDeliveryKind = 'morning-recap' | 'meeting-preparation';
+export type CalendarIntelligenceLocale = 'en' | 'fr' | 'es';
+export type CalendarIntelligenceSetupState = 'ready' | 'setup_required' | 'reauthorization_required' | 'error';
+export interface CalendarIntelligencePrincipal {
+    readonly userId: string;
+    readonly personalTenantId: string;
+    readonly personalWorkspaceId: string;
+    readonly personalContextId: string;
+    readonly deliveryEmail: string;
+    readonly deliveryChannels: readonly CalendarIntelligenceDeliveryChannel[];
+    readonly timezone: string;
+    readonly locale: CalendarIntelligenceLocale;
+}
+export type CalendarIntelligenceDeliveryChannel = 'email' | 'in_app';
+export interface CalendarIntelligenceMeeting {
+    readonly providerEventRef: string;
+    readonly calendarRef?: string;
+    readonly calendarRefs?: readonly string[];
+    readonly workspaceId?: string;
+    readonly workspaceLabel?: string;
+    readonly workspaceLabels?: readonly string[];
+    readonly title: string;
+    readonly description?: string;
+    readonly location?: string;
+    readonly conferenceUrl?: string;
+    readonly startsAt: string;
+    readonly endsAt: string;
+    readonly allDay: boolean;
+    readonly attendeeLabels: readonly string[];
+    readonly declined?: boolean;
+    readonly cancelled?: boolean;
+}
+export interface CalendarIntelligenceEvidenceReference {
+    readonly ref: string;
+    readonly workspaceLabel: string;
+    readonly label: string;
+    readonly observedAt?: string;
+}
+export interface CalendarIntelligenceInsight {
+    readonly summary: string;
+    readonly relevantFacts: readonly {
+        readonly text: string;
+        readonly evidenceRef: string;
+        readonly workspaceLabel: string;
+    }[];
+    readonly risks: readonly string[];
+    readonly preparationQuestions: readonly string[];
+}
+/** Additive provenance for successful private model composition; absence never qualifies model execution. */
+export interface CalendarIntelligenceGenerationProvenance {
+    readonly contractVersion: '1.0.0';
+    readonly promptVersion: string;
+    readonly bindingDigest: string;
+    readonly provider: 'vercel-ai-gateway';
+    readonly model: string;
+    readonly processingApprovalRef: string;
+    readonly transitApprovalRef: string;
+    readonly inferenceRegion: 'eu';
+}
+export interface CalendarIntelligenceEmailDraft {
+    readonly generationProvenance?: CalendarIntelligenceGenerationProvenance;
+    readonly subject: string;
+    /** Deterministic recipient-local event metadata; never model-authored content. */
+    readonly preheader: string;
+    readonly htmlBody: string;
+    readonly textBody: string;
+    readonly compositionVersion: '2.0.0';
+    readonly model: string;
+    readonly fallbackState: 'none' | 'partial' | 'deterministic';
+    readonly evidenceRefs: readonly CalendarIntelligenceEvidenceReference[];
+}
+export declare const companyOsCalendarIntelligenceComposition: Readonly<{
+    readonly source: {
+        readonly provider: 'google-calendar';
+        readonly ownership: 'recipient-personal-context-only';
+        readonly workspaceBookingFallback: 'forbidden';
+        readonly graphScope: 'explicit-calendar-to-authorized-workspace-mapping';
+        readonly scopes: readonly ["https://www.googleapis.com/auth/calendar.events.freebusy", "https://www.googleapis.com/auth/calendar.events.owned", "https://www.googleapis.com/auth/calendar.calendarlist.readonly", "https://www.googleapis.com/auth/calendar.events.readonly"];
+    };
+    readonly delivery: {
+        readonly recipients: 'exactly-one-authenticated-companyos-user';
+        readonly eventAttendees: 'context-only-never-envelope-recipients';
+        readonly morning: 'one-cross-workspace-routed-delivery-per-person-local-date';
+        readonly preparation: 'one-routed-delivery-per-person-provider-event-occurrence';
+        readonly preview: 'current-user-personal-pipeline-non-production';
+        readonly routing: 'communication-os-prepared-and-persisted-before-effect';
+        readonly dispatch: 'communication-os-durable-outbox-with-provider-idempotency';
+        readonly queueAdmission: 'recorded-separately-from-provider-acceptance';
+        readonly fallback: 'durable-in-app-terminal';
+        readonly providerAcceptance: 'recorded-separately-from-delivery-confirmation';
+    };
+    readonly composition: {
+        readonly deterministic: readonly ["recipient", "subject", "preheader", "time", "attendees", "location", "join-link"];
+        readonly ai: 'schema-validated-evidence-bound-untrusted-input';
+        readonly fallback: 'field-by-field-deterministic';
+    };
+    readonly persistence: {
+        readonly eventContent: 'canonical-communication-message-only';
+        readonly emailBodies: 'communication-os-policy-retention';
+        readonly evidence: 'digest-delivery-model-evidence-refs-only';
+    };
+}>;

package/dist/companyos/calendar-intelligence.js

@@ -0,0 +1 @@
+export const COMPANYOS_CALENDAR_INTELLIGENCE_VERSION="2.5.0";export const COMPANYOS_CALENDAR_INTELLIGENCE_GOOGLE_SCOPES=Object.freeze(["https://www.googleapis.com/auth/calendar.events.freebusy","https://www.googleapis.com/auth/calendar.events.owned","https://www.googleapis.com/auth/calendar.calendarlist.readonly","https://www.googleapis.com/auth/calendar.events.readonly"]);export const COMPANYOS_CALENDAR_INTELLIGENCE_COMPATIBILITY=Object.freeze({intent:"additive-minor",priorWorkspacePreferences:"unsupported",workspaceBookingCalendars:"permanently-excluded",unconfiguredRecipients:"setup-required-no-delivery",oauthConsent:"personal-reauthorization-required",omnichannelPreferences:"email-default-with-durable-in-app-fallback",providerAcceptance:"not-delivery-confirmation",queueAdmission:"not-provider-acceptance"});export const COMPANYOS_CALENDAR_INTELLIGENCE_POLICY=Object.freeze({defaultTimezone:"Europe/Paris",defaultLocale:"en",morningRecapLocalTime:"07:00",morningRecapCatchUpMinutes:180,meetingPreparationLeadMinutes:60,eventReadWindowHours:36,maximumEventsPerPerson:40,maximumGraphFactsPerWorkspace:8,durableContentRetention:"P90D-policy-overridable",durableEvidence:"digest-delivery-model-evidence-refs-only",declinedEvents:"excluded",allDayEvents:"recap-only",operatorReplayPath:"/api/companyos/operator/calendar-intelligence/run"});export const companyOsCalendarIntelligenceComposition=Object.freeze({source:{provider:"google-calendar",ownership:"recipient-personal-context-only",workspaceBookingFallback:"forbidden",graphScope:"explicit-calendar-to-authorized-workspace-mapping",scopes:COMPANYOS_CALENDAR_INTELLIGENCE_GOOGLE_SCOPES},delivery:{recipients:"exactly-one-authenticated-companyos-user",eventAttendees:"context-only-never-envelope-recipients",morning:"one-cross-workspace-routed-delivery-per-person-local-date",preparation:"one-routed-delivery-per-person-provider-event-occurrence",preview:"current-user-personal-pipeline-non-production",routing:"communication-os-prepared-and-persisted-before-effect",dispatch:"communication-os-durable-outbox-with-provider-idempotency",queueAdmission:"recorded-separately-from-provider-acceptance",fallback:"durable-in-app-terminal",providerAcceptance:"recorded-separately-from-delivery-confirmation"},composition:{deterministic:["recipient","subject","preheader","time","attendees","location","join-link"],ai:"schema-validated-evidence-bound-untrusted-input",fallback:"field-by-field-deterministic"},persistence:{eventContent:"canonical-communication-message-only",emailBodies:"communication-os-policy-retention",evidence:"digest-delivery-model-evidence-refs-only"}});

package/dist/companyos/calendar-microsoft-personal-discovery.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const PersonalMicrosoftCalendarSchema: z.ZodObject<{
+    displayName: z.ZodString;
+    primary: z.ZodBoolean;
+    canReadBusy: z.ZodBoolean;
+    canOwnWrites: z.ZodBoolean;
+    supportsTeams: z.ZodBoolean;
+    busyCalendarRef: z.ZodString;
+    writeCalendarRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const PersonalMicrosoftCalendarsResultSchema: z.ZodObject<{
+    calendars: z.ZodArray<z.ZodObject<{
+        displayName: z.ZodString;
+        primary: z.ZodBoolean;
+        canReadBusy: z.ZodBoolean;
+        canOwnWrites: z.ZodBoolean;
+        supportsTeams: z.ZodBoolean;
+        busyCalendarRef: z.ZodString;
+        writeCalendarRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const PersonalMicrosoftCalendarsQuery: import("..").OperationSpec<import("@lssm/lib.schema").ZodSchemaType<z.ZodObject<{}, z.core.$strict>>, import("@lssm/lib.schema").ZodSchemaType<z.ZodObject<{
+    calendars: z.ZodArray<z.ZodObject<{
+        displayName: z.ZodString;
+        primary: z.ZodBoolean;
+        canReadBusy: z.ZodBoolean;
+        canOwnWrites: z.ZodBoolean;
+        supportsTeams: z.ZodBoolean;
+        busyCalendarRef: z.ZodString;
+        writeCalendarRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>, undefined>;

package/dist/companyos/calendar-microsoft-personal-discovery.js

@@ -0,0 +1 @@
+import{fromZod as r}from"@lssm/lib.schema";import{z as e}from"zod";import{defineQuery as a}from"../operations/index.js";import{COMPANYOS_CAPABILITY as n,COMPANYOS_DOMAIN as o,COMPANYOS_OWNERS as t,COMPANYOS_STABILITY as i,COMPANYOS_TAGS as s}from"./constants.js";export const PersonalMicrosoftCalendarSchema=e.object({displayName:e.string().max(1024),primary:e.boolean(),canReadBusy:e.boolean(),canOwnWrites:e.boolean(),supportsTeams:e.boolean(),busyCalendarRef:e.string().regex(/^busy-calendar:[a-f0-9]{64}$/),writeCalendarRef:e.string().regex(/^write-calendar:[a-f0-9]{64}$/).optional()}).strict();export const PersonalMicrosoftCalendarsResultSchema=e.object({calendars:e.array(PersonalMicrosoftCalendarSchema).max(1000)}).strict();export const PersonalMicrosoftCalendarsQuery=a({meta:{key:"calendar-intelligence.personal-microsoft-calendars.list",version:"1.0.0",title:"List personal Microsoft calendars",description:"Discover calendars for the authenticated personal Microsoft connection.",goal:"Offer explicit busy-calendar and write-target selection without exposing credentials.",context:"Verified provider identity and current personal authority are required; enumeration does not select calendars or enable planning.",domain:o,owners:[...t],tags:[...s,"calendar","microsoft"],stability:i},capability:{...n},io:{input:r(e.object({}).strict(),{name:"PersonalMicrosoftCalendarsInput"}),output:r(PersonalMicrosoftCalendarsResultSchema,{name:"PersonalMicrosoftCalendarsOutput"}),errors:{MICROSOFT_CALENDAR_UNAVAILABLE:{description:"Microsoft calendars are unavailable.",http:503,when:"Credentials, provider discovery or identity proof is unavailable."},PERSONAL_CONTEXT_REQUIRED:{description:"An enabled personal context is required.",http:409,when:"Personal owner cannot be resolved."},FORBIDDEN:{description:"Current authority no longer permits access.",http:403,when:"Session or owner reproof fails."}}},acceptance:{scenarios:[{key:"private-owner-discovery",given:["A current personal Microsoft connection"],when:["The owner lists calendars"],then:["Only opaque calendar references and capabilities are returned","No calendar is selected and no scheduling effect occurs"]}]},policy:{auth:"user",pii:["calendars.displayName"]}});

package/dist/companyos/calendar-microsoft-personal-http.d.ts

@@ -0,0 +1,32 @@
+/** Additive personal OAuth transport bindings; discovery and calendar effects remain separate. */
+export declare const COMPANYOS_PERSONAL_MICROSOFT_HTTP_CATALOG: readonly [{
+    readonly key: 'calendar-intelligence.personal-microsoft-oauth.start';
+    readonly version: '1.1.0';
+    readonly method: 'POST';
+    readonly path: '/api/v2/opa/personal-calendar/microsoft/authorize';
+}, {
+    readonly key: 'calendar-intelligence.personal-microsoft-oauth.complete';
+    readonly version: '1.2.0';
+    readonly method: 'GET';
+    readonly path: '/api/v2/opa/personal-calendar/microsoft/callback';
+}, {
+    readonly key: 'calendar-intelligence.personal-microsoft-calendars.list';
+    readonly version: '1.0.0';
+    readonly method: 'GET';
+    readonly path: '/api/v2/opa/personal-calendar/microsoft/calendars';
+}, {
+    readonly key: 'calendar-intelligence.personal-microsoft-selection.read';
+    readonly version: '1.0.0';
+    readonly method: 'GET';
+    readonly path: '/api/v2/opa/personal-calendar/microsoft/selection';
+}, {
+    readonly key: 'calendar-intelligence.personal-microsoft-selection.save';
+    readonly version: '1.0.0';
+    readonly method: 'POST';
+    readonly path: '/api/v2/opa/personal-calendar/microsoft/selection';
+}, {
+    readonly key: 'calendar-intelligence.personal-microsoft-calendar.disconnect';
+    readonly version: '1.0.0';
+    readonly method: 'POST';
+    readonly path: '/api/v2/opa/personal-calendar/microsoft/disconnect';
+}];

package/dist/companyos/calendar-microsoft-personal-http.js

@@ -0,0 +1 @@
+export const COMPANYOS_PERSONAL_MICROSOFT_HTTP_CATALOG=[{key:"calendar-intelligence.personal-microsoft-oauth.start",version:"1.1.0",method:"POST",path:"/api/v2/opa/personal-calendar/microsoft/authorize"},{key:"calendar-intelligence.personal-microsoft-oauth.complete",version:"1.2.0",method:"GET",path:"/api/v2/opa/personal-calendar/microsoft/callback"},{key:"calendar-intelligence.personal-microsoft-calendars.list",version:"1.0.0",method:"GET",path:"/api/v2/opa/personal-calendar/microsoft/calendars"},{key:"calendar-intelligence.personal-microsoft-selection.read",version:"1.0.0",method:"GET",path:"/api/v2/opa/personal-calendar/microsoft/selection"},{key:"calendar-intelligence.personal-microsoft-selection.save",version:"1.0.0",method:"POST",path:"/api/v2/opa/personal-calendar/microsoft/selection"},{key:"calendar-intelligence.personal-microsoft-calendar.disconnect",version:"1.0.0",method:"POST",path:"/api/v2/opa/personal-calendar/microsoft/disconnect"}];

package/dist/companyos/calendar-microsoft-personal-selection.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+/** Proposed selection contract; HTTP activation requires current-selection digest reproof. */
+export declare const PersonalMicrosoftCalendarSelectionSchema: z.ZodObject<{
+    expectedSelectionDigest: z.ZodString;
+    selections: z.ZodArray<z.ZodObject<{
+        calendarRef: z.ZodString;
+        workspaceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    writeCalendarRef: z.ZodOptional<z.ZodString>;
+    requireTeams: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const PersonalMicrosoftCalendarSelectionResultSchema: z.ZodObject<{
+    selectionDigest: z.ZodString;
+    selections: z.ZodArray<z.ZodObject<{
+        calendarRef: z.ZodString;
+        workspaceIds: z.ZodArray<z.ZodString>;
+        designatedWriteTarget: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const PersonalMicrosoftCalendarSelectionRead: import("..").OperationSpec<import("@lssm/lib.schema").ZodSchemaType<z.ZodObject<{}, z.core.$strict>>, import("@lssm/lib.schema").ZodSchemaType<z.ZodObject<{
+    selectionDigest: z.ZodString;
+    selections: z.ZodArray<z.ZodObject<{
+        calendarRef: z.ZodString;
+        workspaceIds: z.ZodArray<z.ZodString>;
+        designatedWriteTarget: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>>, undefined>;
+export declare const PersonalMicrosoftCalendarSelectionSave: import("..").OperationSpec<import("@lssm/lib.schema").ZodSchemaType<z.ZodObject<{
+    expectedSelectionDigest: z.ZodString;
+    selections: z.ZodArray<z.ZodObject<{
+        calendarRef: z.ZodString;
+        workspaceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    writeCalendarRef: z.ZodOptional<z.ZodString>;
+    requireTeams: z.ZodBoolean;
+}, z.core.$strict>>, import("@lssm/lib.schema").ZodSchemaType<z.ZodObject<{
+    selected: z.ZodNumber;
+}, z.core.$strict>>, undefined>;

package/dist/companyos/calendar-microsoft-personal-selection.js

@@ -0,0 +1 @@
+import{fromZod as o}from"@lssm/lib.schema";import{z as e}from"zod";import{defineCommand as n,defineQuery as c}from"../operations/index.js";import{COMPANYOS_CAPABILITY as a,COMPANYOS_DOMAIN as d,COMPANYOS_OWNERS as l,COMPANYOS_STABILITY as p,COMPANYOS_TAGS as m}from"./constants.js";export const PersonalMicrosoftCalendarSelectionSchema=e.object({expectedSelectionDigest:e.string().regex(/^sha256:[a-f0-9]{64}$/),selections:e.array(e.object({calendarRef:e.string().regex(/^busy-calendar:[a-f0-9]{64}$/),workspaceIds:e.array(e.string().min(1).max(160)).max(20)}).strict()).max(100),writeCalendarRef:e.string().regex(/^write-calendar:[a-f0-9]{64}$/).optional(),requireTeams:e.boolean()}).strict().superRefine((t,i)=>{if(new Set(t.selections.map((r)=>r.calendarRef)).size!==t.selections.length)i.addIssue({code:"custom",message:"DUPLICATE_CALENDAR_SELECTION"});if(t.selections.some((r)=>new Set(r.workspaceIds).size!==r.workspaceIds.length))i.addIssue({code:"custom",message:"DUPLICATE_WORKSPACE_MAPPING"});if((t.writeCalendarRef||t.requireTeams)&&!t.selections.length)i.addIssue({code:"custom",message:"WRITE_TARGET_REQUIRES_SELECTED_CALENDAR"});if(t.requireTeams&&!t.writeCalendarRef)i.addIssue({code:"custom",message:"TEAMS_REQUIRES_WRITE_TARGET"})});export const PersonalMicrosoftCalendarSelectionResultSchema=e.object({selectionDigest:e.string().regex(/^sha256:[a-f0-9]{64}$/),selections:e.array(e.object({calendarRef:e.string().regex(/^busy-calendar:[a-f0-9]{64}$/),workspaceIds:e.array(e.string().min(1).max(160)).max(20),designatedWriteTarget:e.boolean()}).strict()).max(100)}).strict();const s={version:"1.0.0",domain:d,owners:[...l],stability:p,tags:[...m,"calendar","microsoft"],goal:"Persist explicit personal calendar choices without overwriting concurrent edits.",context:"Owner and authorized workspace mappings are rederived server-side. Selection does not qualify provider execution."};export const PersonalMicrosoftCalendarSelectionRead=c({meta:{...s,version:"1.0.0",key:"calendar-intelligence.personal-microsoft-selection.read",title:"Read personal Microsoft calendar selection",description:"Read persisted choices and their current concurrency digest."},capability:{...a},io:{input:o(e.object({}).strict(),{name:"PersonalMicrosoftSelectionReadInput"}),output:o(PersonalMicrosoftCalendarSelectionResultSchema,{name:"PersonalMicrosoftSelectionReadOutput"})},policy:{auth:"user",pii:[]}});export const PersonalMicrosoftCalendarSelectionSave=n({meta:{...s,version:"1.0.0",key:"calendar-intelligence.personal-microsoft-selection.save",title:"Save personal Microsoft calendar selection",description:"Save verified calendar choices only against the expected persisted digest."},capability:{...a},io:{input:o(PersonalMicrosoftCalendarSelectionSchema,{name:"PersonalMicrosoftSelectionSaveInput"}),output:o(e.object({selected:e.number().int().min(0).max(100)}).strict(),{name:"PersonalMicrosoftSelectionSaveOutput"}),errors:{MICROSOFT_SELECTION_INVALID:{description:"Review calendar choices and write target.",http:422,when:"Selection fails current provider capability or input validation."},MICROSOFT_SELECTION_CONFLICT:{description:"Reload calendar choices before saving again.",http:409,when:"The persisted selection digest changed."}}},policy:{auth:"user",pii:[]}});