agentic-engineering-harness 0.8.7 → 0.8.9

package/dist/releases/release-1790907037815-15519-ba555be5/context/types.d.ts

@@ -0,0 +1,247 @@
+import { z } from "zod";
+export declare const contextPreservationValues: readonly ["VERBATIM", "PROJECTABLE", "COMPRESSIBLE", "RETRIEVABLE", "DISCARDABLE"];
+export type ContextPreservation = (typeof contextPreservationValues)[number];
+export declare const contextKindValues: readonly ["instruction", "execution-envelope", "agent-charter", "skill", "normative", "source", "diff", "validation", "audit", "operation", "handoff", "tool-output", "memory", "repository-map", "raw-evidence", "delivery"];
+export type ContextFragmentKind = (typeof contextKindValues)[number];
+export interface ContextSource {
+    artifact?: string;
+    file?: string;
+    sha256?: string;
+}
+export interface ContextFragment {
+    id: string;
+    kind: ContextFragmentKind;
+    preservation: ContextPreservation;
+    priority: number;
+    content: string;
+    source?: ContextSource;
+    metadata?: Record<string, unknown>;
+}
+export interface ContextFragmentProjection extends Omit<ContextFragment, "content"> {
+    content: string;
+    estimatedTokens: number;
+    originalTokens?: number;
+    projected?: boolean;
+    compressed?: boolean;
+    compression?: {
+        provider: string;
+        providerVersion?: string;
+        reversible: boolean;
+        handle?: string;
+    };
+}
+export interface ContextBudget {
+    maxTokens: number;
+    reserved: {
+        instructions: number;
+        normative: number;
+        evidence: number;
+        response: number;
+    };
+    role: string;
+    phase: string;
+}
+export interface ContextEnvelope {
+    version: 1;
+    operationId: string;
+    logicalAgent: string;
+    phase: string;
+    budget: {
+        maximum: number;
+        estimatedDelivered: number;
+    };
+    fragments: ContextFragmentProjection[];
+    retrieval: {
+        available: boolean;
+        allowedFragmentIds: string[];
+    };
+    provenance: {
+        sha256: string;
+        createdAt: string;
+        projectionVersion: string;
+    };
+}
+export interface ContextMetrics {
+    rawBytes: number;
+    projectedBytes: number;
+    deliveredBytes: number;
+    estimatedRawTokens: number;
+    estimatedProjectedTokens: number;
+    estimatedDeliveredTokens: number;
+    retrievedFragments: number;
+    deliveredFragments: number;
+    compressedFragments: number;
+    discardedFragments: number;
+    retrievalRequests: number;
+    retrievalRetries: number;
+    retrievalEscapes: number;
+    compressionRatio?: number;
+    projectionRatio?: number;
+}
+export interface ContextPreparationRequest {
+    operationId: string;
+    participantId?: string;
+    participantGeneration?: string;
+    runtimeSessionId?: string;
+    logicalAgent: string;
+    role?: string;
+    phase: string;
+    fragments: ContextFragment[];
+    capabilities?: {
+        /** The transport exposes an authorized raw-fragment retrieval mechanism. */
+        authorizedRetrieval?: boolean;
+        /** The transport exposes the configured semantic repository provider. */
+        semanticRetrieval?: boolean;
+    };
+}
+export interface ContextPreparationResult {
+    envelope: ContextEnvelope;
+    rendered: string;
+    metrics: ContextMetrics;
+    retrieval: {
+        root: string;
+        operationId: string;
+        logicalAgent: string;
+        allowedFragmentIds: string[];
+    };
+}
+export interface ContextBudgetConfigLike {
+    inputTokens?: number;
+    maxTokens?: number;
+    reserved?: Partial<ContextBudget["reserved"]>;
+}
+export interface ContextPolicy {
+    mode: "observe" | "enforce";
+    defaultBudget: ContextBudgetConfigLike;
+    agentBudgets: Record<string, ContextBudgetConfigLike>;
+    phaseBudgets: Record<string, ContextBudgetConfigLike>;
+    repositoryMap: {
+        enabled: boolean;
+        tokenBudget: number;
+        maxGraphHops: number;
+    };
+    semanticRetrieval: {
+        provider: string;
+        required: boolean;
+        editing: boolean;
+    };
+    compression: {
+        provider: string;
+        required: boolean;
+        minTokens: number;
+        reversible: boolean;
+        command?: string;
+    };
+    retrieval: {
+        maxRequestsPerTurn: number;
+        maxTokensPerRequest: number;
+        maxTotalTokensPerTurn: number;
+    };
+    outputPolicy: {
+        enabled: boolean;
+        modes: Record<string, "terse" | "compact" | "normal">;
+    };
+}
+export declare const contextFragmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        source: "source";
+        diff: "diff";
+        instruction: "instruction";
+        normative: "normative";
+        operation: "operation";
+        "repository-map": "repository-map";
+        validation: "validation";
+        handoff: "handoff";
+        "raw-evidence": "raw-evidence";
+        "execution-envelope": "execution-envelope";
+        "agent-charter": "agent-charter";
+        skill: "skill";
+        audit: "audit";
+        "tool-output": "tool-output";
+        memory: "memory";
+        delivery: "delivery";
+    }>;
+    preservation: z.ZodEnum<{
+        VERBATIM: "VERBATIM";
+        PROJECTABLE: "PROJECTABLE";
+        COMPRESSIBLE: "COMPRESSIBLE";
+        RETRIEVABLE: "RETRIEVABLE";
+        DISCARDABLE: "DISCARDABLE";
+    }>;
+    priority: z.ZodNumber;
+    content: z.ZodString;
+    source: z.ZodOptional<z.ZodObject<{
+        artifact: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        sha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const contextEnvelopeSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    operationId: z.ZodString;
+    logicalAgent: z.ZodString;
+    phase: z.ZodString;
+    budget: z.ZodObject<{
+        maximum: z.ZodNumber;
+        estimatedDelivered: z.ZodNumber;
+    }, z.core.$strip>;
+    fragments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            source: "source";
+            diff: "diff";
+            instruction: "instruction";
+            normative: "normative";
+            operation: "operation";
+            "repository-map": "repository-map";
+            validation: "validation";
+            handoff: "handoff";
+            "raw-evidence": "raw-evidence";
+            "execution-envelope": "execution-envelope";
+            "agent-charter": "agent-charter";
+            skill: "skill";
+            audit: "audit";
+            "tool-output": "tool-output";
+            memory: "memory";
+            delivery: "delivery";
+        }>;
+        preservation: z.ZodEnum<{
+            VERBATIM: "VERBATIM";
+            PROJECTABLE: "PROJECTABLE";
+            COMPRESSIBLE: "COMPRESSIBLE";
+            RETRIEVABLE: "RETRIEVABLE";
+            DISCARDABLE: "DISCARDABLE";
+        }>;
+        priority: z.ZodNumber;
+        content: z.ZodString;
+        source: z.ZodOptional<z.ZodObject<{
+            artifact: z.ZodOptional<z.ZodString>;
+            file: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        estimatedTokens: z.ZodNumber;
+        originalTokens: z.ZodOptional<z.ZodNumber>;
+        projected: z.ZodOptional<z.ZodBoolean>;
+        compressed: z.ZodOptional<z.ZodBoolean>;
+        compression: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            providerVersion: z.ZodOptional<z.ZodString>;
+            reversible: z.ZodBoolean;
+            handle: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    retrieval: z.ZodObject<{
+        available: z.ZodBoolean;
+        allowedFragmentIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    provenance: z.ZodObject<{
+        sha256: z.ZodString;
+        createdAt: z.ZodString;
+        projectionVersion: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare function assertContextFragment(value: unknown): ContextFragment;
+export declare function assertContextEnvelope(value: unknown): ContextEnvelope;

package/dist/releases/release-1790907037815-15519-ba555be5/context/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/context/types.ts"],"names":[],"mappings":"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"}

package/dist/releases/release-1790907037815-15519-ba555be5/control-center/contracts.d.ts

@@ -0,0 +1,283 @@
+import type { CandidateRevisionV1 } from "../operations/v2Contracts.js";
+import type { KnowledgeSufficiencyStatusV1 } from "../knowledge/index.js";
+import type { ProjectAvailabilityV1, ProjectHealthMetadataV1, ProjectIdentityV1 } from "../projects/index.js";
+import type { RuntimeSnapshotV1 } from "../runtime/index.js";
+import type { CapabilityLeaseV1 } from "../security/authorityV2.js";
+import type { OperationStatus } from "../operations/state.js";
+import type { BuildIdentityV1 } from "../build/identity.js";
+import type { DecisionRequestV1 } from "../security/humanDecision.js";
+import type { OperationEfficiencySummaryV1 } from "../telemetry/efficiency.js";
+export declare const CONTROL_CENTER_CONTRACT_VERSION: 1;
+export type ControlCenterResourceKindV1 = "project" | "operation" | "participant" | "candidate" | "context" | "authority" | "evidence" | "services" | "knowledge" | "event";
+export type ControlCenterResourceIdV1<K extends ControlCenterResourceKindV1 = ControlCenterResourceKindV1> = string & {
+    readonly __controlCenterResourceKind: K;
+    readonly __controlCenterContractVersion: typeof CONTROL_CENTER_CONTRACT_VERSION;
+};
+export type ControlCenterEventIdV1 = ControlCenterResourceIdV1<"event">;
+export type ControlCenterProjectIdV1 = ControlCenterResourceIdV1<"project">;
+export type ControlCenterOperationIdV1 = ControlCenterResourceIdV1<"operation">;
+export type ControlCenterParticipantIdV1 = ControlCenterResourceIdV1<"participant">;
+export type ControlCenterCandidateIdV1 = ControlCenterResourceIdV1<"candidate">;
+export declare function controlCenterResourceId<K extends ControlCenterResourceKindV1>(kind: K, value: string): ControlCenterResourceIdV1<K>;
+export interface ControlCenterProjectProjectionV1 extends Pick<ProjectIdentityV1, "repositoryIdentity" | "displayName" | "configDigest" | "createdAt" | "updatedAt"> {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    projectId: ControlCenterProjectIdV1;
+    availability: ProjectAvailabilityV1;
+    health?: Pick<ProjectHealthMetadataV1, "status" | "healthUrl" | "registeredAt" | "lastCheckedAt">;
+}
+export type ControlCenterOperationKindV1 = "audit" | "run" | "change";
+export type ControlCenterOperationStatusV1 = "QUEUED" | "RUNNING" | "SUCCEEDED" | "FAILED" | "CANCELLED";
+export interface ControlCenterDecisionRequestV1 extends Omit<DecisionRequestV1, "candidate"> {
+    candidate: string;
+}
+/** Server-derived legal controls; the UI renders only what the controller permits. */
+export interface ControlCenterOperationControlsV1 {
+    pause: boolean;
+    resume: boolean;
+    cancel: boolean;
+}
+export interface ControlCenterOperationPauseProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    resumePhase: string;
+    reason: string;
+    requestedBy: string;
+    pausedAt: string;
+    activeParticipantIds: string[];
+    activeProviderLeaseIds: string[];
+}
+export interface ControlCenterOperationProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    operationId: ControlCenterOperationIdV1;
+    kind: ControlCenterOperationKindV1;
+    status: ControlCenterOperationStatusV1;
+    phase: string;
+    revision?: number;
+    projectId?: ControlCenterProjectIdV1;
+    candidateId?: ControlCenterCandidateIdV1;
+    candidateDigest?: string;
+    participantCount: number;
+    runningParticipantCount: number;
+    completedParticipantCount: number;
+    failedParticipantCount: number;
+    blockedParticipantCount: number;
+    blockedStageCount: number;
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string;
+    finishedAt?: string;
+    error?: string;
+    efficiency?: OperationEfficiencySummaryV1;
+    decisionRequest?: ControlCenterDecisionRequestV1;
+    pause?: ControlCenterOperationPauseProjectionV1;
+    controls: ControlCenterOperationControlsV1;
+    stages: ControlCenterStageProjectionV1[];
+}
+export interface ControlCenterStageProjectionV1 {
+    name: string;
+    status: "PENDING" | "RUNNING" | "COMPLETED" | "FAILED" | "BLOCKED" | "SKIPPED";
+    revision: number;
+    startedAt?: string;
+    finishedAt?: string;
+    message?: string;
+    artifact?: string;
+}
+export interface ControlCenterParticipantProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    participantId: ControlCenterParticipantIdV1;
+    operationId?: ControlCenterOperationIdV1;
+    logicalAgent?: string;
+    role?: string;
+    phase?: string;
+    status: "REGISTERED" | "IDLE" | "RUNNING" | "COMPLETED" | "FAILED" | "BLOCKED" | "CANCELLED";
+    specializations: string[];
+    skills: string[];
+    tools: string[];
+    registeredAt?: string;
+    startedAt?: string;
+    finishedAt?: string;
+    resultArtifact?: string;
+    error?: string;
+}
+export interface ControlCenterOperationDetailProjectionV1 extends ControlCenterOperationProjectionV1 {
+    payloadSummary: string;
+    participants: ControlCenterParticipantProjectionV1[];
+}
+export interface ControlCenterCandidateProjectionV1 extends CandidateRevisionV1 {
+    controlCenterId: ControlCenterCandidateIdV1;
+}
+export interface ControlCenterContextProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    operationId?: ControlCenterOperationIdV1;
+    candidateDigest?: string;
+    promptTokens?: number;
+    completionTokens?: number;
+    budgetTokens?: number;
+    consumedTokens?: number;
+    continuationCount: number;
+    manifestDigest?: string;
+    authorizedReferenceCount: number;
+}
+export interface ControlCenterAuthorityProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    operationId?: ControlCenterOperationIdV1;
+    candidateDigest?: string;
+    participantId?: ControlCenterParticipantIdV1;
+    leases: Array<Pick<CapabilityLeaseV1, "version" | "leaseId" | "requestId" | "capability" | "issuedAt" | "expiresAt"> & {
+        operationId: ControlCenterOperationIdV1;
+        participantId: ControlCenterParticipantIdV1;
+        candidateDigest: string;
+    }>;
+}
+export type ControlCenterEvidenceTypeV1 = "run" | "requirement" | "task" | "file" | "check" | "finding" | "agent-session" | "commit" | "pull-request";
+export interface ControlCenterEvidenceProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    evidenceId: ControlCenterResourceIdV1<"evidence">;
+    type: ControlCenterEvidenceTypeV1;
+    label: string;
+    status?: "PASS" | "FAIL" | "WARN" | "PENDING";
+    candidateDigest?: string;
+    operationId?: ControlCenterOperationIdV1;
+    source?: string;
+}
+export type ControlCenterServicesProjectionV1 = RuntimeSnapshotV1;
+export interface ControlCenterKnowledgeProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    mode: "OFFLINE" | "DOCS_ONLY" | "TRUSTED_DISCOVERY";
+    gate: "SUFFICIENT" | "GAP";
+    status: KnowledgeSufficiencyStatusV1;
+    cacheKey?: string;
+    missingCompetencies: string[];
+    sourcePackDigest?: string;
+    trustedSourceCount: number;
+    librarianRequired: boolean;
+}
+export interface ControlCenterQualityProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    status: "ready" | "converging" | "blocked" | "failed" | "unknown";
+    rounds: number;
+    findingCount: number;
+    unresolvedFindingCount: number;
+    candidateDigest?: string;
+}
+export interface ControlCenterCertificationProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    status: "not-started" | "in-progress" | "passed" | "failed" | "unknown";
+    checks: number;
+    passedChecks: number;
+    failedChecks: number;
+    candidateDigest?: string;
+}
+export interface ControlCenterSecurityProjectionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    loopbackOnly: true;
+    authenticated: true;
+    csrfForMutations: true;
+}
+export interface ControlCenterEventDataV1 {
+    operationId: ControlCenterOperationIdV1;
+    revision: number;
+    status: OperationStatus;
+    phase: string;
+    changed?: string[];
+    details?: Record<string, unknown>;
+}
+export type ControlCenterEventTypeV1 = "operation.created" | "operation.updated" | "operation.metadata" | "operation.terminal" | "operation.stage" | "operation.candidate.bound" | "operation.lead.bound" | "operation.participant.registered" | "operation.participant.updated" | "operation.participant.receipt" | "operation.supervisor.registered" | "operation.supervisor.updated" | "operation.controller.claimed" | "operation.controller.process-bound" | "operation.lead.acknowledged";
+export interface ControlCenterEventV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    eventId: ControlCenterEventIdV1;
+    type: ControlCenterEventTypeV1;
+    at: string;
+    data: ControlCenterEventDataV1;
+}
+export interface ControlCenterPairInputV1 {
+    nonce: string;
+}
+export interface ControlCenterPairedSessionV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    csrfToken: string;
+}
+export interface ControlCenterProjectSelectionV1 {
+    projectId?: ControlCenterProjectIdV1;
+    autoOpen: boolean;
+}
+export interface ControlCenterProjectHealthProjectionV1 {
+    availability: ProjectAvailabilityV1;
+    runtime: {
+        status: "healthy" | "unhealthy" | "unreachable" | "unregistered" | "unavailable";
+    };
+    checkedAt: string;
+    durationMs: number;
+}
+export interface ControlCenterActionResultV1 {
+    accepted?: boolean;
+    reason?: string;
+    operationId?: string;
+    status?: ControlCenterOperationStatusV1;
+    phase?: string;
+    revision?: number;
+    candidateRevision?: number;
+    decisionId?: string;
+    requestId?: string;
+    choiceId?: string;
+}
+export interface ControlCenterDecisionInputV1 {
+    operationId: string;
+    requestId: string;
+    choiceId: string;
+    reason?: string;
+}
+export interface ControlCenterSnapshotV1 {
+    projects: ControlCenterProjectProjectionV1[];
+    operations: ControlCenterOperationDetailProjectionV1[];
+    participants: ControlCenterParticipantProjectionV1[];
+    candidates: ControlCenterCandidateProjectionV1[];
+    context: ControlCenterContextProjectionV1;
+    authority: ControlCenterAuthorityProjectionV1;
+    evidence: ControlCenterEvidenceProjectionV1[];
+    services: ControlCenterServicesProjectionV1;
+    knowledge: ControlCenterKnowledgeProjectionV1;
+    quality: ControlCenterQualityProjectionV1;
+    certification: ControlCenterCertificationProjectionV1;
+}
+export interface ControlCenterSnapshotInputV1 {
+    projects?: ControlCenterProjectProjectionV1[];
+    operations?: ControlCenterOperationDetailProjectionV1[];
+    participants?: ControlCenterParticipantProjectionV1[];
+    candidates?: ControlCenterCandidateProjectionV1[];
+    context?: Partial<ControlCenterContextProjectionV1>;
+    authority?: Partial<ControlCenterAuthorityProjectionV1>;
+    evidence?: ControlCenterEvidenceProjectionV1[];
+    services?: ControlCenterServicesProjectionV1;
+    knowledge?: Partial<ControlCenterKnowledgeProjectionV1>;
+    quality?: Partial<ControlCenterQualityProjectionV1> & {
+        activeOperations?: number;
+    };
+    certification?: Partial<ControlCenterCertificationProjectionV1>;
+}
+export interface ControlCenterResourceCollectionV1<K extends ControlCenterResourceKindV1, T> {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    resource: K;
+    generatedAt: string;
+    items: T[];
+}
+export interface ControlCenterResourceDetailV1<K extends ControlCenterResourceKindV1, T> {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    resource: K;
+    generatedAt: string;
+    item: T;
+}
+export interface ControlCenterOverviewV1 extends ControlCenterSnapshotV1 {
+    version: typeof CONTROL_CENTER_CONTRACT_VERSION;
+    generatedAt: string;
+    buildIdentity: BuildIdentityV1;
+    agents: ControlCenterParticipantProjectionV1[];
+    permissions: ControlCenterAuthorityProjectionV1["leases"];
+    security: ControlCenterSecurityProjectionV1;
+    pairing: {
+        mode: "single-use-pairing-session";
+        host: string;
+    };
+    project?: ControlCenterProjectProjectionV1;
+    projectSelection?: ControlCenterProjectSelectionV1;
+    projectHealth?: ControlCenterProjectHealthProjectionV1;
+}

package/dist/releases/release-1790907037815-15519-ba555be5/control-center/contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.js","sourceRoot":"","sources":["../../src/control-center/contracts.ts"],"names":[],"mappings":"AAUA,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAU,CAAC;AAyB1D,MAAM,UAAU,uBAAuB,CAAwC,IAAO,EAAE,KAAa;IACnG,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAChC,IAAI,CAAC,UAAU;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,IAAI,gCAAgC,CAAC,CAAC;IACzF,OAAO,UAA0C,CAAC;AACpD,CAAC"}

package/dist/releases/release-1790907037815-15519-ba555be5/control-center/operationProjection.d.ts

@@ -0,0 +1,4 @@
+import { type OperationRecordV2 } from "../operations/state.js";
+import { type ControlCenterOperationDetailProjectionV1 } from "./contracts.js";
+import type { OperationEfficiencySummaryV1 } from "../telemetry/efficiency.js";
+export declare function projectOperationRecordV1(record: OperationRecordV2, efficiency?: OperationEfficiencySummaryV1): ControlCenterOperationDetailProjectionV1;

package/dist/releases/release-1790907037815-15519-ba555be5/control-center/operationProjection.js

@@ -0,0 +1,127 @@
+import { assertResolvedOperationPolicyV1 } from "../architecture/executionIdentity.js";
+import { currentControllerEpoch } from "../operations/state.js";
+import { candidateRevisionsEqual } from "../operations/v2Contracts.js";
+import { CONTROL_CENTER_CONTRACT_VERSION, controlCenterResourceId } from "./contracts.js";
+export function projectOperationRecordV1(record, efficiency) {
+    const participants = Object.values(record.participants).map((participant) => projectParticipant(record.id, participant));
+    const stages = Object.values(record.stages).map((stage) => ({
+        name: stage.name,
+        status: stage.status,
+        revision: stage.revision,
+        ...(stage.startedAt !== undefined ? { startedAt: stage.startedAt } : {}),
+        ...(stage.finishedAt !== undefined ? { finishedAt: stage.finishedAt } : {}),
+        ...(stage.message !== undefined ? { message: stage.message } : {}),
+        ...(stage.artifact !== undefined ? { artifact: stage.artifact } : {})
+    }));
+    const candidate = record.candidateRevision;
+    const decisionRequest = projectDecisionRequest(record);
+    const pause = projectPause(record);
+    return {
+        version: CONTROL_CENTER_CONTRACT_VERSION,
+        operationId: controlCenterResourceId("operation", record.id),
+        kind: record.kind,
+        status: record.status,
+        phase: record.phase,
+        revision: record.revision,
+        ...(candidate?.projectId ? { projectId: controlCenterResourceId("project", candidate.projectId) } : {}),
+        ...(candidate ? { candidateId: controlCenterResourceId("candidate", candidate.candidateId), candidateDigest: candidate.identityDigest } : {}),
+        participantCount: participants.length,
+        runningParticipantCount: participants.filter((participant) => participant.status === "RUNNING").length,
+        completedParticipantCount: participants.filter((participant) => participant.status === "COMPLETED").length,
+        failedParticipantCount: participants.filter((participant) => participant.status === "FAILED" || participant.status === "CANCELLED").length,
+        blockedParticipantCount: participants.filter((participant) => participant.status === "BLOCKED").length,
+        blockedStageCount: stages.filter((stage) => stage.status === "BLOCKED").length,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        ...(record.startedAt !== undefined ? { startedAt: record.startedAt } : {}),
+        ...(record.finishedAt !== undefined ? { finishedAt: record.finishedAt } : {}),
+        ...(record.error !== undefined ? { error: record.error } : {}),
+        ...(efficiency ? { efficiency } : {}),
+        payloadSummary: `${record.kind} operation ${record.id}`,
+        participants,
+        stages,
+        ...(decisionRequest ? { decisionRequest } : {}),
+        ...(pause ? { pause } : {}),
+        controls: projectControls(record)
+    };
+}
+function projectControls(record) {
+    const active = record.status === "QUEUED" || record.status === "RUNNING";
+    const paused = record.phase === "PAUSED" && Boolean(record.pause);
+    const hasCurrentIdentity = Boolean(record.candidateRevision && record.resolvedOperationPolicy && Number.isSafeInteger(record.operationExecutionRevision));
+    return {
+        pause: active && record.status === "RUNNING" && !paused && hasCurrentIdentity,
+        resume: active && record.status === "RUNNING" && paused,
+        cancel: active
+    };
+}
+function projectPause(record) {
+    if (record.phase !== "PAUSED" || !record.pause)
+        return undefined;
+    return {
+        version: CONTROL_CENTER_CONTRACT_VERSION,
+        resumePhase: record.pause.resumePhase,
+        reason: record.pause.reason,
+        requestedBy: record.pause.requestedBy,
+        pausedAt: record.pause.pausedAt,
+        activeParticipantIds: [...record.pause.drainReceipt.activeParticipantIds],
+        activeProviderLeaseIds: [...record.pause.drainReceipt.activeProviderLeaseIds]
+    };
+}
+function projectParticipant(operationId, participant) {
+    return {
+        version: CONTROL_CENTER_CONTRACT_VERSION,
+        participantId: controlCenterResourceId("participant", participant.id),
+        operationId: controlCenterResourceId("operation", operationId),
+        ...(participant.logicalAgent !== undefined ? { logicalAgent: participant.logicalAgent } : {}),
+        ...(participant.role !== undefined ? { role: participant.role } : {}),
+        ...(participant.phase !== undefined ? { phase: participant.phase } : {}),
+        status: participant.status,
+        specializations: [],
+        skills: [],
+        tools: [],
+        registeredAt: participant.registeredAt,
+        ...(participant.startedAt !== undefined ? { startedAt: participant.startedAt } : {}),
+        ...(participant.finishedAt !== undefined ? { finishedAt: participant.finishedAt } : {}),
+        ...(participant.resultArtifact !== undefined ? { resultArtifact: participant.resultArtifact } : {}),
+        ...(participant.error !== undefined ? { error: participant.error } : {})
+    };
+}
+function projectDecisionRequest(record) {
+    if (record.status !== "RUNNING" || record.phase !== "HUMAN_REQUIRED")
+        return undefined;
+    const request = record.decisionRequest;
+    const continuation = record.continuation;
+    const candidate = record.candidateRevision;
+    const policy = record.resolvedOperationPolicy;
+    const operationExecutionRevision = record.operationExecutionRevision;
+    if (!request || !continuation || continuation.state !== "WAITING" || !candidate || !policy
+        || typeof operationExecutionRevision !== "number" || !Number.isSafeInteger(operationExecutionRevision) || operationExecutionRevision < 1
+        || request.requestId !== continuation.requestId)
+        return undefined;
+    try {
+        assertResolvedOperationPolicyV1(policy);
+    }
+    catch {
+        return undefined;
+    }
+    const controllerEpoch = currentControllerEpoch(record);
+    if (policy.operationId !== record.id || policy.operationExecutionRevision !== operationExecutionRevision
+        || policy.candidateRevision !== candidate.revision || policy.candidateDigest !== candidate.identityDigest
+        || policy.controllerEpoch !== controllerEpoch
+        || (candidate.projectId && policy.projectId !== candidate.projectId))
+        return undefined;
+    const binding = { operationId: record.id, candidate, operationExecutionRevision, policyDigest: policy.digest, controllerEpoch };
+    if (!matchesDecisionBinding(request, binding) || !matchesDecisionBinding(continuation, binding))
+        return undefined;
+    const { candidate: requestCandidate, ...requestFields } = request;
+    return { ...requestFields, candidate: requestCandidate.identityDigest };
+}
+function matchesDecisionBinding(value, binding) {
+    return value.operationId === binding.operationId
+        && candidateRevisionsEqual(value.candidate, binding.candidate)
+        && value.operationExecutionRevision === binding.operationExecutionRevision
+        && value.policyDigest === binding.policyDigest
+        && value.controllerEpoch === binding.controllerEpoch;
+}
+//# sourceMappingURL=operationProjection.js.map