phasegate 0.91.0 → 0.108.0

package/scripts/harness/traceability-model/application/usecases/validate-design-story-annotations-usecase.ts

@@ -3,16 +3,18 @@
  * @unit traceability-model
  */
 
-import type { MetadataValidationOutput } from '../dto/metadata-validation-output.js';
-import type { DesignDocumentPort } from '../../domain/ports/design-document-port.js';
-import type { MetadataValidator } from '../../domain/services/metadata-validator.js';
-import type { MetadataValidationResult } from '../../domain/value-objects/metadata-validation-result.js';
-import type { ProjectRelativePath } from '../../domain/value-objects/project-relative-path.js';
+import type { DesignDocumentPort } from "../../domain/ports/design-document-port.js";
+import type { MetadataValidator } from "../../domain/services/metadata-validator.js";
+import {
+  MetadataValidationResult,
+  type TraceabilityHarnessError,
+} from "../../domain/value-objects/metadata-validation-result.js";
+import type { ProjectRelativePath } from "../../domain/value-objects/project-relative-path.js";
+import type { WorkItemFrontmatter } from "../../domain/value-objects/work-item-frontmatter.js";
+import { WorkItemFrontmatterValidationError } from "../../domain/value-objects/work-item-frontmatter.js";
+import type { MetadataValidationOutput } from "../dto/metadata-validation-output.js";
 
-type DesignStoryAnnotationsValidator = Pick<
-  MetadataValidator,
-  'validateDesignDocument'
->;
+type DesignStoryAnnotationsValidator = Pick<MetadataValidator, "validateDesignDocument">;
 
 const toOutput = (
   filePath: ProjectRelativePath,
@@ -25,13 +27,63 @@ const toOutput = (
     warnings: result.warnings,
   });
 
+const toWorkItemFrontmatterError = (error: WorkItemFrontmatterValidationError): TraceabilityHarnessError =>
+  Object.freeze({
+    code: "L2-002",
+    severity: "error",
+    message: error.message,
+    suggestion: "WI frontmatter の id/type/severity/status 形式を確認してください",
+    fix_example: `---
+id: WI-001
+type: story
+severity: normal
+status: drafted
+---`,
+  });
+
+const mergeValidationResult = (
+  additionalErrors: readonly TraceabilityHarnessError[],
+  result: MetadataValidationResult,
+): MetadataValidationResult => {
+  if (additionalErrors.length === 0) {
+    return result;
+  }
+
+  return MetadataValidationResult.failure({
+    errors: Object.freeze([...additionalErrors, ...result.errors]),
+    warnings: result.warnings,
+  });
+};
+
+const STORY_ID_REQUIRED_MESSAGE = "@story-id は必須です";
+
+const acceptWorkItemFrontmatterAsStoryTrace = (
+  filePath: ProjectRelativePath,
+  frontmatter: WorkItemFrontmatter | null,
+  result: MetadataValidationResult,
+): MetadataValidationResult => {
+  const isWorkItemPath = /(?:^|\/)_cross\/WI-\d+(?:\/|$)/.test(filePath.toString());
+  if (frontmatter === null && !isWorkItemPath) {
+    return result;
+  }
+
+  const errors = result.errors.filter((error) => error.message !== STORY_ID_REQUIRED_MESSAGE);
+  if (errors.length === result.errors.length) {
+    return result;
+  }
+  if (errors.length === 0) {
+    return MetadataValidationResult.success({ warnings: result.warnings });
+  }
+  return MetadataValidationResult.failure({ errors, warnings: result.warnings });
+};
+
 export class DesignDocumentReadApplicationError extends Error {
   readonly filePath: string;
   readonly cause: unknown;
 
   constructor(filePath: string, cause: unknown) {
     super(`design document read failed: ${filePath}`);
-    this.name = 'DesignDocumentReadApplicationError';
+    this.name = "DesignDocumentReadApplicationError";
     this.filePath = filePath;
     this.cause = cause;
   }
@@ -51,18 +103,30 @@ export class ValidateDesignStoryAnnotationsUseCase {
     this.validator = deps.validator;
   }
 
-  async execute(
-    filePaths: readonly ProjectRelativePath[],
-  ): Promise<readonly Readonly<MetadataValidationOutput>[]> {
+  async execute(filePaths: readonly ProjectRelativePath[]): Promise<readonly Readonly<MetadataValidationOutput>[]> {
     const results: Readonly<MetadataValidationOutput>[] = [];
 
     for (const filePath of filePaths) {
       try {
-        if (typeof this.designDocumentPort.readFrontmatterFlags !== 'function') {
-          throw new Error('readFrontmatterFlags is not implemented');
+        if (typeof this.designDocumentPort.readFrontmatterFlags !== "function") {
+          throw new Error("readFrontmatterFlags is not implemented");
         }
-        if (typeof this.designDocumentPort.readStoryAnnotations !== 'function') {
-          throw new Error('readStoryAnnotations is not implemented');
+        if (typeof this.designDocumentPort.readStoryAnnotations !== "function") {
+          throw new Error("readStoryAnnotations is not implemented");
+        }
+
+        const workItemFrontmatterErrors: TraceabilityHarnessError[] = [];
+        let workItemFrontmatter: WorkItemFrontmatter | null = null;
+        if (typeof this.designDocumentPort.readWorkItemFrontmatter === "function") {
+          try {
+            workItemFrontmatter = await this.designDocumentPort.readWorkItemFrontmatter(filePath);
+          } catch (error) {
+            if (error instanceof WorkItemFrontmatterValidationError) {
+              workItemFrontmatterErrors.push(toWorkItemFrontmatterError(error));
+            } else {
+              throw error;
+            }
+          }
         }
 
         const flags = await this.designDocumentPort.readFrontmatterFlags(filePath);
@@ -72,7 +136,8 @@ export class ValidateDesignStoryAnnotationsUseCase {
           annotations,
           flags,
         });
-        results.push(toOutput(filePath, result));
+        const resultWithWorkItemTrace = acceptWorkItemFrontmatterAsStoryTrace(filePath, workItemFrontmatter, result);
+        results.push(toOutput(filePath, mergeValidationResult(workItemFrontmatterErrors, resultWithWorkItemTrace)));
       } catch (error) {
         throw new DesignDocumentReadApplicationError(filePath.toString(), error);
       }

package/scripts/harness/traceability-model/composition-root.ts

@@ -5,19 +5,25 @@
  * traceability-model ユニットの Composition Root。
  * 全コンポーネントを生成・配線し、外部に公開するハンドラー群を返す。
  */
-import { MarkdownStoryCatalogGateway } from './infrastructure/gateways/markdown-story-catalog-gateway.js';
-import { MarkdownUnitDefinitionGateway } from './infrastructure/gateways/markdown-unit-definition-gateway.js';
-import { FileSystemMetadataReader } from './infrastructure/gateways/file-system-metadata-reader.js';
-import { MarkdownDesignDocumentGateway } from './infrastructure/gateways/markdown-design-document-gateway.js';
-import { FileSystemInceptionPlanGateway } from './infrastructure/gateways/file-system-inception-plan-gateway.js';
-import { MetadataValidator } from './domain/services/metadata-validator.js';
-import { TraceabilityChainBuilder } from './domain/services/traceability-chain-builder.js';
-import { StoryIdAliasResolver } from './domain/services/story-id-alias-resolver.js';
-import { ValidateImplementationMetadataUseCase } from './application/usecases/validate-implementation-metadata-usecase.js';
-import { ValidateDesignStoryAnnotationsUseCase } from './application/usecases/validate-design-story-annotations-usecase.js';
-import { ValidateTestStoryMetadataUseCase } from './application/usecases/validate-test-story-metadata-usecase.js';
-import { ValidateMetadataCommandHandler } from './presentation/cli/validate-metadata-command-handler.js';
-import { ProjectRelativePath } from './domain/value-objects/project-relative-path.js';
+
+import { ApplyWorkItemMigrationUseCase } from "./application/usecases/apply-work-item-migration-usecase.js";
+import { PlanWorkItemMigrationUseCase } from "./application/usecases/plan-work-item-migration-usecase.js";
+import { ValidateDesignStoryAnnotationsUseCase } from "./application/usecases/validate-design-story-annotations-usecase.js";
+import { ValidateImplementationMetadataUseCase } from "./application/usecases/validate-implementation-metadata-usecase.js";
+import { ValidateTestStoryMetadataUseCase } from "./application/usecases/validate-test-story-metadata-usecase.js";
+import { MetadataValidator } from "./domain/services/metadata-validator.js";
+import { StoryIdAliasResolver } from "./domain/services/story-id-alias-resolver.js";
+import { TraceabilityChainBuilder } from "./domain/services/traceability-chain-builder.js";
+import { ProjectRelativePath } from "./domain/value-objects/project-relative-path.js";
+import { FileSystemInceptionPlanGateway } from "./infrastructure/gateways/file-system-inception-plan-gateway.js";
+import { FileSystemMetadataReader } from "./infrastructure/gateways/file-system-metadata-reader.js";
+import { FileSystemWorkItemMigrationApplyGateway } from "./infrastructure/gateways/file-system-work-item-migration-apply-gateway.js";
+import { FileSystemWorkItemMigrationSourceGateway } from "./infrastructure/gateways/file-system-work-item-migration-source-gateway.js";
+import { MarkdownDesignDocumentGateway } from "./infrastructure/gateways/markdown-design-document-gateway.js";
+import { MarkdownStoryCatalogGateway } from "./infrastructure/gateways/markdown-story-catalog-gateway.js";
+import { MarkdownUnitDefinitionGateway } from "./infrastructure/gateways/markdown-unit-definition-gateway.js";
+import { MigrateWorkItemsCommandHandler } from "./presentation/cli/migrate-work-items-command-handler.js";
+import { ValidateMetadataCommandHandler } from "./presentation/cli/validate-metadata-command-handler.js";
 
 export function createTraceabilityModelModule(rootDir: string) {
   // Infrastructure gateways
@@ -26,6 +32,8 @@ export function createTraceabilityModelModule(rootDir: string) {
   const metadataReader = new FileSystemMetadataReader({ rootDir });
   const designDocument = new MarkdownDesignDocumentGateway({ rootDir });
   const inceptionPlan = new FileSystemInceptionPlanGateway({ rootDir });
+  const workItemMigrationSource = new FileSystemWorkItemMigrationSourceGateway({ rootDir });
+  const workItemMigrationApply = new FileSystemWorkItemMigrationApplyGateway({ rootDir });
 
   // Domain services
   const metadataValidator = new MetadataValidator({
@@ -42,34 +50,44 @@ export function createTraceabilityModelModule(rootDir: string) {
   const storyIdAliasResolver = new StoryIdAliasResolver(storyCatalog);
 
   // Usecases
-  const validateImplementationMetadataUseCase =
-    new ValidateImplementationMetadataUseCase({
-      metadataReaderPort: metadataReader,
-      validator: metadataValidator,
-    });
-  const validateDesignStoryAnnotationsUseCase =
-    new ValidateDesignStoryAnnotationsUseCase({
-      designDocumentPort: designDocument,
-      validator: metadataValidator,
-    });
-  const validateTestStoryMetadataUseCase =
-    new ValidateTestStoryMetadataUseCase({
-      metadataReaderPort: metadataReader,
-      validator: metadataValidator,
-    });
+  const validateImplementationMetadataUseCase = new ValidateImplementationMetadataUseCase({
+    metadataReaderPort: metadataReader,
+    validator: metadataValidator,
+  });
+  const validateDesignStoryAnnotationsUseCase = new ValidateDesignStoryAnnotationsUseCase({
+    designDocumentPort: designDocument,
+    validator: metadataValidator,
+  });
+  const validateTestStoryMetadataUseCase = new ValidateTestStoryMetadataUseCase({
+    metadataReaderPort: metadataReader,
+    validator: metadataValidator,
+  });
+  const planWorkItemMigrationUseCase = new PlanWorkItemMigrationUseCase({
+    sourcePort: workItemMigrationSource,
+  });
+  const applyWorkItemMigrationUseCase = new ApplyWorkItemMigrationUseCase({
+    planWorkItemMigrationUseCase,
+    applyPort: workItemMigrationApply,
+  });
 
   // Presentation handlers
   const validateMetadataCommandHandler = new ValidateMetadataCommandHandler({
     validateImplementationMetadataUseCase,
     validateDesignStoryAnnotationsUseCase,
     validateTestStoryMetadataUseCase,
-    createProjectRelativePath: (value: string) =>
-      ProjectRelativePath.create(value),
+    createProjectRelativePath: (value: string) => ProjectRelativePath.create(value),
+  });
+  const migrateWorkItemsCommandHandler = new MigrateWorkItemsCommandHandler({
+    planWorkItemMigrationUseCase,
+    applyWorkItemMigrationUseCase,
   });
 
   return {
     validateMetadataCommandHandler,
+    migrateWorkItemsCommandHandler,
     // expose key services for cross-unit use
     storyCatalog,
+    traceabilityChainBuilder,
+    storyIdAliasResolver,
   } as const;
 }

package/scripts/harness/traceability-model/domain/ports/design-document-port.ts

@@ -3,22 +3,16 @@
  * @unit traceability-model
  */
 
-import type { ProjectRelativePathLike } from '../value-objects/chain-link.js';
-import type { DesignDocumentFlags } from '../value-objects/design-document-flags.js';
-import type { StoryIdAnnotation } from '../value-objects/story-id-annotation.js';
+import type { ProjectRelativePathLike } from "../value-objects/chain-link.js";
+import type { DesignDocumentFlags } from "../value-objects/design-document-flags.js";
+import type { StoryIdAnnotation } from "../value-objects/story-id-annotation.js";
+import type { WorkItemFrontmatter } from "../value-objects/work-item-frontmatter.js";
 
 export interface DesignDocumentPort {
   listByUnit?(unitName: string): Promise<readonly ProjectRelativePathLike[]>;
-  findConstructionDocuments?(
-    unitName: string,
-  ): Promise<readonly ProjectRelativePathLike[]>;
-  readStoryAnnotations?(
-    filePath: ProjectRelativePathLike,
-  ): Promise<readonly StoryIdAnnotation[]>;
-  readStoryIdAnnotations?(
-    filePath: ProjectRelativePathLike,
-  ): Promise<readonly StoryIdAnnotation[]>;
-  readFrontmatterFlags?(
-    filePath: ProjectRelativePathLike,
-  ): Promise<DesignDocumentFlags>;
+  findConstructionDocuments?(unitName: string): Promise<readonly ProjectRelativePathLike[]>;
+  readStoryAnnotations?(filePath: ProjectRelativePathLike): Promise<readonly StoryIdAnnotation[]>;
+  readStoryIdAnnotations?(filePath: ProjectRelativePathLike): Promise<readonly StoryIdAnnotation[]>;
+  readFrontmatterFlags?(filePath: ProjectRelativePathLike): Promise<DesignDocumentFlags>;
+  readWorkItemFrontmatter?(filePath: ProjectRelativePathLike): Promise<WorkItemFrontmatter | null>;
 }

package/scripts/harness/traceability-model/domain/ports/work-item-migration-apply-port.ts

@@ -0,0 +1,11 @@
+// @unit traceability-model
+// @layer domain
+
+import type {
+  WorkItemMigrationAppliedCandidate,
+  WorkItemMigrationCandidate,
+} from "../value-objects/work-item-migration-candidate.js";
+
+export interface WorkItemMigrationApplyPort {
+  apply(candidate: WorkItemMigrationCandidate): Promise<WorkItemMigrationAppliedCandidate>;
+}

package/scripts/harness/traceability-model/domain/ports/work-item-migration-source-port.ts

@@ -0,0 +1,9 @@
+// @unit traceability-model
+// @layer domain
+
+import type { LegacyIssueDirectory } from "../value-objects/work-item-migration-candidate.js";
+
+export interface WorkItemMigrationSourcePort {
+  listLegacyIssueDirectories(): Promise<readonly LegacyIssueDirectory[]>;
+  listExistingWorkItemIds(): Promise<readonly string[]>;
+}

package/scripts/harness/traceability-model/domain/services/work-item-migration-planner.ts

@@ -0,0 +1,162 @@
+// @unit traceability-model
+// @layer domain
+
+import type {
+  LegacyIssueDirectory,
+  WorkItemMigrationCandidate,
+  WorkItemMigrationPlan,
+} from "../value-objects/work-item-migration-candidate.js";
+
+const ISSUE_ID_PATTERN = /^ISSUE-(\d+)$/;
+const WI_ID_PATTERN = /^WI-(\d+)$/;
+const H_ID_PATTERN = /^H\d{2}-\d{2}$/;
+
+type LegacyIdKind = "wi" | "issue" | "h" | "unknown";
+type WorkItemKind = "issue" | "story";
+
+export class WorkItemMigrationPlanner {
+  plan(
+    entries: readonly LegacyIssueDirectory[],
+    existingWorkItemIds: readonly string[] = [],
+  ): WorkItemMigrationPlan {
+    const candidates: WorkItemMigrationCandidate[] = [];
+    const warnings: string[] = [];
+
+    const usedNumbers = new Set<number>();
+    for (const id of existingWorkItemIds) {
+      const num = parseWorkItemNumber(id);
+      if (num !== null) usedNumbers.add(num);
+    }
+    for (const entry of entries) {
+      const fixed = toFixedWorkItemId(entry.legacyId);
+      if (fixed === null) continue;
+      const num = parseWorkItemNumber(fixed);
+      if (num !== null) usedNumbers.add(num);
+    }
+
+    let cursor = 1;
+
+    for (const entry of entries) {
+      const kind = classifyLegacyId(entry.legacyId);
+      let nextId: string;
+      let workItemKind: WorkItemKind;
+
+      if (kind === "wi" || kind === "issue") {
+        const fixed = toFixedWorkItemId(entry.legacyId);
+        if (fixed === null) {
+          warnings.push(`unsupported legacy id: ${entry.legacyId}`);
+          continue;
+        }
+        nextId = fixed;
+        workItemKind = "issue";
+      } else if (kind === "h") {
+        while (usedNumbers.has(cursor)) cursor++;
+        nextId = `WI-${String(cursor).padStart(3, "0")}`;
+        usedNumbers.add(cursor);
+        cursor++;
+        workItemKind = "story";
+      } else {
+        warnings.push(`unsupported legacy id: ${entry.legacyId}`);
+        continue;
+      }
+
+      const affects = extractAffects(entry.content);
+      if (entry.scope === "cross" && affects.length === 0) {
+        warnings.push(`${entry.legacyId}: cross-unit WI requires affects`);
+      }
+
+      const targetPath =
+        entry.scope === "cross" ? `docs/inception/_cross/${nextId}` : `docs/inception/${entry.unitName}/${nextId}`;
+
+      candidates.push({
+        legacyId: entry.legacyId,
+        nextId,
+        sourcePath: entry.sourcePath,
+        targetPath,
+        scope: entry.scope,
+        ...(entry.unitName !== undefined ? { unitName: entry.unitName } : {}),
+        descriptionFileName: entry.descriptionFileName,
+        conflict: entry.targetExists,
+        frontmatterPreview: buildFrontmatterPreview({
+          nextId,
+          legacyId: entry.legacyId,
+          severity: extractSeverity(entry.content),
+          affects,
+          includeAffects: entry.scope === "cross",
+          workItemKind,
+        }),
+      });
+    }
+
+    return Object.freeze({
+      candidates: Object.freeze(candidates),
+      warnings: Object.freeze(warnings),
+    });
+  }
+}
+
+function classifyLegacyId(legacyId: string): LegacyIdKind {
+  if (WI_ID_PATTERN.test(legacyId)) return "wi";
+  if (ISSUE_ID_PATTERN.test(legacyId)) return "issue";
+  if (H_ID_PATTERN.test(legacyId)) return "h";
+  return "unknown";
+}
+
+function toFixedWorkItemId(legacyId: string): string | null {
+  if (WI_ID_PATTERN.test(legacyId)) return legacyId;
+
+  const match = ISSUE_ID_PATTERN.exec(legacyId);
+  if (!match) return null;
+
+  return `WI-${match[1].padStart(3, "0")}`;
+}
+
+function parseWorkItemNumber(id: string): number | null {
+  const match = WI_ID_PATTERN.exec(id);
+  if (!match) return null;
+  const num = Number.parseInt(match[1], 10);
+  return Number.isFinite(num) ? num : null;
+}
+
+function extractSeverity(content: string): "trivial" | "normal" | "high" {
+  if (/深刻度\*\*:\s*High/i.test(content)) return "high";
+  if (/深刻度\*\*:\s*Trivial/i.test(content)) return "trivial";
+  return "normal";
+}
+
+function extractAffects(content: string): readonly string[] {
+  const match = /\*\*影響Unit\*\*:\s*(.+)/.exec(content);
+  if (!match) return Object.freeze([]);
+
+  return Object.freeze(
+    match[1]
+      .split(",")
+      .map((value) => value.trim())
+      .filter((value) => value.length > 0),
+  );
+}
+
+function buildFrontmatterPreview(args: {
+  readonly nextId: string;
+  readonly legacyId: string;
+  readonly severity: "trivial" | "normal" | "high";
+  readonly affects: readonly string[];
+  readonly includeAffects: boolean;
+  readonly workItemKind: WorkItemKind;
+}): string {
+  const lines = [
+    "---",
+    `id: ${args.nextId}`,
+    `type: ${args.workItemKind}`,
+    `severity: ${args.severity}`,
+    "status: drafted",
+    `legacy_id: ${args.legacyId}`,
+  ];
+
+  if (args.includeAffects && args.affects.length > 0) {
+    lines.push(`affects: [${args.affects.join(", ")}]`);
+  }
+
+  lines.push("---");
+  return lines.join("\n");
+}

package/scripts/harness/traceability-model/domain/value-objects/work-item-frontmatter.ts

@@ -0,0 +1,57 @@
+// @unit traceability-model
+// @layer domain
+/**
+ * WorkItemFrontmatter — 設計文書 frontmatter から抽出した WI メタデータ（H03-04 / ISSUE-026 Phase A-2）。
+ *
+ * 既存 `parseFrontmatterFlags` (initial_creation) とは独立した型系統で、
+ * WI 一本化の識別と type 別振る舞いの基盤を提供する。
+ */
+
+export type WorkItemType = 'story' | 'issue' | 'fix' | 'refactor' | 'chore';
+export type WorkItemSeverity = 'trivial' | 'normal' | 'high';
+export type WorkItemStatus =
+  | 'drafted'
+  | 'reflected'
+  | 'implemented'
+  | 'tested';
+
+export interface WorkItemFrontmatter {
+  readonly id: string;
+  readonly type: WorkItemType;
+  readonly affects?: readonly string[];
+  readonly severity?: WorkItemSeverity;
+  readonly status?: WorkItemStatus;
+  readonly source?: string;
+  readonly legacyId?: string;
+}
+
+export class WorkItemFrontmatterValidationError extends Error {
+  constructor(reason: string) {
+    super(`WorkItem frontmatter が不正です: ${reason}`);
+    this.name = 'WorkItemFrontmatterValidationError';
+  }
+}
+
+export const WORK_ITEM_ID_PATTERN =
+  /^(?:WI-\d+|H(?:\d{2}|F\d+)-\d{2}|ISSUE-\d+)$/;
+
+export const WORK_ITEM_TYPES: ReadonlySet<WorkItemType> = new Set([
+  'story',
+  'issue',
+  'fix',
+  'refactor',
+  'chore',
+]);
+
+export const WORK_ITEM_SEVERITIES: ReadonlySet<WorkItemSeverity> = new Set([
+  'trivial',
+  'normal',
+  'high',
+]);
+
+export const WORK_ITEM_STATUSES: ReadonlySet<WorkItemStatus> = new Set([
+  'drafted',
+  'reflected',
+  'implemented',
+  'tested',
+]);

package/scripts/harness/traceability-model/domain/value-objects/work-item-migration-candidate.ts

@@ -0,0 +1,47 @@
+// @unit traceability-model
+// @layer domain
+
+export type WorkItemMigrationScope = "cross" | "unit";
+export type WorkItemDescriptionFileName = "description.md" | "issue_description.md";
+
+export interface LegacyIssueDirectory {
+  readonly legacyId: string;
+  readonly sourcePath: string;
+  readonly scope: WorkItemMigrationScope;
+  readonly unitName?: string;
+  readonly descriptionFileName: WorkItemDescriptionFileName | null;
+  readonly content: string;
+  readonly targetExists: boolean;
+}
+
+export interface WorkItemMigrationCandidate {
+  readonly legacyId: string;
+  readonly nextId: string;
+  readonly sourcePath: string;
+  readonly targetPath: string;
+  readonly scope: WorkItemMigrationScope;
+  readonly unitName?: string;
+  readonly descriptionFileName: WorkItemDescriptionFileName | null;
+  readonly conflict: boolean;
+  readonly frontmatterPreview: string;
+}
+
+export interface WorkItemMigrationPlan {
+  readonly candidates: readonly WorkItemMigrationCandidate[];
+  readonly warnings: readonly string[];
+}
+
+export interface WorkItemMigrationAppliedCandidate {
+  readonly legacyId: string;
+  readonly nextId: string;
+  readonly sourcePath: string;
+  readonly targetPath: string;
+  readonly descriptionPath: string;
+}
+
+export interface WorkItemMigrationApplyResult {
+  readonly applied: readonly WorkItemMigrationAppliedCandidate[];
+  readonly skipped: readonly WorkItemMigrationCandidate[];
+  readonly warnings: readonly string[];
+  readonly blocked: boolean;
+}