@lssm/lib.contracts-spec 17.3.2

package/dist/customer-support/capability-matrix-validation-helpers.js

@@ -0,0 +1 @@
+import{isSupportEvidenceAvailable as c,isSupportProofSatisfied as m,supportProofProfileForCapability as h,supportQualificationProofForCapability as g}from"./capability-matrix-evidence.js";import{validateResolvedBlockers as S,validateSupportEvidence as x}from"./capability-matrix-validation-evidence.js";export function validateSupportCapabilityPaths(e){const s=[];for(const o of e.routes)if(!o.startsWith("/"))s.push({code:"invalid_route",path:`${e.id}.routes`,message:`Route ${o} must be application-relative.`});for(const o of e.sourcePaths)if(o.startsWith("/")||o.split("/").includes(".."))s.push({code:"invalid_source_path",path:`${e.id}.sourcePaths`,message:`Source path ${o} must be repository-relative.`});return s}export function validateSupportCapabilityStage(e,s){const o=[],i=e.authModes??[e.authMode],p=e.exposure==="customer"?["anonymous","authenticated_customer"]:e.exposure==="system"?["service"]:["operator"];if(i.length===0||!i.includes(e.authMode)||i.some((t)=>!p.includes(t)))o.push({code:"invalid_actor_context",path:`${e.id}.authModes`,message:`${e.exposure} exposure has incompatible authentication modes.`});const r=(t)=>c(e,t);if(e.stage==="missing"&&(r("contract")||r("implementation"))||e.stage==="contract_only"&&(!r("contract")||r("implementation"))||["scaffolded","implemented_local","integrated","qualified"].includes(e.stage)&&!r("implementation")||e.stage==="implemented_local"&&!r("unit")||e.stage==="integrated"&&!r("integration"))o.push({code:"stage_evidence_mismatch",path:`${e.id}.stage`,message:`${e.stage} does not match its available evidence.`});const n=h(e),a=g(e);if(e.proofProfile!==n)o.push({code:"qualification_profile_mismatch",path:`${e.id}.proofProfile`,message:`${e.moduleId}/${e.exposure} requires the ${n} proof profile.`});if(e.criticality==="release_gate"&&a.some((t)=>!e.requiredProof.includes(t)))o.push({code:"qualification_profile_incomplete",path:`${e.id}.requiredProof`,message:`${e.proofProfile} release gates cannot weaken their minimum proof profile.`});o.push(...x(e,s));o.push(...S(e,s));if(e.stage==="qualified"){const u=[...new Set([...e.requiredProof,...a])].filter((l)=>!m(e,l,s)),d=e.blockers.some((l)=>l.status==="open");if(u.length>0||d)o.push({code:"qualification_incomplete",path:`${e.id}.stage`,message:`Qualification is missing fresh proof (${u.join(", ")||"none"}) or has an open blocker.`})}if(e.stage!=="qualified"&&e.nextActions.length===0)o.push({code:"missing_next_action",path:`${e.id}.nextActions`,message:"Unqualified capabilities require an explicit next action."});return o}export function validateSupportCapabilityCycles(e){return[...f(e,(s)=>s.parentId?[s.parentId]:[],"parentId"),...f(e,(s)=>s.dependencyRefs,"dependencyRefs")]}function f(e,s,o){const i=[],p=new Map(e.map((t)=>[t.id,t])),r=new Set,n=new Set,a=(t)=>{if(r.has(t))return;if(n.has(t)){i.push({code:"cyclic_reference",path:`${t}.${o}`,message:`Capability ${t} participates in a ${o} cycle.`});return}const u=p.get(t);if(!u)return;n.add(t);for(const d of s(u))a(d);n.delete(t);r.add(t)};for(const t of e)a(t.id);return i}

package/dist/customer-support/capability-matrix-validation.d.ts

@@ -0,0 +1,7 @@
+import type { SupportCapabilityMatrix } from './capability-matrix.js';
+export interface SupportCapabilityMatrixIssue {
+    readonly code: 'duplicate_id' | 'unknown_reference' | 'cyclic_reference' | 'invalid_hierarchy' | 'invalid_route' | 'invalid_source_path' | 'invalid_as_of' | 'invalid_evidence' | 'invalid_actor_context' | 'stage_evidence_mismatch' | 'qualification_profile_incomplete' | 'qualification_profile_mismatch' | 'qualification_incomplete' | 'resolved_blocker_evidence_missing' | 'ambiguous_resolution_evidence' | 'invalid_registry_reference' | 'missing_qualification_scope' | 'missing_next_action';
+    readonly path: string;
+    readonly message: string;
+}
+export declare function validateSupportCapabilityMatrix(matrix: SupportCapabilityMatrix): readonly SupportCapabilityMatrixIssue[];

package/dist/customer-support/capability-matrix-validation.js

@@ -0,0 +1 @@
+import{supportTimestamp as l}from"./capability-matrix-evidence.js";import{SUPPORT_DATA_CLASS_REFERENCE_REGISTRY as u,SUPPORT_DATA_STORE_REFERENCE_REGISTRY as c,SUPPORT_EVENT_REFERENCE_REGISTRY as f,SUPPORT_JOURNEY_REFERENCE_REGISTRY as _,SUPPORT_SERVICE_REFERENCE_REGISTRY as m,SUPPORT_SLO_REFERENCE_REGISTRY as R}from"./capability-matrix-registries.js";import{validateSupportCapabilityCycles as h,validateSupportCapabilityPaths as g,validateSupportCapabilityStage as v}from"./capability-matrix-validation-helpers.js";export function validateSupportCapabilityMatrix(e){const t=[],s=a(e.modules,"modules",t),o=a(e.capabilities,"capabilities",t);if(!I(e.meta.asOf))t.push({code:"invalid_as_of",path:"meta.asOf",message:"The matrix asOf value must be an ISO timestamp."});for(const i of e.modules)for(const n of i.routeRoots)if(!n.startsWith("/"))t.push({code:"invalid_route",path:`${i.id}.routeRoots`,message:`Route ${n} must be application-relative.`});for(const i of e.capabilities){d(s,i.moduleId,`${i.id}.moduleId`,t);E(i,e,o,t);for(const n of i.dependencyRefs)d(o,n,`${i.id}.dependencyRefs`,t);t.push(...g(i));S(i,t);a(i.evidence,`${i.id}.evidence`,t);a(i.blockers,`${i.id}.blockers`,t);for(const n of i.blockers)if(n.resolutionEvidenceRef&&i.evidence.filter((r)=>r.id===n.resolutionEvidenceRef).length>1)t.push({code:"ambiguous_resolution_evidence",path:`${i.id}.blockers.${n.id}`,message:`Resolution evidence ${n.resolutionEvidenceRef} is ambiguous.`});t.push(...v(i,e.meta.asOf))}t.push(...h(e.capabilities));return t}function S(e,t){const s=[["serviceRefs",e.serviceRefs,m],["dataStoreRefs",e.dataStoreRefs,c],["eventRefs",e.eventRefs,f],["journeyRefs",e.journeyRefs,_],["sloRefs",e.sloRefs,R],["dataClassRefs",e.dataClassRefs,u]];for(const[i,n,r]of s){if(!n){t.push({code:"invalid_registry_reference",path:`${e.id}.${i}`,message:`SupportOS matrix v1.1 requires ${i}.`});continue}if(new Set(n).size!==n.length)t.push({code:"duplicate_id",path:`${e.id}.${i}`,message:`${i} contains duplicate references.`});for(const p of n)if(!r.includes(p))t.push({code:"invalid_registry_reference",path:`${e.id}.${i}`,message:`Unknown ${i} reference ${p}.`})}const o=e.qualificationScopes;if(!o||o.environments.length===0||o.regions.length===0||o.platforms.length===0||o.locales.length===0||o.providers.length===0||o.personas.length===0||!e.rolloutPhase||!e.accountableOwner||!e.expectedEvidence||e.expectedEvidence.length===0)t.push({code:"missing_qualification_scope",path:`${e.id}.qualificationScopes`,message:"Qualification scopes, rollout phase, accountable owner, and expected evidence are required."})}function E(e,t,s,o){if(!e.parentId)return;d(s,e.parentId,`${e.id}.parentId`,o);const i=t.capabilities.find((n)=>n.id===e.parentId);if(i&&i.moduleId!==e.moduleId)o.push({code:"invalid_hierarchy",path:`${e.id}.parentId`,message:"Parent and child capabilities must belong to the same module."});if(e.parentId===e.id)o.push({code:"invalid_hierarchy",path:`${e.id}.parentId`,message:"A capability cannot parent itself."})}function a(e,t,s){const o=new Set;for(const i of e){if(o.has(i.id))s.push({code:"duplicate_id",path:t,message:`Duplicate id ${i.id}.`});o.add(i.id)}return o}function d(e,t,s,o){if(!e.has(t))o.push({code:"unknown_reference",path:s,message:`Unknown reference ${t}.`})}function I(e){return l(e)!==void 0}

package/dist/customer-support/capability-matrix.d.ts

@@ -0,0 +1,101 @@
+import type { SupportCapabilityDataClassRef, SupportCapabilityDataStoreRef, SupportCapabilityEventRef, SupportCapabilityJourneyRef, SupportCapabilityQualificationScopes, SupportCapabilityRolloutPhase, SupportCapabilityServiceRef, SupportCapabilitySloRef } from './capability-matrix-registries.js';
+export declare const SUPPORT_CAPABILITY_MATRIX_KEY: 'customer-support-v1.capability-matrix';
+export declare const SUPPORT_CAPABILITY_MATRIX_VERSION: '1.1.0';
+export declare const SUPPORT_CAPABILITY_MATRIX_LEGACY_VERSION: '1.0.0';
+export type SupportCapabilityOwner = 'supportos' | 'communicationos' | 'forms' | 'companyos' | 'knowledge' | 'billingos' | 'workflow' | 'decision' | 'sop' | 'personalization' | 'connect' | 'opa';
+export type SupportCapabilityStage = 'missing' | 'contract_only' | 'scaffolded' | 'implemented_local' | 'integrated' | 'qualified';
+export type SupportCapabilityProofProfile = 'standard' | 'customer_surface' | 'data_authority' | 'provider_migration' | 'operational_resilience' | 'ai_governance';
+export type SupportCapabilityProofLayer = 'contract' | 'implementation' | 'unit' | 'integration' | 'e2e' | 'accessibility' | 'security' | 'migration' | 'performance' | 'resilience' | 'production_canary' | 'manual_acceptance';
+export interface SupportCapabilityEvidenceRef {
+    readonly id: string;
+    readonly layer: SupportCapabilityProofLayer;
+    readonly ref: string;
+    readonly mode: 'source' | 'test_definition' | 'execution_receipt' | 'production_receipt';
+    readonly state: 'available' | 'verified' | 'failed' | 'stale' | 'missing';
+    readonly runRef?: string;
+    readonly digest?: string;
+    readonly observedAt?: string;
+    readonly expiresAt?: string;
+}
+export interface SupportCapabilityBlocker {
+    readonly id: string;
+    readonly kind: 'external' | 'product' | 'technical' | 'security' | 'compliance' | 'qualification';
+    readonly severity: 'critical' | 'high' | 'medium' | 'low';
+    readonly summary: string;
+    readonly owner: string;
+    readonly status: 'open' | 'resolved';
+    readonly resolutionEvidenceRef?: string;
+    readonly resolvedAt?: string;
+}
+export interface SupportCapabilityModule {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string;
+    readonly canonicalOwner: SupportCapabilityOwner;
+    readonly routeRoots: readonly string[];
+}
+export interface SupportCapabilityItem {
+    readonly id: string;
+    readonly moduleId: string;
+    readonly parentId?: string;
+    readonly title: string;
+    readonly description: string;
+    readonly canonicalOwner: SupportCapabilityOwner;
+    readonly deliveryOwner: string;
+    readonly milestone: 'foundation' | 'phase-1' | 'phase-2' | 'decision-sops' | 'ai-autonomy' | 'premium-experience' | 'qualification';
+    readonly criticality: 'release_gate' | 'important' | 'enhancement';
+    readonly stage: SupportCapabilityStage;
+    readonly proofProfile: SupportCapabilityProofProfile;
+    readonly exposure: 'customer' | 'operator' | 'admin' | 'system';
+    readonly authMode: 'anonymous' | 'authenticated_customer' | 'operator' | 'service';
+    /** Additive mixed-identity projection; authMode remains the primary compatibility value. */
+    readonly authModes?: readonly ('anonymous' | 'authenticated_customer' | 'operator' | 'service')[];
+    readonly routes: readonly string[];
+    readonly operationRefs: readonly string[];
+    readonly flagRefs: readonly string[];
+    readonly sourcePaths: readonly string[];
+    readonly dependencyRefs: readonly string[];
+    /** v1.1 topology metadata; optional for v1.0-compatible external authors. */
+    readonly serviceRefs?: readonly SupportCapabilityServiceRef[];
+    readonly dataStoreRefs?: readonly SupportCapabilityDataStoreRef[];
+    readonly eventRefs?: readonly SupportCapabilityEventRef[];
+    readonly journeyRefs?: readonly SupportCapabilityJourneyRef[];
+    readonly sloRefs?: readonly SupportCapabilitySloRef[];
+    readonly dataClassRefs?: readonly SupportCapabilityDataClassRef[];
+    readonly qualificationScopes?: SupportCapabilityQualificationScopes;
+    readonly rolloutPhase?: SupportCapabilityRolloutPhase;
+    readonly accountableOwner?: string;
+    readonly expectedEvidence?: readonly SupportCapabilityProofLayer[];
+    readonly platforms: readonly string[];
+    readonly personas: readonly string[];
+    readonly ownerScopes: readonly string[];
+    readonly localeScope: 'not_applicable' | 'product_chrome' | 'tenant_content';
+    readonly requiredProof: readonly SupportCapabilityProofLayer[];
+    readonly evidence: readonly SupportCapabilityEvidenceRef[];
+    readonly blockers: readonly SupportCapabilityBlocker[];
+    readonly acceptanceCriteria: readonly string[];
+    readonly nextActions: readonly string[];
+}
+export interface SupportCapabilityMatrix {
+    readonly meta: {
+        readonly key: typeof SUPPORT_CAPABILITY_MATRIX_KEY;
+        readonly version: typeof SUPPORT_CAPABILITY_MATRIX_VERSION;
+        readonly title: string;
+        readonly description: string;
+        readonly owners: readonly string[];
+        readonly asOf: string;
+    };
+    readonly modules: readonly SupportCapabilityModule[];
+    readonly capabilities: readonly SupportCapabilityItem[];
+}
+export declare function defineSupportCapabilityMatrix<const T extends SupportCapabilityMatrix>(matrix: T): T;
+export declare const SupportCapabilityMatrixDocBlock: {
+    id: string;
+    title: string;
+    summary: string;
+    kind: "reference";
+    visibility: "public";
+    route: string;
+    tags: string[];
+    body: string;
+};

package/dist/customer-support/capability-matrix.js

@@ -0,0 +1,3 @@
+export const SUPPORT_CAPABILITY_MATRIX_KEY="customer-support-v1.capability-matrix";export const SUPPORT_CAPABILITY_MATRIX_VERSION="1.1.0";export const SUPPORT_CAPABILITY_MATRIX_LEGACY_VERSION="1.0.0";export function defineSupportCapabilityMatrix(e){return e}export const SupportCapabilityMatrixDocBlock={id:"customer-support-v1-capability-matrix",title:"SupportOS v1 capability and qualification matrix",summary:"Typed delivery truth for SupportOS modules, feature hierarchy, ownership, routes, evidence, blockers, and production qualification.",kind:"reference",visibility:"public",route:"/docs/platform/supportos-v1-capability-matrix",tags:["supportos","delivery","qualification","product-health"],body:`# SupportOS v1 capability matrix
+
+Version 1.1 adds registry-backed service, storage, event, journey, SLO, data-class, rollout, ownership, and qualification-scope metadata without removing the v1.0 authoring surface. The matrix separates implementation stage from open blockers. Source and test definitions are inventory evidence; executed proof requires immutable receipts, and production proof expires relative to the matrix asOf. Intrinsic semantics prevent proof-profile downgrades, newer failed or stale receipts supersede older passes, and blocker resolution links verified evidence. Only evidence-complete capabilities without open blockers may be marked qualified.`};

package/dist/customer-support/case-assignments.d.ts

@@ -0,0 +1,60 @@
+import type { SupportCaseProjection } from './core.js';
+import type { SupportAuthorityScope } from './ports.js';
+export declare const SUPPORT_CASE_ASSIGNMENT_MODES: readonly ['claim', 'release', 'assign', 'steal'];
+export type SupportCaseAssignmentMode = (typeof SUPPORT_CASE_ASSIGNMENT_MODES)[number];
+export interface SupportCaseAssignmentMutationInput {
+    readonly caseRef: string;
+    readonly queueRef: string;
+    readonly mode: SupportCaseAssignmentMode;
+    readonly assigneeRef?: string;
+    readonly decisionRef?: string;
+    readonly routingDecisionRef?: string;
+    readonly expectedRevision: number;
+    readonly evidenceRefs: readonly string[];
+    readonly idempotencyKey: string;
+}
+export interface SupportCaseAssignmentMutationResult {
+    readonly projection: SupportCaseProjection;
+    readonly receiptRef: string;
+}
+export interface SupportCaseAssignmentAuthorityPort {
+    assignCase(scope: SupportAuthorityScope, input: SupportCaseAssignmentMutationInput): Promise<SupportCaseAssignmentMutationResult>;
+}
+export interface SupportCaseAssignmentGovernancePort {
+    verify(input: {
+        readonly scope: SupportAuthorityScope;
+        readonly caseRef: string;
+        readonly targetAssigneeRef: string;
+        readonly expectedRevision: number;
+        readonly decisionRef: string;
+        readonly observedAt: string;
+    }): Promise<{
+        readonly allowed: boolean;
+        readonly evidenceRef: string;
+        readonly expiresAt: string;
+    }>;
+}
+export declare function assertSupportAssignmentDecision(input: {
+    readonly result: {
+        readonly allowed: boolean;
+        readonly evidenceRef: string;
+        readonly expiresAt: string;
+    };
+    readonly observedAt: string;
+}): string;
+export declare function resolveSupportCaseAssignment(input: {
+    readonly scope: SupportAuthorityScope;
+    readonly current: SupportCaseProjection;
+    readonly mutation: SupportCaseAssignmentMutationInput;
+}): string | undefined;
+export declare const SupportCaseAssignmentsDocBlock: {
+    id: string;
+    title: string;
+    summary: string;
+    kind: "reference";
+    visibility: "public";
+    route: string;
+    tags: string[];
+    body: string;
+};
+export declare const SupportCaseAssignmentsDocRef: import("../docs").DocId;

package/dist/customer-support/case-assignments.js

@@ -0,0 +1,19 @@
+import{docRef as c}from"../docs/registry.js";import{SupportAuthorityError as a}from"./errors.js";export const SUPPORT_CASE_ASSIGNMENT_MODES=["claim","release","assign","steal"];export function assertSupportAssignmentDecision(t){if(!t.result.allowed)throw i("Connect denied the assignment steal decision.");if(!t.result.evidenceRef)throw i("Assignment steal governance evidence is required.");const s=Date.parse(t.result.expiresAt),n=Date.parse(t.observedAt);if(!Number.isFinite(s)||!Number.isFinite(n)||s<=n)throw i("Assignment steal governance decision is expired or invalid.");return t.result.evidenceRef}export function resolveSupportCaseAssignment(t){const{scope:s,current:n,mutation:e}=t,d=s.permissionRefs.includes("support.admin");if((e.mode==="claim"||e.mode==="release")&&(!n.queueRef||e.queueRef!==n.queueRef))throw i("Claim and release must preserve the server-projected queue.");if(e.mode!=="steal"&&e.decisionRef!==void 0)throw r("Only steal accepts a governed decision reference.");if((e.mode==="claim"||e.mode==="release")&&e.routingDecisionRef!==void 0)throw r("Only assign and steal accept a routing decision reference.");if(e.mode==="claim"){if(e.assigneeRef!==void 0)throw r("Claim derives the assignee from authenticated authority.");if(n.assigneeRef&&n.assigneeRef!==s.actorRef)throw o("The case is already assigned to another operator.");return s.actorRef}if(e.mode==="release"){if(e.assigneeRef!==void 0)throw r("Release cannot include an assignee reference.");if(n.assigneeRef!==s.actorRef&&!d)throw i("Only the assigned operator or an administrator can release a case.");return}if(!d)throw i("Assign and steal require SupportOS administrator authority.");if(!e.assigneeRef)throw r("Assign and steal require an assignee reference.");if(e.mode==="assign"&&n.assigneeRef)throw o("Use steal to replace an existing assignment.");if(e.mode==="steal"&&!e.decisionRef)throw i("Steal requires a governed decision reference.");if(e.mode==="steal"&&n.assigneeRef===e.assigneeRef)throw o("Steal must replace the current assignee.");return e.assigneeRef}function r(t){return new a("VALIDATION_FAILED",t)}function i(t){return new a("POLICY_DENIED",t)}function o(t){return new a("REVISION_CONFLICT",t)}export const SupportCaseAssignmentsDocBlock={id:"docs.customer-support.case-assignments",title:"SupportOS case assignments",summary:"Revision-fenced claim, release, assignment, and governed steal semantics.",kind:"reference",visibility:"public",route:"/docs/customer-support/case-assignments",tags:["supportos","assignment","collision","idempotency"],body:`# SupportOS case assignments
+
+Assignment mutations are scoped by authenticated tenant, workspace, and actor.
+Claim always derives the assignee from that actor. Release is limited to the
+current assignee or an administrator. Assign and steal require administrator
+authority, and steal also requires governed evidence. Every write is fenced by
+the case revision and a stable idempotency key. Durable authorities update the
+assignment projection and immutable case history atomically.
+
+The steal decision is verified server-side and bound to scope, case, target,
+revision, and expiry. Exact receipt replay does not require a still-live
+decision; any new or changed mutation does.
+
+An assign or steal mutation may bind a routing decision. Production authorities
+must revalidate the selected case, assignee, active team and membership, target
+queue, current policy revision, and live capacity, then consume that immutable
+decision exactly once in the assignment transaction. Authorities that cannot
+provide atomic decision consumption fail closed.
+`};export const SupportCaseAssignmentsDocRef=c(SupportCaseAssignmentsDocBlock.id);

package/dist/customer-support/case-cursor.d.ts

@@ -0,0 +1,17 @@
+export interface SupportCaseCursor {
+    readonly updatedAt: string;
+    readonly caseRef: string;
+}
+export declare const SupportCaseCursorDocBlock: {
+    id: string;
+    title: string;
+    summary: string;
+    kind: "reference";
+    visibility: "public";
+    route: string;
+    tags: string[];
+    body: string;
+};
+export declare const SupportCaseCursorDocRef: import("../docs").DocId;
+export declare function encodeSupportCaseCursor(updatedAt: string, caseRef: string): string;
+export declare function decodeSupportCaseCursor(cursor: string): SupportCaseCursor;

package/dist/customer-support/case-cursor.js

@@ -0,0 +1,8 @@
+import{docRef as u}from"../docs/registry.js";import{SupportAuthorityError as n}from"./errors.js";const p=2048;const c=200;export const SupportCaseCursorDocBlock={id:"docs.customer-support.case-cursor",title:"SupportOS case cursor",summary:"Bounded, opaque keyset pagination cursor shared by authorities.",kind:"reference",visibility:"public",route:"/docs/customer-support/case-cursor",tags:["supportos","pagination","security"],body:`# SupportOS case cursor
+
+Case collections use one bounded opaque keyset cursor containing the canonical
+updated timestamp and case reference. Managed, self-hosted, and in-memory
+authorities use the same encoder and validator. Malformed, oversized, or stale
+shapes fail with the stable validation error and never become dependency
+outages.
+`};export const SupportCaseCursorDocRef=u(SupportCaseCursorDocBlock.id);export function encodeSupportCaseCursor(o,r){i(o,r);return encodeURIComponent(JSON.stringify([o,r]))}export function decodeSupportCaseCursor(o){if(!o||o.length>p)throw e("SupportOS cursor is empty or exceeds its limit.");try{const r=JSON.parse(decodeURIComponent(o));if(!Array.isArray(r)||r.length!==2||r.some((a)=>typeof a!=="string"))throw e("SupportOS cursor shape is invalid.");const[t,s]=r;i(t,s);return{updatedAt:t,caseRef:s}}catch(r){if(r instanceof n)throw r;throw e("SupportOS cursor encoding is invalid.",r)}}function i(o,r){if(!o||!Number.isFinite(Date.parse(o))||!r||r.length>c)throw e("SupportOS cursor values are invalid.")}function e(o,r){return new n("VALIDATION_FAILED",o,{cause:r})}

package/dist/customer-support/case-lifecycle-event-schemas.d.ts

@@ -0,0 +1,42 @@
+import { EnumType, SchemaModel } from '@lssm/lib.schema';
+declare const fields: {
+    workspaceRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    resourceRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    correlationRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    receiptRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    revision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    resumeStatus: {
+        type: EnumType<[string, string, string]>;
+        isOptional: boolean;
+    };
+    occurredAt: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    actorRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    evidenceRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+};
+export declare const SupportCaseUnsnoozedEventPayloadModel: SchemaModel<typeof fields>;
+export {};

package/dist/customer-support/case-lifecycle-event-schemas.js

@@ -0,0 +1 @@
+import{EnumType as f,ScalarTypeEnum as a,SchemaModel as p}from"@lssm/lib.schema";const c=32;const l=/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/;const m=new f("SupportCaseUnsnoozedResumeStatus",["open","waiting-on-customer","waiting-on-team"]);const i=()=>({type:a.ID(),isOptional:!1});const R={workspaceRef:i(),resourceRef:i(),correlationRef:i(),receiptRef:i(),revision:{type:a.Int_unsecure(),isOptional:!1},resumeStatus:{type:m,isOptional:!1},occurredAt:{type:a.String_unsecure(),isOptional:!1},actorRef:i(),evidenceRefs:{type:a.ID(),isOptional:!1,isArray:!0}};class d extends p{getZod(){return super.getZod().strict().superRefine((e,s)=>{const n=e,r={addIssue:(t)=>s.addIssue(t)};for(const t of["workspaceRef","resourceRef","correlationRef","receiptRef","actorRef"])if(!u(n[t]))o(r,t,`${t} is invalid`);if(!Number.isSafeInteger(n.revision)||Number(n.revision)<1)o(r,"revision","revision must be positive");if(!y(n.occurredAt))o(r,"occurredAt","occurredAt must be canonical ISO time");g(n.evidenceRefs,r)})}}export const SupportCaseUnsnoozedEventPayloadModel=new d({name:"SupportCaseUnsnoozedEventPayloadV1",fields:R});function u(e){return typeof e==="string"&&l.test(e)}function y(e){if(typeof e!=="string"||e.length>64)return!1;const s=Date.parse(e);return Number.isFinite(s)&&new Date(s).toISOString()===e}function g(e,s){if(!Array.isArray(e)||e.length>c){o(s,"evidenceRefs",`evidenceRefs must contain at most ${c} references`);return}if(!e.every(u)||new Set(e).size!==e.length)o(s,"evidenceRefs","evidenceRefs must contain unique bounded references")}function o(e,s,n){e.addIssue({code:"custom",path:[s],message:n})}

package/dist/customer-support/case-lifecycle.d.ts

@@ -0,0 +1,268 @@
+import { SchemaModel, type SchemaModelFieldsAnyConfig } from '@lssm/lib.schema';
+import type { SupportCaseProjection, SupportCaseStatus } from './core.js';
+import type { SupportAuthorityScope } from './ports.js';
+export { SupportCaseUnsnoozedEventPayloadModel } from './case-lifecycle-event-schemas.js';
+export interface SupportCaseSnoozeMutationInput {
+    readonly caseRef: string;
+    readonly snoozeUntil: string;
+    readonly expectedRevision: number;
+    readonly idempotencyKey: string;
+    readonly evidenceRefs: readonly string[];
+}
+export interface SupportCaseArchiveMutationInput {
+    readonly caseRef: string;
+    readonly expectedRevision: number;
+    readonly idempotencyKey: string;
+    readonly evidenceRefs: readonly string[];
+}
+export interface SupportCaseLifecycleMutationResult {
+    readonly projection: SupportCaseProjection;
+    readonly receiptRef: string;
+}
+export interface SupportCaseLifecycleAuthorityPort {
+    snoozeCase(scope: SupportAuthorityScope, input: SupportCaseSnoozeMutationInput): Promise<SupportCaseLifecycleMutationResult>;
+    archiveCase(scope: SupportAuthorityScope, input: SupportCaseArchiveMutationInput): Promise<SupportCaseLifecycleMutationResult>;
+    unsnoozeCase(input: {
+        readonly scope: SupportAuthorityScope;
+        readonly caseRef: string;
+        readonly expectedRevision: number;
+        readonly resumeStatus: Exclude<SupportCaseStatus, 'snoozed' | 'archived'>;
+        readonly effectIdempotencyKey: string;
+    }): Promise<SupportCaseLifecycleMutationResult>;
+}
+export interface SupportCaseArchiveGovernancePort {
+    verify(input: {
+        readonly scope: SupportAuthorityScope;
+        readonly caseRef: string;
+        readonly expectedRevision: number;
+        readonly evidenceRefs: readonly string[];
+        readonly observedAt: string;
+    }): Promise<{
+        readonly allowed: boolean;
+        readonly evidenceRef: string;
+        readonly expiresAt: string;
+    }>;
+}
+declare class StrictLifecycleSchema<Fields extends SchemaModelFieldsAnyConfig> extends SchemaModel<Fields> {
+    getZod(): ReturnType<SchemaModel<Fields>['getZod']>;
+}
+export declare const SupportCaseSnoozeInputV2: StrictLifecycleSchema<{
+    caseRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    expectedRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    idempotencyKey: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    evidenceRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+    snoozeUntil: {
+        type: import("@lssm/lib.schema").FieldType<Date, string>;
+        isOptional: boolean;
+    };
+}>;
+export declare const SupportCaseArchiveInputV2: StrictLifecycleSchema<{
+    caseRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    expectedRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    idempotencyKey: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    evidenceRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+}>;
+export declare const SupportCaseLifecycleDocBlock: {
+    id: string;
+    title: string;
+    summary: string;
+    kind: "reference";
+    visibility: "public";
+    route: string;
+    tags: string[];
+    body: string;
+};
+export declare const SupportCaseLifecycleDocRef: import("../docs").DocId;
+export declare const SupportCaseSnoozeCommandV2: import("..").OperationSpec<SchemaModel<{
+    caseRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    expectedRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    idempotencyKey: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    evidenceRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+    snoozeUntil: {
+        type: import("@lssm/lib.schema").FieldType<Date, string>;
+        isOptional: boolean;
+    };
+}>, SchemaModel<{
+    resourceRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    revision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: true;
+    };
+    receiptRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    status: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    projection: {
+        type: import("@lssm/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+}>, undefined>;
+export declare const SupportCaseArchiveCommandV2: import("..").OperationSpec<SchemaModel<{
+    caseRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    expectedRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    idempotencyKey: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    evidenceRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+}>, SchemaModel<{
+    resourceRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    revision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: true;
+    };
+    receiptRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    status: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    projection: {
+        type: import("@lssm/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+}>, undefined>;
+export declare const supportCaseLifecycleOperations: readonly [import("..").OperationSpec<SchemaModel<{
+    caseRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    expectedRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    idempotencyKey: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    evidenceRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+    snoozeUntil: {
+        type: import("@lssm/lib.schema").FieldType<Date, string>;
+        isOptional: boolean;
+    };
+}>, SchemaModel<{
+    resourceRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    revision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: true;
+    };
+    receiptRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    status: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    projection: {
+        type: import("@lssm/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+}>, undefined>, import("..").OperationSpec<SchemaModel<{
+    caseRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    expectedRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    idempotencyKey: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    evidenceRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+}>, SchemaModel<{
+    resourceRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    revision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: true;
+    };
+    receiptRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    status: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    projection: {
+        type: import("@lssm/lib.schema").FieldType<Record<string, unknown>, Record<string, unknown>>;
+        isOptional: true;
+    };
+}>, undefined>];

package/dist/customer-support/case-lifecycle.js

@@ -0,0 +1,8 @@
+import{ScalarTypeEnum as r,SchemaModel as a}from"@lssm/lib.schema";import{docRef as p}from"../docs/registry.js";import{defineCommand as c}from"../operations/index.js";import{SupportMutationOutput as u,supportOperationErrors as d}from"./operation-schemas.js";export{SupportCaseUnsnoozedEventPayloadModel}from"./case-lifecycle-event-schemas.js";const n={caseRef:{type:r.ID(),isOptional:!1},expectedRevision:{type:r.Int_unsecure(),isOptional:!1},idempotencyKey:{type:r.ID(),isOptional:!1},evidenceRefs:{type:r.ID(),isOptional:!1,isArray:!0}};class s extends a{getZod(){return super.getZod().strict().superRefine((t,e)=>{const o=t;if(!Number.isSafeInteger(o.expectedRevision)||Number(o.expectedRevision)<0)e.addIssue({code:"custom",path:["expectedRevision"],message:"expectedRevision must be nonnegative"});if(typeof o.caseRef!=="string"||!o.caseRef.trim()||typeof o.idempotencyKey!=="string"||!o.idempotencyKey.trim())e.addIssue({code:"custom",message:"caseRef and idempotencyKey are required"})})}}const l={...n,snoozeUntil:{type:r.DateTime(),isOptional:!1}};export const SupportCaseSnoozeInputV2=new s({name:"SupportCaseSnoozeInputV2",fields:l});export const SupportCaseArchiveInputV2=new s({name:"SupportCaseArchiveInputV2",fields:n});export const SupportCaseLifecycleDocBlock={id:"docs.customer-support.case-lifecycle",title:"SupportOS durable case lifecycle",summary:"Revision-fenced snooze, automatic resume, and archive semantics.",kind:"reference",visibility:"public",route:"/docs/customer-support/case-lifecycle",tags:["supportos","cases","snooze","archive"],body:`# SupportOS durable case lifecycle
+
+Snooze and archive mutations derive authority from server context, require an
+idempotency key and current case revision, and append immutable events. Snooze
+persists the prior service state and atomically emits a fenced unsnooze job.
+Hosts must register the matching durable handler before enabling automatic
+resume. Archive is terminal and cannot be used as a substitute for erasure.
+`};export const SupportCaseLifecycleDocRef=p(SupportCaseLifecycleDocBlock.id);const y=(t,e)=>({key:t,version:"2.0.0",title:e,description:`${e} with revision fencing and immutable lifecycle evidence.`,goal:e,context:"Tenant and workspace authority come from authenticated server context.",domain:"customer-support",owners:["platform.support"],tags:["support","supportos","case-lifecycle-v2"],stability:"experimental",docId:[SupportCaseLifecycleDocRef]});function i(t,e,o){return c({meta:y(t,e),io:{input:o,output:u,errors:d},policy:{auth:"user",pii:[]}})}export const SupportCaseSnoozeCommandV2=i("support.case.snooze","Snooze support case",SupportCaseSnoozeInputV2);export const SupportCaseArchiveCommandV2=i("support.case.archive","Archive support case",SupportCaseArchiveInputV2);export const supportCaseLifecycleOperations=[SupportCaseSnoozeCommandV2,SupportCaseArchiveCommandV2];