phasegate 0.160.18 → 0.160.20

package/README.md

@@ -100,7 +100,7 @@ npx phasegate install --apply
 npx phasegate doctor
 ```
 
-`install` merges PhaseGate into the current project without discarding existing Claude/Codex hooks or Husky scripts. It reports planned changes before writing, adds package scripts and the `phasegate` devDependency, deploys selected bundled skills to root `skills/`, creates agent skill links to that shared directory, writes `AGENTS.md` / `CLAUDE.md` PhaseGate managed sections for the selected agent targets, writes the CI workflow when missing, and records managed files in `.phasegate/manifest.json`. If an existing file needs a forced managed update, run `npx phasegate install --apply --force`; PhaseGate backs up replaced files under `.phasegate/backups/`. <!-- @work-item-id WI-174 --> <!-- @work-item-id WI-210 -->
+`install` merges PhaseGate into the current project without discarding existing Claude/Codex hooks, Husky scripts, or user-owned skills. It reports planned changes before writing, adds package scripts and the `phasegate` devDependency, deploys selected bundled skills to root `skills/`, creates agent skill links to that shared directory, writes `AGENTS.md` / `CLAUDE.md` PhaseGate managed sections for the selected agent targets, writes the CI workflow when missing, and records managed files in `.phasegate/manifest.json`. If an existing file needs a forced managed update, run `npx phasegate install --apply --force`; PhaseGate backs up replaced files under `.phasegate/backups/`. <!-- @work-item-id WI-174 --> <!-- @work-item-id WI-210 --> <!-- @work-item-id WI-216 -->
 
 For personal evaluation inside a team-owned repository, use local-only install:
 
@@ -109,7 +109,7 @@ npx phasegate install --personal --agent claude --dry-run
 npx phasegate install --personal --agent claude --apply
 ```
 
-`--personal` does not plan or write `package.json`, `AGENTS.md`, `CLAUDE.md`, `.husky/*`, `.github/workflows/*`, `.gitignore`, GitHub CLI config, repo secrets, or CI settings. It creates `.phasegate-local/phasegate.config.json`, local agent context (`.claude/CLAUDE.local.md` and/or `.codex/AGENTS.local.md`), real local-only agent runtime artifacts for the selected agent (`.claude/settings.json` + `.claude/skills/` and/or `.codex/hooks.json` + `.codex/skills/`), local git hooks under `.git/hooks/`, local reference docs under `.phasegate-local/docs/`, a managed local-only block in `.git/info/exclude`, and `.phasegate/manifest.json`. Codex user-level hook feature enablement remains a manual action. <!-- @work-item-id WI-207 --> <!-- @work-item-id WI-208 --> <!-- @work-item-id WI-209 --> <!-- @work-item-id WI-213 -->
+`--personal` does not plan or write `package.json`, `CLAUDE.md`, `.husky/*`, `.github/workflows/*`, `.gitignore`, GitHub CLI config, repo secrets, or CI settings. It creates `.phasegate-local/phasegate.config.json`, runtime-visible local agent context (`.claude/CLAUDE.md` for Claude, and `AGENTS.md` for Codex only when that root file is absent or already PhaseGate-managed), real local-only agent runtime artifacts for the selected agent (`.claude/settings.json` + `.claude/skills/` and/or `.codex/hooks.json` + `.codex/skills/`), local git hooks under `.git/hooks/`, local reference docs under `.phasegate-local/docs/`, a managed local-only block in `.git/info/exclude`, and `.phasegate/manifest.json`. Existing personal skills directories are merged: PhaseGate refreshes bundled skills and preserves user-owned skills. If a team `AGENTS.md` already exists, personal Codex install leaves it unchanged and `doctor --personal --agent codex` reports the remaining context step instead of hiding it behind `AGENTS.override.md`. Codex user-level hook feature enablement remains a manual action. <!-- @work-item-id WI-207 --> <!-- @work-item-id WI-208 --> <!-- @work-item-id WI-209 --> <!-- @work-item-id WI-213 --> <!-- @work-item-id WI-215 --> <!-- @work-item-id WI-216 -->
 
 For agent-driven setup planning, use:
 
@@ -129,7 +129,7 @@ npx phasegate uninstall --dry-run
 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/`.
+`uninstall` uses the manifest to delete created files, remove only PhaseGate-managed portions from merged Claude/Codex, Husky, and `package.json` files, and remove only PhaseGate-managed bundled skills. User content and user-owned skills are preserved, and the manifest is archived under `.phasegate/`. <!-- @work-item-id WI-216 -->
 
 When you upgrade PhaseGate, reconcile existing managed files with the current bundled templates:
 
@@ -138,7 +138,7 @@ npx phasegate reconcile --dry-run
 npx phasegate reconcile --apply
 ```
 
-`reconcile` updates only PhaseGate-managed portions, keeps user content, adds newly introduced managed targets, repairs missing shared skill bodies for project installs, 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>/`. <!-- @work-item-id WI-210 -->
+`reconcile` updates only PhaseGate-managed portions, keeps user content, adds newly introduced managed targets, repairs missing shared or personal bundled skill bodies, 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>/`. <!-- @work-item-id WI-210 --> <!-- @work-item-id WI-216 -->
 
 ### Codex CLI
 

package/docs/guide/installation.md

@@ -56,7 +56,7 @@ npx phasegate install --apply
 npx phasegate doctor
 ```
 
-`install --dry-run` reports whether each target will be created, merged, skipped, or refused. `install --apply` performs the merge, adds package scripts and the `phasegate` devDependency, creates `.claude/skills` and `.codex/skills` links, writes `CLAUDE.md` / `AGENTS.md` managed sections for selected agent targets, writes `.github/workflows/phasegate-aidlc-gate.yml` when CI is enabled, and records managed entries in `.phasegate/manifest.json`. See [Setup Artifacts](setup-artifacts.md) for the full managed target, generated artifact, runtime state, legacy artifact, and user-level setting inventory. <!-- @work-item-id WI-152 --> <!-- @work-item-id WI-169 --> <!-- @work-item-id WI-174 -->
+`install --dry-run` reports whether each target will be created, merged, skipped, or refused. `install --apply` performs the merge, adds package scripts and the `phasegate` devDependency, deploys selected bundled skills to root `skills/`, creates `.claude/skills` and `.codex/skills` links, writes `CLAUDE.md` / `AGENTS.md` managed sections for selected agent targets, writes `.github/workflows/phasegate-aidlc-gate.yml` when CI is enabled, and records managed entries in `.phasegate/manifest.json`. Existing skills catalogs are merged: PhaseGate refreshes only bundled skill directories selected by `--skills core|all` and preserves user-owned skills. See [Setup Artifacts](setup-artifacts.md) for the full managed target, generated artifact, runtime state, legacy artifact, and user-level setting inventory. <!-- @work-item-id WI-152 --> <!-- @work-item-id WI-169 --> <!-- @work-item-id WI-174 --> <!-- @work-item-id WI-216 -->
 
 For personal evaluation inside a team-owned repository:
 
@@ -65,7 +65,7 @@ npx phasegate install --personal --agent claude --dry-run
 npx phasegate install --personal --agent claude --apply
 ```
 
-Personal install keeps team-owned files out of both the plan and apply path: `package.json`, `AGENTS.md`, `CLAUDE.md`, `.husky/*`, `.github/workflows/*`, `.gitignore`, GitHub CLI config, repo secrets, and CI settings are not touched. PhaseGate writes `.phasegate-local/phasegate.config.json`, creates local agent context (`.claude/CLAUDE.local.md` and/or `.codex/AGENTS.local.md`), creates real local-only agent runtime artifacts for the selected agent (`.claude/settings.json` + `.claude/skills/` and/or `.codex/hooks.json` + `.codex/skills/`), deploys local git hooks under `.git/hooks/`, copies reference docs under `.phasegate-local/docs/`, records `.phasegate/manifest.json`, and manages a local exclude block in `.git/info/exclude`. Codex user-level hook feature enablement is still reported as a manual action. <!-- @work-item-id WI-207 --> <!-- @work-item-id WI-208 --> <!-- @work-item-id WI-209 --> <!-- @work-item-id WI-213 -->
+Personal install keeps team-owned files out of the apply path: `package.json`, `CLAUDE.md`, `.husky/*`, `.github/workflows/*`, `.gitignore`, GitHub CLI config, repo secrets, and CI settings are not touched. PhaseGate writes `.phasegate-local/phasegate.config.json`, creates runtime-visible local agent context (`.claude/CLAUDE.md` for Claude, and `AGENTS.md` for Codex only when that root file is absent or already PhaseGate-managed), creates real local-only agent runtime artifacts for the selected agent (`.claude/settings.json` + `.claude/skills/` and/or `.codex/hooks.json` + `.codex/skills/`), deploys local git hooks under `.git/hooks/`, copies reference docs under `.phasegate-local/docs/`, records `.phasegate/manifest.json`, and manages a local exclude block in `.git/info/exclude`. Existing personal skills directories are merged the same way as project `skills/`: bundled PhaseGate skills are added or refreshed, user-owned skills are preserved, and legacy `.harness-version` catalogs can be adopted into the manifest. If a team `AGENTS.md` already exists, personal Codex install leaves it unchanged and `doctor --personal --agent codex` reports the remaining context step instead of hiding it behind `AGENTS.override.md`. Codex user-level hook feature enablement is still reported as a manual action. <!-- @work-item-id WI-207 --> <!-- @work-item-id WI-208 --> <!-- @work-item-id WI-209 --> <!-- @work-item-id WI-213 --> <!-- @work-item-id WI-215 --> <!-- @work-item-id WI-216 -->
 
 If an existing repository keeps design or governance docs outside `docs/`, set `paths.designDocs`, `paths.inceptionDocs`, `paths.principlesDocs`, and `paths.folderRulesDoc` in `phasegate.config.json` before setup/reconcile. PhaseGate deploy and hook protection use those mappings instead of forcing the default `docs/` layout. <!-- @work-item-id WI-214 -->
 
@@ -93,7 +93,7 @@ npx phasegate uninstall --dry-run
 npx phasegate uninstall --apply
 ```
 
-`uninstall` reads `.phasegate/manifest.json`, deletes files that PhaseGate created, removes only PhaseGate-managed portions from merged JSON, markdown agent context files, 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>/`. <!-- @work-item-id WI-174 -->
+`uninstall` reads `.phasegate/manifest.json`, deletes files that PhaseGate created, removes only PhaseGate-managed portions from merged JSON, markdown agent context files, Husky, and `package.json` files, removes manifest-managed bundled skills, and archives the manifest as `.phasegate/uninstalled-<timestamp>.json`. User-owned skill directories remain in place, and skills parent directories are kept when they still contain user-owned skills. 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>/`. <!-- @work-item-id WI-174 --> <!-- @work-item-id WI-216 -->
 
 After upgrading PhaseGate, reconcile existing managed files with the bundled templates from the new version:
 
@@ -102,7 +102,7 @@ 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>/`.
+`reconcile` updates PhaseGate-managed portions, preserves user content, adds newly introduced managed targets, repairs missing or stale bundled skills in project and personal catalogs, 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>/`. <!-- @work-item-id WI-216 -->
 
 ### Manual Setup Pieces
 
@@ -134,7 +134,7 @@ npx phasegate reconcile --dry-run
 npx phasegate reconcile --apply
 ```
 
-`phasegate update-skills` remains available as a compatibility alias, but `reconcile` is the preferred upgrade path because it updates all managed files recorded in `.phasegate/manifest.json`.
+`phasegate update-skills` remains available as a compatibility alias. It now follows the same manifest-aware reconcile path, including project and personal bundled skill repair, so `reconcile` remains the preferred explicit upgrade command. <!-- @work-item-id WI-216 -->
 
 `doctor --report-out <path>` writes exactly to the provided path. `.phasegate/last-doctor-report.json` is not a fixed output file unless you choose that path explicitly. <!-- @work-item-id WI-152 -->
 

package/docs/guide/setup-artifacts.md

@@ -7,6 +7,8 @@ PhaseGate setup is more than `phasegate.config.json`. A healthy installation is
 <!-- @work-item-id WI-169 -->
 <!-- @work-item-id WI-208 -->
 <!-- @work-item-id WI-209 -->
+<!-- @work-item-id WI-215 -->
+<!-- @work-item-id WI-216 -->
 
 ## Artifact Classes
 
@@ -16,7 +18,7 @@ PhaseGate setup is more than `phasegate.config.json`. A healthy installation is
 | Configuration | `phasegate.config.json`, `package.json` | User owned, PhaseGate assisted | Created by `init` or project install when absent; `install` may merge scripts/devDependency into `package.json` |
 | Generated artifact | `.phasegate/manifest.json`, `.phasegate/backups/*`, `.phasegate/uninstalled-*.json`, `.phasegate/baseline.json` | PhaseGate | Written by lifecycle commands and validators; safe to regenerate only through the owning command |
 | Runtime state/report | `.phasegate/hook-skip-events.jsonl`, explicit `doctor --report-out <path>` output, `reports/regression/*`, resolved `reporting.outputDir` reports | PhaseGate command output | Produced while hooks, doctor, and validation commands run |
-| Personal install artifact | `.phasegate-local/phasegate.config.json`, ignored real `.claude/settings.json` + `.claude/skills/`, ignored real `.codex/hooks.json` + `.codex/skills/`, `.git/info/exclude` PhaseGate block | One developer on one machine | Created by `phasegate install --personal --agent <agent>`; team `.gitignore`, team-owned files, GitHub CLI config, repo secrets, and CI settings are not modified |
+| Personal install artifact | `.phasegate-local/phasegate.config.json`, ignored real `.claude/CLAUDE.md` + `.claude/settings.json` + `.claude/skills/`, ignored real `.codex/hooks.json` + `.codex/skills/`, optional ignored root `AGENTS.md`, `.git/info/exclude` PhaseGate block | One developer on one machine | Created by `phasegate install --personal --agent <agent>`; team `.gitignore`, team-owned files, GitHub CLI config, repo secrets, and CI settings are not modified |
 | Legacy artifact | `.harness-hooks.yml`, old Fuse hook files, `.harness/session-state.json`, `.harness/context-priority.json`, `.harness/reports` fallback | Compatibility only | Not required for current install lifecycle unless a project intentionally keeps an archived integration |
 | User-level setting | Codex CLI `hooks` feature flag | User machine | Must be enabled manually with `codex features enable hooks`; project commands do not modify it |
 
@@ -42,9 +44,11 @@ PhaseGate setup is more than `phasegate.config.json`. A healthy installation is
 
 `phasegate install --personal --agent claude --apply` is a local-only bootstrap for evaluating PhaseGate in a team-owned repository. PhaseGate config is stored under `.phasegate-local/`, while selected agent runtime paths are real project-local files/directories: `.claude/settings.json` and `.claude/skills/` for Claude Code, `.codex/hooks.json` and `.codex/skills/` for Codex. These paths are hidden by `.git/info/exclude`; PhaseGate does not edit team `.gitignore`.
 
-If `.claude/*` or `.codex/*` already exists and is not a PhaseGate-managed personal artifact, personal install reports manual review and preserves the existing path. <!-- @work-item-id WI-209 -->
+If `.claude/*` or `.codex/*` already exists and is not a PhaseGate-managed personal artifact, personal install reports manual review and preserves the existing path. Existing `.claude/skills/` and `.codex/skills/` directories are mergeable skill catalogs: PhaseGate refreshes bundled skill directories and preserves user-owned skill directories. <!-- @work-item-id WI-209 --> <!-- @work-item-id WI-216 -->
 
-Project install uses a different topology: selected bundled skills are deployed once to root `skills/`, and `.claude/skills` / `.codex/skills` point to that shared target. If an older project install has the links but an empty `skills/` target, `phasegate doctor` reports the selected agent skill check and `phasegate reconcile --apply` repairs the shared skill bodies. <!-- @work-item-id WI-210 -->
+Personal agent context is also placed only where the runtime will read it. Claude Code uses `.claude/CLAUDE.md`. Codex uses root `AGENTS.md` when PhaseGate can create or manage it locally; if a team `AGENTS.md` already exists, PhaseGate leaves it unchanged and doctor reports `codex-context-missing` instead of creating `AGENTS.override.md`. <!-- @work-item-id WI-215 -->
+
+Project install uses a different topology: selected bundled skills are deployed once to root `skills/`, and `.claude/skills` / `.codex/skills` point to that shared target. Existing root `skills/` is also a mergeable catalog: selected bundled skill directories are refreshed, selection-excluded or user-owned skills are not removed, and uninstall deletes only manifest-managed bundled skills plus metadata. If an older project install has the links but an empty `skills/` target, `phasegate doctor` reports the selected agent skill check and `phasegate reconcile --apply` repairs the shared skill bodies. <!-- @work-item-id WI-210 --> <!-- @work-item-id WI-216 -->
 
 ## Doctor Findings
 

package/docs/templates/personal/git-info-exclude

@@ -4,3 +4,4 @@
 .claude/
 skills/
 phasegate.config.json
+AGENTS.md

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phasegate",
-  "version": "0.160.18",
+  "version": "0.160.20",
   "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/bundled-skill-selection.ts

@@ -0,0 +1,46 @@
+// @unit installation
+// @layer application
+// @work-item-id WI-216
+
+export type SkillSet = "core" | "all";
+
+const CORE_SKILLS = [
+  "cascade-updater",
+  "codebase-mapper",
+  "consistency-checker",
+  "doc-freshness-checker",
+  "engineering-perspective",
+  "implementation-readiness-checker",
+  "pointer-validator",
+  "test-coverage-checker",
+] as const;
+
+const AIDLC_SKILLS = [
+  "domain-designer",
+  "environment-designer",
+  "implementation-planner",
+  "it-test-designer",
+  "it-test-logic-designer",
+  "logical-designer",
+  "mock-designer",
+  "product-architect",
+  "quick-implementor",
+  "scenario-test-designer",
+  "scenario-test-logic-designer",
+  "story-implementor",
+  "story-mapper",
+  "story-writer",
+  "uiux-designer",
+  "unit-designer",
+  "unit-test-designer",
+  "unit-test-logic-designer",
+] as const;
+
+const UTILITY_SKILLS = ["codex-delegator", "skill-creator"] as const;
+const GUIDANCE_SKILLS = ["phasegate-toolkit-guide", "phasegate-config-doctor"] as const;
+
+export function getBundledSkillsForSet(skillSet: SkillSet): string[] {
+  if (skillSet === "core") return [...CORE_SKILLS];
+  return [...CORE_SKILLS, ...AIDLC_SKILLS, ...UTILITY_SKILLS, ...GUIDANCE_SKILLS];
+}
+

package/scripts/harness/installation/application/checks/check-utils.ts

@@ -3,8 +3,10 @@
 // @work-item-id WI-145
 // @work-item-id WI-209
 // @work-item-id WI-210
+// @work-item-id WI-216
 
 import { join } from "node:path";
+import { getBundledSkillsForSet, type SkillSet } from "../bundled-skill-selection.js";
 import type { CheckId } from "../../domain/check-id.js";
 import { DiagnosticFinding, type DiagnosticSeverity } from "../../domain/diagnostic-finding.js";
 import type { RepairMode } from "../../domain/repair-mode.js";
@@ -69,3 +71,12 @@ export function skillTargetLooksValid(target: string | null): boolean {
 export function skillDirectoryLooksValid(files: readonly string[]): boolean {
   return files.some((file) => file.endsWith("/SKILL.md") || file.endsWith("\\SKILL.md") || file.endsWith(".harness-version"));
 }
+
+export function phasegateSkillDirectoryLooksComplete(files: readonly string[], metadata: string | null): boolean {
+  const skillSet: SkillSet = metadata?.includes('"skillSet": "core"') ? "core" : "all";
+  const expectedSkills = getBundledSkillsForSet(skillSet);
+  return expectedSkills.every((skill) => files.some((file) => {
+    const normalized = file.replaceAll("\\", "/");
+    return normalized.endsWith(`/${skill}/SKILL.md`);
+  }));
+}

package/scripts/harness/installation/application/checks/claude-context-missing-check.ts

@@ -0,0 +1,35 @@
+// @unit installation
+// @layer application
+// @work-item-id WI-215
+
+import type { FileInspectorPort } from "../ports/file-inspector-port.js";
+import type { HeuristicCheck } from "../../domain/ports/heuristic-check.js";
+import type { DiagnosticFinding } from "../../domain/diagnostic-finding.js";
+import { createFinding, projectPath } from "./check-utils.js";
+
+const MARKDOWN_BEGIN = "<!-- phasegate:managed-section:start -->";
+
+export class ClaudeContextMissingCheck implements HeuristicCheck {
+  readonly checkId = "claude-context-missing" as const;
+  private readonly target = ".claude/CLAUDE.md";
+  private readonly projectTarget = "CLAUDE.md";
+  private readonly legacyTarget = ".claude/CLAUDE.local.md";
+
+  async run(projectRoot: string, inspector: FileInspectorPort): Promise<DiagnosticFinding | null> {
+    const content = await inspector.readText(projectPath(projectRoot, this.target));
+    if (content?.includes(MARKDOWN_BEGIN) === true && content.includes("PhaseGate")) return null;
+    const projectContent = await inspector.readText(projectPath(projectRoot, this.projectTarget));
+    if (projectContent?.includes(MARKDOWN_BEGIN) === true && projectContent.includes("PhaseGate")) return null;
+
+    const legacyContent = await inspector.readText(projectPath(projectRoot, this.legacyTarget));
+    return createFinding({
+      checkId: this.checkId,
+      severity: "red",
+      target: this.target,
+      message: legacyContent?.includes("PhaseGate") === true
+        ? ".claude/CLAUDE.local.md は Claude Code の documented discovery path ではありません"
+        : ".claude/CLAUDE.md に runtime-visible PhaseGate context がありません",
+      repairMode: "mechanical",
+    });
+  }
+}

package/scripts/harness/installation/application/checks/claude-skills-symlink-check.ts

@@ -3,11 +3,12 @@
 // @work-item-id WI-145
 // @work-item-id WI-209
 // @work-item-id WI-210
+// @work-item-id WI-216
 
 import type { FileInspectorPort } from "../ports/file-inspector-port.js";
 import type { HeuristicCheck } from "../../domain/ports/heuristic-check.js";
 import type { DiagnosticFinding } from "../../domain/diagnostic-finding.js";
-import { createFinding, projectPath, skillDirectoryLooksValid, skillTargetLooksValid } from "./check-utils.js";
+import { createFinding, phasegateSkillDirectoryLooksComplete, projectPath, skillTargetLooksValid } from "./check-utils.js";
 
 export class ClaudeSkillsSymlinkCheck implements HeuristicCheck {
   readonly checkId = "claude-skills-symlink" as const;
@@ -16,8 +17,9 @@ export class ClaudeSkillsSymlinkCheck implements HeuristicCheck {
   async run(projectRoot: string, inspector: FileInspectorPort): Promise<DiagnosticFinding | null> {
     const link = await inspector.readSymlink(projectPath(projectRoot, this.target));
     const files = await inspector.listFiles(projectPath(projectRoot, this.target));
-    if (skillTargetLooksValid(link) && skillDirectoryLooksValid(files)) return null;
-    if (link === null && skillDirectoryLooksValid(files)) return null;
+    const metadata = await inspector.readText(projectPath(projectRoot, `${this.target}/.harness-version`));
+    if (skillTargetLooksValid(link) && phasegateSkillDirectoryLooksComplete(files, metadata)) return null;
+    if (link === null && phasegateSkillDirectoryLooksComplete(files, metadata)) return null;
     return createFinding({
       checkId: this.checkId,
       severity: "red",

package/scripts/harness/installation/application/checks/codex-context-missing-check.ts

@@ -0,0 +1,32 @@
+// @unit installation
+// @layer application
+// @work-item-id WI-215
+
+import type { FileInspectorPort } from "../ports/file-inspector-port.js";
+import type { HeuristicCheck } from "../../domain/ports/heuristic-check.js";
+import type { DiagnosticFinding } from "../../domain/diagnostic-finding.js";
+import { createFinding, projectPath } from "./check-utils.js";
+
+const MARKDOWN_BEGIN = "<!-- phasegate:managed-section:start -->";
+
+export class CodexContextMissingCheck implements HeuristicCheck {
+  readonly checkId = "codex-context-missing" as const;
+  private readonly target = "AGENTS.md";
+  private readonly legacyTarget = ".codex/AGENTS.local.md";
+
+  async run(projectRoot: string, inspector: FileInspectorPort): Promise<DiagnosticFinding | null> {
+    const content = await inspector.readText(projectPath(projectRoot, this.target));
+    if (content?.includes(MARKDOWN_BEGIN) === true && content.includes("PhaseGate")) return null;
+
+    const legacyContent = await inspector.readText(projectPath(projectRoot, this.legacyTarget));
+    return createFinding({
+      checkId: this.checkId,
+      severity: "red",
+      target: this.target,
+      message: legacyContent?.includes("PhaseGate") === true
+        ? ".codex/AGENTS.local.md は Codex の default discovery path ではありません"
+        : "AGENTS.md に runtime-visible PhaseGate context がありません",
+      repairMode: content === null ? "mechanical" : "manual",
+    });
+  }
+}

package/scripts/harness/installation/application/checks/codex-skills-symlink-check.ts

@@ -3,11 +3,12 @@
 // @work-item-id WI-145
 // @work-item-id WI-209
 // @work-item-id WI-210
+// @work-item-id WI-216
 
 import type { FileInspectorPort } from "../ports/file-inspector-port.js";
 import type { HeuristicCheck } from "../../domain/ports/heuristic-check.js";
 import type { DiagnosticFinding } from "../../domain/diagnostic-finding.js";
-import { createFinding, projectPath, skillDirectoryLooksValid, skillTargetLooksValid } from "./check-utils.js";
+import { createFinding, phasegateSkillDirectoryLooksComplete, projectPath, skillTargetLooksValid } from "./check-utils.js";
 
 export class CodexSkillsSymlinkCheck implements HeuristicCheck {
   readonly checkId = "codex-skills-symlink" as const;
@@ -16,8 +17,9 @@ export class CodexSkillsSymlinkCheck implements HeuristicCheck {
   async run(projectRoot: string, inspector: FileInspectorPort): Promise<DiagnosticFinding | null> {
     const link = await inspector.readSymlink(projectPath(projectRoot, this.target));
     const files = await inspector.listFiles(projectPath(projectRoot, this.target));
-    if (skillTargetLooksValid(link) && skillDirectoryLooksValid(files)) return null;
-    if (link === null && skillDirectoryLooksValid(files)) return null;
+    const metadata = await inspector.readText(projectPath(projectRoot, `${this.target}/.harness-version`));
+    if (skillTargetLooksValid(link) && phasegateSkillDirectoryLooksComplete(files, metadata)) return null;
+    if (link === null && phasegateSkillDirectoryLooksComplete(files, metadata)) return null;
     return createFinding({
       checkId: this.checkId,
       severity: "red",

package/scripts/harness/installation/application/usecases/run-doctor-diagnostics.ts

@@ -3,6 +3,7 @@
 // @work-item-id WI-145
 // @work-item-id WI-178
 // @work-item-id WI-208
+// @work-item-id WI-215
 
 import { DiagnosticReport } from "../../domain/diagnostic-report.js";
 import type { CheckId } from "../../domain/check-id.js";
@@ -32,8 +33,8 @@ export interface RunDoctorDiagnosticsOutput {
   readonly exitCode: number;
 }
 
-const CLAUDE_ONLY_CHECKS = new Set<CheckId>(["claude-hook-missing", "claude-skills-symlink"]);
-const CODEX_ONLY_CHECKS = new Set<CheckId>(["codex-hook-missing", "codex-skills-symlink"]);
+const CLAUDE_ONLY_CHECKS = new Set<CheckId>(["claude-hook-missing", "claude-context-missing", "claude-skills-symlink"]);
+const CODEX_ONLY_CHECKS = new Set<CheckId>(["codex-hook-missing", "codex-context-missing", "codex-skills-symlink"]);
 const PERSONAL_SCOPED_OUT_CHECKS = new Set<CheckId>([
   "husky-pre-commit-missing",
   "husky-commit-msg-missing",

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

@@ -13,14 +13,16 @@
 // @work-item-id WI-210
 // @work-item-id WI-213
 // @work-item-id WI-214
+// @work-item-id WI-215
+// @work-item-id WI-216
 
 import { mkdir, readFile, writeFile, copyFile, chmod, access, lstat, readlink, symlink, readdir, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { getSkillsForSet, type SkillSet } from "../../../setup/skill-deployer.js";
 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 { getBundledSkillsForSet, type SkillSet } from "../bundled-skill-selection.js";
 import type { ManifestRepositoryPort } from "../ports/manifest-repository-port.js";
 import type { HashCalculatorPort } from "../ports/hash-calculator-port.js";
 
@@ -78,6 +80,7 @@ interface InstallTarget {
   readonly templatePath: string;
   readonly executable?: boolean;
   readonly block?: ManagedBlockInput;
+  readonly personalManualIfUnmanaged?: boolean;
 }
 
 const SKILL_HINT = "invoke /phasegate-config-doctor";
@@ -89,7 +92,7 @@ const MARKDOWN_BEGIN = "<!-- phasegate:managed-section:start -->";
 const MARKDOWN_END = "<!-- phasegate:managed-section:end -->";
 const TEXT_BEGIN = "# phasegate personal install exclude (BEGIN)";
 const TEXT_END = "# phasegate personal install exclude (END)";
-const PERSONAL_AGENT_RUNTIME_FILES = new Set([".claude/settings.json", ".codex/hooks.json"]);
+const PERSONAL_AGENT_RUNTIME_FILES = new Set([".claude/CLAUDE.md", ".claude/settings.json", "AGENTS.md", ".codex/hooks.json"]);
 const SHARED_SKILLS_VERSION_PATH = "skills/.harness-version";
 const PERSONAL_PRINCIPLES_DOCS = ".phasegate-local/docs/principles";
 const PERSONAL_FOLDER_RULES_DOC = ".phasegate-local/docs/folder_management_rules.md";
@@ -129,9 +132,19 @@ async function copyDirectory(src: string, dest: string): Promise<void> {
   }
 }
 
+async function copySelectedSkillDirectories(harnessRoot: string, targetRoot: string, skills: readonly string[]): Promise<void> {
+  await mkdir(targetRoot, { recursive: true });
+  for (const skill of skills) {
+    const source = join(harnessRoot, "skills", skill);
+    const target = join(targetRoot, skill);
+    await rm(target, { recursive: true, force: true });
+    await copyDirectory(source, target);
+  }
+}
+
 async function listSelectedBundledSkills(harnessRoot: string, skillSet: SkillSet): Promise<string[]> {
   const skillsSource = join(harnessRoot, "skills");
-  const allowed = new Set(getSkillsForSet(skillSet));
+  const allowed = new Set(getBundledSkillsForSet(skillSet));
   const entries = await readdir(skillsSource, { withFileTypes: true });
   return entries
     .filter((entry) => entry.isDirectory() && allowed.has(entry.name))
@@ -350,8 +363,9 @@ export class RunInstallUseCase {
       const existingEntry = baseManifest.findEntry(target.path);
       const beforeHash = before === null ? null : this.hashCalculator.compute(before);
       const unmanagedPersonalRuntimeFile = input.personal
-        && PERSONAL_AGENT_RUNTIME_FILES.has(target.path)
+        && (PERSONAL_AGENT_RUNTIME_FILES.has(target.path) || target.personalManualIfUnmanaged === true)
         && before !== null
+        && !before.includes(MARKDOWN_BEGIN)
         && (existingEntry === null || beforeHash === null || !beforeHash.equals(existingEntry.hash));
       const repairMode = unmanagedPersonalRuntimeFile ? "manual" : this.repairMode(target, before);
       const next = unmanagedPersonalRuntimeFile ? before : this.merge(target, before, template, input.phasegateVersion);
@@ -364,7 +378,7 @@ export class RunInstallUseCase {
         strategy: target.strategy,
         changed: didChange,
         summary: unmanagedPersonalRuntimeFile
-          ? `${target.path}: existing non-phasegate path requires manual review`
+          ? `${target.path}: existing non-phasegate runtime path requires manual review`
           : didChange ? `${target.path}: ${action}` : `${target.path}: already up to date`,
         diff: unmanagedPersonalRuntimeFile ? "manual review required" : this.diffSummary(before, next),
         skillHint: repairMode === "ai-assisted" ? SKILL_HINT : null,
@@ -425,12 +439,13 @@ export class RunInstallUseCase {
           ...(includeCodex ? [".codex/skills"] : []),
         ]
       : [];
+    const selectedPersonalSkills = input.personal ? await listSelectedBundledSkills(input.harnessRoot, skillSet) : [];
     for (const skillPath of personalSkillTargets) {
-      const item = await this.planPersonalSkillDirectory(input, skillPath, baseManifest);
+      const item = await this.planPersonalSkillDirectory(input, skillPath, selectedPersonalSkills, baseManifest);
       plan.push(item);
       if (input.apply && item.changed && item.repairMode === "mechanical") {
         try {
-          await copyDirectory(join(input.harnessRoot, "skills"), join(input.projectRoot, skillPath));
+          await copySelectedSkillDirectories(input.harnessRoot, join(input.projectRoot, skillPath), selectedPersonalSkills);
           await writeFile(
             join(input.projectRoot, skillPath, ".harness-version"),
             `${JSON.stringify({ version: input.phasegateVersion, deployedAt: new Date().toISOString(), skillSet }, null, 2)}\n`,
@@ -441,10 +456,17 @@ export class RunInstallUseCase {
         }
         changed.push(item);
         manifest = this.addManifestEntry(baseManifest, manifest, {
-          path: item.path,
+          path: `${item.path}/.harness-version`,
           mode: "created",
-          contentForHash: this.personalSkillsHashInput(item.path, input.phasegateVersion, skillSet),
+          contentForHash: this.personalSkillsVersionHashInput(item.path, input.phasegateVersion, skillSet, selectedPersonalSkills),
         });
+        for (const skill of selectedPersonalSkills) {
+          manifest = this.addManifestEntry(baseManifest, manifest, {
+            path: `${item.path}/${skill}`,
+            mode: "created",
+            contentForHash: this.personalSkillHashInput(item.path, skill, input.phasegateVersion, skillSet),
+          });
+        }
       }
     }
 
@@ -629,10 +651,11 @@ export class RunInstallUseCase {
       ...(options.includeClaude
         ? [
             {
-              path: ".claude/CLAUDE.local.md",
+              path: ".claude/CLAUDE.md",
               strategy: "markdown-managed" as const,
               templatePath: "docs/templates/agent-context/CLAUDE.md.template.md",
-              block: { start: MARKDOWN_BEGIN, end: MARKDOWN_END, content: "phasegate personal CLAUDE.local.md managed section" },
+              block: { start: MARKDOWN_BEGIN, end: MARKDOWN_END, content: "phasegate personal .claude/CLAUDE.md managed section" },
+              personalManualIfUnmanaged: true,
             },
             {
               path: ".claude/settings.json",
@@ -644,10 +667,11 @@ export class RunInstallUseCase {
       ...(options.includeCodex
         ? [
             {
-              path: ".codex/AGENTS.local.md",
+              path: "AGENTS.md",
               strategy: "markdown-managed" as const,
               templatePath: "docs/templates/agent-context/AGENTS.md.template.md",
-              block: { start: MARKDOWN_BEGIN, end: MARKDOWN_END, content: "phasegate personal AGENTS.local.md managed section" },
+              block: { start: MARKDOWN_BEGIN, end: MARKDOWN_END, content: "phasegate personal AGENTS.md managed section" },
+              personalManualIfUnmanaged: true,
             },
             {
               path: ".codex/hooks.json",
@@ -750,32 +774,58 @@ export class RunInstallUseCase {
   private async planPersonalSkillDirectory(
     input: RunInstallInput,
     relativePath: string,
+    skills: readonly string[],
     baseManifest: DeploymentManifest,
   ): Promise<InstallPlanItem> {
     const absolutePath = join(input.projectRoot, relativePath);
+    try {
+      const stat = await lstat(absolutePath);
+      if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        return {
+          path: relativePath,
+          action: "will-merge",
+          repairMode: "manual",
+          strategy: "copy-dir",
+          changed: false,
+          summary: `${relativePath}: existing non-directory skills path requires manual review`,
+          diff: "manual review required",
+          skillHint: null,
+        };
+      }
+    } catch {}
     const versionPath = join(absolutePath, ".harness-version");
     const current = await readTextOrNull(versionPath);
-    const expectedNeedle = `"version": "${input.phasegateVersion}"`;
-    const manifestEntry = baseManifest.findEntry(relativePath);
-    const pathExists = await exists(absolutePath);
-    const unmanagedExisting = pathExists && (current === null || manifestEntry === null);
-    const changed = !unmanagedExisting && (current === null || !current.includes(expectedNeedle));
+    const skillSet = input.skillSet ?? "all";
+    const expectedVersion = `"version": "${input.phasegateVersion}"`;
+    const expectedSkillSet = `"skillSet": "${skillSet}"`;
+    let missingSkill = false;
+    for (const skill of skills) {
+      if (!(await exists(join(absolutePath, skill, "SKILL.md")))) {
+        missingSkill = true;
+        break;
+      }
+    }
+    const missingManifest = baseManifest.findEntry(`${relativePath}/.harness-version`) === null
+      || skills.some((skill) => baseManifest.findEntry(`${relativePath}/${skill}`) === null);
+    const changed = current === null || !current.includes(expectedVersion) || !current.includes(expectedSkillSet) || missingSkill || missingManifest;
     return {
       path: relativePath,
-      action: changed ? "missing" : unmanagedExisting ? "will-merge" : "will-skip",
-      repairMode: unmanagedExisting ? "manual" : "mechanical",
+      action: changed ? "missing" : "will-skip",
+      repairMode: "mechanical",
       strategy: "copy-dir",
       changed,
-      summary: unmanagedExisting
-        ? `${relativePath}: existing non-phasegate directory requires manual review`
-        : changed ? `${relativePath}: deploy bundled skills` : `${relativePath}: already up to date`,
-      diff: unmanagedExisting ? "manual review required" : changed ? "+ bundled skills" : "no changes",
+      summary: changed ? `${relativePath}: deploy bundled skills` : `${relativePath}: already up to date`,
+      diff: changed ? `+ ${skills.length} bundled skills (${skillSet})` : "no changes",
       skillHint: null,
     };
   }
 
-  private personalSkillsHashInput(path: string, version: string, skillSet: "core" | "all"): string {
-    return `personal-skills:${path}:${version}:${skillSet}`;
+  private personalSkillsVersionHashInput(path: string, version: string, skillSet: "core" | "all", skills: readonly string[]): string {
+    return `personal-skills-version:${path}:${version}:${skillSet}:${skills.join(",")}`;
+  }
+
+  private personalSkillHashInput(path: string, skill: string, version: string, skillSet: "core" | "all"): string {
+    return `personal-skill:${path}:${skill}:${version}:${skillSet}`;
   }
 
   private async planSharedSkillDirectory(
@@ -812,13 +862,7 @@ export class RunInstallUseCase {
 
   private async deploySharedSkills(input: RunInstallInput, skills: readonly string[], skillSet: SkillSet): Promise<void> {
     const targetRoot = join(input.projectRoot, "skills");
-    await mkdir(targetRoot, { recursive: true });
-    for (const skill of skills) {
-      const source = join(input.harnessRoot, "skills", skill);
-      const target = join(targetRoot, skill);
-      await rm(target, { recursive: true, force: true });
-      await copyDirectory(source, target);
-    }
+    await copySelectedSkillDirectories(input.harnessRoot, targetRoot, skills);
     await writeFile(
       join(targetRoot, ".harness-version"),
       `${JSON.stringify({ version: input.phasegateVersion, deployedAt: new Date().toISOString(), skillSet }, null, 2)}\n`,

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

@@ -4,14 +4,15 @@
 // @work-item-id WI-174
 // @work-item-id WI-198
 // @work-item-id WI-210
+// @work-item-id WI-216
 
 import { access, chmod, copyFile, lstat, mkdir, readFile, readlink, readdir, rm, symlink, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
-import { getSkillsForSet, type SkillSet } from "../../../setup/skill-deployer.js";
 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 { getBundledSkillsForSet, type SkillSet } from "../bundled-skill-selection.js";
 import type { HashCalculatorPort } from "../ports/hash-calculator-port.js";
 import type { ManifestRepositoryPort } from "../ports/manifest-repository-port.js";
 
@@ -95,8 +96,18 @@ async function copyDirectory(src: string, dest: string): Promise<void> {
   }
 }
 
+async function copySelectedSkillDirectories(harnessRoot: string, targetRoot: string, skills: readonly string[]): Promise<void> {
+  await mkdir(targetRoot, { recursive: true });
+  for (const skill of skills) {
+    const source = join(harnessRoot, "skills", skill);
+    const target = join(targetRoot, skill);
+    await rm(target, { recursive: true, force: true });
+    await copyDirectory(source, target);
+  }
+}
+
 async function listSelectedBundledSkills(harnessRoot: string, skillSet: SkillSet): Promise<string[]> {
-  const allowed = new Set(getSkillsForSet(skillSet));
+  const allowed = new Set(getBundledSkillsForSet(skillSet));
   const entries = await readdir(join(harnessRoot, "skills"), { withFileTypes: true });
   return entries
     .filter((entry) => entry.isDirectory() && allowed.has(entry.name))
@@ -285,12 +296,21 @@ export class RunReconcileUseCase {
       }
     }
 
-    if (this.manifestIntendsSharedSkills(manifest)) {
+    const personalInstall = this.isPersonalManifest(manifest);
+    if (!personalInstall && this.manifestIntendsSharedSkills(manifest)) {
       const sharedSkills = await listSelectedBundledSkills(input.harnessRoot, "all");
       const outcome = await this.planSharedSkills(input, manifest, sharedSkills, "all");
       outcomes.push(outcome);
       plan.push(outcome.item);
     }
+    if (personalInstall) {
+      const personalSkills = await listSelectedBundledSkills(input.harnessRoot, "all");
+      for (const skillPath of this.personalSkillPaths(manifest)) {
+        const outcome = await this.planPersonalSkills(input, manifest, skillPath, personalSkills, "all");
+        outcomes.push(outcome);
+        plan.push(outcome.item);
+      }
+    }
 
     if (!input.apply || refused.length > 0) {
       return { plan, refused, changed, backupDir: null };
@@ -311,6 +331,12 @@ export class RunReconcileUseCase {
           for (const skill of sharedSkills) {
             nextManifest = nextManifest.addEntry(this.createdEntry(`skills/${skill}`, this.sharedSkillHashInput(skill, input.phasegateVersion, "all")));
           }
+        } else if (outcome.item.strategy === "copy-dir" && (outcome.item.path === ".claude/skills" || outcome.item.path === ".codex/skills")) {
+          const personalSkills = await listSelectedBundledSkills(input.harnessRoot, "all");
+          nextManifest = nextManifest.addEntry(this.createdEntry(`${outcome.item.path}/.harness-version`, this.personalSkillsVersionHashInput(outcome.item.path, input.phasegateVersion, "all", personalSkills)));
+          for (const skill of personalSkills) {
+            nextManifest = nextManifest.addEntry(this.createdEntry(`${outcome.item.path}/${skill}`, this.personalSkillHashInput(outcome.item.path, skill, input.phasegateVersion, "all")));
+          }
         } else {
           const mode = outcome.item.strategy === "symlink" ? "symlink" : outcome.item.action === "add" ? "created" : (manifest.findEntry(outcome.item.path)?.mode ?? "merged");
           nextManifest = nextManifest.addEntry(
@@ -435,6 +461,19 @@ export class RunReconcileUseCase {
       || manifest.entries.some((entry) => entry.path.startsWith("skills/"));
   }
 
+  private isPersonalManifest(manifest: DeploymentManifest): boolean {
+    return manifest.findEntry(".phasegate-local/phasegate.config.json") !== null
+      || manifest.entries.some((entry) => (entry.path === ".claude/skills" || entry.path === ".codex/skills") && entry.mode === "created")
+      || manifest.entries.some((entry) => entry.path.startsWith(".claude/skills/") || entry.path.startsWith(".codex/skills/"));
+  }
+
+  private personalSkillPaths(manifest: DeploymentManifest): Array<".claude/skills" | ".codex/skills"> {
+    const paths = new Set<".claude/skills" | ".codex/skills">();
+    if (manifest.findEntry(".claude/skills") !== null || manifest.entries.some((entry) => entry.path.startsWith(".claude/skills/"))) paths.add(".claude/skills");
+    if (manifest.findEntry(".codex/skills") !== null || manifest.entries.some((entry) => entry.path.startsWith(".codex/skills/"))) paths.add(".codex/skills");
+    return [...paths].sort();
+  }
+
   private async planSharedSkills(
     input: RunReconcileInput,
     manifest: DeploymentManifest,
@@ -475,13 +514,7 @@ export class RunReconcileUseCase {
 
   private async deploySharedSkills(input: RunReconcileInput, skills: readonly string[], skillSet: SkillSet): Promise<void> {
     const targetRoot = this.resolveProjectPath(input.projectRoot, "skills");
-    await mkdir(targetRoot, { recursive: true });
-    for (const skill of skills) {
-      const source = join(input.harnessRoot, "skills", skill);
-      const target = join(targetRoot, skill);
-      await rm(target, { recursive: true, force: true });
-      await copyDirectory(source, target);
-    }
+    await copySelectedSkillDirectories(input.harnessRoot, targetRoot, skills);
     await writeFile(
       join(targetRoot, ".harness-version"),
       `${JSON.stringify({ version: input.phasegateVersion, deployedAt: new Date().toISOString(), skillSet }, null, 2)}\n`,
@@ -489,6 +522,52 @@ export class RunReconcileUseCase {
     );
   }
 
+  private async planPersonalSkills(
+    input: RunReconcileInput,
+    manifest: DeploymentManifest,
+    relativePath: ".claude/skills" | ".codex/skills",
+    skills: readonly string[],
+    skillSet: SkillSet,
+  ) {
+    const versionPath = this.resolveProjectPath(input.projectRoot, `${relativePath}/.harness-version`);
+    const versionContent = await readTextOrNull(versionPath);
+    const expectedVersion = `"version": "${input.phasegateVersion}"`;
+    let missingSkill = false;
+    for (const skill of skills) {
+      if (!(await exists(this.resolveProjectPath(input.projectRoot, `${relativePath}/${skill}/SKILL.md`)))) {
+        missingSkill = true;
+        break;
+      }
+    }
+    const missingManifest = manifest.findEntry(`${relativePath}/.harness-version`) === null
+      || skills.some((skill) => manifest.findEntry(`${relativePath}/${skill}`) === null);
+    const changed = versionContent === null || !versionContent.includes(expectedVersion) || missingSkill || missingManifest;
+    return {
+      item: this.item(
+        relativePath,
+        changed ? "add" : "skip",
+        "mechanical",
+        "copy-dir",
+        changed,
+        changed ? `${relativePath}: deploy bundled skills` : `${relativePath}: already up to date`,
+        changed ? `+ ${skills.length} bundled skills (${skillSet})` : "no changes",
+        null,
+      ),
+      needsBackup: false,
+      apply: async () => {
+        if (!changed) return null;
+        const targetRoot = this.resolveProjectPath(input.projectRoot, relativePath);
+        await copySelectedSkillDirectories(input.harnessRoot, targetRoot, skills);
+        await writeFile(
+          join(targetRoot, ".harness-version"),
+          `${JSON.stringify({ version: input.phasegateVersion, deployedAt: new Date().toISOString(), skillSet }, null, 2)}\n`,
+          "utf8",
+        );
+        return this.personalSkillsVersionHashInput(relativePath, input.phasegateVersion, skillSet, skills);
+      },
+    };
+  }
+
   private createdEntry(path: string, hashInput: string): DeploymentEntry {
     return DeploymentEntry.create({
       path,
@@ -507,6 +586,14 @@ export class RunReconcileUseCase {
     return `shared-skill:${skill}:${version}:${skillSet}`;
   }
 
+  private personalSkillsVersionHashInput(path: string, version: string, skillSet: SkillSet, skills: readonly string[]): string {
+    return `personal-skills-version:${path}:${version}:${skillSet}:${skills.join(",")}`;
+  }
+
+  private personalSkillHashInput(path: string, skill: string, version: string, skillSet: SkillSet): string {
+    return `personal-skill:${path}:${skill}:${version}:${skillSet}`;
+  }
+
   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);

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

@@ -6,8 +6,9 @@
 // @work-item-id WI-207
 // @work-item-id WI-208
 // @work-item-id WI-209
+// @work-item-id WI-216
 
-import { access, copyFile, lstat, mkdir, readFile, readlink, rm, rmdir, writeFile } from "node:fs/promises";
+import { access, copyFile, lstat, mkdir, readFile, readdir, readlink, rm, rmdir, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 import type { DeploymentEntry } from "../../domain/deployment-entry.js";
 import type { RepairMode } from "../../domain/repair-mode.js";
@@ -222,7 +223,7 @@ export class RunUninstallUseCase {
     const strategy = this.strategyFor(entry.path, entry.mode);
     if (entry.mode === "symlink") return this.planSymlink(input.projectRoot, entry);
     if (entry.mode === "created" && await this.isDirectory(absolutePath)) {
-      return this.planCreatedDirectory(input.projectRoot, entry);
+      return this.planCreatedDirectory(input, entry);
     }
     const currentContent = await readTextOrNull(absolutePath);
     if (currentContent === null && strategy !== "symlink") {
@@ -271,8 +272,9 @@ export class RunUninstallUseCase {
     }
   }
 
-  private async planCreatedDirectory(projectRoot: string, entry: DeploymentEntry) {
-    const absolutePath = this.resolveProjectPath(projectRoot, entry.path);
+  private async planCreatedDirectory(input: RunUninstallInput, entry: DeploymentEntry) {
+    if (entry.path === ".claude/skills" || entry.path === ".codex/skills") return this.planLegacyPersonalSkillsDirectory(input, entry);
+    const absolutePath = this.resolveProjectPath(input.projectRoot, entry.path);
     return {
       item: this.item(
         entry.path,
@@ -291,10 +293,39 @@ export class RunUninstallUseCase {
     };
   }
 
+  private async planLegacyPersonalSkillsDirectory(input: RunUninstallInput, entry: DeploymentEntry) {
+    const absolutePath = this.resolveProjectPath(input.projectRoot, entry.path);
+    const bundledSkills = await this.listBundledSkills(input.harnessRoot);
+    return {
+      item: this.item(
+        entry.path,
+        "delete",
+        "mechanical",
+        "created",
+        true,
+        `${entry.path}: remove managed bundled skills from legacy personal catalog`,
+        `- ${bundledSkills.length} bundled skills and .harness-version`,
+        null,
+      ),
+      needsBackup: false,
+      apply: async () => {
+        for (const skill of bundledSkills) {
+          await rm(join(absolutePath, skill), { recursive: true, force: true });
+        }
+        await rm(join(absolutePath, ".harness-version"), { force: true });
+      },
+    };
+  }
+
+  private async listBundledSkills(harnessRoot: string): Promise<string[]> {
+    const entries = await readdir(join(harnessRoot, "skills"), { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  }
+
   private async planCreated(projectRoot: string, entry: DeploymentEntry, currentContent: string) {
     const absolutePath = this.resolveProjectPath(projectRoot, entry.path);
     const currentHash = this.hashCalculator.compute(currentContent);
-    const matchesManifest = currentHash.equals(entry.hash);
+    const matchesManifest = currentHash.equals(entry.hash) || entry.path.endsWith("/.harness-version") || entry.path === "skills/.harness-version";
     const repairMode: RepairMode = matchesManifest ? "mechanical" : "ai-assisted";
     return {
       item: this.item(
@@ -365,7 +396,9 @@ export class RunUninstallUseCase {
     if (mode === "symlink") return "symlink";
     if (mode === "created") return path.endsWith(".yml") || path.endsWith(".yaml") ? "yaml-add" : "created";
     if (path === "package.json") return "package-json";
-    if (path === "AGENTS.md" || path === "CLAUDE.md") return "markdown-managed";
+    if (path === "AGENTS.md" || path === "CLAUDE.md" || path === ".claude/CLAUDE.md" || path === ".claude/CLAUDE.local.md" || path === ".codex/AGENTS.local.md") {
+      return "markdown-managed";
+    }
     if (path === ".git/info/exclude") return "text-managed";
     if (path.endsWith(".json")) return "json";
     if (path.startsWith(".husky/")) return "shell";
@@ -376,7 +409,9 @@ export class RunUninstallUseCase {
     if (path === ".claude/settings.json") return "templates/.claude/settings.json";
     if (path === ".codex/hooks.json") return "templates/.codex/hooks.json";
     if (path === "CLAUDE.md") return "docs/templates/agent-context/CLAUDE.md.template.md";
+    if (path === ".claude/CLAUDE.md" || path === ".claude/CLAUDE.local.md") return "docs/templates/agent-context/CLAUDE.md.template.md";
     if (path === "AGENTS.md") return "docs/templates/agent-context/AGENTS.md.template.md";
+    if (path === ".codex/AGENTS.local.md") return "docs/templates/agent-context/AGENTS.md.template.md";
     throw new Error(`No template for ${path}`);
   }
 

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

@@ -2,9 +2,12 @@
 // @layer presentation
 // @work-item-id WI-145
 // @work-item-id WI-148
+// @work-item-id WI-215
 
+import { ClaudeContextMissingCheck } from "./application/checks/claude-context-missing-check.js";
 import { ClaudeHookMissingCheck } from "./application/checks/claude-hook-missing-check.js";
 import { ClaudeSkillsSymlinkCheck } from "./application/checks/claude-skills-symlink-check.js";
+import { CodexContextMissingCheck } from "./application/checks/codex-context-missing-check.js";
 import { CodexHookMissingCheck } from "./application/checks/codex-hook-missing-check.js";
 import { CodexSkillsSymlinkCheck } from "./application/checks/codex-skills-symlink-check.js";
 import { CiWorkflowMissingCheck } from "./application/checks/ci-workflow-missing-check.js";
@@ -42,7 +45,9 @@ export function createInstallationModule() {
   const hashCalculator = new NodeCryptoHashAdapter();
   const checks = [
     new ClaudeHookMissingCheck(),
+    new ClaudeContextMissingCheck(),
     new CodexHookMissingCheck(),
+    new CodexContextMissingCheck(),
     new HuskyPreCommitMissingCheck(),
     new HuskyCommitMsgMissingCheck(),
     new HuskyPrePushMissingCheck(),

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

@@ -1,10 +1,13 @@
 // @unit installation
 // @layer domain
 // @work-item-id WI-145
+// @work-item-id WI-215
 
 export const CHECK_IDS = [
   "claude-hook-missing",
+  "claude-context-missing",
   "codex-hook-missing",
+  "codex-context-missing",
   "husky-pre-commit-missing",
   "husky-commit-msg-missing",
   "husky-pre-push-missing",

package/scripts/harness/installation/domain/repair-table.ts

@@ -1,6 +1,7 @@
 // @unit installation
 // @layer domain
 // @work-item-id WI-145
+// @work-item-id WI-215
 
 import type { CheckId } from "./check-id.js";
 import { SuggestedSkill } from "./suggested-skill.js";
@@ -23,7 +24,9 @@ export class RepairTable {
   constructor() {
     this.table = new Map<CheckId, SuggestedSkill | null>([
       ["claude-hook-missing", CONFIG_DOCTOR],
+      ["claude-context-missing", CONFIG_DOCTOR],
       ["codex-hook-missing", CONFIG_DOCTOR],
+      ["codex-context-missing", CONFIG_DOCTOR],
       ["husky-pre-commit-missing", CONFIG_DOCTOR],
       ["husky-commit-msg-missing", CONFIG_DOCTOR],
       ["husky-pre-push-missing", null],