openxiangda-devkit-core 2.0.0-alpha.98 → 2.0.0

package/dist/application-services.d.ts

@@ -1,8 +1,9 @@
-import { type DeploymentEnvironment, type DeploymentRun, type DevkitResult, type Diagnostic, type ConfigurationValidationResult, type WorkspaceIdentity } from "openxiangda-contracts";
+import type { DeploymentStrategy } from 'openxiangda-contracts';
+import { OPENXIANGDA_CONTRACT_VERSION, SCHEMA_VERSIONS, type DeploymentEnvironment, type DeploymentRun, type DevkitResult, type Diagnostic, type ConfigurationValidationResult, type WorkspaceIdentity } from "openxiangda-contracts";
 import { type CompiledAppPackage } from "./compiler/index.js";
 import { OpenXiangdaControlPlaneClient, type CreateApplicationSecretInput, type CreateNativeRoleMembershipInput, type CreateOAuthClientInput, type ControlPlaneClientOptions, type NativeRelationshipGrantFilter, type RotateApplicationSecretInput, type UpdateApplicationSecretInput, type UpdateNativeRoleMembershipInput, type UpdateOAuthClientInput } from "./control-plane-client.js";
 import { type ToolchainCapsule } from "./toolchain-capsule.js";
-import { type AppSpecRisk } from "./app-spec.js";
+import { type AppSpecContractIndex, type AppSpecRisk } from "./app-spec.js";
 export interface GenerateOptions {
     root?: string;
     check?: boolean;
@@ -39,10 +40,8 @@ export interface SealedArtifactStatus {
     reasonCode?: "OPENXIANGDA_CHECK_DOES_NOT_SEAL";
     nextCommand: "openxiangda check" | "openxiangda deploy";
 }
-interface SealedApplication extends BuiltApplication {
-    artifactContent: Record<string, string>;
-}
 export interface DeployOptions extends BuildOptions {
+    deploymentStrategy?: DeploymentStrategy;
     environment: "preproduction";
     environmentId?: string;
     idempotencyKey?: string;
@@ -56,9 +55,61 @@ export declare class OpenXiangdaApplicationServices {
         client?: OpenXiangdaControlPlaneClient;
         clientOptions?: ControlPlaneClientOptions;
     });
-    workspaceContext(root?: string): Promise<DevkitResult<import("openxiangda-contracts").WorkspaceContext>>;
+    workspaceContext(root?: string): Promise<DevkitResult<{
+        development: {
+            application: {
+                path: string;
+                content: string;
+            } | null;
+            records: {
+                id: string;
+                title: string;
+                status: string;
+                path: string;
+                kind: import("./app-spec.js").AppSpecDocumentKind;
+            }[];
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+        schemaVersion: typeof SCHEMA_VERSIONS.workspaceContext;
+        workspace: WorkspaceIdentity;
+        roots: {
+            frontend: string;
+            backend: string;
+            platform: string;
+        };
+        toolchain: {
+            packageName?: "openxiangda-devkit-core";
+            version: string;
+            contractVersion: typeof OPENXIANGDA_CONTRACT_VERSION;
+            nodeVersion: string;
+            packageManager: string;
+            studio?: import("openxiangda-contracts").StudioWorkspaceProtocolCapabilities;
+        };
+        environments: Array<{
+            id?: string;
+            name: string;
+            kind: DeploymentEnvironment;
+        }>;
+        changedDomains: Array<"frontend" | "backend" | "data" | "authz" | "events" | "workflow" | "config">;
+    }>>;
     appSpecInit(root?: string): Promise<DevkitResult<{
-        schemaVersion: "openxiangda.appspec/context/v2";
+        schemaVersion: "openxiangda.appspec/context/v4";
         enabled: boolean;
         advisory: boolean;
         releaseGate: boolean;
@@ -72,7 +123,7 @@ export declare class OpenXiangdaApplicationServices {
         resources?: string[];
         actions?: string[];
     }): Promise<DevkitResult<{
-        schemaVersion: "openxiangda.appspec/context/v2";
+        schemaVersion: "openxiangda.appspec/context/v4";
         enabled: boolean;
         advisory: boolean;
         releaseGate: boolean;
@@ -89,7 +140,7 @@ export declare class OpenXiangdaApplicationServices {
         resources?: string[];
         actions?: string[];
     }): Promise<DevkitResult<{
-        schemaVersion: "openxiangda.appspec/context/v2";
+        schemaVersion: "openxiangda.appspec/context/v4";
         enabled: boolean;
         advisory: boolean;
         releaseGate: boolean;
@@ -97,15 +148,157 @@ export declare class OpenXiangdaApplicationServices {
         risk: AppSpecRisk;
         status: string;
     }>>;
-    appSpecContext(root?: string, selector?: string): Promise<DevkitResult<import("./app-spec.js").AppSpecContext>>;
-    appSpecCheck(root?: string): Promise<DevkitResult<import("./app-spec.js").AppSpecContext>>;
+    appSpecContext(root?: string, selector?: string, historyOffset?: number): Promise<DevkitResult<{
+        lifecycle: {
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+        schemaVersion: "openxiangda.appspec/context/v4";
+        enabled: boolean;
+        mode: "guided";
+        releaseGate: true;
+        root: "appspec";
+        selector: string | null;
+        contract: AppSpecContractIndex;
+        index: {
+            application: import("./app-spec.js").AppSpecDocumentSummary | null;
+            capabilities: import("./app-spec.js").AppSpecDocumentSummary[];
+            activeChanges: import("./app-spec.js").AppSpecDocumentSummary[];
+            decisions: import("./app-spec.js").AppSpecDocumentSummary[];
+            designs: import("./app-spec.js").AppSpecDocumentSummary[];
+            history: import("./app-spec.js").AppSpecDocumentSummary[];
+        };
+        application: import("./app-spec.js").AppSpecDocument | null;
+        capabilities: import("./app-spec.js").AppSpecDocument[];
+        activeChanges: import("./app-spec.js").AppSpecDocument[];
+        archivedChanges: import("./app-spec.js").AppSpecDocument[];
+        decisions: import("./app-spec.js").AppSpecDocument[];
+        designs: import("./app-spec.js").AppSpecDocument[];
+        historyPage: {
+            offset: number;
+            limit: number;
+            total: number;
+            nextOffset: number | null;
+        };
+        contextBudget: {
+            maximumBytes: number;
+            contentBytes: number;
+            truncated: boolean;
+            omitted: import("./app-spec.js").AppSpecDocumentSummary[];
+        };
+        stats: {
+            files: number;
+            bytes: number;
+            capabilities: number;
+            activeChanges: number;
+            historyChanges: number;
+            decisions: number;
+            designs: number;
+            requirements: number;
+            acceptanceScenarios: number;
+        };
+        workspaceDigest: string | null;
+        selectionDigest: string | null;
+        diagnostics: Diagnostic[];
+    }>>;
+    appSpecCheck(root?: string): Promise<DevkitResult<{
+        lifecycle: {
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+        schemaVersion: "openxiangda.appspec/context/v4";
+        enabled: boolean;
+        mode: "guided";
+        releaseGate: true;
+        root: "appspec";
+        selector: string | null;
+        contract: AppSpecContractIndex;
+        index: {
+            application: import("./app-spec.js").AppSpecDocumentSummary | null;
+            capabilities: import("./app-spec.js").AppSpecDocumentSummary[];
+            activeChanges: import("./app-spec.js").AppSpecDocumentSummary[];
+            decisions: import("./app-spec.js").AppSpecDocumentSummary[];
+            designs: import("./app-spec.js").AppSpecDocumentSummary[];
+            history: import("./app-spec.js").AppSpecDocumentSummary[];
+        };
+        application: import("./app-spec.js").AppSpecDocument | null;
+        capabilities: import("./app-spec.js").AppSpecDocument[];
+        activeChanges: import("./app-spec.js").AppSpecDocument[];
+        archivedChanges: import("./app-spec.js").AppSpecDocument[];
+        decisions: import("./app-spec.js").AppSpecDocument[];
+        designs: import("./app-spec.js").AppSpecDocument[];
+        historyPage: {
+            offset: number;
+            limit: number;
+            total: number;
+            nextOffset: number | null;
+        };
+        contextBudget: {
+            maximumBytes: number;
+            contentBytes: number;
+            truncated: boolean;
+            omitted: import("./app-spec.js").AppSpecDocumentSummary[];
+        };
+        stats: {
+            files: number;
+            bytes: number;
+            capabilities: number;
+            activeChanges: number;
+            historyChanges: number;
+            decisions: number;
+            designs: number;
+            requirements: number;
+            acceptanceScenarios: number;
+        };
+        workspaceDigest: string | null;
+        selectionDigest: string | null;
+        diagnostics: Diagnostic[];
+    }>>;
+    appSpecVerify(root: string | undefined, deploymentId: string, evidencePath?: string): Promise<DevkitResult<{
+        ok: boolean;
+        path: string;
+        sourceDeploymentId: string;
+        packageDigest: string;
+        scenarios: any;
+        diagnostics: Diagnostic[];
+    }>>;
     appSpecClose(input: {
         root?: string;
         id: string;
         summary?: string;
         currentSpec?: "merged" | "not-applicable";
     }): Promise<DevkitResult<{
-        schemaVersion: "openxiangda.appspec/context/v2";
+        schemaVersion: "openxiangda.appspec/context/v4";
         enabled: boolean;
         advisory: boolean;
         releaseGate: boolean;
@@ -113,7 +306,7 @@ export declare class OpenXiangdaApplicationServices {
         status: string;
         converged: boolean;
     } | {
-        schemaVersion: "openxiangda.appspec/context/v2";
+        schemaVersion: "openxiangda.appspec/context/v4";
         enabled: boolean;
         advisory: boolean;
         releaseGate: boolean;
@@ -147,6 +340,129 @@ export declare class OpenXiangdaApplicationServices {
         aiCatalogDigest: string;
         contract: import("openxiangda-contracts").ContractBundleV3;
         aiCatalog: import("openxiangda-contracts").AiCapabilityCatalog;
+        permissionReview: {
+            digest: string;
+            schemaVersion: "openxiangda.permission-review/v2";
+            appCode: string;
+            configDigest: string;
+            contractDigest: string;
+            authority: "declaration-projection";
+            runtimeAuthorizationRequired: true;
+            semantics: {
+                roleCapabilities: "sealed-declared-grants; current-user application roles are unioned";
+                roleDeniedCapabilities: "removed from that role during compilation; not a global deny across roles";
+                capabilityMatch: "static prerequisite only; never runtime allow";
+                fieldPolicies: "resource operation is required; field rules can only narrow it; empty is deny";
+                hiddenFields: "presentation only; not an authorization rule";
+                rowPolicies: "raw declarations; evaluated by the platform with current identity, grants and record facts";
+                workflowTasks: "platform Task Surface and fresh command token decide current participant, state, field and operation access";
+                navigation: "page selection and visibility do not grant resource or operation access";
+                perspectives: "read projections only; never replace the actor or mutation/workflow authorization";
+            };
+            roles: {
+                capabilityCodes: string[];
+                description?: string;
+                code: string;
+                name: string;
+            }[];
+            capabilities: import("openxiangda-contracts").AppCapabilityContract[];
+            perspectives: import("openxiangda-contracts").AppPerspectiveContract[];
+            pages: {
+                adminAccess: import("openxiangda-contracts").AppFrontendRouteAccess | null;
+                admin: import("openxiangda-contracts").AppAdminPageContract[];
+                custom: import("openxiangda-contracts").AppFrontendRouteContract[];
+                standard: import("openxiangda-contracts").AppRouteManifestEntryV3[];
+            };
+            resources: {
+                code: string;
+                name: string;
+                operationCapabilities: {
+                    read: string;
+                    create: string;
+                    update: string;
+                    delete: string;
+                };
+                dataPolicyCode: string | null;
+                mutationOwner: "native" | "action" | "readonly" | "workflow" | null;
+                generated: {
+                    list?: boolean;
+                    detail?: boolean;
+                    create?: boolean;
+                    update?: boolean;
+                    delete?: boolean;
+                } | null;
+                views: {
+                    code: string;
+                    name: string;
+                    generated: Required<{
+                        list?: boolean;
+                        detail?: boolean;
+                        create?: boolean;
+                        update?: boolean;
+                        delete?: boolean;
+                    }>;
+                    fieldOrder: {
+                        list: string[];
+                        form: string[];
+                        detail: string[];
+                    };
+                    mobile: {
+                        enabled: boolean;
+                    };
+                }[];
+                defaultFieldOrder: {
+                    list: string[] | null;
+                    form: string[] | null;
+                    detail: string[] | null;
+                } | null;
+                fields: {
+                    code: string;
+                    type: "boolean" | "date" | "file" | "subtable" | "text.short" | "text.long" | "text.rich" | "number.integer" | "number.decimal" | "time" | "datetime" | "date-range" | "datetime-range" | "option.single" | "option.multiple" | "cascade.single" | "cascade.multiple" | "user.single" | "user.multiple" | "department.single" | "department.multiple" | "resource-ref.single" | "resource-ref.multiple" | "image" | "signature" | "address" | "location" | "uuid" | "json" | "serial-number";
+                    label: string;
+                    hidden: boolean;
+                    system: boolean;
+                    read: import("./compiler/permission-review.js").PermissionReviewFieldRequirement;
+                    create: import("./compiler/permission-review.js").PermissionReviewFieldRequirement;
+                    update: import("./compiler/permission-review.js").PermissionReviewFieldRequirement;
+                    mask: "null" | "omit" | null;
+                }[];
+            }[];
+            authorization: {
+                authenticatedUserRoleCode: string | null;
+                dataPolicies: import("openxiangda-contracts").AppDataPolicyDeclaration[];
+                scopeDimensions: import("openxiangda-contracts").AppScopeDimensionDeclaration[];
+                scopeSources: import("openxiangda-contracts").AppScopeSourceDeclaration[];
+                roleMembershipSources: import("openxiangda-contracts").AppRoleMembershipSourceDeclaration[];
+                relationshipGrantSources: import("openxiangda-contracts").AppRelationshipGrantSourceDeclaration[];
+                authorizationTransitions: import("openxiangda-contracts").AppAuthorizationTransitionDeclaration[];
+                publicAccess: import("openxiangda-contracts").AnonymousPublicAccessContractV2 | null;
+            };
+            operations: import("openxiangda-contracts").AppApiOperationContract[];
+            workflows: {
+                runtimeAuthorizationRequired: true;
+                contracts: import("openxiangda-contracts").AppWorkflowContract[];
+                definitions: {
+                    workflowCode: string;
+                    version: number;
+                    subject: import("openxiangda-contracts").WorkflowSubjectDefinition;
+                    organizationContext: {
+                        department?: {
+                            source: "none" | "user_primary_department" | "choose_if_multiple" | "always_choose" | "fixed" | "from_input" | "from_role_scope";
+                            required?: boolean;
+                            value?: string;
+                            path?: string;
+                            dimension?: string;
+                        };
+                    } | null;
+                    startAt: string;
+                    nodes: Record<string, import("openxiangda-contracts").WorkflowNode>;
+                }[];
+                bindings: import("openxiangda-contracts").NativeWorkflowBindingDeclaration[];
+                activations: import("openxiangda-contracts").NativeWorkflowActivationDeclaration[];
+                providers: import("openxiangda-contracts").NativeWorkflowProviderDeclaration[];
+                editableParameters: import("openxiangda-contracts").NativeWorkflowEditableParameterDeclaration[];
+            };
+        };
         adminNavigationAuthoring: {
             schemaVersion: string;
             owner: string;
@@ -170,7 +486,41 @@ export declare class OpenXiangdaApplicationServices {
             workflowProviders: number;
         };
     }>>;
+    contractContext(root?: string, input?: {
+        selector?: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<{
+        data: {
+            configDigest: string;
+            contractDigest: string;
+            aiCatalogDigest: string;
+            counts: {
+                backendSecrets: number;
+                backendOperations: number;
+                frontendRoutes: number;
+                anonymousPublicPolicies: number;
+                dataResources: number;
+                aiCapabilities: number;
+                eventSubscriptions: number;
+                timerSubscriptions: number;
+                workflowDefinitions: number;
+                workflowBindings: number;
+                workflowProviders: number;
+            };
+            selector: string;
+            selection: unknown;
+        };
+        ok: boolean;
+        operation: string;
+        workspace: WorkspaceIdentity;
+        diagnostics: Diagnostic[];
+        nextActions: import("openxiangda-contracts").NextAction[];
+        traceId?: string;
+    }>;
     platformCapabilities(root?: string): Promise<DevkitResult<import("openxiangda-contracts").PlatformCapabilities>>;
+    administrationContext(root: string | undefined, environmentKey?: string): Promise<DevkitResult<import("openxiangda-contracts").ApplicationAdministrationContext>>;
+    workflowNodeConfigurations(root: string | undefined, workflowCode: string, environmentKey?: string): Promise<DevkitResult<import("openxiangda-contracts").WorkflowNodeConfigurations>>;
     provisionApplication(root?: string): Promise<DevkitResult<undefined> | DevkitResult<import("openxiangda-contracts").ProvisionedApplication>>;
     oauthClients(root?: string): Promise<DevkitResult<{
         items: import("openxiangda-contracts").OAuthClient[];
@@ -225,25 +575,14 @@ export declare class OpenXiangdaApplicationServices {
         limit?: number;
         offset?: number;
     }): Promise<DevkitResult<import("openxiangda-contracts").NativeRoleMembershipPage>>;
-    createNativeRoleMembership(root: string | undefined, input: CreateNativeRoleMembershipInput): Promise<DevkitResult<{
-        membership: import("openxiangda-contracts").NativeRoleMembership;
-        roleSubjectSetVersion: string;
-    }>>;
-    updateNativeRoleMembership(root: string | undefined, membershipId: string, input: UpdateNativeRoleMembershipInput): Promise<DevkitResult<{
-        membership: import("openxiangda-contracts").NativeRoleMembership;
-        roleSubjectSetVersion: string;
-        revokedSessionCount: number;
-    }>>;
+    createNativeRoleMembership(root: string | undefined, input: CreateNativeRoleMembershipInput): Promise<DevkitResult<import("openxiangda-contracts").NativeRoleMembershipMutationResult>>;
+    updateNativeRoleMembership(root: string | undefined, membershipId: string, input: UpdateNativeRoleMembershipInput): Promise<DevkitResult<import("openxiangda-contracts").NativeRoleMembershipMutationResult>>;
     revokeNativeRoleMembership(root: string | undefined, membershipId: string, input: {
         environmentKey: DeploymentEnvironment;
         operationId: string;
         expectedRevision: number;
-    }): Promise<DevkitResult<{
-        membership: import("openxiangda-contracts").NativeRoleMembership;
-        roleSubjectSetVersion: string;
-        revokedRelationshipCount: number;
-        revokedSessionCount: number;
-    }>>;
+        reason: string;
+    }): Promise<DevkitResult<import("openxiangda-contracts").NativeRoleMembershipMutationResult>>;
     nativeSuperAdmins(root: string | undefined, environmentKey: string, input?: {
         status?: "active" | "revoked";
         userId?: string;
@@ -336,7 +675,7 @@ export declare class OpenXiangdaApplicationServices {
         contractDigest: string;
         aiCatalogDigest: string;
     }>>;
-    check(root?: string, environmentKey?: DeploymentEnvironment): Promise<DevkitResult<{
+    check(root?: string, environmentKey?: DeploymentEnvironment): Promise<DevkitResult<undefined> | DevkitResult<{
         generated: {
             output: string;
             changed: boolean;
@@ -345,18 +684,45 @@ export declare class OpenXiangdaApplicationServices {
         } | undefined;
         compatibility: ConfigurationValidationResult | null;
         stages: {
+            name: string;
+            state: "passed" | "failed" | "skipped";
             ok: boolean;
-            exitCode: number;
+            exitCode: number | null;
             output: string;
-            name: string;
+            reused?: boolean;
         }[];
         sealedArtifact: SealedArtifactStatus;
         appSpec: {
+            lifecycle: {
+                schemaVersion: "openxiangda.development-lifecycle/v2";
+                stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+                readyForImplementation: boolean;
+                design: {
+                    readyForImplementation: boolean;
+                    reviewId: string | null;
+                    scope: "change" | "initial" | null;
+                    baselineDigest: string | null;
+                    documentIds: string[];
+                    diagnostics: Diagnostic[];
+                };
+                readyForTest: boolean;
+                changeId: string | null;
+                acceptanceIds: string[];
+                currentSpecDigest: string | null;
+                diagnostics: Diagnostic[];
+                nextCommand: string;
+            };
             enabled: boolean;
-            mode: "advisory";
-            releaseGate: false;
+            mode: "guided";
+            releaseGate: true;
             workspaceDigest: string | null;
             selectionDigest: string | null;
+            historyPage: {
+                offset: number;
+                limit: number;
+                total: number;
+                nextOffset: number | null;
+            };
             contextBudget: {
                 maximumBytes: number;
                 contentBytes: number;
@@ -370,6 +736,7 @@ export declare class OpenXiangdaApplicationServices {
                 activeChanges: number;
                 historyChanges: number;
                 decisions: number;
+                designs: number;
                 requirements: number;
                 acceptanceScenarios: number;
             };
@@ -385,6 +752,7 @@ export declare class OpenXiangdaApplicationServices {
         ok: boolean;
         exitCode: number;
         output: string;
+        outputTruncated: boolean;
     }>>;
     build(input?: BuildOptions): Promise<DevkitResult<BuiltApplication>>;
     buildPreview(root?: string): Promise<{
@@ -401,18 +769,129 @@ export declare class OpenXiangdaApplicationServices {
                 } | undefined;
                 compatibility: ConfigurationValidationResult | null;
                 stages: {
+                    name: string;
+                    state: "passed" | "failed" | "skipped";
                     ok: boolean;
-                    exitCode: number;
+                    exitCode: number | null;
                     output: string;
+                    reused?: boolean;
+                }[];
+                sealedArtifact: SealedArtifactStatus;
+                appSpec: {
+                    lifecycle: {
+                        schemaVersion: "openxiangda.development-lifecycle/v2";
+                        stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+                        readyForImplementation: boolean;
+                        design: {
+                            readyForImplementation: boolean;
+                            reviewId: string | null;
+                            scope: "change" | "initial" | null;
+                            baselineDigest: string | null;
+                            documentIds: string[];
+                            diagnostics: Diagnostic[];
+                        };
+                        readyForTest: boolean;
+                        changeId: string | null;
+                        acceptanceIds: string[];
+                        currentSpecDigest: string | null;
+                        diagnostics: Diagnostic[];
+                        nextCommand: string;
+                    };
+                    enabled: boolean;
+                    mode: "guided";
+                    releaseGate: true;
+                    workspaceDigest: string | null;
+                    selectionDigest: string | null;
+                    historyPage: {
+                        offset: number;
+                        limit: number;
+                        total: number;
+                        nextOffset: number | null;
+                    };
+                    contextBudget: {
+                        maximumBytes: number;
+                        contentBytes: number;
+                        truncated: boolean;
+                        omitted: import("./app-spec.js").AppSpecDocumentSummary[];
+                    };
+                    stats: {
+                        files: number;
+                        bytes: number;
+                        capabilities: number;
+                        activeChanges: number;
+                        historyChanges: number;
+                        decisions: number;
+                        designs: number;
+                        requirements: number;
+                        acceptanceScenarios: number;
+                    };
+                    diagnostics: {
+                        errors: number;
+                        warnings: number;
+                        info: number;
+                    };
+                    nextCommand: string;
+                };
+            } | undefined;
+        };
+        ok: boolean;
+        workspace: WorkspaceIdentity;
+        diagnostics: Diagnostic[];
+        nextActions: import("openxiangda-contracts").NextAction[];
+        traceId?: string;
+    } | {
+        operation: string;
+        data: {
+            sealed: boolean;
+            packageDigest: null;
+            check: {
+                generated: {
+                    output: string;
+                    changed: boolean;
+                    contractDigest: string;
+                    aiCatalogDigest: string;
+                } | undefined;
+                compatibility: ConfigurationValidationResult | null;
+                stages: {
                     name: string;
+                    state: "passed" | "failed" | "skipped";
+                    ok: boolean;
+                    exitCode: number | null;
+                    output: string;
+                    reused?: boolean;
                 }[];
                 sealedArtifact: SealedArtifactStatus;
                 appSpec: {
+                    lifecycle: {
+                        schemaVersion: "openxiangda.development-lifecycle/v2";
+                        stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+                        readyForImplementation: boolean;
+                        design: {
+                            readyForImplementation: boolean;
+                            reviewId: string | null;
+                            scope: "change" | "initial" | null;
+                            baselineDigest: string | null;
+                            documentIds: string[];
+                            diagnostics: Diagnostic[];
+                        };
+                        readyForTest: boolean;
+                        changeId: string | null;
+                        acceptanceIds: string[];
+                        currentSpecDigest: string | null;
+                        diagnostics: Diagnostic[];
+                        nextCommand: string;
+                    };
                     enabled: boolean;
-                    mode: "advisory";
-                    releaseGate: false;
+                    mode: "guided";
+                    releaseGate: true;
                     workspaceDigest: string | null;
                     selectionDigest: string | null;
+                    historyPage: {
+                        offset: number;
+                        limit: number;
+                        total: number;
+                        nextOffset: number | null;
+                    };
                     contextBudget: {
                         maximumBytes: number;
                         contentBytes: number;
@@ -426,6 +905,7 @@ export declare class OpenXiangdaApplicationServices {
                         activeChanges: number;
                         historyChanges: number;
                         decisions: number;
+                        designs: number;
                         requirements: number;
                         acceptanceScenarios: number;
                     };
@@ -446,20 +926,82 @@ export declare class OpenXiangdaApplicationServices {
     }>;
     private buildSealed;
     deploymentPlan(input: {
+        deploymentStrategy?: DeploymentStrategy;
         root?: string;
         environment: "preproduction";
+        environmentId?: string;
+        idempotencyKey?: string;
     }): Promise<DevkitResult<undefined> | DevkitResult<{
+        lifecycle: {
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+    }> | DevkitResult<{
+        runtimeCapacity: import("openxiangda-contracts").RuntimeCapacityPreflight;
         environment: "preproduction";
         appCode: string;
         sealed: boolean;
         packageDigest: null;
         buildOwner: string;
+        source: import("./delivery-source.js").PublishedDeliverySource;
         frontendRoot: string;
         backendRoot: string;
         configDigest: string;
         contractDigest: string;
     }>>;
-    deploy(input: DeployOptions): Promise<DevkitResult<undefined> | DevkitResult<SealedApplication> | DevkitResult<DeploymentRun> | {
+    deploy(input: DeployOptions): Promise<DevkitResult<undefined> | DevkitResult<{
+        lifecycle: {
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+    }> | DevkitResult<{
+        sealedArtifact: SealedArtifactStatus;
+        package: CompiledAppPackage;
+        artifactContent: Record<string, string>;
+    }> | DevkitResult<DeploymentRun> | {
+        operation: string;
+        ok: boolean;
+        workspace: WorkspaceIdentity;
+        data?: {
+            output: string;
+            changed: boolean;
+            contractDigest: string;
+            aiCatalogDigest: string;
+        };
+        diagnostics: Diagnostic[];
+        nextActions: import("openxiangda-contracts").NextAction[];
+        traceId?: string;
+    } | {
         operation: string;
         ok: boolean;
         workspace: WorkspaceIdentity;
@@ -472,18 +1014,45 @@ export declare class OpenXiangdaApplicationServices {
             } | undefined;
             compatibility: ConfigurationValidationResult | null;
             stages: {
+                name: string;
+                state: "passed" | "failed" | "skipped";
                 ok: boolean;
-                exitCode: number;
+                exitCode: number | null;
                 output: string;
-                name: string;
+                reused?: boolean;
             }[];
             sealedArtifact: SealedArtifactStatus;
             appSpec: {
+                lifecycle: {
+                    schemaVersion: "openxiangda.development-lifecycle/v2";
+                    stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+                    readyForImplementation: boolean;
+                    design: {
+                        readyForImplementation: boolean;
+                        reviewId: string | null;
+                        scope: "change" | "initial" | null;
+                        baselineDigest: string | null;
+                        documentIds: string[];
+                        diagnostics: Diagnostic[];
+                    };
+                    readyForTest: boolean;
+                    changeId: string | null;
+                    acceptanceIds: string[];
+                    currentSpecDigest: string | null;
+                    diagnostics: Diagnostic[];
+                    nextCommand: string;
+                };
                 enabled: boolean;
-                mode: "advisory";
-                releaseGate: false;
+                mode: "guided";
+                releaseGate: true;
                 workspaceDigest: string | null;
                 selectionDigest: string | null;
+                historyPage: {
+                    offset: number;
+                    limit: number;
+                    total: number;
+                    nextOffset: number | null;
+                };
                 contextBudget: {
                     maximumBytes: number;
                     contentBytes: number;
@@ -497,6 +1066,7 @@ export declare class OpenXiangdaApplicationServices {
                     activeChanges: number;
                     historyChanges: number;
                     decisions: number;
+                    designs: number;
                     requirements: number;
                     acceptanceScenarios: number;
                 };
@@ -512,6 +1082,7 @@ export declare class OpenXiangdaApplicationServices {
         nextActions: import("openxiangda-contracts").NextAction[];
         traceId?: string;
     }>;
+    private runtimeCapacityPlan;
     deploymentStatus(root: string | undefined, deploymentId?: string): Promise<DevkitResult<undefined> | DevkitResult<DeploymentRun>>;
     environmentStatus(root?: string): Promise<DevkitResult<import("openxiangda-contracts").ApplicationEnvironmentList>>;
     startEnvironment(root: string | undefined, environment: DeploymentEnvironment, options?: {
@@ -562,6 +1133,16 @@ export declare class OpenXiangdaApplicationServices {
     retry(root: string | undefined, deploymentId: string): Promise<DevkitResult<DeploymentRun>>;
     cancel(root: string | undefined, deploymentId: string): Promise<DevkitResult<DeploymentRun>>;
     private deploymentRecoveryActions;
+    productionDeploymentPlan(root: string | undefined, deploymentId: string): Promise<DevkitResult<{
+        environment: string;
+        sourceDeploymentId: string;
+        appVersionId: string;
+        packageDigest: string;
+        sealed: boolean;
+        submitted: boolean;
+        rebuild: boolean;
+        businessAcceptance: string;
+    }>>;
     deployProduction(root: string | undefined, deploymentId: string): Promise<DevkitResult<undefined> | DevkitResult<DeploymentRun>>;
     private productionPromotionDiagnostics;
     rollback(root: string | undefined, environment: DeploymentEnvironment, appVersionId: string, options?: {
@@ -581,7 +1162,10 @@ export declare class OpenXiangdaApplicationServices {
     private configurationCompatibilityDiagnostic;
     private client;
     private get toolchainVersion();
+    private deliveryCacheContext;
     private get toolchainCapsule();
+    private initializeBackend;
+    private packageScriptLabel;
     private runPackageScript;
     private repositoryIdentity;
     private directoryBundle;
@@ -596,5 +1180,4 @@ export declare class OpenXiangdaApplicationServices {
     private ok;
     private result;
 }
-export {};
 //# sourceMappingURL=application-services.d.ts.map