phasegate 0.145.3 → 0.146.0

package/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.145.4] - 2026-05-11
+
+### Added
+
+- **WI-148 — manifest-driven reconcile + init deprecation** — `phasegate reconcile --dry-run|--apply [--force] [--json]` を追加し、`.phasegate/manifest.json` に記録済みの PhaseGate managed files を現行 bundled template / package version に追従できるようにした。
+  - `merged` entries は PhaseGate managed portion だけを更新し、user scripts / hooks / dependencies は保持する。
+  - `created` entries は hash が manifest と一致する場合のみ template に追従し、user 改変ありの場合は `--force` 無しで refuse、force 時は `.phasegate/backups/reconcile-*/` に退避してから上書きする。
+  - manifest に無い現行 deploy target は install と同じく追加し、apply 後は manifest の version/hash を更新する。
+  - `update-skills` は互換 alias として `reconcile` に委譲し、`init` 実行時は v1.0 削除予定の deprecation warning を表示する。
+
 ## [0.145.3] - 2026-05-11
 
 ### Added

package/README.ja.md

@@ -116,6 +116,15 @@ npx phasegate uninstall --apply
 
 `uninstall` は manifest を読んで、PhaseGate が作成したファイルを削除し、merge した Claude / Codex / Husky / `package.json` から PhaseGate 管理部分だけを取り除きます。ユーザーの既存設定は保持し、manifest は `.phasegate/` 配下に履歴として archive します。
 
+PhaseGate をアップグレードした後は、reconcile で既存の managed files を現在の bundled template に追従できます。
+
+```sh
+npx phasegate reconcile --dry-run
+npx phasegate reconcile --apply
+```
+
+`reconcile` は PhaseGate 管理部分だけを更新し、ユーザーの hook / script / dependency は保持します。新しい deploy target が追加されていれば install と同じく追加し、`.phasegate/manifest.json` の version / hash も更新します。install 後に user 改変された managed file は `--force` 無しでは refuse し、force 時は `.phasegate/backups/reconcile-<timestamp>/` に退避してから上書きします。
+
 ### Codex CLI を使う場合
 
 ```bash

package/README.md

@@ -109,6 +109,15 @@ npx phasegate uninstall --apply
 
 `uninstall` uses the manifest to delete created files and remove only PhaseGate-managed portions from merged Claude/Codex, Husky, and `package.json` files. User content is preserved, and the manifest is archived under `.phasegate/`.
 
+When you upgrade PhaseGate, reconcile existing managed files with the current bundled templates:
+
+```sh
+npx phasegate reconcile --dry-run
+npx phasegate reconcile --apply
+```
+
+`reconcile` updates only PhaseGate-managed portions, keeps user content, adds newly introduced managed targets, and refreshes `.phasegate/manifest.json` with the current version and hashes. If a managed file was edited after install, `reconcile --apply` refuses that entry until you rerun with `--force`; PhaseGate writes a backup under `.phasegate/backups/reconcile-<timestamp>/`.
+
 ### Codex CLI
 
 ```bash

package/docs/guide/installation.md

@@ -73,6 +73,17 @@ npx phasegate uninstall --apply
 
 `uninstall` reads `.phasegate/manifest.json`, deletes files that PhaseGate created, removes only PhaseGate-managed portions from merged JSON, Husky, and `package.json` files, and archives the manifest as `.phasegate/uninstalled-<timestamp>.json`. If a managed file was modified after install, `uninstall --apply` refuses that entry until you rerun with `--force`, which creates a backup under `.phasegate/backups/uninstall-<timestamp>/`.
 
+After upgrading PhaseGate, reconcile existing managed files with the bundled templates from the new version:
+
+```bash
+npx phasegate reconcile --dry-run
+npx phasegate reconcile --apply
+```
+
+`reconcile` updates PhaseGate-managed portions, preserves user content, adds newly introduced managed targets, and refreshes `.phasegate/manifest.json` with current version/hash metadata. If a managed file was edited after install, `reconcile --apply` refuses that entry until you rerun with `--force`, which creates a backup under `.phasegate/backups/reconcile-<timestamp>/`.
+
+`phasegate update-skills` remains available as a compatibility alias for `phasegate reconcile`.
+
 ### Manual Setup Pieces
 
 If you do not use `init` or `install`, copy the design principle documents manually:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phasegate",
-  "version": "0.145.3",
+  "version": "0.146.0",
   "packageManager": "pnpm@10.30.1",
   "description": "Phasegate — AI-agnostic quality defense toolkit. Enforces structural integrity between design intent and code.",
   "license": "MIT",

package/scripts/harness/installation/application/checks/wi-workflow-drift-check.ts

@@ -0,0 +1,64 @@
+// @unit installation
+// @layer application
+// @work-item-id WI-143
+
+import { join, relative, sep } from "node:path";
+import { DiagnosticFinding } from "../../domain/diagnostic-finding.js";
+import type { HeuristicCheck } from "../../domain/ports/heuristic-check.js";
+import type { FileInspectorPort } from "../ports/file-inspector-port.js";
+
+interface PhasegateConfigProbe {
+  readonly quickMode?: {
+    readonly relaxedGates?: readonly string[];
+  };
+}
+
+export class WiWorkflowDriftCheck implements HeuristicCheck {
+  readonly checkId = "wi-workflow-drift" as const;
+
+  async run(projectRoot: string, inspector: FileInspectorPort): Promise<DiagnosticFinding | null> {
+    const inceptionRoot = join(projectRoot, "docs", "inception");
+    const files = await inspector.listFiles(inceptionRoot);
+    const relativeFiles = files.map((file) => toPosix(relative(projectRoot, file)));
+    const workItemCount = relativeFiles.filter(isWorkItemDescription).length;
+    const adHocPlans = relativeFiles.filter(isAdHocPlan);
+    const hasPhaseGateRelaxed = await this.hasRelaxedPhaseGate(projectRoot, inspector);
+
+    if (workItemCount > 0 || adHocPlans.length === 0) {
+      return null;
+    }
+
+    const message = hasPhaseGateRelaxed
+      ? `WI-first drift detected: 0 WI directories, ${adHocPlans.length} ad-hoc plan file(s), and quickMode.relaxedGates includes phase-gate.`
+      : `WI-first drift detected: 0 WI directories and ${adHocPlans.length} ad-hoc plan file(s).`;
+
+    return DiagnosticFinding.create({
+      checkId: this.checkId,
+      severity: "red",
+      target: "docs/inception",
+      message,
+      repairMode: "mechanical",
+      repairHint: "phasegate migrate work-items --apply",
+      suggestedSkill: null,
+    });
+  }
+
+  private async hasRelaxedPhaseGate(projectRoot: string, inspector: FileInspectorPort): Promise<boolean> {
+    const config = await inspector.readJson<PhasegateConfigProbe>(join(projectRoot, "phasegate.config.json"));
+    return config?.quickMode?.relaxedGates?.includes("phase-gate") ?? false;
+  }
+}
+
+function toPosix(path: string): string {
+  return path.split(sep).join("/");
+}
+
+function isWorkItemDescription(path: string): boolean {
+  return /^docs\/inception\/(?:_cross|[^/]+)\/WI-\d{3}\/description\.md$/.test(path);
+}
+
+function isAdHocPlan(path: string): boolean {
+  if (!path.startsWith("docs/inception/")) return false;
+  if (/\/WI-\d{3}\//.test(path)) return false;
+  return path.includes("/codding_plan/") || path.endsWith("_plan.md");
+}

package/scripts/harness/installation/application/usecases/run-reconcile.ts

@@ -0,0 +1,437 @@
+// @unit installation
+// @layer application
+// @work-item-id WI-148
+
+import { access, chmod, copyFile, lstat, mkdir, readFile, readlink, symlink, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { DeploymentEntry } from "../../domain/deployment-entry.js";
+import { DeploymentManifest } from "../../domain/deployment-manifest.js";
+import type { ManagedBlockInput } from "../../domain/managed-block.js";
+import type { RepairMode } from "../../domain/repair-mode.js";
+import type { HashCalculatorPort } from "../ports/hash-calculator-port.js";
+import type { ManifestRepositoryPort } from "../ports/manifest-repository-port.js";
+
+type ReconcileAction = "missing-manifest" | "update" | "add" | "link" | "skip" | "refuse";
+type StrategyType = "json" | "shell" | "yaml-add" | "package-json" | "symlink" | "unknown";
+
+export interface ReconcilePlanItem {
+  readonly path: string;
+  readonly action: ReconcileAction;
+  readonly repairMode: RepairMode;
+  readonly strategy: StrategyType;
+  readonly changed: boolean;
+  readonly summary: string;
+  readonly diff: string;
+  readonly skillHint: string | null;
+}
+
+export interface RunReconcileInput {
+  readonly projectRoot: string;
+  readonly harnessRoot: string;
+  readonly phasegateVersion: string;
+  readonly dryRun: boolean;
+  readonly apply: boolean;
+  readonly force: boolean;
+}
+
+export interface RunReconcileResult {
+  readonly plan: readonly ReconcilePlanItem[];
+  readonly refused: readonly ReconcilePlanItem[];
+  readonly changed: readonly ReconcilePlanItem[];
+  readonly backupDir: string | null;
+}
+
+interface ReconcileTarget {
+  readonly path: string;
+  readonly strategy: StrategyType;
+  readonly templatePath?: string;
+  readonly executable?: boolean;
+  readonly block?: ManagedBlockInput;
+}
+
+const SKILL_HINT = "invoke /phasegate-config-doctor";
+const SHELL_BEGIN = "# === phasegate managed (BEGIN) ===";
+const SHELL_END = "# === phasegate managed (END) ===";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readTextOrNull(path: string): Promise<string | null> {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+function normalizeJsonEntry(value: unknown): string {
+  return JSON.stringify(value);
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function phasegateOwnedJsonEntry(entry: unknown): boolean {
+  return normalizeJsonEntry(entry).includes("phasegate");
+}
+
+function replaceHookArrays(existing: unknown, incoming: unknown): unknown[] {
+  const userEntries = (Array.isArray(existing) ? existing : []).filter((entry) => !phasegateOwnedJsonEntry(entry));
+  const seen = new Set(userEntries.map((entry) => normalizeJsonEntry(entry)));
+  const result = [...userEntries];
+  for (const entry of Array.isArray(incoming) ? incoming : []) {
+    const key = normalizeJsonEntry(entry);
+    if (!seen.has(key)) {
+      result.push(entry);
+      seen.add(key);
+    }
+  }
+  return result;
+}
+
+function reconcileJsonObject(existing: Record<string, unknown>, incoming: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = { ...existing };
+  const existingHooks = isRecord(existing.hooks) ? existing.hooks : {};
+  const incomingHooks = isRecord(incoming.hooks) ? incoming.hooks : {};
+  const nextHooks: Record<string, unknown> = {};
+  const events = new Set([...Object.keys(existingHooks), ...Object.keys(incomingHooks)]);
+  for (const event of events) {
+    const entries = replaceHookArrays(existingHooks[event], incomingHooks[event]);
+    if (entries.length > 0) nextHooks[event] = entries;
+  }
+  if (Object.keys(nextHooks).length > 0) result.hooks = nextHooks;
+  else delete result.hooks;
+
+  const existingPermissions = isRecord(existing.permissions) ? existing.permissions : {};
+  const incomingPermissions = isRecord(incoming.permissions) ? incoming.permissions : {};
+  const incomingDeny = Array.isArray(incomingPermissions.deny) ? incomingPermissions.deny : [];
+  if (Object.keys(existingPermissions).length > 0 || Object.keys(incomingPermissions).length > 0) {
+    const existingDeny = Array.isArray(existingPermissions.deny) ? existingPermissions.deny : [];
+    const preservedDeny = existingDeny.filter((entry) => typeof entry !== "string" || !incomingDeny.includes(entry));
+    result.permissions = {
+      ...existingPermissions,
+      ...incomingPermissions,
+      deny: [...new Set([...preservedDeny, ...incomingDeny])],
+    };
+  }
+  return result;
+}
+
+function reconcileShell(existing: string | null, incoming: string): string {
+  const incomingBlock = `${SHELL_BEGIN}\n${incoming.trim()}\n${SHELL_END}`;
+  if (existing === null || existing.trim().length === 0) return `${incoming.trim()}\n`;
+  const pattern = new RegExp(`${escapeRegExp(SHELL_BEGIN)}[\\s\\S]*?${escapeRegExp(SHELL_END)}`);
+  if (pattern.test(existing)) return existing.replace(pattern, incomingBlock).replace(/\s*$/, "\n");
+  return `${existing.replace(/\s*$/, "\n\n")}${incomingBlock}\n`;
+}
+
+function reconcilePackageJson(existing: Record<string, unknown>, version: string): Record<string, unknown> {
+  const devDependencies = isRecord(existing.devDependencies) ? existing.devDependencies : {};
+  const scripts = isRecord(existing.scripts) ? existing.scripts : {};
+  return {
+    ...existing,
+    scripts: {
+      ...scripts,
+      "phasegate:lint": "phasegate lint",
+      "phasegate:check-ready": "phasegate phasegate:check-ready",
+      "phasegate:doctor": "phasegate doctor",
+    },
+    devDependencies: {
+      ...devDependencies,
+      phasegate: `^${version}`,
+    },
+  };
+}
+
+export class RunReconcileUseCase {
+  constructor(
+    private readonly manifestRepository: ManifestRepositoryPort,
+    private readonly hashCalculator: HashCalculatorPort,
+  ) {}
+
+  async execute(input: RunReconcileInput): Promise<RunReconcileResult> {
+    const manifest = await this.manifestRepository.load(input.projectRoot);
+    if (manifest === null) {
+      const item = this.item(
+        ".phasegate/manifest.json",
+        "missing-manifest",
+        "manual",
+        "unknown",
+        false,
+        "manifest missing; run phasegate install before reconcile",
+        "manual setup required",
+        SKILL_HINT,
+      );
+      return { plan: [item], refused: [], changed: [], backupDir: null };
+    }
+
+    const targets = this.createTargets();
+    const targetsByPath = new Map(targets.map((target) => [target.path, target]));
+    let nextManifest = DeploymentManifest.reconstitute({
+      version: input.phasegateVersion,
+      installedAt: manifest.installedAt,
+      entries: manifest.entries,
+    });
+    const plan: ReconcilePlanItem[] = [];
+    const refused: ReconcilePlanItem[] = [];
+    const changed: ReconcilePlanItem[] = [];
+    const backupStamp = `reconcile-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+    let backupDir: string | null = null;
+
+    const outcomes: Array<{
+      readonly item: ReconcilePlanItem;
+      readonly needsBackup: boolean;
+      readonly apply: () => Promise<string | null>;
+    }> = [];
+
+    for (const entry of manifest.entries) {
+      const target = targetsByPath.get(entry.path);
+      if (target === undefined) {
+        const item = this.item(entry.path, "skip", "manual", "unknown", false, `${entry.path}: no bundled template`, "manual review required", SKILL_HINT);
+        plan.push(item);
+        continue;
+      }
+      const outcome = await this.planManagedEntry(input, entry, target);
+      outcomes.push(outcome);
+      plan.push(outcome.item);
+      if (input.apply && outcome.item.changed && (outcome.item.repairMode === "ai-assisted" || outcome.item.repairMode === "manual") && !input.force) {
+        refused.push({ ...outcome.item, action: "refuse" });
+      }
+    }
+
+    for (const target of targets) {
+      if (manifest.findEntry(target.path) !== null) continue;
+      const outcome = await this.planMissingTarget(input, target);
+      outcomes.push(outcome);
+      plan.push(outcome.item);
+      if (input.apply && outcome.item.changed && (outcome.item.repairMode === "ai-assisted" || outcome.item.repairMode === "manual") && !input.force) {
+        refused.push({ ...outcome.item, action: "refuse" });
+      }
+    }
+
+    if (!input.apply || refused.length > 0) {
+      return { plan, refused, changed, backupDir: null };
+    }
+
+    for (const outcome of outcomes) {
+      if (!outcome.item.changed) continue;
+      if (outcome.needsBackup) {
+        backupDir ??= join(input.projectRoot, ".phasegate", "backups", backupStamp);
+        await this.backup(input.projectRoot, outcome.item.path, backupDir);
+      }
+      const hashContent = await outcome.apply();
+      changed.push(outcome.item);
+      if (hashContent !== null) {
+        const mode = outcome.item.strategy === "symlink" ? "symlink" : outcome.item.action === "add" ? "created" : (manifest.findEntry(outcome.item.path)?.mode ?? "merged");
+        nextManifest = nextManifest.addEntry(
+          DeploymentEntry.create({
+            path: outcome.item.path,
+            mode,
+            block: mode === "merged" ? this.managedBlockFor(outcome.item.path, outcome.item.strategy) : null,
+            hash: this.hashCalculator.compute(hashContent),
+            deployedAt: new Date().toISOString(),
+          }),
+        );
+      }
+    }
+
+    if (changed.length > 0 || manifest.version !== input.phasegateVersion) {
+      await this.manifestRepository.save(input.projectRoot, nextManifest);
+    }
+    return { plan, refused, changed, backupDir };
+  }
+
+  private async planManagedEntry(input: RunReconcileInput, entry: DeploymentEntry, target: ReconcileTarget) {
+    if (target.strategy === "symlink") return this.planSymlink(input.projectRoot, target.path);
+    const absolutePath = this.resolveProjectPath(input.projectRoot, entry.path);
+    const before = await readTextOrNull(absolutePath);
+    if (before === null) return this.planMissingTarget(input, target);
+    const currentHash = this.hashCalculator.compute(before);
+    const matchesManifest = currentHash.equals(entry.hash);
+    const template = target.templatePath ? await readFile(join(input.harnessRoot, target.templatePath), "utf8") : "";
+    const next = entry.mode === "created" && target.strategy !== "package-json"
+      ? template
+      : this.reconcileContent(target, before, template, input.phasegateVersion);
+    const changed = before !== next;
+    const repairMode: RepairMode = matchesManifest ? "mechanical" : "ai-assisted";
+    return {
+      item: this.item(
+        entry.path,
+        changed ? "update" : "skip",
+        repairMode,
+        target.strategy,
+        changed,
+        changed ? `${entry.path}: update managed portion` : `${entry.path}: already up to date`,
+        this.diffSummary(before, next),
+        repairMode === "ai-assisted" ? SKILL_HINT : null,
+      ),
+      needsBackup: !matchesManifest || input.force,
+      apply: async () => {
+        await mkdir(dirname(absolutePath), { recursive: true });
+        await writeFile(absolutePath, next, "utf8");
+        if (target.executable) await chmod(absolutePath, 0o755);
+        return next;
+      },
+    };
+  }
+
+  private async planMissingTarget(input: RunReconcileInput, target: ReconcileTarget) {
+    if (target.strategy === "symlink") return this.planSymlink(input.projectRoot, target.path);
+    const absolutePath = this.resolveProjectPath(input.projectRoot, target.path);
+    const before = await readTextOrNull(absolutePath);
+    const template = target.templatePath ? await readFile(join(input.harnessRoot, target.templatePath), "utf8") : "";
+    const next = before === null && target.strategy !== "package-json"
+      ? template
+      : this.reconcileContent(target, before, template, input.phasegateVersion);
+    const changed = before !== next;
+    const repairMode: RepairMode = target.strategy === "shell" && before !== null && !before.includes(SHELL_BEGIN) ? "ai-assisted" : "mechanical";
+    return {
+      item: this.item(
+        target.path,
+        before === null ? "add" : changed ? "update" : "skip",
+        repairMode,
+        target.strategy,
+        changed,
+        changed ? `${target.path}: add missing managed target` : `${target.path}: already up to date`,
+        this.diffSummary(before, next),
+        repairMode === "ai-assisted" ? SKILL_HINT : null,
+      ),
+      needsBackup: before !== null,
+      apply: async () => {
+        await mkdir(dirname(absolutePath), { recursive: true });
+        await writeFile(absolutePath, next, "utf8");
+        if (target.executable) await chmod(absolutePath, 0o755);
+        return next;
+      },
+    };
+  }
+
+  private async planSymlink(projectRoot: string, relativePath: string) {
+    const absolutePath = this.resolveProjectPath(projectRoot, relativePath);
+    try {
+      const stat = await lstat(absolutePath);
+      if (stat.isSymbolicLink() && (await readlink(absolutePath)) === "../skills") {
+        return {
+          item: this.item(relativePath, "skip", "mechanical", "symlink", false, `${relativePath}: already linked`, "no changes", null),
+          needsBackup: false,
+          apply: async () => "../skills",
+        };
+      }
+      return {
+        item: this.item(relativePath, "skip", "manual", "symlink", false, `${relativePath}: existing non-phasegate path requires manual review`, "manual review required", SKILL_HINT),
+        needsBackup: false,
+        apply: async () => null,
+      };
+    } catch {
+      return {
+        item: this.item(relativePath, "link", "mechanical", "symlink", true, `${relativePath}: create symlink`, "+ symlink ../skills", null),
+        needsBackup: false,
+        apply: async () => {
+          await mkdir(join(projectRoot, "skills"), { recursive: true });
+          await mkdir(dirname(absolutePath), { recursive: true });
+          await symlink("../skills", absolutePath, process.platform === "win32" ? "junction" : "dir");
+          return "../skills";
+        },
+      };
+    }
+  }
+
+  private reconcileContent(target: ReconcileTarget, before: string | null, template: string, version: string): string {
+    if (target.strategy === "yaml-add") return template;
+    if (target.strategy === "shell") return reconcileShell(before, template);
+    if (target.strategy === "package-json") {
+      const existing = before === null ? {} : (JSON.parse(before) as unknown);
+      return `${JSON.stringify(reconcilePackageJson(isRecord(existing) ? existing : {}, version), null, 2)}\n`;
+    }
+    const existing = before === null ? {} : (JSON.parse(before) as unknown);
+    const incoming = JSON.parse(template) as unknown;
+    return `${JSON.stringify(reconcileJsonObject(isRecord(existing) ? existing : {}, isRecord(incoming) ? incoming : {}), null, 2)}\n`;
+  }
+
+  private createTargets(): readonly ReconcileTarget[] {
+    return [
+      { path: ".claude/settings.json", strategy: "json", templatePath: "templates/.claude/settings.json" },
+      { path: ".codex/hooks.json", strategy: "json", templatePath: "templates/.codex/hooks.json" },
+      {
+        path: ".husky/pre-commit",
+        strategy: "shell",
+        templatePath: "docs/templates/hooks/pre-commit",
+        executable: true,
+        block: { start: SHELL_BEGIN, end: SHELL_END, content: "phasegate pre-commit managed block" },
+      },
+      {
+        path: ".husky/commit-msg",
+        strategy: "shell",
+        templatePath: "docs/templates/hooks/commit-msg",
+        executable: true,
+        block: { start: SHELL_BEGIN, end: SHELL_END, content: "phasegate commit-msg managed block" },
+      },
+      {
+        path: ".husky/pre-push",
+        strategy: "shell",
+        templatePath: "docs/templates/hooks/pre-push",
+        executable: true,
+        block: { start: SHELL_BEGIN, end: SHELL_END, content: "phasegate pre-push managed block" },
+      },
+      { path: ".github/workflows/phasegate-aidlc-gate.yml", strategy: "yaml-add", templatePath: "docs/templates/ci/aidlc-gate.yml" },
+      { path: "package.json", strategy: "package-json", templatePath: "package.json" },
+      { path: ".claude/skills", strategy: "symlink" },
+      { path: ".codex/skills", strategy: "symlink" },
+    ];
+  }
+
+  private async backup(projectRoot: string, relativePath: string, backupDir: string): Promise<void> {
+    const source = this.resolveProjectPath(projectRoot, relativePath);
+    if (!(await exists(source))) return;
+    const target = join(backupDir, relativePath);
+    await mkdir(dirname(target), { recursive: true });
+    await copyFile(source, target);
+  }
+
+  private managedBlockFor(path: string, strategy: StrategyType): ManagedBlockInput | null {
+    if (strategy === "shell") return { start: SHELL_BEGIN, end: SHELL_END, content: `phasegate ${path} managed block` };
+    if (strategy === "json" || strategy === "package-json") {
+      return { start: "phasegate structured merge", end: "phasegate structured merge", content: `${strategy}:${path}` };
+    }
+    return null;
+  }
+
+  private resolveProjectPath(projectRoot: string, relativePath: string): string {
+    const absolutePath = resolve(projectRoot, relativePath);
+    const root = resolve(projectRoot);
+    if (absolutePath !== root && !absolutePath.startsWith(`${root}/`) && relative(root, absolutePath).startsWith("..")) {
+      throw new Error(`Manifest entry escapes project root: ${relativePath}`);
+    }
+    return absolutePath;
+  }
+
+  private diffSummary(before: string | null, next: string): string {
+    if (before === next) return "no changes";
+    if (before === null) return `+ ${next.split(/\r?\n/).filter(Boolean).length} lines`;
+    return `~ ${before.length} bytes -> ${next.length} bytes`;
+  }
+
+  private item(
+    path: string,
+    action: ReconcileAction,
+    repairMode: RepairMode,
+    strategy: StrategyType,
+    changed: boolean,
+    summary: string,
+    diff: string,
+    skillHint: string | null,
+  ): ReconcilePlanItem {
+    return { path, action, repairMode, strategy, changed, summary, diff, skillHint };
+  }
+}

package/scripts/harness/installation/composition-root.ts

@@ -1,6 +1,7 @@
 // @unit installation
 // @layer presentation
 // @work-item-id WI-145
+// @work-item-id WI-148
 
 import { ClaudeHookMissingCheck } from "./application/checks/claude-hook-missing-check.js";
 import { ClaudeSkillsSymlinkCheck } from "./application/checks/claude-skills-symlink-check.js";
@@ -11,7 +12,9 @@ import { HuskyCommitMsgMissingCheck } from "./application/checks/husky-commit-ms
 import { HuskyPreCommitMissingCheck } from "./application/checks/husky-pre-commit-missing-check.js";
 import { HuskyPrePushMissingCheck } from "./application/checks/husky-pre-push-missing-check.js";
 import { PackageJsonDevdepMissingCheck } from "./application/checks/package-json-devdep-missing-check.js";
+import { WiWorkflowDriftCheck } from "./application/checks/wi-workflow-drift-check.js";
 import { RunInstallUseCase } from "./application/usecases/run-install.js";
+import { RunReconcileUseCase } from "./application/usecases/run-reconcile.js";
 import { RunUninstallUseCase } from "./application/usecases/run-uninstall.js";
 import { RunDoctorDiagnosticsUseCase } from "./application/usecases/run-doctor-diagnostics.js";
 import type { MergeStrategy } from "./domain/ports/merge-strategy.js";
@@ -22,6 +25,7 @@ import { NodeCryptoHashAdapter } from "./infrastructure/adapters/node-crypto-has
 import { NodeFsFileInspectorAdapter } from "./infrastructure/adapters/node-fs-file-inspector-adapter.js";
 import { DoctorHandler } from "./presentation/cli/doctor-handler.js";
 import { InstallHandler } from "./presentation/cli/install-handler.js";
+import { ReconcileHandler } from "./presentation/cli/reconcile-handler.js";
 import { UninstallHandler } from "./presentation/cli/uninstall-handler.js";
 
 type FutureInstallationStrategyPorts = {
@@ -46,17 +50,21 @@ export function createInstallationModule() {
     new PackageJsonDevdepMissingCheck(),
     new ClaudeSkillsSymlinkCheck(),
     new CodexSkillsSymlinkCheck(),
+    new WiWorkflowDriftCheck(),
   ];
   const runDoctorDiagnosticsUseCase = new RunDoctorDiagnosticsUseCase(checks, inspector, manifestRepository);
   const runInstallUseCase = new RunInstallUseCase(manifestRepository, hashCalculator);
+  const runReconcileUseCase = new RunReconcileUseCase(manifestRepository, hashCalculator);
   const runUninstallUseCase = new RunUninstallUseCase(manifestRepository, hashCalculator);
   return {
     manifestRepository,
     runDoctorDiagnosticsUseCase,
     runInstallUseCase,
+    runReconcileUseCase,
     runUninstallUseCase,
     doctorHandler: new DoctorHandler(runDoctorDiagnosticsUseCase),
     installHandler: new InstallHandler(runInstallUseCase),
+    reconcileHandler: new ReconcileHandler(runReconcileUseCase),
     uninstallHandler: new UninstallHandler(runUninstallUseCase),
     futureInstallationStrategyPorts,
   };

package/scripts/harness/installation/domain/check-id.ts

@@ -12,6 +12,7 @@ export const CHECK_IDS = [
   "package-json-devdep-missing",
   "claude-skills-symlink",
   "codex-skills-symlink",
+  "wi-workflow-drift",
 ] as const;
 
 export type CheckId = (typeof CHECK_IDS)[number];

package/scripts/harness/installation/infrastructure/adapters/node-fs-file-inspector-adapter.ts

@@ -45,7 +45,16 @@ export class NodeFsFileInspectorAdapter implements FileInspectorPort {
   async listFiles(absolutePath: string): Promise<string[]> {
     try {
       const entries = await readdir(absolutePath, { withFileTypes: true });
-      return entries.filter((entry) => entry.isFile()).map((entry) => join(absolutePath, entry.name));
+      const files: string[] = [];
+      for (const entry of entries) {
+        const entryPath = join(absolutePath, entry.name);
+        if (entry.isFile()) {
+          files.push(entryPath);
+        } else if (entry.isDirectory()) {
+          files.push(...(await this.listFiles(entryPath)));
+        }
+      }
+      return files;
     } catch {
       return [];
     }

package/scripts/harness/installation/presentation/cli/reconcile-handler.ts

@@ -0,0 +1,50 @@
+// @unit installation
+// @layer presentation
+// @work-item-id WI-148
+
+import type { RunReconcileUseCase } from "../../application/usecases/run-reconcile.js";
+
+export interface ReconcileHandlerInput {
+  readonly projectRoot: string;
+  readonly harnessRoot: string;
+  readonly phasegateVersion: string;
+  readonly dryRun: boolean;
+  readonly apply: boolean;
+  readonly force: boolean;
+  readonly json: boolean;
+}
+
+export interface ReconcileHandlerResult {
+  readonly stdout: string;
+  readonly exitCode: number;
+}
+
+export class ReconcileHandler {
+  constructor(private readonly useCase: RunReconcileUseCase) {}
+
+  async execute(input: ReconcileHandlerInput): Promise<ReconcileHandlerResult> {
+    const result = await this.useCase.execute(input);
+    if (input.json) {
+      return {
+        stdout: JSON.stringify(result, null, 2),
+        exitCode: result.refused.length > 0 ? 1 : 0,
+      };
+    }
+    const lines = [
+      input.apply ? "phasegate reconcile apply" : "phasegate reconcile dry-run",
+      ...result.plan.map((item) => {
+        const hint = item.skillHint ? `; hint: ${item.skillHint}` : "";
+        return `- ${item.path}: ${item.action} (${item.repairMode}, ${item.strategy}); diff: ${item.diff}${hint}`;
+      }),
+    ];
+    if (result.backupDir !== null) lines.push(`backups: ${result.backupDir}`);
+    if (result.refused.length > 0) {
+      lines.push("");
+      lines.push("Refused ai-assisted/manual targets. Re-run with --force after reviewing the hint.");
+    }
+    return {
+      stdout: lines.join("\n"),
+      exitCode: result.refused.length > 0 ? 1 : 0,
+    };
+  }
+}

package/scripts/harness/main.ts

@@ -8,7 +8,13 @@
  * 起動時に config-foundation で設定を解決し、他Unit に注入する（Cross-unit wiring）。
  */
 
-import { access, readFile as fsReadFile, readlink as fsReadlink, writeFile as fsWriteFile } from "node:fs/promises";
+import {
+  mkdir as fsMkdir,
+  readFile as fsReadFile,
+  readdir as fsReaddir,
+  readlink as fsReadlink,
+  writeFile as fsWriteFile,
+} from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { createAdrFoundationModule } from "./adr-foundation/composition-root.js";
 import { createBiomeAstEngineModule } from "./biome-ast-engine/composition-root.js";
@@ -52,7 +58,6 @@ import {
   deployHuskyPrePushHook,
   deploySkills,
   getCategoryForSkill,
-  getDeployedVersion,
   getHarnessVersion,
   initHarnessConfig,
 } from "./setup/skill-deployer.js";
@@ -78,15 +83,6 @@ function toTraceabilityModelOptions(resolvedConfig: HarnessConfigV2 | undefined)
     : undefined;
 }
 
-async function pathExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 interface PackageJsonDocument {
   readonly [key: string]: unknown;
   readonly dependencies?: unknown;
@@ -148,12 +144,15 @@ Usage: phasegate <command> [options]
 Setup:
   init                         Initialize project: deploy skills + design docs + phasegate.config.json
                                (--name <project-name>, --preset <full|standard|minimal|custom>,
-                                --skills <core|all>, --agent <claude|codex|both>, --with-husky, --with-ci, --yes)
-  update-skills                Re-deploy skills from current harness version
+                                --skills <core|all>, --agent <claude|codex|both>, --workflow <standard|strict>,
+                                --with-husky, --with-ci, --yes)
+  update-skills                Alias for reconcile (kept for compatibility)
   doctor                       Diagnose silent installation failures (--json, --strict, --report-out <path>)
+  scaffold-wi <unit> <type>    Create docs/inception/{unit}/WI-XXX/description.md
+  emit-agent-rules             Print AGENTS.md / CLAUDE.md WI workflow rules block
   install                      Install phasegate managed files (--dry-run|--apply, --force)
   uninstall                    Uninstall phasegate managed files (--dry-run|--apply, --force)
-  reconcile                    Reconcile phasegate managed files (stub until WI-148)
+  reconcile                    Reconcile phasegate managed files (--dry-run|--apply, --force)
 
 Commands:
   enable-feature <name>        Enable a harness feature
@@ -242,6 +241,103 @@ function hasFlag(args: readonly string[], flag: string): boolean {
   return args.includes(flag);
 }
 
+type WorkflowMode = "standard" | "strict";
+type ScaffoldWorkItemType = "story" | "issue" | "chore";
+
+function parseWorkflowMode(value: string | undefined): WorkflowMode {
+  return value === "strict" ? "strict" : "standard";
+}
+
+function parseScaffoldWorkItemType(value: string | undefined): ScaffoldWorkItemType | null {
+  if (value === "story" || value === "issue" || value === "chore") return value;
+  return null;
+}
+
+function emitAgentRulesBlock(): string {
+  return [
+    "## PhaseGate WI Workflow (auto-generated; do not edit by hand)",
+    "- All plans/designs/implementations require a WI directory first.",
+    "- Path: `docs/inception/{unit}/WI-XXX/description.md` with required frontmatter.",
+    "- Use `phasegate scaffold-wi <unit> <type>` to create one.",
+    "- Plans written under `docs/inception/codding_plan/` are legacy; new plans go in WI dirs.",
+  ].join("\n");
+}
+
+async function listFilesRecursive(root: string): Promise<string[]> {
+  try {
+    const entries = await fsReaddir(root, { withFileTypes: true });
+    const files: string[] = [];
+    for (const entry of entries) {
+      const path = join(root, entry.name);
+      if (entry.isFile()) {
+        files.push(path);
+      } else if (entry.isDirectory()) {
+        files.push(...(await listFilesRecursive(path)));
+      }
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+
+async function nextWorkItemId(rootDir: string): Promise<string> {
+  const files = await listFilesRecursive(join(rootDir, "docs", "inception"));
+  let max = 0;
+  for (const file of files) {
+    const match = file.match(/\/WI-(\d{3})\/description\.md$/);
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return `WI-${String(max + 1).padStart(3, "0")}`;
+}
+
+async function countLegacyPlansWithoutWorkItems(rootDir: string): Promise<number> {
+  const files = await listFilesRecursive(join(rootDir, "docs", "inception"));
+  const hasWorkItem = files.some((file) => /\/WI-\d{3}\/description\.md$/.test(file));
+  if (hasWorkItem) return 0;
+  return files.filter((file) => file.includes("/codding_plan/") || file.endsWith("_plan.md")).length;
+}
+
+async function scaffoldInceptionRoots(rootDir: string, unit: string | null = null): Promise<void> {
+  await fsMkdir(join(rootDir, "docs", "inception", "_shared"), { recursive: true });
+  await fsMkdir(join(rootDir, "docs", "inception", "_cross"), { recursive: true });
+  if (unit && unit !== "_cross" && unit !== "_shared") {
+    await fsMkdir(join(rootDir, "docs", "inception", unit), { recursive: true });
+    await fsWriteFile(join(rootDir, "docs", "inception", unit, ".gitkeep"), "", "utf8").catch(() => undefined);
+  }
+}
+
+async function scaffoldWorkItem(rootDir: string, unit: string, type: ScaffoldWorkItemType): Promise<string> {
+  const id = await nextWorkItemId(rootDir);
+  await scaffoldInceptionRoots(rootDir, unit);
+  const targetBase = unit === "_cross" ? join(rootDir, "docs", "inception", "_cross") : join(rootDir, "docs", "inception", unit);
+  const targetDir = join(targetBase, id);
+  await fsMkdir(targetDir, { recursive: true });
+  const descriptionPath = join(targetDir, "description.md");
+  const titleScope = unit === "_cross" ? "Cross-cutting" : unit;
+  const content = [
+    "---",
+    `id: ${id}`,
+    `type: ${type}`,
+    "severity: normal",
+    "status: drafted",
+    "---",
+    "",
+    `# ${id}: ${titleScope} work item`,
+    "",
+    "## Context",
+    "",
+    "TBD",
+    "",
+    "## Acceptance Criteria",
+    "",
+    "- [ ] TBD",
+    "",
+  ].join("\n");
+  await fsWriteFile(descriptionPath, content, "utf8");
+  return descriptionPath;
+}
+
 async function createFileManifestRecord(
   rootDir: string,
   relativePath: string,
@@ -359,17 +455,21 @@ Options:
   --preset <full|standard|minimal|custom>   Phase dependency preset (default: "standard")
   --skills <core|all>             Skill set to deploy (default: "all")
   --agent <claude|codex|both>     Agent integration target (default: "claude")
+  --workflow <standard|strict>    Workflow enforcement defaults (default: "standard")
   --with-husky                    Install Husky pre-commit hooks
   --with-ci                       Install GitHub Actions workflows
   --yes                           Skip confirmation prompts
   --help, -h                      Show this help`,
   "update-skills": `Usage: phasegate update-skills [options]
 
-Redeploy skills in .claude/skills/ from the installed phasegate version. WARNING: overwrites existing skill files.
+Compatibility alias for phasegate reconcile. WARNING: this command no longer redeploys skills directly.
+It updates PhaseGate-managed files from the installed manifest.
 
 Options:
-  --skills <core|all>             Skill set to deploy
-  --agent <claude|codex|both>     Agent integration target
+  --dry-run                       Preview target actions without writing (default)
+  --apply                         Write reconcile results and manifest
+  --force                         Force ai-assisted/manual targets after backing up existing files
+  --json                          Output machine-readable JSON
   --help, -h                      Show this help`,
   install: `Usage: phasegate install [options]
 
@@ -381,6 +481,16 @@ Options:
   --force                         Force ai-assisted/manual targets after backing up existing files
   --json                          Output machine-readable JSON
   --help, -h                      Show this help`,
+  reconcile: `Usage: phasegate reconcile [options]
+
+Reconcile PhaseGate-managed files with the current bundled templates.
+
+Options:
+  --dry-run                       Preview target actions without writing (default)
+  --apply                         Write managed updates and manifest
+  --force                         Force ai-assisted/manual targets after backing up existing files
+  --json                          Output machine-readable JSON
+  --help, -h                      Show this help`,
   validate: `Usage: phasegate validate [options]
 
 Run validators against the project. Without --layer, runs all enabled validator layers (L2/L3/L4).
@@ -771,7 +881,19 @@ async function main(): Promise<void> {
     switch (command) {
       // ── harness setup ──
       case "init": {
-        const KNOWN_INIT_FLAGS = ["--name", "--preset", "--skills", "--agent", "--with-husky", "--with-ci", "--yes"];
+        console.log("Warning: phasegate init is deprecated and will be removed in v1.0.");
+        console.log("Use phasegate install for idempotent setup with structured merge.");
+        console.log("Existing legacy init behavior is preserved. Run phasegate doctor to verify installation state.");
+        const KNOWN_INIT_FLAGS = [
+          "--name",
+          "--preset",
+          "--skills",
+          "--agent",
+          "--workflow",
+          "--with-husky",
+          "--with-ci",
+          "--yes",
+        ];
         const flagError = validateKnownFlags(args, KNOWN_INIT_FLAGS);
         if (flagError) {
           console.error(flagError);
@@ -802,6 +924,12 @@ async function main(): Promise<void> {
           process.exit(2);
         }
         const agent = agentRaw;
+        const workflowRaw = parseFlag(args, "--workflow");
+        if (workflowRaw !== undefined && workflowRaw !== "standard" && workflowRaw !== "strict") {
+          console.error(`Invalid --workflow value: "${workflowRaw}". Use "standard" or "strict".`);
+          process.exit(2);
+        }
+        const workflow = parseWorkflowMode(workflowRaw);
         const deployClaude = agent === "claude" || agent === "both";
         const deployCodex = agent === "codex" || agent === "both";
         const result = await deploySkills(harnessRoot, rootDir, skillSet);
@@ -811,7 +939,13 @@ async function main(): Promise<void> {
           codex: deployCodex,
         });
         const withCi = hasFlag(args, "--with-ci");
-        const configResult = await initHarnessConfig(rootDir, projectName, phasePreset, { ciEnabled: withCi });
+        const configResult = await initHarnessConfig(rootDir, projectName, phasePreset, {
+          ciEnabled: withCi,
+          workflow,
+        });
+        if (workflow === "strict") {
+          await scaffoldInceptionRoots(rootDir);
+        }
         const hooksResult = deployClaude
           ? await deployHookScripts(harnessRoot, rootDir)
           : {
@@ -885,6 +1019,9 @@ async function main(): Promise<void> {
         }
         if (configResult.created) {
           console.log(`✓ phasegate.config.json created`);
+          if (workflow === "strict") {
+            console.log(`✓ strict workflow configured (quickMode.relaxedGates: [], allowedCategories: ["chore"])`);
+          }
         } else {
           console.log(`  phasegate.config.json already exists, skipped`);
         }
@@ -960,6 +1097,13 @@ async function main(): Promise<void> {
           }
         }
         console.log(`✓ Harness v${result.version} initialized (agent: ${agent})`);
+        const legacyPlanCount = await countLegacyPlansWithoutWorkItems(rootDir);
+        if (legacyPlanCount > 0) {
+          console.log("");
+          console.log(`Detected ${legacyPlanCount} legacy plan file(s) with no WI directories.`);
+          console.log("Run migration? [Y/n]");
+          console.log("  phasegate migrate work-items --apply");
+        }
         console.log("");
         console.log("Next steps:");
         if (skillSet === "core") {
@@ -989,41 +1133,28 @@ async function main(): Promise<void> {
       }
 
       case "update-skills": {
-        const deployed = await getDeployedVersion(rootDir);
-        const current = await getHarnessVersion(harnessRoot);
-        const previousSkillSet: SkillSet = deployed?.skillSet ?? "all";
-        const overrideSkillSet = parseFlag(args, "--skills");
-        const updateSkillSet: SkillSet =
-          overrideSkillSet === "core" || overrideSkillSet === "all" ? overrideSkillSet : previousSkillSet;
-        if (deployed) {
-          console.log(`Previously deployed: v${deployed.version} (${deployed.deployedAt}, set: ${previousSkillSet})`);
-        } else {
-          console.log("No previously deployed skills found");
+        const KNOWN_RECONCILE_FLAGS = ["--dry-run", "--apply", "--force", "--json"];
+        const flagError = validateKnownFlags(args, KNOWN_RECONCILE_FLAGS);
+        if (flagError) {
+          console.error(flagError);
+          process.exit(2);
         }
-        console.log(`Current harness version: v${current}`);
-        const result = await deploySkills(harnessRoot, rootDir, updateSkillSet);
-        const shouldLinkClaude =
-          (await pathExists(join(rootDir, ".claude", "settings.json"))) ||
-          (await pathExists(join(rootDir, ".claude", "skills")));
-        const shouldLinkCodex =
-          (await pathExists(join(rootDir, ".codex", "hooks.json"))) ||
-          (await pathExists(join(rootDir, ".codex", "skills")));
-        await deployAgentSkillLinks(rootDir, {
-          claude: shouldLinkClaude,
-          codex: shouldLinkCodex,
+        const apply = hasFlag(args, "--apply");
+        const dryRun = hasFlag(args, "--dry-run") || !apply;
+        const mod = createInstallationModule();
+        const phasegateVersion = await getHarnessVersion(harnessRoot);
+        const result = await mod.reconcileHandler.execute({
+          projectRoot: rootDir,
+          harnessRoot,
+          phasegateVersion,
+          dryRun,
+          apply,
+          force: hasFlag(args, "--force"),
+          json,
         });
-        await saveInstallationManifest(rootDir, current, [
-          ...result.deployedSkills.map((skill) => ({
-            path: join("skills", skill),
-            mode: "created" as const,
-            contentForHash: `${current}:${skill}`,
-          })),
-          await createFileManifestRecord(rootDir, join("skills", ".harness-version")),
-          shouldLinkClaude ? await createSymlinkManifestRecord(rootDir, join(".claude", "skills")) : null,
-          shouldLinkCodex ? await createSymlinkManifestRecord(rootDir, join(".codex", "skills")) : null,
-        ]);
-        console.log(`✓ Skills updated (${result.deployedSkills.length} skills redeployed, set: ${updateSkillSet})`);
-        process.exit(0);
+        if (!json) console.log("phasegate update-skills is deprecated; running phasegate reconcile.");
+        console.log(result.stdout);
+        process.exit(result.exitCode);
         break;
       }
 
@@ -1042,6 +1173,25 @@ async function main(): Promise<void> {
         break;
       }
 
+      case "emit-agent-rules": {
+        console.log(emitAgentRulesBlock());
+        process.exit(0);
+        break;
+      }
+
+      case "scaffold-wi": {
+        const unit = args[1];
+        const type = parseScaffoldWorkItemType(args[2]);
+        if (!unit || !type) {
+          console.error("Usage: phasegate scaffold-wi <unit|_cross> <story|issue|chore>");
+          process.exit(2);
+        }
+        const descriptionPath = await scaffoldWorkItem(rootDir, unit, type);
+        console.log(`Created ${descriptionPath}`);
+        process.exit(0);
+        break;
+      }
+
       case "install": {
         const KNOWN_INSTALL_FLAGS = ["--dry-run", "--apply", "--force", "--json"];
         const flagError = validateKnownFlags(args, KNOWN_INSTALL_FLAGS);
@@ -1091,8 +1241,27 @@ async function main(): Promise<void> {
       }
 
       case "reconcile": {
-        console.error("Not yet implemented: phasegate reconcile is owned by WI-148");
-        process.exit(2);
+        const KNOWN_RECONCILE_FLAGS = ["--dry-run", "--apply", "--force", "--json"];
+        const flagError = validateKnownFlags(args, KNOWN_RECONCILE_FLAGS);
+        if (flagError) {
+          console.error(flagError);
+          process.exit(2);
+        }
+        const apply = hasFlag(args, "--apply");
+        const dryRun = hasFlag(args, "--dry-run") || !apply;
+        const mod = createInstallationModule();
+        const phasegateVersion = await getHarnessVersion(harnessRoot);
+        const result = await mod.reconcileHandler.execute({
+          projectRoot: rootDir,
+          harnessRoot,
+          phasegateVersion,
+          dryRun,
+          apply,
+          force: hasFlag(args, "--force"),
+          json,
+        });
+        console.log(result.stdout);
+        process.exit(result.exitCode);
         break;
       }
 

package/scripts/harness/setup/skill-deployer.ts

@@ -422,6 +422,7 @@ export async function deployHookScripts(harnessRoot: string, projectRoot: string
 
 export interface InitHarnessConfigOptions {
   ciEnabled?: boolean;
+  workflow?: "standard" | "strict";
 }
 
 export async function initHarnessConfig(
@@ -438,6 +439,7 @@ export async function initHarnessConfig(
     // ファイルが存在しない場合はテンプレートを作成
   }
 
+  const strictWorkflow = options.workflow === "strict";
   const template = {
     project: {
       name: projectName,
@@ -447,7 +449,12 @@ export async function initHarnessConfig(
       preset: "clean",
     },
     layers: {},
-    quickMode: {},
+    quickMode: strictWorkflow
+      ? {
+          allowedCategories: ["chore"],
+          relaxedGates: [],
+        }
+      : {},
     phaseDependencies: {
       preset: phasePreset ?? "default",
       override: false,

package/skills/implementation-planner/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: implementation-planner
-description: "Unit仕様とドメインモデル設計を元に実装計画を立てる。ストーリーIDや機能名から関連Unitを特定し、API設計・レイヤー別実装方針を整理してmdファイルで出力する。使用タイミング: 実装計画を立てて、US-XXXの実装方針を決めて、この機能の設計を整理して、など実装前の計画策定時。"
+description: "Unit仕様とドメインモデル設計を元に実装計画を立てる。WI IDや機能名から関連Unitを特定し、API設計・レイヤー別実装方針を整理してmdファイルで出力する。使用タイミング: 実装計画を立てて、WI-XXXの実装方針を決めて、この機能の設計を整理して、など実装前の計画策定時。"
 model: sonnet
 review: opus
 ---
@@ -35,6 +35,11 @@ UnitドキュメントとConstructionのドメインモデル設計を元に、*
 
 ## ワークフロー
 
+## Pre-flight check (BLOCKING)
+
+Before generating any plan, verify `docs/inception/{unit}/WI-XXX/description.md` exists.
+If not, halt and ask the user to create the WI first, or offer to run `phasegate scaffold-wi <unit> <story|issue|chore>`.
+
 ```
 入力解析 → Unit特定 → ドメインモデル確認 → 既存実装確認 → 計画作成 → 出力
 ```
@@ -42,7 +47,7 @@ UnitドキュメントとConstructionのドメインモデル設計を元に、*
 ### Step 1: 入力解析
 
 ユーザー入力から抽出:
-- ストーリーID（US-XXX形式）
+- WI ID（WI-XXX形式）
 - 機能名・タスク説明
 - 優先度・制約条件
 
@@ -85,6 +90,7 @@ UnitドキュメントとConstructionのドメインモデル設計を元に、*
 計画をmdファイルとして出力。パスの推奨:
 ```
 docs/inception/{task_id}_plan.md
+docs/inception/{unit}/WI-XXX/tdd_implementation_plan.md
 ```
 
 **[Question][Answer]セクション必須**: 不明点や確認事項をまとめ、ユーザーからのフィードバックを受け取れるようにする。

package/skills/logical-designer/SKILL.md

@@ -18,6 +18,11 @@ Unit単位でアーキテクチャの各層（DB → ドメイン → ユース
 
 ## 前提条件チェック
 
+## Pre-flight check (BLOCKING)
+
+Before generating any plan, verify `docs/inception/{unit}/WI-XXX/description.md` exists.
+If not, halt and ask the user to create the WI first, or offer to run `phasegate scaffold-wi <unit> <story|issue|chore>`.
+
 ### 必須インプット（存在しなければ`[Question]`で提供を要求）
 
 - **横断モード:**
@@ -95,7 +100,7 @@ Unit単位でアーキテクチャの各層（DB → ドメイン → ユース
 設計方針・スコープ・不明点を整理し、人間の承認を得る。
 
 ### 出力ファイル
-`docs/inception/{unit}/logical_design_plan.md`（横断）または `docs/inception/{unit}/{story_id}/logical_design_plan.md`（ストーリー固有）
+`docs/inception/{unit}/WI-XXX/logical_design_plan.md`
 
 ### 計画ファイルの構成
 
@@ -173,7 +178,7 @@ Unit単位でアーキテクチャの各層（DB → ドメイン → ユース
 | 種別 | 配置先 |
 |------|--------|
 | 横断成果物 | `docs/product/construction/{unit}/logical_design.md` |
-| ストーリー固有成果物 | `docs/inception/{unit}/{story_id}/logical_design.md` |
+| ストーリー固有成果物 | `docs/inception/{unit}/WI-XXX/logical_design.md` |
 
 > **注意**: ストーリー固有の設計は `docs/inception/` に配置する（`docs/folder_management_rules.md` のルール準拠）。`docs/product/construction/` にはUnit全体の共有設計のみを配置する。
 
@@ -194,22 +199,22 @@ traceability:
 ---
 ```
 
-`initial_creation: true` は「新規作成であり、後述の `@story-id` 注釈が必須」であることを示す。
+`initial_creation: true` は「新規作成であり、後述の `@work-item-id` 注釈が必須」であることを示す。
 
-### 2. `@story-id` インライン注釈
+### 2. `@work-item-id` インライン注釈
 
-ユーザーストーリーに紐づく設計要素の直前に `@story-id HXX-XX` を独立行で記述する。
+WI に紐づく設計要素の直前に `@work-item-id WI-XXX` を独立行で記述する。
 
 ```markdown
-@story-id H03-02
+@work-item-id WI-001
 ### ユースケース: 注文を確定する
 ```
 
 形式ルール:
 - **独立行** — 他のテキストと混在させない
 - **直後に設計要素** — 空行を挟まない
-- **StoryCatalog 存在** — `HXX-XX` は `docs/product/user_stories.md` に存在する ID
-- **複数ストーリー時** — 注釈行を連続で並べ、最後の直後に設計要素を置く
+- **WorkItem 存在** — `WI-XXX` は `docs/inception/{unit}/WI-XXX/description.md` に存在する ID
+- **複数WI時** — 注釈行を連続で並べ、最後の直後に設計要素を置く
 
 ---
 

package/skills/story-writer/SKILL.md

@@ -11,6 +11,11 @@ review: opus
 
 ## 前提条件チェック
 
+## Pre-flight check (BLOCKING)
+
+Before generating any plan, verify `docs/inception/{unit}/WI-XXX/description.md` exists.
+If not, halt and ask the user to create the WI first, or offer to run `phasegate scaffold-wi <unit> <story|issue|chore>`.
+
 ### 必須インプット（存在しなければ`[Question]`で提供を要求）
 - **要求文書** — 何を作るかを記述した文書。形式は問わない（議事録、要件メモ、口頭要約のテキスト等）