phasegate 0.264.0 → 0.315.0

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

@@ -2,6 +2,7 @@
 // @layer domain
 // @work-item-id WI-145
 // @work-item-id WI-215
+// @work-item-id WI-330
 
 export const CHECK_IDS = [
   "claude-hook-missing",
@@ -16,6 +17,7 @@ export const CHECK_IDS = [
   "claude-skills-symlink",
   "codex-skills-symlink",
   "wi-workflow-drift",
+  "config-status",
 ] as const;
 
 export type CheckId = (typeof CHECK_IDS)[number];

package/scripts/harness/installation/domain/config-status.ts

@@ -0,0 +1,17 @@
+// @unit installation
+// @layer domain
+// @work-item-id WI-330
+
+export const CONFIG_STATUSES = ["missing", "invalid-json", "invalid-schema", "valid"] as const;
+
+export type ConfigStatus = (typeof CONFIG_STATUSES)[number];
+
+export function isConfigStatus(value: string): value is ConfigStatus {
+  return (CONFIG_STATUSES as readonly string[]).includes(value);
+}
+
+export interface ConfigStatusProbeResult {
+  readonly status: ConfigStatus;
+  readonly configPath: string;
+  readonly detail: string | null;
+}

package/scripts/harness/installation/domain/deployment-manifest.ts

@@ -1,19 +1,32 @@
 // @unit installation
 // @layer domain
 // @work-item-id WI-145
+// @work-item-id WI-326
 
 import { DeploymentEntry, type DeploymentEntryJson } from "./deployment-entry.js";
 
+// Records which install-time options produced this manifest so a later
+// reconcile can honor the original opt-in state instead of assuming defaults.
+// Optional for backward compatibility: manifests written before WI-326 carry
+// no flags, and consumers must fall back to legacy behavior in that case.
+export interface InstallationFlags {
+  readonly includeHusky: boolean;
+  readonly includeCi: boolean;
+  readonly personal: boolean;
+}
+
 export interface DeploymentManifestInput {
   readonly version: string;
   readonly installedAt: string;
   readonly entries: readonly DeploymentEntry[];
+  readonly installationFlags?: InstallationFlags;
 }
 
 export interface DeploymentManifestJson {
   readonly version: string;
   readonly installedAt: string;
   readonly entries: readonly DeploymentEntryJson[];
+  readonly installationFlags?: InstallationFlags;
 }
 
 export class DeploymentManifest {
@@ -22,6 +35,7 @@ export class DeploymentManifest {
   readonly version: string;
   readonly installedAt: string;
   readonly entries: readonly DeploymentEntry[];
+  readonly installationFlags?: InstallationFlags;
 
   private constructor(input: DeploymentManifestInput) {
     if (!DeploymentManifest.SEMVER_PATTERN.test(input.version)) {
@@ -30,6 +44,12 @@ export class DeploymentManifest {
     if (!Number.isFinite(Date.parse(input.installedAt))) {
       throw new Error("DeploymentManifest installedAt must be ISO8601-compatible");
     }
+    if (input.installationFlags !== undefined) {
+      const { includeHusky, includeCi, personal } = input.installationFlags;
+      if (typeof includeHusky !== "boolean" || typeof includeCi !== "boolean" || typeof personal !== "boolean") {
+        throw new Error("DeploymentManifest installationFlags must contain boolean includeHusky/includeCi/personal");
+      }
+    }
     const paths = new Set<string>();
     for (const entry of input.entries) {
       if (paths.has(entry.path)) {
@@ -40,6 +60,14 @@ export class DeploymentManifest {
     this.version = input.version;
     this.installedAt = input.installedAt;
     this.entries = Object.freeze([...input.entries]);
+    this.installationFlags =
+      input.installationFlags === undefined
+        ? undefined
+        : Object.freeze({
+            includeHusky: input.installationFlags.includeHusky,
+            includeCi: input.installationFlags.includeCi,
+            personal: input.installationFlags.personal,
+          });
     Object.freeze(this);
   }
 
@@ -56,6 +84,7 @@ export class DeploymentManifest {
       version: input.version,
       installedAt: input.installedAt,
       entries: input.entries.map((entry) => DeploymentEntry.fromJSON(entry)),
+      installationFlags: input.installationFlags,
     });
   }
 
@@ -65,6 +94,7 @@ export class DeploymentManifest {
       version: this.version,
       installedAt: this.installedAt,
       entries: [...entries, entry],
+      installationFlags: this.installationFlags,
     });
   }
 
@@ -73,6 +103,16 @@ export class DeploymentManifest {
       version: this.version,
       installedAt: this.installedAt,
       entries: this.entries.filter((entry) => entry.path !== path),
+      installationFlags: this.installationFlags,
+    });
+  }
+
+  withInstallationFlags(installationFlags: InstallationFlags): DeploymentManifest {
+    return DeploymentManifest.reconstitute({
+      version: this.version,
+      installedAt: this.installedAt,
+      entries: this.entries,
+      installationFlags,
     });
   }
 
@@ -85,6 +125,9 @@ export class DeploymentManifest {
       version: this.version,
       installedAt: this.installedAt,
       entries: this.entries.map((entry) => entry.toJSON()),
+      // Omit the key entirely for legacy manifests so serialized output stays
+      // byte-compatible with pre-WI-326 manifest.json files.
+      ...(this.installationFlags === undefined ? {} : { installationFlags: this.installationFlags }),
     };
   }
 }

package/scripts/harness/installation/domain/ports/heuristic-check.ts

@@ -1,12 +1,21 @@
 // @unit installation
 // @layer domain
 // @work-item-id WI-145
+// @work-item-id WI-343
 
 import type { CheckId } from "../check-id.js";
 import type { DiagnosticFinding } from "../diagnostic-finding.js";
 import type { FileInspector } from "./file-inspector.js";
 
+export interface HeuristicCheckContext {
+  readonly installationMode: "project" | "personal";
+}
+
 export interface HeuristicCheck {
   readonly checkId: CheckId;
-  run(projectRoot: string, inspector: FileInspector): Promise<DiagnosticFinding | null>;
+  run(
+    projectRoot: string,
+    inspector: FileInspector,
+    context?: HeuristicCheckContext,
+  ): Promise<DiagnosticFinding | null>;
 }

package/scripts/harness/installation/infrastructure/adapters/config-status-probe-adapter.ts

@@ -0,0 +1,79 @@
+// @unit installation
+// @layer infrastructure
+// @work-item-id WI-330
+
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { createConfigFoundationModule } from "../../../config-foundation/composition-root.js";
+import { ConfigValidationError } from "../../../config-foundation/domain/errors/config-validation-error.js";
+import {
+  ConfigNotFoundError,
+  ConfigParseError,
+} from "../../../config-foundation/infrastructure/repositories/file-system-config-repository.js";
+import type { ConfigStatusProbePort } from "../../application/ports/config-status-probe-port.js";
+import type { ConfigStatusProbeResult } from "../../domain/config-status.js";
+
+const PROJECT_CONFIG_PATH = "phasegate.config.json";
+const PERSONAL_CONFIG_PATH = join(".phasegate-local", "phasegate.config.json");
+
+async function exists(targetPath: string): Promise<boolean> {
+  try {
+    await access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * WI-330: doctor 用の config 状態 probe。
+ *
+ * FileSystemConfigRepository と同じ候補順（project 直下 → .phasegate-local/ の personal install）で
+ * projectRoot 直下のみを解決する。cwd からの上方探索は行わない — doctor は「このプロジェクトの
+ * config」を診断するため、親ディレクトリの config を拾うと診断が偽装される。
+ * 妥当性判定は config-foundation の実 load 経路（JSON parse + AJV schema + preset 解決）を
+ * そのまま使い、CLI 本体と同じ基準で invalid を検出する。
+ */
+export class ConfigStatusProbeAdapter implements ConfigStatusProbePort {
+  private readonly cache = new Map<string, Promise<ConfigStatusProbeResult>>();
+
+  probe(projectRoot: string): Promise<ConfigStatusProbeResult> {
+    const cached = this.cache.get(projectRoot);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const inspected = this.inspect(projectRoot);
+    this.cache.set(projectRoot, inspected);
+    return inspected;
+  }
+
+  private async inspect(projectRoot: string): Promise<ConfigStatusProbeResult> {
+    for (const relativePath of [PROJECT_CONFIG_PATH, PERSONAL_CONFIG_PATH]) {
+      const absolutePath = join(projectRoot, relativePath);
+      if (await exists(absolutePath)) {
+        return await this.classify(absolutePath, relativePath);
+      }
+    }
+    return { status: "missing", configPath: PROJECT_CONFIG_PATH, detail: null };
+  }
+
+  private async classify(absolutePath: string, relativePath: string): Promise<ConfigStatusProbeResult> {
+    try {
+      await createConfigFoundationModule().usecases.loadResolvedConfigUseCase.execute(absolutePath);
+      return { status: "valid", configPath: relativePath, detail: null };
+    } catch (error) {
+      if (error instanceof ConfigNotFoundError) {
+        return { status: "missing", configPath: relativePath, detail: null };
+      }
+      if (error instanceof ConfigParseError) {
+        const detail = error.cause instanceof Error ? error.cause.message : error.message;
+        return { status: "invalid-json", configPath: relativePath, detail };
+      }
+      if (error instanceof ConfigValidationError) {
+        return { status: "invalid-schema", configPath: relativePath, detail: error.message };
+      }
+      const detail = error instanceof Error ? error.message : String(error);
+      return { status: "invalid-schema", configPath: relativePath, detail };
+    }
+  }
+}

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

@@ -3,10 +3,14 @@
 // @work-item-id WI-145
 // @work-item-id WI-178
 // @work-item-id WI-208
+// @work-item-id WI-330
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
-import type { DoctorAgentScope, RunDoctorDiagnosticsUseCase } from "../../application/usecases/run-doctor-diagnostics.js";
+import type {
+  DoctorAgentScope,
+  RunDoctorDiagnosticsUseCase,
+} from "../../application/usecases/run-doctor-diagnostics.js";
 import { DiagnosticReportFormatter } from "../formatters/diagnostic-report-formatter.js";
 
 export interface DoctorHandlerInput {
@@ -39,6 +43,7 @@ export class DoctorHandler {
       report: result.report,
       agent: result.agent,
       installationMode: result.installationMode,
+      configStatus: result.configStatus,
       scopedOutFindings: result.scopedOutFindings,
       phasegateVersion: input.phasegateVersion,
       projectRoot: input.projectRoot,

package/scripts/harness/installation/presentation/formatters/diagnostic-report-formatter.ts

@@ -5,14 +5,20 @@
 // @work-item-id WI-179
 // @work-item-id WI-180
 // @work-item-id WI-208
+// @work-item-id WI-330
 
-import type { DoctorAgentScope, ScopedOutDiagnosticFinding } from "../../application/usecases/run-doctor-diagnostics.js";
+import type {
+  DoctorAgentScope,
+  ScopedOutDiagnosticFinding,
+} from "../../application/usecases/run-doctor-diagnostics.js";
+import type { ConfigStatus } from "../../domain/config-status.js";
 import type { DiagnosticReport } from "../../domain/diagnostic-report.js";
 
 export interface DiagnosticReportFormatterInput {
   readonly report: DiagnosticReport;
   readonly agent: DoctorAgentScope;
   readonly installationMode: "project" | "personal";
+  readonly configStatus: ConfigStatus;
   readonly scopedOutFindings: readonly ScopedOutDiagnosticFinding[];
   readonly phasegateVersion: string;
   readonly projectRoot: string;
@@ -32,6 +38,7 @@ export class DiagnosticReportFormatter {
           description: scopeDescription(input.agent, input.installationMode),
         },
         overallStatus: input.report.overallStatus,
+        configStatus: input.configStatus,
         findings: input.report.findings.map((finding) => ({
           ...finding.toJSON(),
           applicability: "applicable",
@@ -64,6 +71,7 @@ export class DiagnosticReportFormatter {
       `phasegate doctor v${input.phasegateVersion}`,
       `Project: ${input.projectRoot}`,
       `Scope: ${input.agent} / ${input.installationMode} (${scopeDescription(input.agent, input.installationMode)})`,
+      `Config: ${input.configStatus}`,
       "",
     ];
     for (const finding of input.report.findings) {
@@ -79,10 +87,14 @@ export class DiagnosticReportFormatter {
     }
     const redCount = input.report.findings.filter((finding) => finding.severity === "red").length;
     const warnCount = input.report.findings.filter((finding) => finding.severity === "warn").length;
-    lines.push(`Status: ${input.report.overallStatus.toUpperCase()} (${input.report.findings.length} findings: ${redCount} red, ${warnCount} warn)`);
+    lines.push(
+      `Status: ${input.report.overallStatus.toUpperCase()} (${input.report.findings.length} findings: ${redCount} red, ${warnCount} warn)`,
+    );
     if (input.scopedOutFindings.length > 0) {
       const checkIds = input.scopedOutFindings.map(({ finding }) => finding.checkId).join(", ");
-      lines.push(`Scoped out: ${input.scopedOutFindings.length} informational findings not applicable to --agent ${input.agent}; not repair targets for this scope: ${checkIds}.`);
+      lines.push(
+        `Scoped out: ${input.scopedOutFindings.length} informational findings not applicable to --agent ${input.agent}; not repair targets for this scope: ${checkIds}.`,
+      );
     }
     lines.push(`Exit: ${input.exitCode}`);
     return lines.join("\n");
@@ -91,8 +103,10 @@ export class DiagnosticReportFormatter {
 
 function scopeDescription(agent: DoctorAgentScope, installationMode: "project" | "personal"): string {
   if (installationMode === "personal") {
-    if (agent === "claude") return "Personal Claude Code sandbox; team/project Husky, CI, package, and Codex-only findings are not repair targets.";
-    if (agent === "codex") return "Personal Codex sandbox; team/project Husky, CI, package, and Claude-only findings are not repair targets.";
+    if (agent === "claude")
+      return "Personal Claude Code sandbox; team/project Husky, CI, package, and Codex-only findings are not repair targets.";
+    if (agent === "codex")
+      return "Personal Codex sandbox; team/project Husky, CI, package, and Claude-only findings are not repair targets.";
     return "Personal sandbox diagnostics; team/project Husky, CI, and package findings are not repair targets.";
   }
   if (agent === "claude") return "Claude Code and shared setup targets; Codex-only findings are not applicable.";

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

@@ -5,6 +5,7 @@
  * @work-item-id WI-109
  * @work-item-id WI-189
  * @work-item-id WI-305
+ * @work-item-id WI-332
  *
  * Pre-commit CLI entry.
  * Runs L2 validators against staged TypeScript files AND design-document
@@ -27,6 +28,7 @@ import type { ValidateMetadataCommandOutput } from "../traceability-model/presen
 import type { AggregatedValidationReport } from "../validator-system/application/dto/aggregated-validation-report.js";
 import type { ValidationResultContract } from "../validator-system/application/dto/validation-result-contract.js";
 import { createValidatorSystemModule } from "../validator-system/composition-root.js";
+import { isEffectivelyPassed } from "../validator-system/domain/services/effective-severity-policy.js";
 import { HumanValidationResultFormatter } from "../validator-system/presentation/formatters/human-validation-result-formatter.js";
 import { createWorldModelModule } from "../world-model/index.js";
 
@@ -293,9 +295,19 @@ function getStagedDesignChangeFiles(): string[] {
   }
 }
 
+/**
+ * WI-332 / ADR-017: pre-commit 経路には config の failOnWarning 配線が存在しないため、
+ * ADR-017 の既定値 (false) に固定する。validate.failOnWarning を pre-commit にも効かせる
+ * 判断をする場合は、この定数を options 経由の配線に置き換えること。
+ */
+const PRE_COMMIT_FAIL_ON_WARNING = false;
+
 function buildReport(results: readonly ValidationResultContract[]): AggregatedValidationReport {
-  const passed = results.filter((r) => r.passed && !r.skipped).length;
-  const failed = results.filter((r) => !r.passed && !r.skipped).length;
+  // WI-332 / ADR-017: 手動集約 (`failed === 0` の raw passed 判定) をやめ、
+  // validate / ci-check / complete-check と同じ共有実効判定 isEffectivelyPassed を通す。
+  // warning-only の validator failure は既定で effectively passed = exit 0。
+  const passed = results.filter((r) => !r.skipped && isEffectivelyPassed(r, PRE_COMMIT_FAIL_ON_WARNING)).length;
+  const failed = results.filter((r) => !r.skipped && !isEffectivelyPassed(r, PRE_COMMIT_FAIL_ON_WARNING)).length;
   const skipped = results.filter((r) => r.skipped).length;
   const allErrors = results.flatMap((r) => r.errors);
   const errorCount = allErrors.filter((e) => e.severity === "error").length;
@@ -452,7 +464,9 @@ export async function validateBypassTrailers(
 }
 
 function classifyValidatorFailure(result: ValidationResultContract): BypassBlockerClass | undefined {
-  if (result.passed || result.skipped) return undefined;
+  // WI-332: blocker 分類も buildReport と同じ実効判定を通す。warning-only failure は
+  // exit 0 (effectively passed) なので、bypass audit の blocker としても数えない。
+  if (isEffectivelyPassed(result, PRE_COMMIT_FAIL_ON_WARNING)) return undefined;
   const nonBypassable = NON_BYPASSABLE_VALIDATOR_IDS.includes(result.validatorId);
   return {
     code: result.validatorId,

package/scripts/harness/main.ts

@@ -41,7 +41,7 @@ import {
   rm as fsRm,
   writeFile as fsWriteFile,
 } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createAdrFoundationModule } from "./adr-foundation/composition-root.js";
 import { createBiomeAstEngineModule } from "./biome-ast-engine/composition-root.js";
@@ -75,7 +75,7 @@ import {
 import { FileSystemStoryReflectionAdapter } from "./phase-dependency-model/infrastructure/filesystem/file-system-story-reflection-adapter.js";
 import { StoryReflectionStatusPresenter } from "./phase-dependency-model/presentation/cli/story-reflection-status-presenter.js";
 import { buildPhase2Extensions } from "./phase2-extensions/composition-root.js";
-import { createQuickModeCompositionRoot } from "./quick-mode/composition-root.js";
+import { createQuickModeCompositionRoot, type QuickModeCompositionRootOptions } from "./quick-mode/composition-root.js";
 import { buildRegressionSuite } from "./regression-suite/composition-root.js";
 import type { SkillSet } from "./setup/skill-deployer.js";
 import {
@@ -228,7 +228,7 @@ Commands:
 
   lint                         Run lint checks (--json, --target <path>)
 
-  validate                     Run validators (--layer L2|L3|L4|all; L0 prints runtime hook info, --unit, --format human|agent|ci|json, --json)
+  validate                     Run validators (--layer L0|L2|L3|L4|all; L0 prints runtime hook info, --unit, --format human|agent|ci|json, --json)
   ci-check                     CI check (--quick for quick mode, --fail-on-reject, --dry-run, --files)
   check-change-category        Classify changed paths for quick mode (--paths <csv>, --format human|json)
 
@@ -501,6 +501,15 @@ function parseValidateFormat(args: readonly string[]): "human" | "agent" | "ci"
   throw new Error(`Invalid --format value for validate: '${raw}'. Supported values: human, agent, ci, json.`);
 }
 
+function parseValidateLayer(args: readonly string[]): "L0" | "L2" | "L3" | "L4" | "all" | undefined {
+  const raw = parseFlag(args, "--layer");
+  if (raw === undefined) return undefined;
+  if (raw === "L0" || raw === "L2" || raw === "L3" || raw === "L4" || raw === "all") return raw;
+
+  const lintGuidance = raw === "L1" ? "\nL1 は `npx phasegate lint` で実行してください。" : "";
+  throw new Error(`不正な --layer 値: ${raw}\n有効値: L0, L2, L3, L4, all${lintGuidance}`);
+}
+
 function levenshtein(a: string, b: string): number {
   const m = a.length;
   const n = b.length;
@@ -553,12 +562,25 @@ function validateKnownFlags(args: readonly string[], known: readonly string[]):
   return null;
 }
 
+/**
+ * Full Mode session が許可する変更カテゴリ。
+ *
+ * WI-348: 照合相手は quick-mode の `ChangeCategoryValue`
+ * (`bugfix | docs | test | config | feature | domain | api`) であり、
+ * レイヤー名（application / infrastructure / presentation）ではない。
+ * 旧実装はレイヤー名語彙を書き出していたため、交差が domain / config のみとなり
+ * session を張っても feature / api の書き込みがブロックされ続けていた。
+ * ChangeCategory の全語彙を許可し、session のスコープ制御は
+ * unit / 期限 / target path 側の判定に委ねる。
+ */
 const FULL_MODE_SESSION_ALLOWED_CATEGORIES = Object.freeze([
-  "domain",
-  "application",
-  "infrastructure",
-  "presentation",
+  "bugfix",
+  "docs",
+  "test",
   "config",
+  "feature",
+  "domain",
+  "api",
 ]);
 
 interface FullModeSessionFile {
@@ -694,8 +716,8 @@ Options:
   --agent <claude|codex|both>     Agent context and hook targets (default: both)
   --skills <core|all>             Rendered agent context skill mode (default: all)
   --workflow <standard|strict>    Rendered agent context workflow mode (default: standard)
-  --with-husky                    Include Husky hook targets
-  --with-ci                       Include GitHub Actions target
+  --with-husky                    Include Husky hook targets (opt-in; omitted by default)
+  --with-ci                       Include GitHub Actions target (opt-in; omitted by default)
   --personal                      Use local-only install: no package.json, agent docs, Husky, CI, .gitignore, GitHub CLI, secrets, or CI setting writes.
                                   With --agent claude, initializes .phasegate-local config/settings/skills and ignored .claude shims.
   --json                          Output machine-readable JSON
@@ -1855,7 +1877,18 @@ function emitV2SchemaWarningOnce(sourcePath: string): void {
   );
 }
 
-async function loadResolvedConfig(): Promise<HarnessConfigV2 | undefined> {
+/**
+ * 不正 config でも fail-open（警告 + 既定設定で続行）にするコマンド。
+ * GitHub #40: config 検証の fail-closed が dispatch より上流にあると、pre-tool-use hook
+ * 経由で Write/Edit/Bash が全遮断され、config 自身を修復する経路が消える（自己修復
+ * デッドロック）。hook（エージェントのツール遮断点）と doctor（自己診断）は復旧経路
+ * として常に起動可能でなければならない。validate / ci-check 等の検査系コマンドは
+ * fail-closed を維持する（gated スコープへの書き込みは hook 内の phase-gate 判定が
+ * 引き続き fail-closed でブロックする）。
+ */
+const CONFIG_FAIL_OPEN_COMMANDS: ReadonlySet<string> = new Set(["hook", "doctor"]);
+
+async function loadResolvedConfig(command?: string): Promise<HarnessConfigV2 | undefined> {
   try {
     const configModule = createConfigFoundationModule();
     const result = await configModule.usecases.loadResolvedConfigUseCase.execute();
@@ -1866,6 +1899,15 @@ async function loadResolvedConfig(): Promise<HarnessConfigV2 | undefined> {
   } catch (error) {
     if (error instanceof ConfigValidationError) {
       process.stderr.write(`Invalid phasegate.config.json: ${error.message}\n`);
+      if (command !== undefined && CONFIG_FAIL_OPEN_COMMANDS.has(command)) {
+        process.stderr.write(
+          "Warning: continuing with default settings so diagnosis and self-repair stay possible. Fix the reported path in phasegate.config.json to restore full gating.\n",
+        );
+        return undefined;
+      }
+      process.stderr.write(
+        "Recovery: fix the reported path/type in phasegate.config.json (or restore it from version control). `phasegate doctor` and agent hooks remain available while the config is invalid.\n",
+      );
       process.exit(2);
     }
     if (error instanceof ConfigNotFoundError) {
@@ -1881,6 +1923,32 @@ async function loadResolvedConfig(): Promise<HarnessConfigV2 | undefined> {
   }
 }
 
+/**
+ * WI-351: quick-mode composition root へ解決済み configPath / rootDir を注入する。
+ *
+ * 無指定だと `HarnessConfigQuickModeConfigAdapter` は `process.cwd()/phasegate.config.json`、
+ * `FsFileExistenceAdapter` は `process.cwd()` を基準にする。サブディレクトリから CLI を
+ * 実行すると config を見失い、相対パスの存在判定（= CREATE/MODIFY 推定）も
+ * プロジェクトルート基準の hook とずれて分類結果が食い違う。
+ * config-foundation が上方探索で解決した sourcePath を基準に揃える
+ * （hook 側で WI-346 が行ったのと同じ整合）。
+ * config 未検出・不正時は従来どおり cwd 基準へフォールバックする（fail-open）。
+ */
+async function resolveQuickModeCompositionOptions(): Promise<QuickModeCompositionRootOptions> {
+  try {
+    const configModule = createConfigFoundationModule();
+    const { sourcePath } = await configModule.usecases.loadResolvedConfigUseCase.execute();
+    if (typeof sourcePath === "string" && sourcePath !== "") {
+      const configDir = dirname(sourcePath);
+      const rootDir = basename(configDir) === ".phasegate-local" ? dirname(configDir) : configDir;
+      return { configPath: sourcePath, rootDir };
+    }
+  } catch {
+    // 解決できない場合はフォールバック（下の return）
+  }
+  return { rootDir: getProjectRoot() };
+}
+
 async function loadWorldResolvedConfig() {
   try {
     const configModule = createConfigFoundationModule();
@@ -1942,7 +2010,7 @@ async function main(): Promise<void> {
   const json = hasFlag(args, "--json");
 
   // Cross-unit wiring: 設定を先に解決し、各Unit に注入する
-  const resolvedConfig = command.startsWith("world:") ? undefined : await loadResolvedConfig();
+  const resolvedConfig = command.startsWith("world:") ? undefined : await loadResolvedConfig(command);
 
   try {
     switch (command) {
@@ -2346,8 +2414,8 @@ async function main(): Promise<void> {
           force: hasFlag(args, "--force"),
           includeClaude,
           includeCodex,
-          includeHusky: !personal,
-          includeCi: !personal,
+          includeHusky: !personal && hasFlag(args, "--with-husky"),
+          includeCi: !personal && hasFlag(args, "--with-ci"),
           skillSet: skillSetRaw,
           workflow: parseWorkflowMode(workflowRaw),
           agent,
@@ -2868,7 +2936,7 @@ async function main(): Promise<void> {
       // ── validator-system ──
       case "validate": {
         const mod = createValidatorSystemModule(toValidatorSystemConfig(resolvedConfig));
-        const layer = parseFlag(args, "--layer") as "L0" | "L2" | "L3" | "L4" | "all" | undefined;
+        const layer = parseValidateLayer(args);
         const unit = parseFlag(args, "--unit");
         const phase = parseFlag(args, "--phase");
         const format = parseValidateFormat(args) ?? (json ? "ci" : undefined);
@@ -2936,7 +3004,7 @@ async function main(): Promise<void> {
           );
           return;
         }
-        const mod = createQuickModeCompositionRoot();
+        const mod = createQuickModeCompositionRoot(await resolveQuickModeCompositionOptions());
         const paths = parseFlag(args, "--paths");
         const format = parseFlag(args, "--format") as "human" | "json" | undefined;
         const failOnFullRequired = hasFlag(args, "--fail-on-full-required");