sdd-mcp-server 4.0.0 → 5.0.0

package/dist/application/services/WorkflowEngineService.d.ts

@@ -1,21 +1,44 @@
-import { Project, WorkflowPhase } from '../../domain/types.js';
+import { PhaseRecord, Project, TaskStatus, WorkflowPhase } from '../../domain/types.js';
 import { ProjectRepository, LoggerPort, FileSystemPort } from '../../domain/ports.js';
-import { ProjectService } from './ProjectService.js';
-import { TemplateService } from './TemplateService.js';
-import { ContextCompactionService, ApprovablePhase } from './ContextCompactionService.js';
+import { ContextCompactionService, type ApprovablePhase, type ContextLoadRequest, type ContextLoadResult } from './ContextCompactionService.js';
+import { type DesignValidationResult } from './WorkflowValidationService.js';
+export type NextAction = {
+    kind: 'submit-phase' | 'revise-phase' | 'request-approval';
+    phase: ApprovablePhase;
+} | {
+    kind: 'review-test-cases';
+    phase: 'tasks';
+} | {
+    kind: 'start-implementation';
+} | {
+    kind: 'continue-task';
+    taskNumber: string;
+    taskState: TaskStatus;
+} | {
+    kind: 'select-task';
+    candidates: Array<{
+        taskNumber: string;
+        taskState: TaskStatus;
+    }>;
+} | {
+    kind: 'blocked';
+    code: 'ArtifactDrift';
+    phase: ApprovablePhase;
+} | {
+    kind: 'complete';
+};
 export interface ApprovalRequest {
     readonly projectRoot: string;
     readonly featureName: string;
     readonly phase: ApprovablePhase;
+    readonly expectedRevision: number;
+    readonly expectedArtifactSha256: string;
 }
 export interface ReviewTestCasesRequest {
     readonly projectRoot: string;
     readonly featureName: string;
-}
-export interface RollbackRequest {
-    readonly projectRoot: string;
-    readonly featureName: string;
-    readonly triggeredBy: string;
+    readonly expectedTasksRevision: number;
+    readonly expectedArtifactSha256: string;
 }
 export interface HandoffPublication {
     readonly status: 'published' | 'pending-regeneration';
@@ -37,7 +60,9 @@ export interface ApprovalResult {
 export interface ReviewTestCasesResult {
     readonly featureName: string;
     readonly reviewed: true;
-    readonly canApproveTasks: boolean;
+    readonly tasksRevision: number;
+    readonly artifactSha256: string;
+    readonly canApproveTasks: true;
     readonly handoff: HandoffPublication;
 }
 export interface FeatureRequest {
@@ -45,68 +70,153 @@ export interface FeatureRequest {
     readonly featureName: string;
 }
 export interface InitializeFeatureRequest extends FeatureRequest {
-    readonly language: string;
-    readonly reviewTestCases: boolean;
+    readonly description: string;
+    readonly language?: 'en' | 'ja' | 'zh-TW';
 }
-export interface GeneratePhaseRequest extends FeatureRequest {
+export interface SubmitPhaseArtifactRequest extends FeatureRequest {
     readonly phase: ApprovablePhase;
+    readonly content: string;
+    readonly expectedRevision: number;
+    readonly expectedArtifactSha256: string | null;
     readonly reviewTestCases?: boolean;
 }
+export interface PhaseSubmissionResult {
+    readonly featureName: string;
+    readonly phase: ApprovablePhase;
+    readonly revision: number;
+    readonly artifact: {
+        readonly path: string;
+        readonly sha256: string;
+    };
+    readonly validation: {
+        readonly status: 'passed' | 'failed';
+        readonly blockers: readonly {
+            code: string;
+            message: string;
+            reference?: string;
+        }[];
+    };
+    readonly approvalRequired: boolean;
+}
 export interface DurableFeatureStatus {
     readonly featureName: string;
     readonly phase: WorkflowPhase;
-    readonly currentPhase?: WorkflowPhase;
-    readonly nextPhase?: WorkflowPhase;
-    readonly canProgress?: boolean;
-    readonly blockers?: string[];
-    readonly testCases?: {
+    readonly currentPhase: WorkflowPhase;
+    readonly nextAction: NextAction;
+    readonly blockers: readonly string[];
+    readonly phases: Record<ApprovablePhase, PhaseRecord & {
+        observedArtifactSha256?: string;
+    }>;
+    readonly checkpoint: {
         required: boolean;
         reviewed: boolean;
+        reviewedRevision?: number;
+        reviewedArtifactSha256?: string;
+    };
+    readonly implementation?: {
+        revision: number;
+        completed: number;
+        total: number;
+        active: number;
+        blocked: number;
     };
 }
+export interface RecordTaskProgressRequest extends FeatureRequest {
+    readonly taskNumber: string;
+    readonly action: 'start' | 'record-red' | 'record-green' | 'complete' | 'block';
+    readonly expectedRevision: number;
+    readonly evidence?: {
+        command: string;
+        exitCode: number;
+        summary: string;
+    };
+    readonly affectedArtifacts?: string[];
+    readonly blocker?: string;
+}
 export declare class WorkflowEngineService {
     private readonly projectRepository;
-    private readonly projectService;
-    private readonly templateService;
     private readonly contextCompactionService;
     private readonly logger;
     private readonly fileSystem?;
-    private static readonly featureLocks;
-    constructor(projectRepository: ProjectRepository, projectService: ProjectService, templateService: TemplateService, contextCompactionService: ContextCompactionService, logger: LoggerPort, fileSystem?: FileSystemPort);
+    private readonly validator;
+    constructor(projectRepository: ProjectRepository, contextCompactionService: ContextCompactionService, logger: LoggerPort, fileSystem?: FileSystemPort);
+    initializeFeature(request: InitializeFeatureRequest): Promise<Project>;
+    submitPhaseArtifact(request: SubmitPhaseArtifactRequest): Promise<PhaseSubmissionResult>;
     approve(request: ApprovalRequest): Promise<ApprovalResult>;
     reviewTestCases(request: ReviewTestCasesRequest): Promise<ReviewTestCasesResult>;
-    rollback(request: RollbackRequest): Promise<{
-        readonly featureName: string;
-        readonly rolledBackPhase: ApprovablePhase;
-        readonly handoff: HandoffPublication;
+    beginImplementation(request: FeatureRequest): Promise<{
+        featureName: string;
+        phase: WorkflowPhase.IMPLEMENTATION | WorkflowPhase.IMPLEMENTATION_COMPLETED;
+        ready: true;
+        revision: number;
+        tasks: {
+            completed: number;
+            total: number;
+            active: number;
+            blocked: number;
+        };
+        nextAction: NextAction;
+        handoff: HandoffPublication;
     }>;
-    initializeFeature(request: InitializeFeatureRequest): Promise<Project>;
+    recordTaskProgress(request: RecordTaskProgressRequest): Promise<{
+        featureName: string;
+        taskNumber: string;
+        taskState: TaskStatus;
+        revision: number;
+        nextAction: NextAction;
+        handoff: HandoffPublication;
+    }>;
+    getFeatureStatus(request: FeatureRequest): Promise<DurableFeatureStatus>;
+    loadFeatureContext(request: ContextLoadRequest): Promise<ContextLoadResult>;
     listFeatureStatuses(request: {
-        readonly projectRoot: string;
+        projectRoot: string;
     }): Promise<DurableFeatureStatus[]>;
-    getFeatureStatus(request: FeatureRequest): Promise<DurableFeatureStatus>;
     loadProject(request: FeatureRequest): Promise<Project>;
-    generatePhase(request: GeneratePhaseRequest): Promise<string>;
-    beginImplementation(request: FeatureRequest): Promise<{
-        readonly featureName: string;
-        readonly phase: WorkflowPhase;
-        readonly ready: true;
-    }>;
-    private requireAtomicFileSystem;
-    private assertPhaseCanBeGenerated;
-    private persistPhaseDocument;
-    private buildGeneratedSpec;
-    private renderPhase;
-    private phaseTitle;
+    validateDesignArtifact(request: FeatureRequest): Promise<DesignValidationResult>;
+    private withLockedFeature;
+    private normalizeSpec;
+    private buildStatus;
+    private resolveNextAction;
+    private validate;
+    private readUpstream;
+    private assertNoApprovedArtifactDrift;
+    private commitPhaseSubmission;
+    private recoverSubmission;
+    private replaceCas;
+    private parseLegacyTasks;
+    private visibleLegacyLines;
     private hydrateProject;
-    private readDate;
-    private readWorkflowPhase;
-    private resolveProgression;
-    private withFeatureLock;
-    private readDiskSpec;
-    private readApprovals;
-    private readReviewState;
-    private writeSpecAtomic;
+    private assertPriorApproved;
+    private assertLegacyOrdering;
+    private assertLegacyPhaseRank;
+    private phaseValue;
+    private legacyPhaseValue;
+    private implementationCounts;
+    private allComplete;
+    private invalidTransition;
+    private evidence;
+    private normalizeArtifacts;
+    private requireAtomicFileSystem;
+    private normalizeV5;
+    private normalizeV5Implementation;
+    private normalizeV5Evidence;
+    private requireSpecRecord;
+    private requireStringArray;
+    private assertPersistedArtifactPaths;
+    private isProjectRelativePath;
+    private assertV5Invariants;
+    private assertImplementationTasks;
+    private assertExecutionEvidence;
+    private specBytes;
+    private persistSpecCas;
+    private parseSpecBytes;
+    private requireArtifact;
+    private readRequired;
+    private assertGovernedFilesContained;
+    private readOptional;
+    private readOptionalSync;
+    private artifactPhaseFromJournal;
+    private assertJournalValidation;
+    private journalAncillaryState;
     private publishHandoff;
-    private synchronizeRepository;
 }