phasegate 0.140.0 → 0.142.0

package/scripts/harness/harness-api/infrastructure/adapters/validator-system-execution-adapter.ts

@@ -45,6 +45,7 @@ export class ValidatorSystemExecutionAdapter implements ValidatorExecutionPort {
         return results.map((r) => ({
           validatorId: r.validatorId,
           passed: r.passed,
+          skipped: r.skipped,
           errors: r.errors.map((e) => ({ code: e.code, severity: e.severity, message: e.message })),
         }));
       },
@@ -56,6 +57,7 @@ export class ValidatorSystemExecutionAdapter implements ValidatorExecutionPort {
         return report.results.map((r) => ({
           validatorId: r.validatorId,
           passed: r.passed,
+          skipped: r.skipped,
           errors: r.errors.map((e) => ({ code: e.code, severity: e.severity, message: e.message })),
         }));
       },

package/scripts/harness/integrations/pre-commit.ts

@@ -18,7 +18,6 @@ import { execSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { createConfigFoundationModule } from "../config-foundation/composition-root.js";
 import { toValidatorSystemConfig } from "../config-foundation/application/mappers/validator-system-config-mapper.js";
-import { ConfigNotFoundError } from "../config-foundation/infrastructure/repositories/file-system-config-repository.js";
 import { createTraceabilityModelModule } from "../traceability-model/composition-root.js";
 import type { ValidateMetadataCommandOutput } from "../traceability-model/presentation/cli/validate-metadata-command-handler.js";
 import type { AggregatedValidationReport } from "../validator-system/application/dto/aggregated-validation-report.js";
@@ -38,13 +37,17 @@ const WORK_ITEM_PATH_PATTERN = /(?:^|\/)WI-\d+(?:\/|$)/;
 const WORK_ITEM_TRAILER_PATTERN = /^Work-Item:\s*WI-\d+\s*$/m;
 const TEST_FILE_SUFFIXES = Object.freeze([".test.ts", ".test.tsx", ".spec.ts", ".spec.tsx"]);
 
+function isConfigNotFoundError(err: unknown): boolean {
+  return err instanceof Error && err.name === "ConfigNotFoundError";
+}
+
 async function loadValidatorSystemConfig(): Promise<object | undefined> {
   const configMod = createConfigFoundationModule();
   try {
     const resolvedConfig = await configMod.usecases.loadResolvedConfigUseCase.execute();
     return toValidatorSystemConfig(resolvedConfig.config);
   } catch (err) {
-    if (err instanceof ConfigNotFoundError) return undefined;
+    if (isConfigNotFoundError(err)) return undefined;
     throw err;
   }
 }
@@ -57,7 +60,7 @@ async function loadTraceabilityModelOptions(): Promise<
     const resolvedConfig = await configMod.usecases.loadResolvedConfigUseCase.execute();
     return { pathRoots: { designDocsRoot: resolvedConfig.config.paths.designDocs } };
   } catch (err) {
-    if (err instanceof ConfigNotFoundError) return undefined;
+    if (isConfigNotFoundError(err)) return undefined;
     throw err;
   }
 }
@@ -68,7 +71,7 @@ async function loadPreCommitImplementationExtensions(): Promise<readonly string[
     const resolvedConfig = await configMod.usecases.loadResolvedConfigUseCase.execute();
     return resolvedConfig.config.preCommit?.implementationExtensions;
   } catch (err) {
-    if (err instanceof ConfigNotFoundError) return undefined;
+    if (isConfigNotFoundError(err)) return undefined;
     throw err;
   }
 }

package/scripts/harness/main.ts

@@ -98,6 +98,7 @@ Commands:
   disable-feature <name>       Disable a harness feature
   list-features                List available features
   migrate                      Migrate phasegate.config.json (--schema v3, --config <path>)
+  work-items:status            Report or apply derived WI frontmatter status (--dry-run|--apply, --id, --fail-on-stale, --json)
 
   render-errors                Render harness errors (--format human|agent|ci)
   validate-fix                 Validate fix examples (--code <code>)
@@ -192,6 +193,13 @@ function parseTriStateFlag(args: readonly string[], positiveFlag: string, negati
   return positiveIdx > negativeIdx;
 }
 
+function parseValidateFormat(args: readonly string[]): "human" | "agent" | "ci" | undefined {
+  const raw = parseFlag(args, "--format");
+  if (raw === undefined) return undefined;
+  if (raw === "human" || raw === "agent" || raw === "ci") return raw;
+  throw new Error(`Invalid --format value for validate: '${raw}'. Supported values: human, agent, ci.`);
+}
+
 function levenshtein(a: string, b: string): number {
   const m = a.length;
   const n = b.length;
@@ -299,6 +307,17 @@ Options:
   "phasegate:status": `Usage: phasegate phasegate:status
 
 Display harness status (enabled validators, schema version, hook deployment).`,
+  "work-items:status": `Usage: phasegate work-items:status (--dry-run|--apply) [options]
+
+Derive WI frontmatter status from inception, product reflection, implementation, and test evidence.
+
+Options:
+  --dry-run         Print current status, derived status, reason, and next action.
+  --apply           Update only the status line in each stale description.md frontmatter.
+  --id <WI-XXX>     Limit report/apply to one work item.
+  --fail-on-stale   Return exit code 1 when dry-run finds stale status.
+  --json            Output machine-readable JSON.
+  --help, -h        Show this help`,
   "phasegate:detect-drift": `Usage: phasegate phasegate:detect-drift [options]
 
 Run L4-001 drift detection between design documents and source code. WARNING: scans the project filesystem.
@@ -955,6 +974,23 @@ async function main(): Promise<void> {
         break;
       }
 
+      case "work-items:status": {
+        const mod = createTraceabilityModelModule(
+          rootDir,
+          toTraceabilityModelOptions(resolvedConfig),
+        );
+        const result = await mod.workItemStatusCommandHandler.execute({
+          dryRun: hasFlag(args, "--dry-run"),
+          apply: hasFlag(args, "--apply"),
+          failOnStale: hasFlag(args, "--fail-on-stale"),
+          id: parseFlag(args, "--id"),
+          json,
+        });
+        console.log(result.text);
+        process.exit(result.exitCode);
+        break;
+      }
+
       // ── phase-dependency-model ──
       case "check-phase-gate": {
         const phaseConfig = resolvedConfig ? toPhaseConfigSection(resolvedConfig) : undefined;
@@ -1024,7 +1060,7 @@ async function main(): Promise<void> {
         const layer = parseFlag(args, "--layer") as "L0" | "L2" | "L3" | "L4" | "all" | undefined;
         const unit = parseFlag(args, "--unit");
         const phase = parseFlag(args, "--phase");
-        const format = parseFlag(args, "--format") as "human" | "agent" | "ci" | undefined;
+        const format = parseValidateFormat(args);
         // WI-094 / ADR-017: --fail-on-warning / --no-fail-on-warning / 未指定→config値
         const failOnWarning = parseTriStateFlag(args, "--fail-on-warning", "--no-fail-on-warning");
         const noL4 = hasFlag(args, "--no-l4");

package/scripts/harness/phase-dependency-model/infrastructure/filesystem/file-system-story-reflection-adapter.ts

@@ -146,7 +146,12 @@ export class FileSystemStoryReflectionAdapter implements StoryReflectionFileSyst
     }
 
     const legacyId = await this.readLegacyId(storyId);
-    return legacyId !== null && annotationIds.includes(legacyId);
+    if (legacyId === null || !annotationIds.includes(legacyId)) {
+      return false;
+    }
+
+    const unitId = this.extractProductUnitId(productPath);
+    return !(await this.isAmbiguousLegacyId(legacyId, storyId, unitId));
   }
 
   private extractAnnotationIds(content: string): readonly string[] {
@@ -182,6 +187,47 @@ export class FileSystemStoryReflectionAdapter implements StoryReflectionFileSyst
     return null;
   }
 
+  private extractProductUnitId(productPath: string): string | null {
+    const normalized = productPath.split(path.sep).join("/");
+    const match = /^docs\/product\/construction\/([^/]+)\//.exec(normalized);
+    return match?.[1] ?? null;
+  }
+
+  private async isAmbiguousLegacyId(legacyId: string, storyId: string, unitId: string | null): Promise<boolean> {
+    const scopedStoryIds = unitId === null
+      ? await this.listAllWorkItemDirectories()
+      : await this.listStoryDirectories(unitId);
+    const matchingStoryIds: string[] = [];
+
+    for (const candidateStoryId of scopedStoryIds) {
+      const candidateLegacyId = await this.readLegacyId(candidateStoryId);
+      if (candidateLegacyId === legacyId) {
+        matchingStoryIds.push(candidateStoryId);
+      }
+    }
+
+    return matchingStoryIds.length > 1 || (matchingStoryIds.length === 1 && matchingStoryIds[0] !== storyId);
+  }
+
+  private async listAllWorkItemDirectories(): Promise<readonly string[]> {
+    const ids = new Set<string>();
+    for (const id of await this.listCrossWorkItemDirectories()) {
+      ids.add(id);
+    }
+
+    const inceptionDir = path.join(this.rootDir, this.inceptionRoot);
+    for (const entry of await this.readDirectories(inceptionDir)) {
+      if (!entry.isDirectory()) continue;
+      const name = entry.name;
+      if (name.startsWith("_") || name.startsWith(".") || name === "issues") continue;
+      for (const id of await this.listUnitWorkItemDirectories(name)) {
+        ids.add(id);
+      }
+    }
+
+    return [...ids].sort();
+  }
+
   private async listDescriptionCandidates(storyId: string): Promise<readonly string[]> {
     const inceptionDir = path.join(this.rootDir, this.inceptionRoot);
     const candidates: string[] = [path.join(inceptionDir, "_cross", storyId, "description.md")];

package/scripts/harness/traceability-model/application/usecases/apply-work-item-status-usecase.ts

@@ -0,0 +1,30 @@
+// @unit traceability-model
+// @layer application
+// @work-item-id WI-126
+
+import type { WorkItemStatusPort } from "../../domain/ports/work-item-status-port.js";
+import type { WorkItemStatusApplyResult } from "../../domain/value-objects/work-item-status-report.js";
+import type { DeriveWorkItemStatusUseCase } from "./derive-work-item-status-usecase.js";
+
+export interface ApplyWorkItemStatusUseCaseDeps {
+  readonly deriveWorkItemStatusUseCase: Pick<DeriveWorkItemStatusUseCase, "execute">;
+  readonly workItemStatusPort: WorkItemStatusPort;
+}
+
+export class ApplyWorkItemStatusUseCase {
+  private readonly deriveWorkItemStatusUseCase: Pick<DeriveWorkItemStatusUseCase, "execute">;
+  private readonly workItemStatusPort: WorkItemStatusPort;
+
+  constructor(deps: ApplyWorkItemStatusUseCaseDeps) {
+    this.deriveWorkItemStatusUseCase = deps.deriveWorkItemStatusUseCase;
+    this.workItemStatusPort = deps.workItemStatusPort;
+  }
+
+  async execute(input: { readonly id?: string } = {}): Promise<WorkItemStatusApplyResult> {
+    const reports = await this.deriveWorkItemStatusUseCase.execute();
+    const targetReports = input.id
+      ? reports.filter((report) => report.id === input.id)
+      : reports;
+    return this.workItemStatusPort.applyDerivedStatuses(targetReports);
+  }
+}

package/scripts/harness/traceability-model/application/usecases/derive-work-item-status-usecase.ts

@@ -0,0 +1,27 @@
+// @unit traceability-model
+// @layer application
+// @work-item-id WI-126
+
+import type { WorkItemStatusPort } from "../../domain/ports/work-item-status-port.js";
+import { WorkItemStatusDerivationService } from "../../domain/services/work-item-status-derivation-service.js";
+import type { WorkItemStatusReport } from "../../domain/value-objects/work-item-status-report.js";
+
+export interface DeriveWorkItemStatusUseCaseDeps {
+  readonly workItemStatusPort: WorkItemStatusPort;
+  readonly derivationService: WorkItemStatusDerivationService;
+}
+
+export class DeriveWorkItemStatusUseCase {
+  private readonly workItemStatusPort: WorkItemStatusPort;
+  private readonly derivationService: WorkItemStatusDerivationService;
+
+  constructor(deps: DeriveWorkItemStatusUseCaseDeps) {
+    this.workItemStatusPort = deps.workItemStatusPort;
+    this.derivationService = deps.derivationService;
+  }
+
+  async execute(): Promise<readonly WorkItemStatusReport[]> {
+    const inputs = await this.workItemStatusPort.listWorkItemStatusInputs();
+    return Object.freeze(inputs.map((input) => this.derivationService.derive(input)));
+  }
+}

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

@@ -7,6 +7,8 @@
  */
 
 import { ApplyWorkItemMigrationUseCase } from "./application/usecases/apply-work-item-migration-usecase.js";
+import { ApplyWorkItemStatusUseCase } from "./application/usecases/apply-work-item-status-usecase.js";
+import { DeriveWorkItemStatusUseCase } from "./application/usecases/derive-work-item-status-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";
@@ -14,17 +16,20 @@ import { ValidateTestStoryMetadataUseCase } from "./application/usecases/validat
 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 { WorkItemStatusDerivationService } from "./domain/services/work-item-status-derivation-service.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 { FileSystemWorkItemIdentityGateway } from "./infrastructure/gateways/file-system-work-item-identity-gateway.js";
+import { FileSystemWorkItemStatusGateway } from "./infrastructure/gateways/file-system-work-item-status-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";
+import { WorkItemStatusCommandHandler } from "./presentation/cli/work-item-status-command-handler.js";
 
 export interface TraceabilityModelPathRoots {
   readonly designDocsRoot: string;
@@ -63,6 +68,7 @@ export function createTraceabilityModelModule(
   const workItemMigrationSource = new FileSystemWorkItemMigrationSourceGateway({ rootDir });
   const workItemMigrationApply = new FileSystemWorkItemMigrationApplyGateway({ rootDir });
   const workItemIdentity = new FileSystemWorkItemIdentityGateway({ rootDir });
+  const workItemStatus = new FileSystemWorkItemStatusGateway({ rootDir });
 
   // Domain services
   const metadataValidator = new MetadataValidator({
@@ -78,6 +84,7 @@ export function createTraceabilityModelModule(
     storyCatalogPath,
   });
   const storyIdAliasResolver = new StoryIdAliasResolver(storyCatalog);
+  const workItemStatusDerivationService = new WorkItemStatusDerivationService();
 
   // Usecases
   const validateImplementationMetadataUseCase = new ValidateImplementationMetadataUseCase({
@@ -100,6 +107,14 @@ export function createTraceabilityModelModule(
     planWorkItemMigrationUseCase,
     applyPort: workItemMigrationApply,
   });
+  const deriveWorkItemStatusUseCase = new DeriveWorkItemStatusUseCase({
+    workItemStatusPort: workItemStatus,
+    derivationService: workItemStatusDerivationService,
+  });
+  const applyWorkItemStatusUseCase = new ApplyWorkItemStatusUseCase({
+    deriveWorkItemStatusUseCase,
+    workItemStatusPort: workItemStatus,
+  });
 
   // Presentation handlers
   const validateMetadataCommandHandler = new ValidateMetadataCommandHandler({
@@ -112,10 +127,15 @@ export function createTraceabilityModelModule(
     planWorkItemMigrationUseCase,
     applyWorkItemMigrationUseCase,
   });
+  const workItemStatusCommandHandler = new WorkItemStatusCommandHandler({
+    deriveWorkItemStatusUseCase,
+    applyWorkItemStatusUseCase,
+  });
 
   return {
     validateMetadataCommandHandler,
     migrateWorkItemsCommandHandler,
+    workItemStatusCommandHandler,
     // expose key services for cross-unit use
     storyCatalog,
     traceabilityChainBuilder,

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

@@ -0,0 +1,16 @@
+// @unit traceability-model
+// @layer domain
+// @work-item-id WI-126
+
+import type {
+  WorkItemStatusApplyResult,
+  WorkItemStatusInput,
+  WorkItemStatusReport,
+} from "../value-objects/work-item-status-report.js";
+
+export interface WorkItemStatusPort {
+  listWorkItemStatusInputs(): Promise<readonly WorkItemStatusInput[]>;
+  applyDerivedStatuses(
+    reports: readonly WorkItemStatusReport[],
+  ): Promise<WorkItemStatusApplyResult>;
+}

package/scripts/harness/traceability-model/domain/services/work-item-status-derivation-service.ts

@@ -0,0 +1,121 @@
+// @unit traceability-model
+// @layer domain
+// @work-item-id WI-126
+
+import type { WorkItemStatus } from "../value-objects/work-item-frontmatter.js";
+import type {
+  WorkItemStatusInput,
+  WorkItemStatusReport,
+} from "../value-objects/work-item-status-report.js";
+
+const ORDER: Record<WorkItemStatus, number> = {
+  drafted: 0,
+  reflected: 1,
+  implemented: 2,
+  tested: 3,
+  completed: 3,
+};
+
+export class WorkItemStatusDerivationService {
+  derive(input: WorkItemStatusInput): WorkItemStatusReport {
+    const derivedStatus = this.deriveStatus(input);
+    const currentStatus = input.frontmatter.status ?? "drafted";
+    const reason = this.reasonFor(input, derivedStatus);
+    const nextAction = this.nextActionFor(input, derivedStatus);
+
+    return Object.freeze({
+      id: input.frontmatter.id,
+      type: input.frontmatter.type,
+      descriptionPath: input.descriptionPath,
+      currentStatus,
+      derivedStatus,
+      stale: currentStatus !== derivedStatus,
+      reason,
+      nextAction,
+      evidence: Object.freeze({
+        hasRequiredInceptionArtifacts: this.hasRequiredInceptionArtifacts(input),
+        reflectedUnits: Object.freeze([...this.reflectedUnits(input)]),
+        missingReflectionUnits: Object.freeze([...this.missingReflectionUnits(input)]),
+        implementationPaths: Object.freeze([...input.implementationPaths]),
+        testPaths: Object.freeze([...input.testPaths]),
+      }),
+    });
+  }
+
+  private deriveStatus(input: WorkItemStatusInput): WorkItemStatus {
+    const type = input.frontmatter.type;
+    if (type === "chore") return "drafted";
+
+    const reflected = this.missingReflectionUnits(input).length === 0;
+    const implemented = input.implementationPaths.length > 0;
+    const tested = input.testPaths.length > 0;
+
+    if (type === "fix") {
+      if (implemented) return "implemented";
+      if (reflected) return "reflected";
+      return "drafted";
+    }
+
+    if (tested) return "tested";
+    if (implemented) return "implemented";
+    if (reflected) return "reflected";
+    return "drafted";
+  }
+
+  private reasonFor(input: WorkItemStatusInput, status: WorkItemStatus): string {
+    if (!this.hasRequiredInceptionArtifacts(input)) {
+      return `missing inception artifacts: ${this.missingInceptionArtifacts(input).join(", ")}`;
+    }
+    if (status === "tested") return "test evidence with @work-item-id exists";
+    if (status === "implemented") return "implementation evidence with @work-item-id exists";
+    if (status === "reflected") return "all affected units have product reflection";
+    if (input.frontmatter.type === "chore") return "chore work items complete at drafted";
+    return "product reflection is not complete";
+  }
+
+  private nextActionFor(input: WorkItemStatusInput, status: WorkItemStatus): string {
+    const missingArtifacts = this.missingInceptionArtifacts(input);
+    if (missingArtifacts.length > 0) {
+      return `create inception artifacts: ${missingArtifacts.join(", ")}`;
+    }
+    const missingUnits = this.missingReflectionUnits(input);
+    if (missingUnits.length > 0) {
+      return `reflect @work-item-id ${input.frontmatter.id} in product docs for: ${missingUnits.join(", ")}`;
+    }
+    if (input.frontmatter.type === "chore") return "no further status transition required";
+    if (status === "reflected") return `add implementation annotated with @work-item-id ${input.frontmatter.id}`;
+    if (status === "implemented" && input.frontmatter.type !== "fix") {
+      return `add tests annotated with @work-item-id ${input.frontmatter.id}`;
+    }
+    return "status is up to date";
+  }
+
+  private hasRequiredInceptionArtifacts(input: WorkItemStatusInput): boolean {
+    return this.missingInceptionArtifacts(input).length === 0;
+  }
+
+  private missingInceptionArtifacts(input: WorkItemStatusInput): readonly string[] {
+    const existing = new Set(input.existingInceptionArtifacts);
+    return input.requiredInceptionArtifacts.filter((artifact) => !existing.has(artifact));
+  }
+
+  private reflectedUnits(input: WorkItemStatusInput): readonly string[] {
+    const reflected = new Set<string>();
+    for (const filePath of input.productReflectionPaths) {
+      const unit = this.extractConstructionUnit(filePath);
+      if (unit) reflected.add(unit);
+    }
+    return input.affectedUnits.filter((unit) => reflected.has(unit));
+  }
+
+  private missingReflectionUnits(input: WorkItemStatusInput): readonly string[] {
+    if (input.frontmatter.type === "chore") return [];
+    const reflected = new Set(this.reflectedUnits(input));
+    return input.affectedUnits.filter((unit) => !reflected.has(unit));
+  }
+
+  private extractConstructionUnit(filePath: string): string | null {
+    const match = /^docs\/product\/construction\/([^/]+)\//.exec(filePath);
+    return match?.[1] ?? null;
+  }
+}

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

@@ -0,0 +1,47 @@
+// @unit traceability-model
+// @layer domain
+// @work-item-id WI-126
+
+import type {
+  WorkItemFrontmatter,
+  WorkItemStatus,
+  WorkItemType,
+} from "./work-item-frontmatter.js";
+
+export interface WorkItemStatusEvidence {
+  readonly hasRequiredInceptionArtifacts: boolean;
+  readonly reflectedUnits: readonly string[];
+  readonly missingReflectionUnits: readonly string[];
+  readonly implementationPaths: readonly string[];
+  readonly testPaths: readonly string[];
+}
+
+export interface WorkItemStatusInput {
+  readonly descriptionPath: string;
+  readonly directoryId: string;
+  readonly ownerUnit: string | null;
+  readonly frontmatter: WorkItemFrontmatter;
+  readonly requiredInceptionArtifacts: readonly string[];
+  readonly existingInceptionArtifacts: readonly string[];
+  readonly affectedUnits: readonly string[];
+  readonly productReflectionPaths: readonly string[];
+  readonly implementationPaths: readonly string[];
+  readonly testPaths: readonly string[];
+}
+
+export interface WorkItemStatusReport {
+  readonly id: string;
+  readonly type: WorkItemType;
+  readonly descriptionPath: string;
+  readonly currentStatus: WorkItemStatus;
+  readonly derivedStatus: WorkItemStatus;
+  readonly stale: boolean;
+  readonly reason: string;
+  readonly nextAction: string;
+  readonly evidence: WorkItemStatusEvidence;
+}
+
+export interface WorkItemStatusApplyResult {
+  readonly updated: readonly WorkItemStatusReport[];
+  readonly unchanged: readonly WorkItemStatusReport[];
+}