@lssm/lib.contracts-spec 17.3.2

package/dist/editions/editor/schema.d.ts

@@ -0,0 +1,246 @@
+import { z } from 'zod';
+export declare const editionEditorTreeNodeKindSchema: z.ZodEnum<{
+    credit_note: "credit_note";
+    database_projection: "database_projection";
+    edition: "edition";
+    file: "file";
+    file_projection: "file_projection";
+    form: "form";
+    hybrid_projection: "hybrid_projection";
+    invoice: "invoice";
+    knowledge_doc: "knowledge_doc";
+    note: "note";
+    policy: "policy";
+    quote: "quote";
+    subject: "subject";
+}>;
+export declare const editionEditorPresenceStatusSchema: z.ZodEnum<{
+    active: "active";
+    idle: "idle";
+    offline: "offline";
+}>;
+export declare const editionEditorChangeKindSchema: z.ZodEnum<{
+    additive: "additive";
+    breaking: "breaking";
+    migration: "migration";
+    modified: "modified";
+    none: "none";
+    rollback: "rollback";
+}>;
+export declare const editionEditorApprovalStatusSchema: z.ZodEnum<{
+    approved: "approved";
+    changes_requested: "changes_requested";
+    pending: "pending";
+    rejected: "rejected";
+}>;
+export declare const editionEditorTreeNodeSchema: z.ZodType<{
+    id: string;
+    kind: z.infer<typeof editionEditorTreeNodeKindSchema>;
+    label: string;
+    storageKind?: 'file' | 'database';
+    state?: string;
+    children: unknown[];
+}>;
+export declare const editionCollaborationPresenceSchema: z.ZodObject<{
+    actorRef: z.ZodString;
+    displayName: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        idle: "idle";
+        offline: "offline";
+    }>;
+    cursorRef: z.ZodOptional<z.ZodString>;
+    selectionRef: z.ZodOptional<z.ZodString>;
+    lastSeenAt: z.ZodString;
+}, z.core.$strict>;
+export declare const editionEditorCommentSchema: z.ZodObject<{
+    commentRef: z.ZodString;
+    actorRef: z.ZodString;
+    body: z.ZodString;
+    createdAt: z.ZodString;
+    resolved: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const editionEditorApprovalSchema: z.ZodObject<{
+    approvalRef: z.ZodString;
+    actorRef: z.ZodString;
+    status: z.ZodEnum<{
+        approved: "approved";
+        changes_requested: "changes_requested";
+        pending: "pending";
+        rejected: "rejected";
+    }>;
+    policyDecisionRef: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strict>;
+export declare const editionEditorTimelineItemSchema: z.ZodObject<{
+    eventRef: z.ZodString;
+    label: z.ZodString;
+    at: z.ZodString;
+    actorRef: z.ZodString;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const editionDiffReviewViewModelSchema: z.ZodObject<{
+    baseEditionRef: z.ZodOptional<z.ZodString>;
+    currentEditionRef: z.ZodString;
+    changeKind: z.ZodEnum<{
+        additive: "additive";
+        breaking: "breaking";
+        migration: "migration";
+        modified: "modified";
+        none: "none";
+        rollback: "rollback";
+    }>;
+    summary: z.ZodString;
+    affectedRefs: z.ZodArray<z.ZodString>;
+    comments: z.ZodArray<z.ZodObject<{
+        commentRef: z.ZodString;
+        actorRef: z.ZodString;
+        body: z.ZodString;
+        createdAt: z.ZodString;
+        resolved: z.ZodBoolean;
+    }, z.core.$strict>>;
+    approvals: z.ZodArray<z.ZodObject<{
+        approvalRef: z.ZodString;
+        actorRef: z.ZodString;
+        status: z.ZodEnum<{
+            approved: "approved";
+            changes_requested: "changes_requested";
+            pending: "pending";
+            rejected: "rejected";
+        }>;
+        policyDecisionRef: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+    policyDecisionRefs: z.ZodArray<z.ZodString>;
+    canApplyReversible: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const editionEvidencePanelViewModelSchema: z.ZodObject<{
+    connectVerdictRefs: z.ZodArray<z.ZodString>;
+    testEvidenceRefs: z.ZodArray<z.ZodString>;
+    replayEvidenceRefs: z.ZodArray<z.ZodString>;
+    rollbackEvidenceRefs: z.ZodArray<z.ZodString>;
+    promotionEvidenceRefs: z.ZodArray<z.ZodString>;
+    migrationRefs: z.ZodArray<z.ZodString>;
+    experimentRefs: z.ZodArray<z.ZodString>;
+    policyDecisionRefs: z.ZodArray<z.ZodString>;
+    harnessRunRefs: z.ZodArray<z.ZodString>;
+    knowledgeProvenanceRefs: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const editionAiProposalReviewViewModelSchema: z.ZodObject<{
+    proposalRef: z.ZodString;
+    aiRunRef: z.ZodString;
+    risk: z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+    suggestedPatchRef: z.ZodOptional<z.ZodString>;
+    reversibleApplyPlanRef: z.ZodOptional<z.ZodString>;
+    knowledgeProvenanceRefs: z.ZodArray<z.ZodString>;
+    policyDecisionRefs: z.ZodArray<z.ZodString>;
+    requiresHumanApproval: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const editionEditorViewModelSchema: z.ZodObject<{
+    viewId: z.ZodString;
+    workspaceRef: z.ZodString;
+    activeEdition: z.ZodType<import("..").EditionLifecycle, unknown, z.core.$ZodTypeInternals<import("..").EditionLifecycle, unknown>>;
+    tree: z.ZodArray<z.ZodType<{
+        id: string;
+        kind: z.infer<typeof editionEditorTreeNodeKindSchema>;
+        label: string;
+        storageKind?: 'file' | 'database';
+        state?: string;
+        children: unknown[];
+    }, unknown, z.core.$ZodTypeInternals<{
+        id: string;
+        kind: z.infer<typeof editionEditorTreeNodeKindSchema>;
+        label: string;
+        storageKind?: 'file' | 'database';
+        state?: string;
+        children: unknown[];
+    }, unknown>>>;
+    validationIssues: z.ZodArray<z.ZodObject<{
+        path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    evidence: z.ZodObject<{
+        connectVerdictRefs: z.ZodArray<z.ZodString>;
+        testEvidenceRefs: z.ZodArray<z.ZodString>;
+        replayEvidenceRefs: z.ZodArray<z.ZodString>;
+        rollbackEvidenceRefs: z.ZodArray<z.ZodString>;
+        promotionEvidenceRefs: z.ZodArray<z.ZodString>;
+        migrationRefs: z.ZodArray<z.ZodString>;
+        experimentRefs: z.ZodArray<z.ZodString>;
+        policyDecisionRefs: z.ZodArray<z.ZodString>;
+        harnessRunRefs: z.ZodArray<z.ZodString>;
+        knowledgeProvenanceRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    diff: z.ZodObject<{
+        baseEditionRef: z.ZodOptional<z.ZodString>;
+        currentEditionRef: z.ZodString;
+        changeKind: z.ZodEnum<{
+            additive: "additive";
+            breaking: "breaking";
+            migration: "migration";
+            modified: "modified";
+            none: "none";
+            rollback: "rollback";
+        }>;
+        summary: z.ZodString;
+        affectedRefs: z.ZodArray<z.ZodString>;
+        comments: z.ZodArray<z.ZodObject<{
+            commentRef: z.ZodString;
+            actorRef: z.ZodString;
+            body: z.ZodString;
+            createdAt: z.ZodString;
+            resolved: z.ZodBoolean;
+        }, z.core.$strict>>;
+        approvals: z.ZodArray<z.ZodObject<{
+            approvalRef: z.ZodString;
+            actorRef: z.ZodString;
+            status: z.ZodEnum<{
+                approved: "approved";
+                changes_requested: "changes_requested";
+                pending: "pending";
+                rejected: "rejected";
+            }>;
+            policyDecisionRef: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
+        policyDecisionRefs: z.ZodArray<z.ZodString>;
+        canApplyReversible: z.ZodBoolean;
+    }, z.core.$strict>;
+    proposal: z.ZodOptional<z.ZodObject<{
+        proposalRef: z.ZodString;
+        aiRunRef: z.ZodString;
+        risk: z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+        }>;
+        suggestedPatchRef: z.ZodOptional<z.ZodString>;
+        reversibleApplyPlanRef: z.ZodOptional<z.ZodString>;
+        knowledgeProvenanceRefs: z.ZodArray<z.ZodString>;
+        policyDecisionRefs: z.ZodArray<z.ZodString>;
+        requiresHumanApproval: z.ZodBoolean;
+    }, z.core.$strict>>;
+    presence: z.ZodArray<z.ZodObject<{
+        actorRef: z.ZodString;
+        displayName: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            idle: "idle";
+            offline: "offline";
+        }>;
+        cursorRef: z.ZodOptional<z.ZodString>;
+        selectionRef: z.ZodOptional<z.ZodString>;
+        lastSeenAt: z.ZodString;
+    }, z.core.$strict>>;
+    timeline: z.ZodArray<z.ZodObject<{
+        eventRef: z.ZodString;
+        label: z.ZodString;
+        at: z.ZodString;
+        actorRef: z.ZodString;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;

package/dist/editions/editor/schema.js

@@ -0,0 +1 @@
+import{z as e}from"zod";import{editionLifecycleSchema as i}from"../validation.js";export const editionEditorTreeNodeKindSchema=e.enum(["subject","invoice","quote","credit_note","file","form","note","policy","knowledge_doc","edition","file_projection","database_projection","hybrid_projection"]);export const editionEditorPresenceStatusSchema=e.enum(["active","idle","offline"]);export const editionEditorChangeKindSchema=e.enum(["none","additive","modified","breaking","migration","rollback"]);export const editionEditorApprovalStatusSchema=e.enum(["pending","approved","changes_requested","rejected"]);export const editionEditorTreeNodeSchema=e.lazy(()=>e.object({id:e.string().min(1),kind:editionEditorTreeNodeKindSchema,label:e.string().min(1),storageKind:e.enum(["file","database"]).optional(),state:e.string().min(1).optional(),children:e.array(editionEditorTreeNodeSchema)}).strict());export const editionCollaborationPresenceSchema=e.object({actorRef:e.string().min(1),displayName:e.string().min(1),status:editionEditorPresenceStatusSchema,cursorRef:e.string().min(1).optional(),selectionRef:e.string().min(1).optional(),lastSeenAt:e.string().min(1)}).strict();export const editionEditorCommentSchema=e.object({commentRef:e.string().min(1),actorRef:e.string().min(1),body:e.string().min(1),createdAt:e.string().min(1),resolved:e.boolean()}).strict();export const editionEditorApprovalSchema=e.object({approvalRef:e.string().min(1),actorRef:e.string().min(1),status:editionEditorApprovalStatusSchema,policyDecisionRef:e.string().min(1).optional(),createdAt:e.string().min(1)}).strict();export const editionEditorTimelineItemSchema=e.object({eventRef:e.string().min(1),label:e.string().min(1),at:e.string().min(1),actorRef:e.string().min(1),evidenceRefs:e.array(e.string().min(1))}).strict();export const editionDiffReviewViewModelSchema=e.object({baseEditionRef:e.string().min(1).optional(),currentEditionRef:e.string().min(1),changeKind:editionEditorChangeKindSchema,summary:e.string().min(1),affectedRefs:e.array(e.string().min(1)),comments:e.array(editionEditorCommentSchema),approvals:e.array(editionEditorApprovalSchema),policyDecisionRefs:e.array(e.string().min(1)),canApplyReversible:e.boolean()}).strict();export const editionEvidencePanelViewModelSchema=e.object({connectVerdictRefs:e.array(e.string().min(1)),testEvidenceRefs:e.array(e.string().min(1)),replayEvidenceRefs:e.array(e.string().min(1)),rollbackEvidenceRefs:e.array(e.string().min(1)),promotionEvidenceRefs:e.array(e.string().min(1)),migrationRefs:e.array(e.string().min(1)),experimentRefs:e.array(e.string().min(1)),policyDecisionRefs:e.array(e.string().min(1)),harnessRunRefs:e.array(e.string().min(1)),knowledgeProvenanceRefs:e.array(e.string().min(1))}).strict();export const editionAiProposalReviewViewModelSchema=e.object({proposalRef:e.string().min(1),aiRunRef:e.string().min(1),risk:e.enum(["low","medium","high"]),suggestedPatchRef:e.string().min(1).optional(),reversibleApplyPlanRef:e.string().min(1).optional(),knowledgeProvenanceRefs:e.array(e.string().min(1)),policyDecisionRefs:e.array(e.string().min(1)),requiresHumanApproval:e.boolean()}).strict();export const editionEditorViewModelSchema=e.object({viewId:e.string().min(1),workspaceRef:e.string().min(1),activeEdition:i,tree:e.array(editionEditorTreeNodeSchema),validationIssues:e.array(e.object({path:e.array(e.union([e.string(),e.number()])),message:e.string()})),evidence:editionEvidencePanelViewModelSchema,diff:editionDiffReviewViewModelSchema,proposal:editionAiProposalReviewViewModelSchema.optional(),presence:e.array(editionCollaborationPresenceSchema),timeline:e.array(editionEditorTimelineItemSchema)}).strict();

package/dist/editions/editor/types.d.ts

@@ -0,0 +1,100 @@
+import type { EditionLifecycle, EditionStorageKind, EditionValidationIssue } from '../types.js';
+export type EditionEditorNodeKind = 'subject' | 'invoice' | 'quote' | 'credit_note' | 'file' | 'form' | 'note' | 'policy' | 'knowledge_doc' | 'edition' | 'file_projection' | 'database_projection' | 'hybrid_projection';
+export type EditionEditorPresenceStatus = 'active' | 'idle' | 'offline';
+export type EditionEditorChangeKind = 'none' | 'additive' | 'modified' | 'breaking' | 'migration' | 'rollback';
+export type EditionEditorApprovalStatus = 'pending' | 'approved' | 'changes_requested' | 'rejected';
+export interface EditionEditorTreeNode {
+    id: string;
+    kind: EditionEditorNodeKind;
+    label: string;
+    storageKind?: EditionStorageKind;
+    state?: EditionLifecycle['identity']['state'];
+    children: EditionEditorTreeNode[];
+}
+export interface EditionCollaborationPresence {
+    actorRef: string;
+    displayName: string;
+    status: EditionEditorPresenceStatus;
+    cursorRef?: string;
+    selectionRef?: string;
+    lastSeenAt: string;
+}
+export interface EditionEditorComment {
+    commentRef: string;
+    actorRef: string;
+    body: string;
+    createdAt: string;
+    resolved: boolean;
+}
+export interface EditionEditorApproval {
+    approvalRef: string;
+    actorRef: string;
+    status: EditionEditorApprovalStatus;
+    policyDecisionRef?: string;
+    createdAt: string;
+}
+export interface EditionEditorTimelineItem {
+    eventRef: string;
+    label: string;
+    at: string;
+    actorRef: string;
+    evidenceRefs: string[];
+}
+export interface EditionDiffReviewViewModel {
+    baseEditionRef?: string;
+    currentEditionRef: string;
+    changeKind: EditionEditorChangeKind;
+    summary: string;
+    affectedRefs: string[];
+    comments: EditionEditorComment[];
+    approvals: EditionEditorApproval[];
+    policyDecisionRefs: string[];
+    canApplyReversible: boolean;
+}
+export interface EditionEvidencePanelViewModel {
+    connectVerdictRefs: string[];
+    testEvidenceRefs: string[];
+    replayEvidenceRefs: string[];
+    rollbackEvidenceRefs: string[];
+    promotionEvidenceRefs: string[];
+    migrationRefs: string[];
+    experimentRefs: string[];
+    policyDecisionRefs: string[];
+    harnessRunRefs: string[];
+    knowledgeProvenanceRefs: string[];
+}
+export interface EditionAiProposalReviewViewModel {
+    proposalRef: string;
+    aiRunRef: string;
+    risk: 'low' | 'medium' | 'high';
+    suggestedPatchRef?: string;
+    reversibleApplyPlanRef?: string;
+    knowledgeProvenanceRefs: string[];
+    policyDecisionRefs: string[];
+    requiresHumanApproval: boolean;
+}
+export interface EditionEditorViewModel {
+    viewId: string;
+    workspaceRef: string;
+    activeEdition: EditionLifecycle;
+    tree: EditionEditorTreeNode[];
+    validationIssues: EditionValidationIssue[];
+    evidence: EditionEvidencePanelViewModel;
+    diff: EditionDiffReviewViewModel;
+    proposal?: EditionAiProposalReviewViewModel;
+    presence: EditionCollaborationPresence[];
+    timeline: EditionEditorTimelineItem[];
+}
+export interface ResolveEditionEditorViewInput {
+    edition: EditionLifecycle;
+    workspaceRef: string;
+    baseEditionRef?: string;
+    validationIssues?: EditionValidationIssue[];
+    presence?: EditionCollaborationPresence[];
+    comments?: EditionEditorComment[];
+    approvals?: EditionEditorApproval[];
+    timeline?: EditionEditorTimelineItem[];
+    proposal?: EditionAiProposalReviewViewModel;
+    harnessRunRefs?: string[];
+    knowledgeProvenanceRefs?: string[];
+}

package/dist/editions/enterprise-guardrails.d.ts

@@ -0,0 +1,25 @@
+export interface EditionEnterpriseGuardrailContext {
+    contextRef: string;
+    tenantRef: string;
+    workspaceRef: string;
+    verticalRef: string;
+    actorRef: string;
+    policyDecisionRefs: string[];
+    auditEventRefs: string[];
+    redactionRefs: string[];
+    tenantIsolationRefs: string[];
+    observabilityRefs: string[];
+    evidenceRefs: string[];
+}
+export interface EditionEnterpriseGuardrailResult {
+    ready: boolean;
+    missingKinds: string[];
+    auditTrailRefs: string[];
+    policyDecisionRefs: string[];
+    redactionRefs: string[];
+    observabilityRefs: string[];
+}
+export declare function evaluateEditionEnterpriseGuardrails(input: {
+    context: EditionEnterpriseGuardrailContext;
+}): EditionEnterpriseGuardrailResult;
+export declare const ManagedCompanyOsEnterpriseGuardrailContextFixture: EditionEnterpriseGuardrailContext;

package/dist/editions/enterprise-guardrails.js

@@ -0,0 +1 @@
+export function evaluateEditionEnterpriseGuardrails(e){const t=[];n(t,"policy",e.context.policyDecisionRefs);n(t,"audit",e.context.auditEventRefs);n(t,"redaction",e.context.redactionRefs);n(t,"tenant-isolation",e.context.tenantIsolationRefs);n(t,"observability",e.context.observabilityRefs);n(t,"evidence",e.context.evidenceRefs);if(!e.context.tenantRef.startsWith("tenant:"))t.push("tenant-ref");const o=`isolation:${e.context.tenantRef}`;if(!e.context.tenantIsolationRefs.includes(o))t.push("tenant-isolation-match");if(!e.context.workspaceRef.startsWith("workspace:"))t.push("workspace-ref");return{ready:t.length===0,missingKinds:t,auditTrailRefs:i([...e.context.auditEventRefs,...e.context.evidenceRefs]),policyDecisionRefs:e.context.policyDecisionRefs,redactionRefs:e.context.redactionRefs,observabilityRefs:e.context.observabilityRefs}}export const ManagedCompanyOsEnterpriseGuardrailContextFixture={contextRef:"enterprise:companyos:contract-editions:guardrails",tenantRef:"tenant:managed-companyos-acme",workspaceRef:"workspace:managed-companyos",verticalRef:"vertical:managed-companyos",actorRef:"actor:contract-steward",policyDecisionRefs:["policy-decision:companyos:connect-full-loop","policy-decision:knowledge:companyos:read"],auditEventRefs:["audit:companyos:full-loop:started","audit:improvement:customer-profile:db-v2-copy-tune:evaluated"],redactionRefs:["redaction:companyos:customer-pii:masked"],tenantIsolationRefs:["isolation:tenant:managed-companyos-acme"],observabilityRefs:["trace:companyos:contract-edition-full-loop","metric:companyos:contract-edition-latency"],evidenceRefs:["harness-run:companyos:contract-edition-full-loop","replay:companyos:contract-edition-full-loop"]};function n(e,t,o){if(!o.length)e.push(t)}function i(e){return Array.from(new Set(e))}

package/dist/editions/evidence-boundary.d.ts

@@ -0,0 +1,10 @@
+export type EditionEvidenceSystem = 'harness' | 'replay' | 'connect' | 'knowledge' | 'policy' | 'audit' | 'rollback' | 'metric' | 'artifact' | 'trace' | 'redaction' | 'isolation' | 'coach' | 'release';
+export interface EditionEvidenceBoundaryReport {
+    valid: boolean;
+    unknownRefs: string[];
+    coverage: Record<EditionEvidenceSystem, string[]>;
+}
+export declare function evaluateEditionEvidenceBoundary(input: {
+    evidenceRefs: string[];
+    requiredSystems: EditionEvidenceSystem[];
+}): EditionEvidenceBoundaryReport;

package/dist/editions/evidence-boundary.js

@@ -0,0 +1 @@
+export function evaluateEditionEvidenceBoundary(e){const i=d(),r=[];for(const t of e.evidenceRefs){const c=a(t);if(!c){r.push(t);continue}i[c].push(t)}const o=e.requiredSystems.filter((t)=>i[t].length===0);return{valid:r.length===0&&o.length===0,unknownRefs:[...r,...o.map((t)=>`${t}:missing`)],coverage:i}}function a(e){if(s(e))return;if(n(e,"harness-run:"))return"harness";if(n(e,"replay:"))return"replay";if(n(e,"connect:"))return"connect";if(n(e,"knowledge:")||n(e,"knowledge-evidence:")||n(e,"knowledge-query:")||n(e,"canon:"))return"knowledge";if(n(e,"policy-decision:"))return"policy";if(n(e,"audit:"))return"audit";if(n(e,"rollback:"))return"rollback";if(n(e,"metric:"))return"metric";if(n(e,"artifact:"))return"artifact";if(n(e,"trace:"))return"trace";if(n(e,"redaction:"))return"redaction";if(n(e,"isolation:"))return"isolation";if(n(e,"coach.suggestion.offered:"))return"coach";if(n(e,"release:"))return"release";return}function n(e,i){return e.startsWith(i)&&e.slice(i.length).trim().length>0}function s(e){return/[*?[\]{}]/u.test(e)}function d(){return{harness:[],replay:[],connect:[],knowledge:[],policy:[],audit:[],rollback:[],metric:[],artifact:[],trace:[],redaction:[],isolation:[],coach:[],release:[]}}

package/dist/editions/experiments.d.ts

@@ -0,0 +1,57 @@
+import type { EditionLifecycle } from './types.js';
+export type EditionExperimentStatus = 'draft' | 'running' | 'paused' | 'winner_selected' | 'promoted' | 'rolled_back';
+export interface EditionExperimentVariantBinding {
+    variantRef: string;
+    editionRef: string;
+    allocation: number;
+    activeScopeRefs: string[];
+    metricEvidenceRefs: string[];
+    rollbackReady: boolean;
+}
+export interface EditionExperimentBinding {
+    experimentRef: string;
+    status: EditionExperimentStatus;
+    controlVariantRef: string;
+    variants: EditionExperimentVariantBinding[];
+    policyDecisionRefs: string[];
+    connectVerdictRefs: string[];
+    harnessRunRefs: string[];
+    testEvidenceRefs: string[];
+    replayEvidenceRefs: string[];
+    promotionEvidenceRefs: string[];
+}
+export interface EditionExperimentMetricState {
+    metricRef: string;
+    label: string;
+    status: 'missing' | 'collecting' | 'ready';
+    winnerVariantRef?: string;
+    evidenceRefs: string[];
+}
+export interface EditionPromotionReadiness {
+    ready: boolean;
+    winnerVariantRef?: string;
+    missingEvidenceKinds: string[];
+    requiredEvidenceRefs: string[];
+}
+export interface EditionExperimentDashboardViewModel {
+    dashboardId: string;
+    experiment: EditionExperimentBinding;
+    activeEdition: EditionLifecycle;
+    metrics: EditionExperimentMetricState[];
+    promotionReadiness: EditionPromotionReadiness;
+    rollbackReadyVariantRefs: string[];
+}
+export declare function evaluateEditionPromotionReadiness(input: {
+    experiment: EditionExperimentBinding;
+    metrics: EditionExperimentMetricState[];
+    winnerVariantRef?: string;
+    requiredEvidenceRefs: string[];
+}): EditionPromotionReadiness;
+export declare function resolveEditionExperimentDashboard(input: {
+    experiment: EditionExperimentBinding;
+    activeEdition: EditionLifecycle;
+    metrics: EditionExperimentMetricState[];
+    requiredEvidenceRefs: string[];
+}): EditionExperimentDashboardViewModel;
+export declare const ManagedCompanyOsEditionExperimentBindingFixture: EditionExperimentBinding;
+export declare const ManagedCompanyOsEditionExperimentMetricsFixture: EditionExperimentMetricState[];

package/dist/editions/experiments.js

@@ -0,0 +1 @@
+export function evaluateEditionPromotionReadiness(e){const i=e.winnerVariantRef??a(e.metrics),t=e.experiment.variants.find((r)=>r.variantRef===i),n=[];if(!i||!t)n.push("winner");if(!t?.rollbackReady)n.push("rollback");if(!["winner_selected","promoted"].includes(e.experiment.status))n.push("experiment-status");const o=e.experiment.variants.reduce((r,s)=>r+s.allocation,0);if(Math.abs(o-1)>0.001)n.push("allocation");if(e.experiment.variants.some((r)=>!r.activeScopeRefs.length))n.push("scope");if(!e.experiment.connectVerdictRefs.length)n.push("connect");if(!e.experiment.policyDecisionRefs.length)n.push("policy");if(!e.experiment.harnessRunRefs.length)n.push("harness");if(!e.experiment.testEvidenceRefs.length)n.push("test");if(!e.experiment.replayEvidenceRefs.length)n.push("replay");if(!e.experiment.promotionEvidenceRefs.length)n.push("promotion");for(const r of e.requiredEvidenceRefs)if(!c(e,r))n.push(r);return{ready:n.length===0,winnerVariantRef:i,missingEvidenceKinds:n,requiredEvidenceRefs:e.requiredEvidenceRefs}}export function resolveEditionExperimentDashboard(e){const i=evaluateEditionPromotionReadiness({experiment:e.experiment,metrics:e.metrics,requiredEvidenceRefs:e.requiredEvidenceRefs});return{dashboardId:`edition-experiment:${e.experiment.experimentRef}`,experiment:e.experiment,activeEdition:e.activeEdition,metrics:e.metrics,promotionReadiness:i,rollbackReadyVariantRefs:e.experiment.variants.filter((t)=>t.rollbackReady).map((t)=>t.variantRef)}}export const ManagedCompanyOsEditionExperimentBindingFixture={experimentRef:"experiment:customer-profile-redesign:v1",status:"winner_selected",controlVariantRef:"variant:file-v1",variants:[{variantRef:"variant:file-v1",editionRef:"companyos.customer-profile.file.v1",allocation:0.5,activeScopeRefs:["vertical:managed-companyos-core"],metricEvidenceRefs:["metric:customer-profile:file-v1:conversion"],rollbackReady:!0},{variantRef:"variant:db-v2-growth",editionRef:"companyos.customer-profile.db.experiment.v2",allocation:0.5,activeScopeRefs:["vertical:managed-companyos-growth"],metricEvidenceRefs:["metric:customer-profile:db-v2:conversion"],rollbackReady:!0}],policyDecisionRefs:["policy-decision:companyos:experiment-promotion"],connectVerdictRefs:["connect:companyos:experiment-promotion:permit"],harnessRunRefs:["harness-run:customer-profile-experiment"],testEvidenceRefs:["test:customer-profile-experiment"],replayEvidenceRefs:["replay:customer-profile-experiment"],promotionEvidenceRefs:["promotion:companyos:db-experiment:approved"]};export const ManagedCompanyOsEditionExperimentMetricsFixture=[{metricRef:"metric:customer-profile:conversion",label:"Customer profile completion conversion",status:"ready",winnerVariantRef:"variant:db-v2-growth",evidenceRefs:["metric:customer-profile:db-v2:conversion"]}];function a(e){return e.find((i)=>i.status==="ready")?.winnerVariantRef}function c(e,i){return e.experiment.connectVerdictRefs.includes(i)||e.experiment.policyDecisionRefs.includes(i)||e.experiment.harnessRunRefs.includes(i)||e.experiment.testEvidenceRefs.includes(i)||e.experiment.replayEvidenceRefs.includes(i)||e.experiment.promotionEvidenceRefs.includes(i)||e.experiment.variants.some((t)=>t.metricEvidenceRefs.includes(i))||e.metrics.some((t)=>t.evidenceRefs.includes(i))}

package/dist/editions/fixtures.d.ts

@@ -0,0 +1,3 @@
+import type { EditionLifecycle } from './types.js';
+export declare const ManagedCompanyOsFilePublishedEditionFixture: EditionLifecycle;
+export declare const ManagedCompanyOsDatabaseExperimentEditionFixture: EditionLifecycle;

package/dist/editions/fixtures.js

@@ -0,0 +1 @@
+export const ManagedCompanyOsFilePublishedEditionFixture={identity:{subjectKey:"companyos.contract.customer-profile",subjectType:"managed-companyos.contract",editionKind:"contract",editionId:"companyos.customer-profile.file.v1",state:"published",createdBy:"human:platform",createdAt:"2026-06-06T00:00:00.000Z"},governedFacet:{versions:{contractVersion:"1.0.0",editionVersion:"1",storageRevision:"git:main:customer-profile",releaseVersion:"2026.06.0"},lineageRefs:[],sourceRefs:["file:packages/libs/contracts-spec/src/companyos/customer.ts"],evolutionIntent:"behavior_compatible",connectVerdictRefs:["connect:companyos:file-release:permit"]},storage:{kind:"file",path:"packages/libs/contracts-spec/src/companyos/customer.ts",branch:"main",releaseCapsuleRef:"release:companyos:2026.06.0"},authority:{policyRef:"policy:companyos:file-release",scopes:["vertical","workspace","subject_class"],storageAuthority:"file",allowedModes:["suggest","draft_patch","human_approval_required"],requiresHumanApprovalFor:["breaking","migration_required"],allowsAutonomousPromotion:!1,allowsAutonomousRollback:!1,allowsDatabaseLiveIteration:!1,requiresFileMaterializationForRelease:!0},evidence:{compatibilityIntent:"behavior_compatible",connectVerdictRefs:["connect:companyos:file-release:permit"],testEvidenceRefs:["test:companyos:file-release"],replayEvidenceRefs:["replay:companyos:file-release"],rollbackEvidenceRefs:["rollback:companyos:file-release:v0"],promotionEvidenceRefs:["promotion:companyos:file-release"],migrationRefs:[],releaseRefs:["release:companyos:2026.06.0"],experimentRefs:[],policyDecisionRefs:["policy-decision:companyos:file-release"]}};export const ManagedCompanyOsDatabaseExperimentEditionFixture={identity:{subjectKey:"companyos.contract.customer-profile",subjectType:"managed-companyos.contract",editionKind:"contract",editionId:"companyos.customer-profile.db.experiment.v2",state:"experiment",createdBy:"ai:contract-steward",createdAt:"2026-06-06T00:00:00.000Z"},governedFacet:{versions:{contractVersion:"2.0.0",editionVersion:"2",storageRevision:"dbrev:customer-profile:42",experimentVersion:"exp:customer-profile-redesign:1"},lineageRefs:["companyos.customer-profile.file.v1"],sourceRefs:["db:editions/companyos.customer-profile.db.experiment.v2"],evolutionIntent:"experiment",connectVerdictRefs:["connect:companyos:db-experiment:require_review"]},storage:{kind:"database",recordRef:"db:editions/companyos.customer-profile.db.experiment.v2",workspaceRef:"workspace:managed-companyos",verticalRef:"vertical:managed-companyos-growth",collaborationSessionRefs:["collab:customer-profile-redesign"],revisionRef:"dbrev:customer-profile:42",historyRefs:["history:customer-profile:1","history:customer-profile:42"],rollbackRefs:["rollback:customer-profile:file-v1"]},hybrid:{state:"db_draft_to_file_patch",sourceStorage:"database",targetStorage:"file",sourceRef:"db:editions/companyos.customer-profile.db.experiment.v2",targetRef:"file:packages/libs/contracts-spec/src/companyos/customer.ts",authoritativeStorage:"database",selectorRef:"selector:vertical:managed-companyos-growth",resolutionPolicyRef:"policy:companyos:db-to-file-materialization",evidenceRefs:["artifact:db-draft-to-file-patch"]},authority:{policyRef:"policy:companyos:database-experiment",scopes:["vertical","workspace","subject_class","lifecycle_state"],storageAuthority:"database",allowedModes:["suggest","draft_patch","apply_reversible","mixed"],requiresHumanApprovalFor:["breaking","migration_required"],allowsAutonomousPromotion:!1,allowsAutonomousRollback:!0,allowsDatabaseLiveIteration:!0,requiresFileMaterializationForRelease:!0},evidence:{compatibilityIntent:"experiment",connectVerdictRefs:["connect:companyos:db-experiment:require_review"],testEvidenceRefs:["test:companyos:db-experiment"],replayEvidenceRefs:["replay:companyos:db-experiment"],rollbackEvidenceRefs:["rollback:customer-profile:file-v1"],promotionEvidenceRefs:["promotion:companyos:db-experiment:blocked"],migrationRefs:["migration:customer-profile:v1-to-v2"],releaseRefs:[],experimentRefs:["experiment:customer-profile-redesign:v1"],policyDecisionRefs:["policy-decision:companyos:db-experiment"]}};

package/dist/editions/full-loop-gate.d.ts

@@ -0,0 +1,6 @@
+export interface ManagedCompanyOsFullLoopGateReport {
+    ready: boolean;
+    missingKinds: string[];
+    evidenceRefs: string[];
+}
+export declare function evaluateManagedCompanyOsFullLoopGate(): ManagedCompanyOsFullLoopGateReport;

package/dist/editions/full-loop-gate.js

@@ -0,0 +1 @@
+import{resolveManagedCompanyOsFullLoopScenario as l}from"./companyos-scenario.js";import{EditionFullLoopDeliveryAssets as c,EditionFullLoopDeliveryRecords as g,evaluateEditionDeliveryAudit as m}from"./delivery-audit.js";import{evaluateEditionEvidenceBoundary as u}from"./evidence-boundary.js";import{evaluateEditionOntologyBoundary as y}from"./ontology-boundary.js";import{evaluateEditionRuntimeWiring as f}from"./runtime-wiring.js";import{evaluateEditionStorageParity as p}from"./storage-parity.js";export function evaluateManagedCompanyOsFullLoopGate(){const e=l(),s=y({editor:e.editor,dashboard:e.experimentDashboard,rollback:e.rollback,canonicalOntologyRefs:e.canonicalOntologyRefs,dataViewRefs:e.dataViewRefs}),n=f(),a=u({evidenceRefs:e.evidenceTrailRefs,requiredSystems:["harness","replay","connect","knowledge"]}),r=p({fileEditions:[e.stableFileEdition],databaseEditions:[e.databaseExperimentEdition],hybridPatchRefs:[e.hybridPatch],releaseMaterializationRefs:[e.hybridPatch.targetRef,e.releaseProjection.hybrid.targetRef]}),t=m({modules:g,assets:c}),d=[...i("ontology",s.contractBacked?[]:s.missingBindings),...i("evidence",a.valid?[]:a.unknownRefs),...i("storage",r.firstClass?[]:r.missingKinds),...i("delivery",t.complete?[]:Object.keys(t.missingByModule)),...i("runtime-wiring",n.wired?[]:n.missingKinds),...i("harness",e.harnessCoverage.ready?[]:e.harnessCoverage.missingArtifactKinds),...i("knowledge",e.knowledgeReadiness.ready?[]:e.knowledgeReadiness.missingKinds),...i("connect",e.connectGate.allowed&&e.connectGate.reviewResolved?[]:e.connectGate.missingEvidenceKinds),...i("intelligence",e.coachSurface.decisions.every((o)=>o.ready)?[]:e.coachSurface.decisions.flatMap((o)=>o.missingEvidenceKinds)),...i("enterprise",e.enterpriseGuardrailResult.ready?[]:e.enterpriseGuardrailResult.missingKinds)];return{ready:e.readyForEnterpriseReview&&d.length===0,missingKinds:d,evidenceRefs:[...e.evidenceTrailRefs,...n.operationRefs,...n.builderRefs,...n.integrationRefs]}}function i(e,s){return s.map((n)=>`${e}:${n}`)}

package/dist/editions/harness-evidence.d.ts

@@ -0,0 +1,41 @@
+import type { EvidenceArtifact, EvidenceArtifactKind, HarnessAssertionResult, HarnessRunRecord, HarnessScenarioSpec } from '../harness/types.js';
+export interface EditionHarnessEvidenceRefs {
+    harnessRunRefs: string[];
+    replayEvidenceRefs: string[];
+    testEvidenceRefs: string[];
+    artifactRefs: string[];
+}
+export interface EditionHarnessReplayEnvelope {
+    envelopeRef: string;
+    sourcePackage: '@lssm/lib.harness';
+    scenario: HarnessScenarioSpec;
+    run: HarnessRunRecord;
+    assertions: HarnessAssertionResult[];
+    artifacts: EvidenceArtifact[];
+    replayBundleRef: string;
+    coveredEditionRefs: string[];
+    evidenceRefs: EditionHarnessEvidenceRefs;
+    status: 'passed' | 'failed' | 'blocked';
+}
+export interface EditionHarnessCoverageResult {
+    ready: boolean;
+    missingArtifactKinds: EvidenceArtifactKind[];
+    failedAssertionRefs: string[];
+    blockedStepRefs: string[];
+    evidenceRefs: EditionHarnessEvidenceRefs;
+}
+export declare function createEditionHarnessReplayEnvelope(input: {
+    envelopeRef: string;
+    scenario: HarnessScenarioSpec;
+    run: HarnessRunRecord;
+    assertions: HarnessAssertionResult[];
+    artifacts: EvidenceArtifact[];
+    replayBundleRef: string;
+    coveredEditionRefs: string[];
+}): EditionHarnessReplayEnvelope;
+export declare function evaluateEditionHarnessCoverage(input: {
+    envelope: EditionHarnessReplayEnvelope;
+    requiredArtifactKinds: EvidenceArtifactKind[];
+}): EditionHarnessCoverageResult;
+export declare const ManagedCompanyOsHarnessScenarioFixture: HarnessScenarioSpec;
+export declare const ManagedCompanyOsHarnessReplayEnvelopeFixture: EditionHarnessReplayEnvelope;

package/dist/editions/harness-evidence.js

@@ -0,0 +1 @@
+export function createEditionHarnessReplayEnvelope(e){return{envelopeRef:e.envelopeRef,sourcePackage:"@lssm/lib.harness",scenario:e.scenario,run:e.run,assertions:e.assertions,artifacts:e.artifacts,replayBundleRef:e.replayBundleRef,coveredEditionRefs:e.coveredEditionRefs,evidenceRefs:{harnessRunRefs:[e.run.runId],replayEvidenceRefs:[e.replayBundleRef],testEvidenceRefs:e.assertions.map((t)=>t.assertionKey),artifactRefs:e.artifacts.map((t)=>t.artifactId)},status:o(e.run,e.assertions)}}export function evaluateEditionHarnessCoverage(e){const t=new Set(e.envelope.artifacts.map((s)=>s.kind)),n=e.requiredArtifactKinds.filter((s)=>!t.has(s)),a=e.envelope.assertions.filter((s)=>s.status==="failed").map((s)=>s.assertionKey),r=e.envelope.run.steps.filter((s)=>s.status==="blocked").map((s)=>s.stepId);return{ready:e.envelope.status==="passed"&&n.length===0&&a.length===0&&r.length===0,missingArtifactKinds:n,failedAssertionRefs:a,blockedStepRefs:r,evidenceRefs:e.envelope.evidenceRefs}}export const ManagedCompanyOsHarnessScenarioFixture={meta:{key:"harness.scenario.contract-edition.companyos-full-loop",title:"Managed CompanyOS contract edition full-loop replay",version:"1.0.0",description:"Validate editor, DB iteration, hybrid file materialization, rollback, and promotion readiness.",domain:"contracts",stability:"beta",owners:["team:contractspec"],tags:["contracts","editions","companyos"]},target:{isolation:"preview",preferredTargets:["preview","sandbox"]},allowedModes:["deterministic-browser","code-execution"],steps:[{key:"open-editor",description:"Open the realtime contract edition editor.",actionClass:"navigate",intent:"inspect editor evidence panel",expectedEvidence:["screenshot","dom-snapshot"]},{key:"run-replay",description:"Replay the edition lifecycle and rollback path.",actionClass:"code-exec-read",intent:"prove lifecycle can be replayed without mutation",expectedEvidence:["trace","step-summary"]}],assertions:[{key:"promotion-ready",type:"json-match",description:"Promotion readiness includes Connect and harness evidence."},{key:"rollback-ready",type:"step-status",description:"Rollback replay is executable."}],requiredEvidence:["screenshot","dom-snapshot","trace","step-summary"],success:{requireAllAssertions:!0,maxBlockedSteps:0}};export const ManagedCompanyOsHarnessReplayEnvelopeFixture=createEditionHarnessReplayEnvelope({envelopeRef:"harness-envelope:companyos:contract-edition-full-loop",scenario:ManagedCompanyOsHarnessScenarioFixture,run:{runId:"harness-run:companyos:contract-edition-full-loop",status:"completed",mode:"deterministic-browser",scenarioKey:ManagedCompanyOsHarnessScenarioFixture.meta.key,target:{targetId:"preview:companyos-contract-editions",kind:"preview",isolation:"preview",environment:"test"},steps:ManagedCompanyOsHarnessScenarioFixture.steps.map((e)=>({stepId:`step:${e.key}`,stepKey:e.key,runId:"harness-run:companyos:contract-edition-full-loop",mode:e.mode??"deterministic-browser",actionClass:e.actionClass,verdict:"autonomous",requiresApproval:!1,status:"completed"})),evidenceCount:4,createdAt:"2026-06-06T00:00:00.000Z",updatedAt:"2026-06-06T00:01:00.000Z"},assertions:ManagedCompanyOsHarnessScenarioFixture.assertions.map((e)=>({assertionKey:e.key,status:"passed"})),artifacts:["screenshot","dom-snapshot","trace","step-summary"].map((e)=>({artifactId:`artifact:companyos:${e}`,kind:e,runId:"harness-run:companyos:contract-edition-full-loop",uri:`harness://companyos/${e}`,createdAt:"2026-06-06T00:01:00.000Z"})),replayBundleRef:"replay:companyos:contract-edition-full-loop",coveredEditionRefs:["companyos.customer-profile.file.v1","companyos.customer-profile.db.experiment.v2"]});function o(e,t){if(e.status==="blocked")return"blocked";return e.status==="completed"&&t.every((n)=>n.status==="passed")?"passed":"failed"}

package/dist/editions/improvement-types.d.ts

@@ -0,0 +1,52 @@
+import type { EditionAuthorityMode, EditionEvolutionIntent, EditionLifecycle } from './types.js';
+export type EditionImprovementLoopMode = 'autonomous' | 'human_in_loop' | 'mixed';
+export type EditionImprovementStage = 'observe' | 'suggest' | 'draft' | 'verify' | 'review' | 'apply' | 'promote' | 'rollback' | 'blocked';
+export type EditionImprovementDecisionAction = 'suggest_only' | 'draft_patch' | 'request_human_review' | 'apply_reversible' | 'promote_candidate' | 'rollback_candidate' | 'block_candidate';
+export interface EditionImprovementCandidate {
+    candidateRef: string;
+    targetEditionRef: string;
+    intent: EditionEvolutionIntent;
+    authorityMode: EditionAuthorityMode;
+    suggestedByRef: string;
+    summary: string;
+    riskLevel: 'low' | 'medium' | 'high';
+    knowledgeProvenanceRefs: string[];
+    connectVerdictRefs: string[];
+    harnessRunRefs: string[];
+    replayEvidenceRefs: string[];
+    policyDecisionRefs: string[];
+    requiredEvidenceRefs: string[];
+    draftPatchRef?: string;
+    rollbackPlanRef?: string;
+    experimentRef?: string;
+}
+export interface EditionImprovementLoopState {
+    loopRef: string;
+    mode: EditionImprovementLoopMode;
+    stage: EditionImprovementStage;
+    activeEdition: EditionLifecycle;
+    scopeRefs: string[];
+    candidates: EditionImprovementCandidate[];
+    historyRefs: string[];
+}
+export interface EditionImprovementDecision {
+    candidateRef: string;
+    action: EditionImprovementDecisionAction;
+    stage: EditionImprovementStage;
+    ready: boolean;
+    requiresHumanReview: boolean;
+    missingEvidenceKinds: string[];
+    reasonRefs: string[];
+}
+export interface EditionImprovementLoopViewModel {
+    loopRef: string;
+    mode: EditionImprovementLoopMode;
+    stage: EditionImprovementStage;
+    activeEdition: EditionLifecycle;
+    decisions: EditionImprovementDecision[];
+    suggestionQueueRefs: string[];
+    draftQueueRefs: string[];
+    humanReviewQueueRefs: string[];
+    autonomousActionRefs: string[];
+    auditEventRefs: string[];
+}

package/dist/editions/improvement.d.ts

@@ -0,0 +1,12 @@
+import type { EditionImprovementCandidate, EditionImprovementDecision, EditionImprovementLoopMode, EditionImprovementLoopState, EditionImprovementLoopViewModel } from './improvement-types.js';
+import type { EditionLifecycle } from './types.js';
+export type { EditionImprovementCandidate, EditionImprovementDecision, EditionImprovementDecisionAction, EditionImprovementLoopMode, EditionImprovementLoopState, EditionImprovementLoopViewModel, EditionImprovementStage, } from './improvement-types.js';
+export declare function evaluateEditionImprovementCandidate(input: {
+    candidate: EditionImprovementCandidate;
+    edition: EditionLifecycle;
+    mode: EditionImprovementLoopMode;
+}): EditionImprovementDecision;
+export declare function resolveEditionImprovementLoop(input: {
+    state: EditionImprovementLoopState;
+}): EditionImprovementLoopViewModel;
+export declare const ManagedCompanyOsImprovementCandidateFixture: EditionImprovementCandidate;

package/dist/editions/improvement.js

@@ -0,0 +1 @@
+export function evaluateEditionImprovementCandidate(e){const o=a(e.candidate),t=d(e),n=s({candidate:e.candidate,edition:e.edition,mode:e.mode,missingEvidenceKinds:o,requiresHumanReview:t});return{candidateRef:e.candidate.candidateRef,action:n,stage:c(n),ready:n!=="block_candidate"&&o.length===0,requiresHumanReview:t,missingEvidenceKinds:o,reasonRefs:m(e.candidate,o)}}export function resolveEditionImprovementLoop(e){const o=e.state.candidates.map((t)=>evaluateEditionImprovementCandidate({candidate:t,edition:e.state.activeEdition,mode:e.state.mode}));return{loopRef:e.state.loopRef,mode:e.state.mode,stage:e.state.stage,activeEdition:e.state.activeEdition,decisions:o,suggestionQueueRefs:r(o,"suggest_only"),draftQueueRefs:r(o,"draft_patch"),humanReviewQueueRefs:r(o,"request_human_review"),autonomousActionRefs:o.filter((t)=>["apply_reversible","promote_candidate","rollback_candidate"].includes(t.action)).map((t)=>t.candidateRef),auditEventRefs:[...e.state.historyRefs,...o.flatMap((t)=>t.reasonRefs)]}}export const ManagedCompanyOsImprovementCandidateFixture={candidateRef:"improvement:customer-profile:db-v2-copy-tune",targetEditionRef:"companyos.customer-profile.db.experiment.v2",intent:"behavior_compatible",authorityMode:"apply_reversible",suggestedByRef:"intelligence:coach:contract-steward",summary:"Tune customer profile copy from observed onboarding friction.",riskLevel:"low",knowledgeProvenanceRefs:["knowledge:companyos:customer-profile:canon"],connectVerdictRefs:["connect:companyos:copy-tune:permit"],harnessRunRefs:["harness-run:customer-profile-copy-tune"],replayEvidenceRefs:["replay:customer-profile-copy-tune"],policyDecisionRefs:["policy-decision:companyos:copy-tune"],requiredEvidenceRefs:["knowledge:companyos:customer-profile:canon"],draftPatchRef:"patch:customer-profile:db-v2-copy-tune",rollbackPlanRef:"rollback:customer-profile:db-v2-copy-tune"};function a(e){const o=[];i(o,"knowledge",e.knowledgeProvenanceRefs);i(o,"connect",e.connectVerdictRefs);i(o,"harness",e.harnessRunRefs);i(o,"replay",e.replayEvidenceRefs);i(o,"policy",e.policyDecisionRefs);if(!e.rollbackPlanRef)o.push("rollback");for(const t of e.requiredEvidenceRefs)if(!p(e,t))o.push(t);return o}function d(e){return e.mode==="human_in_loop"||e.candidate.authorityMode==="human_approval_required"||e.edition.authority.requiresHumanApprovalFor.includes(e.candidate.intent)||e.candidate.riskLevel==="high"&&e.mode!=="autonomous"}function s(e){if(e.missingEvidenceKinds.length)return e.candidate.draftPatchRef?"draft_patch":"suggest_only";if(e.requiresHumanReview)return"request_human_review";if(!e.edition.authority.allowedModes.includes(e.candidate.authorityMode))return"block_candidate";if(e.candidate.intent==="rollback_ready")return e.edition.authority.allowsAutonomousRollback?"rollback_candidate":"request_human_review";if(e.candidate.intent==="experiment"&&e.candidate.experimentRef)return e.edition.authority.allowsAutonomousPromotion?"promote_candidate":"request_human_review";if(e.candidate.authorityMode==="apply_reversible")return"apply_reversible";return e.candidate.draftPatchRef?"draft_patch":"suggest_only"}function c(e){return{suggest_only:"suggest",draft_patch:"draft",request_human_review:"review",apply_reversible:"apply",promote_candidate:"promote",rollback_candidate:"rollback",block_candidate:"blocked"}[e]}function m(e,o){return[`audit:${e.candidateRef}:evaluated`,...o.map((t)=>`audit:${e.candidateRef}:missing:${t}`)]}function r(e,o){return e.filter((t)=>t.action===o).map((t)=>t.candidateRef)}function i(e,o,t){if(!t.length)e.push(o)}function p(e,o){return[...e.knowledgeProvenanceRefs,...e.connectVerdictRefs,...e.harnessRunRefs,...e.replayEvidenceRefs,...e.policyDecisionRefs].includes(o)}