phasegate 0.160.12 → 0.160.14

package/README.md

@@ -102,6 +102,15 @@ 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, creates agent skill links, 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 -->
 
+For personal evaluation inside a team-owned repository, use local-only install:
+
+```bash
+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. For Claude Code it automatically creates `.phasegate-local/phasegate.config.json`, `.phasegate-local/claude/settings.json`, `.phasegate-local/skills/`, ignored root `.claude/settings.json` and `.claude/skills` shims, a managed local-only block in `.git/info/exclude`, and `.phasegate/manifest.json`. Codex user-level hook setup remains a manual action instead of a project-local `.codex/hooks.json` write. <!-- @work-item-id WI-207 --> <!-- @work-item-id WI-208 -->
+
 For agent-driven setup planning, use:
 
 ```bash

package/docs/guide/getting-started.md

@@ -12,6 +12,7 @@ Start with one question: what kind of repository are you setting up?
 |---|---|---|
 | New project with agent hooks | `npx phasegate init --name <project> --agent both --with-husky --with-ci` | `phasegate.config.json`, skills, hooks, agent context files, Husky, and CI targets exist |
 | Existing repository | `npx phasegate install --dry-run` then `npx phasegate install --apply` | Existing hooks/scripts are preserved and `.phasegate/manifest.json` records managed targets |
+| Personal evaluation in a team repository | `npx phasegate install --personal --agent claude --dry-run` then `npx phasegate install --personal --agent claude --apply` | Team-owned files stay untouched; `.phasegate-local/` stores config/settings/skills and ignored `.claude/*` shims expose them to Claude Code |
 | CI-only rollout | `npx phasegate setup:agent --intent ci-only --with-ci --dry-run --json` | The plan explains CI changes without requiring local hooks |
 | Codex-only project | `npx phasegate init --agent codex --with-husky` | `.codex/hooks.json`, `AGENTS.md`, `.codex/skills`, and pre-commit backstop are present |
 | Strict validation rollout | `npx phasegate setup:agent --intent strict --dry-run --json` | The plan lists strict checks, L4 risk, rollback, and validation commands |

package/docs/guide/installation.md

@@ -58,6 +58,15 @@ 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 -->
 
+For personal evaluation inside a team-owned repository:
+
+```bash
+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. For Claude Code, PhaseGate writes local-only artifacts under `.phasegate-local/`, creates ignored root `.claude/settings.json` and `.claude/skills` shims for Claude discovery, records `.phasegate/manifest.json`, and manages a local exclude block in `.git/info/exclude`. Codex user-level hook setup is reported as a manual action instead of writing project-local `.codex/hooks.json`. <!-- @work-item-id WI-207 --> <!-- @work-item-id WI-208 -->
+
 For agent-readable planning before writing files:
 
 ```bash

package/docs/guide/recipes.md

@@ -24,6 +24,15 @@ npx phasegate baseline --dry-run
 
 Use this when a repository already has meaningful history or custom automation. Treat any refused target as an agent-assisted review task instead of forcing it blindly.
 
+## Personal Evaluation Recipe
+
+```bash
+npx phasegate install --personal --dry-run
+npx phasegate install --personal --apply
+```
+
+Use this inside a team-owned repository when you want local PhaseGate artifacts without changing `package.json`, agent context files, Husky hooks, CI workflows, or team `.gitignore`. <!-- @work-item-id WI-207 -->
+
 ## Agent Hooks Recipe
 
 ```bash

package/docs/guide/setup-artifacts.md

@@ -5,6 +5,7 @@ PhaseGate setup is more than `phasegate.config.json`. A healthy installation is
 <!-- @work-item-id WI-152 -->
 <!-- @work-item-id WI-157 -->
 <!-- @work-item-id WI-169 -->
+<!-- @work-item-id WI-208 -->
 
 ## Artifact Classes
 
@@ -14,6 +15,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`; `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`, `.phasegate-local/claude/settings.json`, `.phasegate-local/skills/`, ignored root `.claude/settings.json` and `.claude/skills` shims, `.git/info/exclude` PhaseGate block | One developer on one machine | Created by `phasegate install --personal --agent claude`; 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 |
 
@@ -33,6 +35,12 @@ PhaseGate setup is more than `phasegate.config.json`. A healthy installation is
 
 `init --with-ci` still deploys the legacy-compatible template set, including `.github/workflows/aidlc-gate.yml`, `.github/workflows/consistency-check.yml`, and `.github/workflows/agent-context-refresh.yml`. Structured `install` uses `.github/workflows/phasegate-aidlc-gate.yml` so it can coexist with existing project CI without taking over a generic workflow filename.
 
+## Personal Install Artifacts
+
+`phasegate install --personal --agent claude --apply` is a local-only bootstrap for evaluating PhaseGate in a team-owned repository. Substantive files are stored under `.phasegate-local/`, while root `.claude/settings.json` and `.claude/skills` are symlinks so Claude Code can discover the settings and skills. The root shims are hidden by `.git/info/exclude`; PhaseGate does not edit team `.gitignore`.
+
+If `.claude/settings.json` or `.claude/skills` already exists and is not the PhaseGate personal shim, personal install reports manual review and preserves the existing path.
+
 ## Doctor Findings
 
 `phasegate doctor` evaluates setup health from the managed targets and related project state. Findings include `repairMode`, optional `repairHint`, and optional `suggestedSkill`.

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

@@ -0,0 +1,6 @@
+.phasegate/
+.phasegate-local/
+.codex/
+.claude/
+skills/
+phasegate.config.json

package/docs/templates/personal/phasegate-local-config.json

@@ -0,0 +1,77 @@
+{
+  "project": {
+    "name": "personal-phasegate",
+    "preset": "standard"
+  },
+  "layers": {
+    "L1": {
+      "enabled": true
+    },
+    "L2": {
+      "enabled": true
+    },
+    "L3": {
+      "enabled": true
+    },
+    "L4": {
+      "enabled": false
+    }
+  },
+  "quickMode": {
+    "allowedCategories": [
+      "bugfix",
+      "docs",
+      "test",
+      "config"
+    ],
+    "maintainedLayers": [
+      "L1",
+      "L2"
+    ],
+    "relaxedGates": [
+      "phase-gate",
+      "2-phase-execution"
+    ],
+    "fullModeRequiredWhen": {
+      "mixedCategories": true,
+      "newDomainFile": true,
+      "apiContractChange": true
+    }
+  },
+  "phaseDependencies": {
+    "preset": "default",
+    "override": false,
+    "customRules": []
+  },
+  "planningMode": {
+    "default": "interactive",
+    "perPhase": {}
+  },
+  "harnesses": {
+    "agentLessonCollection": false,
+    "cascadeUpdate": false,
+    "bundleSizeLimit": 0,
+    "deadCodeGC": false
+  },
+  "paths": {
+    "designDocs": "docs/product/construction",
+    "inceptionDocs": "docs/inception"
+  },
+  "reporting": {
+    "format": "json",
+    "outputDir": "reports"
+  },
+  "protectedFiles": {
+    "exclude": [
+      "tsconfig.json",
+      "package.json"
+    ]
+  },
+  "baseline": {
+    "enabled": true,
+    "path": ".phasegate/baseline.json"
+  },
+  "architecture": {
+    "preset": "clean"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phasegate",
-  "version": "0.160.12",
+  "version": "0.160.14",
   "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/agent-integration/presentation/phasegate-status-context.ts

@@ -1,6 +1,7 @@
 /**
  * @layer presentation
  * @unit agent-integration
+ * @work-item-id WI-208
  *
  * Phasegate 状態を context 文字列として組み立てる共有ヘルパー。
  * SessionStart / UserPromptSubmit hook が共通で使用する。
@@ -54,18 +55,27 @@ const DEFAULT_PROTECTED_PATTERNS = [
 export async function findConfigPath(startDir: string): Promise<string | null> {
   let dir = startDir;
   while (true) {
-    const candidate = path.join(dir, 'phasegate.config.json');
-    try {
-      await fs.access(candidate);
-      return candidate;
-    } catch {
-      const parent = path.dirname(dir);
-      if (parent === dir) return null;
-      dir = parent;
+    const candidates = [
+      path.join(dir, 'phasegate.config.json'),
+      path.join(dir, '.phasegate-local', 'phasegate.config.json'),
+    ];
+    for (const candidate of candidates) {
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch {}
     }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
   }
 }
 
+export function projectRootForConfig(configPath: string): string {
+  const configDir = path.dirname(configPath);
+  return path.basename(configDir) === '.phasegate-local' ? path.dirname(configDir) : configDir;
+}
+
 async function loadConfig(configPath: string): Promise<PhasegateConfig> {
   try {
     const raw = await fs.readFile(configPath, 'utf8');
@@ -122,7 +132,7 @@ export async function collectPhasegateStatus(cwd: string): Promise<PhasegateStat
   const configPath = await findConfigPath(cwd);
   const configFound = configPath !== null;
   const config: PhasegateConfig = configFound ? await loadConfig(configPath) : {};
-  const projectRoot = configFound ? path.dirname(configPath) : cwd;
+  const projectRoot = configFound ? projectRootForConfig(configPath) : cwd;
 
   const protectedPatterns = computeProtectedPatterns(config);
   const blockedUnits = await findBlockedUnits(projectRoot, config);

package/scripts/harness/agent-integration/presentation/post-tool-use-hook.ts

@@ -1,6 +1,7 @@
 /**
  * @layer presentation
  * @unit agent-integration
+ * @work-item-id WI-208
  *
  * PostToolUse Hook Adapter
  * Claude Code の PostToolUse Hook エントリポイント
@@ -30,19 +31,28 @@ async function readStdin(): Promise<string> {
 async function findConfigPath(): Promise<string> {
   let dir = process.cwd();
   while (true) {
-    const candidate = path.join(dir, 'phasegate.config.json');
-    try {
-      await fs.access(candidate);
-      return candidate;
-    } catch {
-      const parent = path.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
+    const candidates = [
+      path.join(dir, 'phasegate.config.json'),
+      path.join(dir, '.phasegate-local', 'phasegate.config.json'),
+    ];
+    for (const candidate of candidates) {
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch {}
     }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
   return path.join(process.cwd(), 'phasegate.config.json');
 }
 
+function projectRootForConfig(configPath: string): string {
+  const configDir = path.dirname(configPath);
+  return path.basename(configDir) === '.phasegate-local' ? path.dirname(configDir) : configDir;
+}
+
 async function main(): Promise<void> {
   let raw: string;
   try {
@@ -82,7 +92,7 @@ async function main(): Promise<void> {
 
     if (output.skipReason) {
       await recordHookSkipEvent({
-        projectRoot: path.dirname(configPath),
+        projectRoot: projectRootForConfig(configPath),
         hookType: 'post-tool-use',
         reason: output.skipReason,
         targetPaths: [],

package/scripts/harness/agent-integration/presentation/pre-tool-use-hook.ts

@@ -3,6 +3,7 @@
  * @unit agent-integration
  * @work-item-id WI-202 / WI-204
  * @work-item-id WI-206
+ * @work-item-id WI-208
  *
  * PreToolUse Hook Adapter
  * Claude Code の PreToolUse Hook エントリポイント
@@ -57,19 +58,28 @@ async function readStdin(): Promise<string> {
 async function findConfigPath(startDir: string): Promise<string> {
   let dir = startDir;
   while (true) {
-    const candidate = path.join(dir, 'phasegate.config.json');
-    try {
-      await fs.access(candidate);
-      return candidate;
-    } catch {
-      const parent = path.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
+    const candidates = [
+      path.join(dir, 'phasegate.config.json'),
+      path.join(dir, '.phasegate-local', 'phasegate.config.json'),
+    ];
+    for (const candidate of candidates) {
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch {}
     }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
   return path.join(startDir, 'phasegate.config.json');
 }
 
+function projectRootForConfig(configPath: string): string {
+  const configDir = path.dirname(configPath);
+  return path.basename(configDir) === '.phasegate-local' ? path.dirname(configDir) : configDir;
+}
+
 function isProjectExternalAbsolutePath(filePath: string): boolean {
   return path.isAbsolute(filePath);
 }
@@ -139,24 +149,25 @@ async function main(): Promise<void> {
     const configPath = await findConfigPath(cwd);
     const projectTargetFilePaths = targetFilePaths.filter((filePath) => !isProjectExternalAbsolutePath(filePath));
     const projectTargetChanges = targetChanges.filter((change) => !isProjectExternalAbsolutePath(change.filePath));
+    const projectRoot = projectRootForConfig(configPath);
     const configQueryPort = new HarnessConfigConfigQueryAdapter(configPath);
     const phaseGateQueryPort = new PhaseGateQueryAdapter();
     const storyReflectionQueryPort = new FileSystemStoryReflectionQueryAdapter({
-      rootDir: path.dirname(configPath),
+      rootDir: projectRoot,
       configPath,
     });
     const fullModeRequirementQueryPort = new QuickModeFullModeRequirementAdapter({
       classifyUseCaseFactory: () => createQuickModeCompositionRoot().classifyUseCase,
     });
     const baselineGrandfatherQueryPort = new CiGovernanceBaselineGrandfatherAdapter({
-      baseDir: path.dirname(configPath),
+      baseDir: projectRoot,
       configQueryPort,
     });
     const errorGuidanceQueryPort = new HarnessErrorGuidanceAdapter({
-      rootDir: path.dirname(configPath),
+      rootDir: projectRoot,
     });
     const fullModeSessionQueryPort = new FileSystemFullModeSessionQueryAdapter({
-      rootDir: path.dirname(configPath),
+      rootDir: projectRoot,
       configQueryPort,
     });
     const useCase = new HandlePreToolUseUseCase({

package/scripts/harness/agent-integration/presentation/stop-hook.ts

@@ -2,6 +2,7 @@
  * @layer presentation
  * @unit agent-integration
  * @work-item-id WI-203
+ * @work-item-id WI-208
  *
  * Stop Hook Adapter
  * Claude Code の Stop Hook エントリポイント
@@ -45,19 +46,28 @@ async function readStdin(): Promise<string> {
 async function findConfigPath(): Promise<string> {
   let dir = process.cwd();
   while (true) {
-    const candidate = path.join(dir, 'phasegate.config.json');
-    try {
-      await fs.access(candidate);
-      return candidate;
-    } catch {
-      const parent = path.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
+    const candidates = [
+      path.join(dir, 'phasegate.config.json'),
+      path.join(dir, '.phasegate-local', 'phasegate.config.json'),
+    ];
+    for (const candidate of candidates) {
+      try {
+        await fs.access(candidate);
+        return candidate;
+      } catch {}
     }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
   return path.join(process.cwd(), 'phasegate.config.json');
 }
 
+function projectRootForConfig(configPath: string): string {
+  const configDir = path.dirname(configPath);
+  return path.basename(configDir) === '.phasegate-local' ? path.dirname(configDir) : configDir;
+}
+
 async function main(): Promise<void> {
   let raw: string;
   try {
@@ -99,7 +109,7 @@ async function main(): Promise<void> {
 
     if (output.skipReason === 'REENTRY_DETECTED') {
       await recordHookSkipEvent({
-        projectRoot: path.dirname(configPath),
+        projectRoot: projectRootForConfig(configPath),
         hookType: 'stop',
         reason: output.skipReason,
         targetPaths: [],

package/scripts/harness/agent-integration/presentation/user-prompt-submit-hook.ts

@@ -1,12 +1,13 @@
 // @unit agent-integration
 // @layer presentation
+// @work-item-id WI-208
 
-import * as path from 'node:path';
 import {
   buildUserPromptSubmitContext,
   collectPhasegateStatus,
   collectRecentViolations,
   findConfigPath,
+  projectRootForConfig,
 } from './phasegate-status-context.js';
 
 async function readStdin(): Promise<string> {
@@ -29,7 +30,7 @@ async function main(): Promise<void> {
   // 違反検知の起点は config が見つかったディレクトリ (= project root)。
   // config が無ければ cwd をそのまま使う。
   const configPath = await findConfigPath(cwd);
-  const projectRoot = configPath !== null ? path.dirname(configPath) : cwd;
+  const projectRoot = configPath !== null ? projectRootForConfig(configPath) : cwd;
   const violations = await collectRecentViolations(projectRoot, status);
   const additionalContext = buildUserPromptSubmitContext(status, violations);
 

package/scripts/harness/config-foundation/infrastructure/repositories/file-system-config-repository.ts

@@ -7,6 +7,7 @@ import path from 'node:path';
 import type { ConfigRepositoryPort } from '../../domain/ports/config-repository-port.js';
 
 const DEFAULT_CONFIG_FILE_NAME = 'phasegate.config.json';
+const PERSONAL_CONFIG_PATH = path.join('.phasegate-local', DEFAULT_CONFIG_FILE_NAME);
 
 export class ConfigNotFoundError extends Error {
   readonly configPath: string;
@@ -45,10 +46,15 @@ async function findNearestConfig(startDirectory: string): Promise<string | null>
   let currentDirectory = path.resolve(startDirectory);
 
   while (true) {
-    const candidate = path.join(currentDirectory, DEFAULT_CONFIG_FILE_NAME);
-
-    if (await exists(candidate)) {
-      return candidate;
+    const candidates = [
+      path.join(currentDirectory, DEFAULT_CONFIG_FILE_NAME),
+      path.join(currentDirectory, PERSONAL_CONFIG_PATH),
+    ];
+
+    for (const candidate of candidates) {
+      if (await exists(candidate)) {
+        return candidate;
+      }
     }
 
     const parentDirectory = path.dirname(currentDirectory);

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

@@ -2,6 +2,7 @@
 // @layer application
 // @work-item-id WI-145
 // @work-item-id WI-178
+// @work-item-id WI-208
 
 import { DiagnosticReport } from "../../domain/diagnostic-report.js";
 import type { CheckId } from "../../domain/check-id.js";
@@ -26,12 +27,20 @@ export interface RunDoctorDiagnosticsInput {
 export interface RunDoctorDiagnosticsOutput {
   readonly report: DiagnosticReport;
   readonly agent: DoctorAgentScope;
+  readonly installationMode: "project" | "personal";
   readonly scopedOutFindings: readonly ScopedOutDiagnosticFinding[];
   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 PERSONAL_SCOPED_OUT_CHECKS = new Set<CheckId>([
+  "husky-pre-commit-missing",
+  "husky-commit-msg-missing",
+  "husky-pre-push-missing",
+  "ci-workflow-missing",
+  "package-json-devdep-missing",
+]);
 
 export class RunDoctorDiagnosticsUseCase {
   constructor(
@@ -42,15 +51,20 @@ export class RunDoctorDiagnosticsUseCase {
 
   async execute(input: RunDoctorDiagnosticsInput): Promise<RunDoctorDiagnosticsOutput> {
     const agent = input.agent ?? "both";
-    await this.manifestRepository.load(input.projectRoot).catch(() => null);
+    const manifest = await this.manifestRepository.load(input.projectRoot).catch(() => null);
+    const installationMode = manifest?.findEntry(".phasegate-local/phasegate.config.json") !== null && manifest !== null ? "personal" : "project";
     const rawFindings = (await Promise.all(
       this.checks.map((check) => check.run(input.projectRoot, this.inspector)),
     )).filter((finding) => finding !== null);
-    const { findings, scopedOutFindings } = this.applyAgentScope(rawFindings, agent);
+    const { findings, scopedOutFindings } = this.applyPersonalScope(
+      this.applyAgentScope(rawFindings, agent),
+      installationMode,
+    );
     const report = DiagnosticReport.create(findings);
     return {
       report,
       agent,
+      installationMode,
       scopedOutFindings,
       exitCode: this.decideExitCode(report, input.strict),
     };
@@ -77,6 +91,26 @@ export class RunDoctorDiagnosticsUseCase {
     return { findings: applicable, scopedOutFindings: scopedOut };
   }
 
+  private applyPersonalScope(
+    scoped: { readonly findings: readonly DiagnosticFinding[]; readonly scopedOutFindings: readonly ScopedOutDiagnosticFinding[] },
+    installationMode: "project" | "personal",
+  ): { readonly findings: readonly DiagnosticFinding[]; readonly scopedOutFindings: readonly ScopedOutDiagnosticFinding[] } {
+    if (installationMode !== "personal") return scoped;
+    const applicable: DiagnosticFinding[] = [];
+    const scopedOut: ScopedOutDiagnosticFinding[] = [...scoped.scopedOutFindings];
+    for (const finding of scoped.findings) {
+      if (PERSONAL_SCOPED_OUT_CHECKS.has(finding.checkId)) {
+        scopedOut.push({
+          finding,
+          scopeReason: `${finding.checkId} is a team/project install target and is intentionally out of scope for personal install.`,
+        });
+      } else {
+        applicable.push(finding);
+      }
+    }
+    return { findings: applicable, scopedOutFindings: scopedOut };
+  }
+
   private decideExitCode(report: DiagnosticReport, strict: boolean): number {
     if (report.hasRedFlag()) return 1;
     if (strict && report.hasWarning()) return 1;

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

@@ -7,8 +7,10 @@
 // @work-item-id WI-177
 // @work-item-id WI-182
 // @work-item-id WI-183
+// @work-item-id WI-207
+// @work-item-id WI-208
 
-import { mkdir, readFile, writeFile, copyFile, chmod, access, lstat, readlink, symlink } from "node:fs/promises";
+import { mkdir, readFile, writeFile, copyFile, chmod, access, lstat, readlink, symlink, readdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { DeploymentEntry } from "../../domain/deployment-entry.js";
 import { DeploymentManifest } from "../../domain/deployment-manifest.js";
@@ -18,7 +20,7 @@ import type { ManifestRepositoryPort } from "../ports/manifest-repository-port.j
 import type { HashCalculatorPort } from "../ports/hash-calculator-port.js";
 
 type InstallAction = "missing" | "will-merge" | "will-skip" | "will-overwrite";
-type StrategyType = "json" | "shell" | "yaml-add" | "package-json" | "markdown-managed";
+type StrategyType = "json" | "shell" | "yaml-add" | "package-json" | "markdown-managed" | "text-managed" | "copy" | "copy-dir" | "symlink";
 
 export interface InstallPlanItem {
   readonly path: string;
@@ -45,6 +47,7 @@ export interface RunInstallInput {
   readonly skillSet?: "core" | "all";
   readonly workflow?: "standard" | "strict";
   readonly agent?: "claude" | "codex" | "both";
+  readonly personal?: boolean;
 }
 
 export interface RunInstallResult {
@@ -79,6 +82,10 @@ const SHELL_BEGIN = "# === phasegate managed (BEGIN) ===";
 const SHELL_END = "# === phasegate managed (END) ===";
 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_CLAUDE_SETTINGS_LINK = "../.phasegate-local/claude/settings.json";
+const PERSONAL_CLAUDE_SKILLS_LINK = "../.phasegate-local/skills";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -101,6 +108,20 @@ async function readTextOrNull(path: string): Promise<string | null> {
   }
 }
 
+async function copyDirectory(src: string, dest: string): Promise<void> {
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else if (entry.isFile()) {
+      await copyFile(srcPath, destPath);
+    }
+  }
+}
+
 function normalizeJsonEntry(value: unknown): string {
   return JSON.stringify(value);
 }
@@ -152,6 +173,14 @@ function mergeShell(existing: string | null, incoming: string): string {
   return `${existing.replace(/\s*$/, "\n\n")}${block}\n`;
 }
 
+function mergeTextManaged(existing: string | null, incoming: string): string {
+  const block = `${TEXT_BEGIN}\n${incoming.trim()}\n${TEXT_END}`;
+  if (existing === null || existing.trim().length === 0) return `${block}\n`;
+  const pattern = new RegExp(`${escapeRegExp(TEXT_BEGIN)}[\\s\\S]*?${escapeRegExp(TEXT_END)}`);
+  if (pattern.test(existing)) return existing.replace(pattern, block).replace(/\s*$/, "\n");
+  return `${existing.replace(/\s*$/, "\n\n")}${block}\n`;
+}
+
 function managedMarkdownBlock(content: string): string {
   const start = content.indexOf(MARKDOWN_BEGIN);
   const end = content.indexOf(MARKDOWN_END);
@@ -282,7 +311,9 @@ export class RunInstallUseCase {
     const skillSet = input.skillSet ?? "all";
     const workflow = input.workflow ?? "standard";
     const agent = input.agent ?? (includeClaude && includeCodex ? "both" : includeCodex ? "codex" : "claude");
-    const targets = this.createTargets({ includeClaude, includeCodex, includeHusky, includeCi });
+    const targets = input.personal
+      ? this.createPersonalTargets({ includeClaude })
+      : this.createTargets({ includeClaude, includeCodex, includeHusky, includeCi });
     const existingManifest = await this.manifestRepository.load(input.projectRoot);
     const baseManifest = existingManifest ?? DeploymentManifest.create(input.phasegateVersion);
     let manifest = baseManifest;
@@ -326,23 +357,23 @@ export class RunInstallUseCase {
         await this.backup(input.projectRoot, target.path, backupDir);
       }
 
+      try {
+        await mkdir(dirname(absolutePath), { recursive: true });
+      } catch (error) {
+        return this.withApplyError({ plan, refused, changed, backupDir }, target.path, "mkdir", error);
+      }
+      try {
+        await writeFile(absolutePath, next, "utf8");
+      } catch (error) {
+        return this.withApplyError({ plan, refused, changed, backupDir }, target.path, "writeFile", error);
+      }
+      if (target.executable) {
         try {
-          await mkdir(dirname(absolutePath), { recursive: true });
-        } catch (error) {
-          return this.withApplyError({ plan, refused, changed, backupDir }, target.path, "mkdir", error);
-        }
-        try {
-          await writeFile(absolutePath, next, "utf8");
+          await chmod(absolutePath, 0o755);
         } catch (error) {
-          return this.withApplyError({ plan, refused, changed, backupDir }, target.path, "writeFile", error);
-        }
-        if (target.executable) {
-          try {
-            await chmod(absolutePath, 0o755);
-          } catch (error) {
-            return this.withApplyError({ plan, refused, changed, backupDir }, target.path, "chmod", error);
-          }
+          return this.withApplyError({ plan, refused, changed, backupDir }, target.path, "chmod", error);
         }
+      }
       changed.push(item);
 
       const mode = before === null ? "created" : "merged";
@@ -363,41 +394,76 @@ export class RunInstallUseCase {
       }
     }
 
-    const linkPaths = [
-      ...(includeClaude ? [".claude/skills"] : []),
-      ...(includeCodex ? [".codex/skills"] : []),
-    ];
-    for (const linkPath of linkPaths) {
-      const item = await this.planSkillLink(input.projectRoot, linkPath);
+    if (input.personal && includeClaude) {
+      const item = await this.planPersonalSkills(input);
+      plan.push(item);
+      if (input.apply && item.changed) {
+        try {
+          await copyDirectory(join(input.harnessRoot, "skills"), join(input.projectRoot, ".phasegate-local", "skills"));
+          await writeFile(
+            join(input.projectRoot, ".phasegate-local", "skills", ".harness-version"),
+            `${JSON.stringify({ version: input.phasegateVersion, deployedAt: new Date().toISOString(), skillSet }, null, 2)}\n`,
+            "utf8",
+          );
+        } catch (error) {
+          return this.withApplyError({ plan, refused, changed, backupDir }, item.path, "copyDirectory", error);
+        }
+        changed.push(item);
+        manifest = this.addManifestEntry(baseManifest, manifest, {
+          path: item.path,
+          mode: "created",
+          contentForHash: this.personalSkillsHashInput(input.phasegateVersion, skillSet),
+        });
+      }
+    }
+
+    const linkSpecs = input.personal
+      ? [
+          ...(includeClaude
+            ? [
+                { path: ".claude/settings.json", target: PERSONAL_CLAUDE_SETTINGS_LINK },
+                { path: ".claude/skills", target: PERSONAL_CLAUDE_SKILLS_LINK },
+              ]
+            : []),
+        ]
+      : [
+          ...(includeClaude ? [{ path: ".claude/skills", target: "../skills" }] : []),
+          ...(includeCodex ? [{ path: ".codex/skills", target: "../skills" }] : []),
+        ];
+    for (const linkSpec of linkSpecs) {
+      const item = await this.planSkillLink(input.projectRoot, linkSpec.path, linkSpec.target);
       plan.push(item);
       if (!input.apply || !item.changed) continue;
       try {
-        await mkdir(join(input.projectRoot, "skills"), { recursive: true });
-        await mkdir(dirname(join(input.projectRoot, linkPath)), { recursive: true });
+        if (!input.personal) await mkdir(join(input.projectRoot, "skills"), { recursive: true });
+        await mkdir(dirname(join(input.projectRoot, linkSpec.path)), { recursive: true });
       } catch (error) {
-        return this.withApplyError({ plan, refused, changed, backupDir }, linkPath, "mkdir", error);
+        return this.withApplyError({ plan, refused, changed, backupDir }, linkSpec.path, "mkdir", error);
       }
       try {
-        await symlink("../skills", join(input.projectRoot, linkPath), process.platform === "win32" ? "junction" : "dir");
+        await symlink(linkSpec.target, join(input.projectRoot, linkSpec.path), process.platform === "win32" ? "junction" : "dir");
       } catch (error) {
-        return this.withApplyError({ plan, refused, changed, backupDir }, linkPath, "symlink", error);
+        return this.withApplyError({ plan, refused, changed, backupDir }, linkSpec.path, "symlink", error);
       }
       changed.push(item);
-      const hash = this.hashCalculator.compute("../skills");
-      const existingEntry = baseManifest.findEntry(linkPath);
-      if (existingEntry !== null && existingEntry.hash.equals(hash)) {
-        manifest = manifest.addEntry(existingEntry);
-      } else {
-        manifest = manifest.addEntry(
-          DeploymentEntry.create({
-            path: linkPath,
-            mode: "symlink",
-            block: null,
-            hash,
-            deployedAt: new Date().toISOString(),
-          }),
-        );
-      }
+      manifest = this.addManifestEntry(baseManifest, manifest, {
+        path: linkSpec.path,
+        mode: "symlink",
+        contentForHash: linkSpec.target,
+      });
+    }
+
+    if (input.personal && includeCodex) {
+      plan.push({
+        path: "~/.codex/hooks.json",
+        action: "will-skip",
+        repairMode: "manual",
+        strategy: "json",
+        changed: false,
+        summary: "~/.codex/hooks.json: personal mode does not write user-level Codex settings; configure hooks manually",
+        diff: "manual user-level Codex hook setup required",
+        skillHint: null,
+      });
     }
 
     if (input.apply && changed.length > 0) {
@@ -498,8 +564,37 @@ export class RunInstallUseCase {
     ];
   }
 
+  private createPersonalTargets(options: { readonly includeClaude: boolean }): readonly InstallTarget[] {
+    return [
+      {
+        path: ".phasegate-local/phasegate.config.json",
+        strategy: "copy" as const,
+        templatePath: "docs/templates/personal/phasegate-local-config.json",
+      },
+      ...(options.includeClaude
+        ? [
+            {
+              path: ".phasegate-local/claude/settings.json",
+              strategy: "copy" as const,
+              templatePath: "templates/.claude/settings.json",
+            },
+          ]
+        : []),
+      {
+        path: ".git/info/exclude",
+        strategy: "text-managed" as const,
+        templatePath: "docs/templates/personal/git-info-exclude",
+        block: { start: TEXT_BEGIN, end: TEXT_END, content: "phasegate personal install exclude block" },
+      },
+    ];
+  }
+
   private repairMode(target: InstallTarget, before: string | null): RepairMode {
     if (target.strategy === "shell") return shellRepairMode(before);
+    if (target.strategy === "text-managed") return "mechanical";
+    if (target.strategy === "copy") return "mechanical";
+    if (target.strategy === "copy-dir") return "mechanical";
+    if (target.strategy === "symlink") return "mechanical";
     if (target.strategy === "json") return jsonRepairMode(before);
     if (target.strategy === "markdown-managed") return "mechanical";
     return "mechanical";
@@ -513,7 +608,9 @@ export class RunInstallUseCase {
 
   private merge(target: InstallTarget, before: string | null, template: string, version: string): string {
     if (target.strategy === "yaml-add") return before ?? template;
+    if (target.strategy === "copy") return before ?? template;
     if (target.strategy === "shell") return mergeShell(before, template);
+    if (target.strategy === "text-managed") return mergeTextManaged(before, template);
     if (target.strategy === "markdown-managed") return mergeManagedMarkdown(before, template);
     if (target.strategy === "package-json") {
       const existing = before === null ? {} : (JSON.parse(before) as unknown);
@@ -542,16 +639,59 @@ export class RunInstallUseCase {
     };
   }
 
-  private async planSkillLink(projectRoot: string, relativePath: string): Promise<InstallPlanItem> {
+  private async planPersonalSkills(input: RunInstallInput): Promise<InstallPlanItem> {
+    const versionPath = join(input.projectRoot, ".phasegate-local", "skills", ".harness-version");
+    const current = await readTextOrNull(versionPath);
+    const expectedNeedle = `"version": "${input.phasegateVersion}"`;
+    const changed = current === null || !current.includes(expectedNeedle);
+    return {
+      path: ".phasegate-local/skills",
+      action: changed ? "missing" : "will-skip",
+      repairMode: "mechanical",
+      strategy: "copy-dir",
+      changed,
+      summary: changed ? ".phasegate-local/skills: deploy bundled skills" : ".phasegate-local/skills: already up to date",
+      diff: changed ? "+ bundled skills" : "no changes",
+      skillHint: null,
+    };
+  }
+
+  private personalSkillsHashInput(version: string, skillSet: "core" | "all"): string {
+    return `personal-skills:${version}:${skillSet}`;
+  }
+
+  private addManifestEntry(
+    baseManifest: DeploymentManifest,
+    manifest: DeploymentManifest,
+    input: { readonly path: string; readonly mode: "created" | "symlink"; readonly contentForHash: string },
+  ): DeploymentManifest {
+    const hash = this.hashCalculator.compute(input.contentForHash);
+    const existingEntry = baseManifest.findEntry(input.path);
+    if (existingEntry !== null && existingEntry.hash.equals(hash)) {
+      return manifest.addEntry(existingEntry);
+    }
+    return manifest.addEntry(
+      DeploymentEntry.create({
+        path: input.path,
+        mode: input.mode,
+        block: null,
+        hash,
+        deployedAt: new Date().toISOString(),
+      }),
+    );
+  }
+
+  private async planSkillLink(projectRoot: string, relativePath: string, target: string): Promise<InstallPlanItem> {
     const absolutePath = join(projectRoot, relativePath);
+    const parentPath = dirname(absolutePath);
     try {
       const stat = await lstat(absolutePath);
-      if (stat.isSymbolicLink() && (await readlink(absolutePath)) === "../skills") {
+      if (stat.isSymbolicLink() && (await readlink(absolutePath)) === target) {
         return {
           path: relativePath,
           action: "will-skip",
           repairMode: "mechanical",
-          strategy: "yaml-add",
+          strategy: "symlink",
           changed: false,
           summary: `${relativePath}: already linked`,
           diff: "no changes",
@@ -562,21 +702,36 @@ export class RunInstallUseCase {
         path: relativePath,
         action: "will-merge",
         repairMode: "manual",
-        strategy: "yaml-add",
+        strategy: "symlink",
         changed: false,
         summary: `${relativePath}: existing non-phasegate path requires manual review`,
         diff: "manual review required",
         skillHint: null,
       };
     } catch {
+      try {
+        const parentStat = await lstat(parentPath);
+        if (!parentStat.isDirectory()) {
+          return {
+            path: relativePath,
+            action: "will-merge",
+            repairMode: "manual",
+            strategy: "symlink",
+            changed: false,
+            summary: `${relativePath}: parent path exists and requires manual review`,
+            diff: "manual review required",
+            skillHint: null,
+          };
+        }
+      } catch {}
       return {
         path: relativePath,
         action: "missing",
         repairMode: "mechanical",
-        strategy: "yaml-add",
+        strategy: "symlink",
         changed: true,
         summary: `${relativePath}: create symlink`,
-        diff: "+ symlink ../skills",
+        diff: `+ symlink ${target}`,
         skillHint: null,
       };
     }

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

@@ -3,6 +3,8 @@
 // @work-item-id WI-147
 // @work-item-id WI-174
 // @work-item-id WI-199
+// @work-item-id WI-207
+// @work-item-id WI-208
 
 import { access, copyFile, lstat, mkdir, readFile, readlink, rm, rmdir, writeFile } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
@@ -12,7 +14,7 @@ import type { HashCalculatorPort } from "../ports/hash-calculator-port.js";
 import type { ManifestRepositoryPort } from "../ports/manifest-repository-port.js";
 
 type UninstallAction = "missing-manifest" | "delete" | "unlink" | "reverse-merge" | "skip" | "refuse";
-type StrategyType = "created" | "json" | "shell" | "package-json" | "markdown-managed" | "symlink" | "yaml-add" | "unknown";
+type StrategyType = "created" | "json" | "shell" | "package-json" | "markdown-managed" | "symlink" | "yaml-add" | "text-managed" | "unknown";
 
 export interface UninstallPlanItem {
   readonly path: string;
@@ -47,6 +49,8 @@ const SHELL_BEGIN = "# === phasegate managed (BEGIN) ===";
 const SHELL_END = "# === phasegate managed (END) ===";
 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 PHASEGATE_SCRIPT_PREFIX = "phasegate:";
 const PROTECTED_UNINSTALL_PATHS = new Set(["package.json", "package-lock.json"]);
 
@@ -119,6 +123,11 @@ export function reverseManagedMarkdown(currentContent: string): string {
   return currentContent.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").replace(/\s*$/, "\n").replace(/^\n/, "");
 }
 
+export function reverseTextManaged(currentContent: string): string {
+  const pattern = new RegExp(`\\n?${escapeRegExp(TEXT_BEGIN)}[\\s\\S]*?${escapeRegExp(TEXT_END)}\\n?`);
+  return currentContent.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").replace(/\s*$/, "\n").replace(/^\n/, "");
+}
+
 export function reversePackageJsonMerge(currentContent: string): string {
   const parsed = JSON.parse(currentContent) as unknown;
   const result = isRecord(parsed) ? { ...parsed } : {};
@@ -155,6 +164,7 @@ export class RunUninstallUseCase {
         repairMode: "manual",
         strategy: "unknown",
         changed: false,
+        protected: false,
         summary: "manifest missing; run phasegate doctor and clean up manually",
         diff: "manual cleanup required",
         skillHint: SKILL_HINT,
@@ -208,8 +218,12 @@ export class RunUninstallUseCase {
     readonly apply: () => Promise<void>;
   }> {
     const absolutePath = this.resolveProjectPath(input.projectRoot, entry.path);
-    const currentContent = await readTextOrNull(absolutePath);
     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);
+    }
+    const currentContent = await readTextOrNull(absolutePath);
     if (currentContent === null && strategy !== "symlink") {
       return {
         item: this.item(entry.path, "skip", "mechanical", strategy, false, `${entry.path}: already absent`, "no changes", null),
@@ -218,7 +232,6 @@ export class RunUninstallUseCase {
       };
     }
 
-    if (entry.mode === "symlink") return this.planSymlink(input.projectRoot, entry);
     if (entry.mode === "created") return this.planCreated(input.projectRoot, entry, currentContent ?? "");
     return this.planMerged(input, entry, currentContent ?? "", strategy);
   }
@@ -232,9 +245,9 @@ export class RunUninstallUseCase {
     } catch {
       target = null;
     }
-    if (target === "../skills") {
+    if (target !== null && this.hashCalculator.compute(target).equals(entry.hash)) {
       return {
-        item: this.item(entry.path, "unlink", "mechanical", "symlink", true, `${entry.path}: remove symlink`, "- symlink ../skills", null),
+        item: this.item(entry.path, "unlink", "mechanical", "symlink", true, `${entry.path}: remove symlink`, `- symlink ${target}`, null),
         needsBackup: false,
         apply: async () => {
           await rm(absolutePath, { force: true });
@@ -248,6 +261,35 @@ export class RunUninstallUseCase {
     };
   }
 
+  private async isDirectory(path: string): Promise<boolean> {
+    try {
+      const stat = await lstat(path);
+      return stat.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  private async planCreatedDirectory(projectRoot: string, entry: DeploymentEntry) {
+    const absolutePath = this.resolveProjectPath(projectRoot, entry.path);
+    return {
+      item: this.item(
+        entry.path,
+        "delete",
+        "mechanical",
+        "created",
+        true,
+        `${entry.path}: delete created directory`,
+        "- directory",
+        null,
+      ),
+      needsBackup: false,
+      apply: async () => {
+        await rm(absolutePath, { recursive: true, force: true });
+      },
+    };
+  }
+
   private async planCreated(projectRoot: string, entry: DeploymentEntry, currentContent: string) {
     const absolutePath = this.resolveProjectPath(projectRoot, entry.path);
     const currentHash = this.hashCalculator.compute(currentContent);
@@ -312,6 +354,7 @@ export class RunUninstallUseCase {
   private async reverseMerged(harnessRoot: string, path: string, currentContent: string, strategy: StrategyType): Promise<string> {
     if (strategy === "shell") return currentContent.includes(SHELL_BEGIN) ? reverseShellMerge(currentContent) : currentContent;
     if (strategy === "markdown-managed") return currentContent.includes(MARKDOWN_BEGIN) ? reverseManagedMarkdown(currentContent) : currentContent;
+    if (strategy === "text-managed") return currentContent.includes(TEXT_BEGIN) ? reverseTextManaged(currentContent) : currentContent;
     if (strategy === "package-json") return reversePackageJsonMerge(currentContent);
     if (strategy === "json") return reverseJsonMerge(currentContent, await readFile(join(harnessRoot, this.templateFor(path)), "utf8"));
     throw new Error(`Unsupported merged strategy: ${strategy}`);
@@ -322,6 +365,7 @@ export class RunUninstallUseCase {
     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 === ".git/info/exclude") return "text-managed";
     if (path.endsWith(".json")) return "json";
     if (path.startsWith(".husky/")) return "shell";
     return "unknown";

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

@@ -2,6 +2,7 @@
 // @layer presentation
 // @work-item-id WI-145
 // @work-item-id WI-178
+// @work-item-id WI-208
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
@@ -37,6 +38,7 @@ export class DoctorHandler {
     const formatInput = {
       report: result.report,
       agent: result.agent,
+      installationMode: result.installationMode,
       scopedOutFindings: result.scopedOutFindings,
       phasegateVersion: input.phasegateVersion,
       projectRoot: input.projectRoot,

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

@@ -2,6 +2,7 @@
 // @layer presentation
 // @work-item-id WI-146
 // @work-item-id WI-175
+// @work-item-id WI-207
 
 import type { RunInstallUseCase } from "../../application/usecases/run-install.js";
 
@@ -20,6 +21,7 @@ export interface InstallHandlerInput {
   readonly skillSet?: "core" | "all";
   readonly workflow?: "standard" | "strict";
   readonly agent?: "claude" | "codex" | "both";
+  readonly personal?: boolean;
 }
 
 export interface InstallHandlerResult {
@@ -39,7 +41,7 @@ export class InstallHandler {
       };
     }
     const lines = [
-      input.apply ? "phasegate install apply" : "phasegate install dry-run",
+      input.apply ? `phasegate install${input.personal ? " --personal" : ""} apply` : `phasegate install${input.personal ? " --personal" : ""} 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}`;

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

@@ -4,6 +4,7 @@
 // @work-item-id WI-178
 // @work-item-id WI-179
 // @work-item-id WI-180
+// @work-item-id WI-208
 
 import type { DoctorAgentScope, ScopedOutDiagnosticFinding } from "../../application/usecases/run-doctor-diagnostics.js";
 import type { DiagnosticReport } from "../../domain/diagnostic-report.js";
@@ -11,6 +12,7 @@ import type { DiagnosticReport } from "../../domain/diagnostic-report.js";
 export interface DiagnosticReportFormatterInput {
   readonly report: DiagnosticReport;
   readonly agent: DoctorAgentScope;
+  readonly installationMode: "project" | "personal";
   readonly scopedOutFindings: readonly ScopedOutDiagnosticFinding[];
   readonly phasegateVersion: string;
   readonly projectRoot: string;
@@ -26,7 +28,8 @@ export class DiagnosticReportFormatter {
         projectRoot: input.projectRoot,
         scope: {
           agent: input.agent,
-          description: scopeDescription(input.agent),
+          installationMode: input.installationMode,
+          description: scopeDescription(input.agent, input.installationMode),
         },
         overallStatus: input.report.overallStatus,
         findings: input.report.findings.map((finding) => ({
@@ -60,7 +63,7 @@ export class DiagnosticReportFormatter {
     const lines = [
       `phasegate doctor v${input.phasegateVersion}`,
       `Project: ${input.projectRoot}`,
-      `Scope: ${input.agent} (${scopeDescription(input.agent)})`,
+      `Scope: ${input.agent} / ${input.installationMode} (${scopeDescription(input.agent, input.installationMode)})`,
       "",
     ];
     for (const finding of input.report.findings) {
@@ -86,7 +89,12 @@ export class DiagnosticReportFormatter {
   }
 }
 
-function scopeDescription(agent: DoctorAgentScope): string {
+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.";
+    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.";
   if (agent === "codex") return "Codex and shared setup targets; Claude-only findings are not applicable.";
   return "Full setup diagnostics for Claude, Codex, and shared targets.";

package/scripts/harness/main.ts

@@ -171,7 +171,7 @@ Setup:
   scaffold-wi <unit|_cross> <story|issue|chore>
                                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)
+  install                      Install phasegate managed files (--dry-run|--apply, --force, --personal, --agent <claude|codex|both>)
   uninstall                    Uninstall phasegate managed files (--dry-run|--apply, --force)
   reconcile                    Reconcile phasegate managed files (--dry-run|--apply, --force)
   setup:agent                  Diagnose repo setup and produce/apply an agent-readable setup plan
@@ -625,6 +625,8 @@ Options:
   --workflow <standard|strict>    Rendered agent context workflow mode (default: standard)
   --with-husky                    Include Husky hook targets
   --with-ci                       Include GitHub Actions target
+  --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
   --help, -h                      Show this help`,
   "setup:agent": `Usage: phasegate setup:agent [options]
@@ -2045,7 +2047,7 @@ async function main(): Promise<void> {
       }
 
       case "install": {
-        const KNOWN_INSTALL_FLAGS = ["--dry-run", "--apply", "--force", "--json", "--agent", "--skills", "--workflow", "--with-husky", "--with-ci"];
+        const KNOWN_INSTALL_FLAGS = ["--dry-run", "--apply", "--force", "--json", "--agent", "--skills", "--workflow", "--with-husky", "--with-ci", "--personal"];
         const flagError = validateKnownFlags(args, KNOWN_INSTALL_FLAGS);
         if (flagError) {
           console.error(flagError);
@@ -2066,6 +2068,7 @@ async function main(): Promise<void> {
         }
         const includeClaude = agent === "claude" || agent === "both";
         const includeCodex = agent === "codex" || agent === "both";
+        const personal = hasFlag(args, "--personal");
         const mod = createInstallationModule();
         const phasegateVersion = await getHarnessVersion(harnessRoot);
         const result = await mod.installHandler.execute({
@@ -2077,11 +2080,12 @@ async function main(): Promise<void> {
           force: hasFlag(args, "--force"),
           includeClaude,
           includeCodex,
-          includeHusky: true,
-          includeCi: true,
+          includeHusky: personal ? false : true,
+          includeCi: personal ? false : true,
           skillSet: skillSetRaw,
           workflow: parseWorkflowMode(workflowRaw),
           agent,
+          personal,
           json,
         });
         console.log(result.stdout);

package/skills/README.md

@@ -16,6 +16,8 @@
 
 `.agent/skills` は旧 setup 由来の互換パスです。新規導入では管理対象にしません。<!-- @work-item-id WI-157 -->
 
+`phasegate install --personal` はチーム所有リポジトリでの個人評価用です。このモードでは `.claude/skills` / `.codex/skills` のリンクを作成せず、`.phasegate-local/config.json` と `.git/info/exclude` の local-only managed block だけを扱います。通常の共有導入が必要になった時点で `phasegate install --dry-run` / `phasegate install --apply` を使います。<!-- @work-item-id WI-207 -->
+
 ## 新しいスキルの追加
 
 新しいスキルを追加する場合は、この `skills` ディレクトリに直接追加してください。あわせて `docs/guide/skills-overview.md`、README の skill 数、必要なら `skills/phasegate-toolkit-guide/SKILL.md` の参照先を更新します。シンボリックリンクを通じて、対応エージェントから利用可能になります。<!-- @work-item-id WI-154 -->

package/skills/phasegate-config-doctor/SKILL.md

@@ -35,6 +35,8 @@ phasegate を導入した直後の config は単純な default で、実プロ
 | hook config | `.claude/scripts/hook-config.json` | 既存 hook 設定確認 |
 | doctor report | 明示された report path、またはユーザーが指定した `.phasegate/last-doctor-report.json` | `repairMode` / `repairHint` / `suggestedSkill` の確認 |
 | manifest | `.phasegate/manifest.json` | install / reconcile / uninstall の managed target と hash 状態確認 |
+| personal config | `.phasegate-local/phasegate.config.json` | `install --personal` の local-only 設定確認 |
+| git local exclude | `.git/info/exclude` | `install --personal` の repository-local ignore block 確認 |
 | Claude hooks | `.claude/settings.json` | managed hook JSON と user customization の確認 |
 | Codex hooks | `.codex/hooks.json` | managed hook JSON と Codex hook 配線確認 |
 | Husky scripts | `.husky/pre-commit`, `.husky/commit-msg`, `.husky/pre-push` | pre-commit backstop と bypass audit の確認 |
@@ -127,6 +129,7 @@ product-architect で Unit を作り、いくつかの logical_design を書い
 #### 観点 9: setup lifecycle と doctor finding
 
 - `phasegate doctor --json` の finding に `repairMode: "ai-assisted"` と `suggestedSkill.skillName = "phasegate-config-doctor"` がある → 本 skill が merge 方針、保持する user content、実行すべき `install --apply` / `--force` / `reconcile --apply` を提案する
+- チーム所有リポジトリで個人評価だけを行う相談では、通常の `install --apply` ではなく `phasegate install --personal --agent claude --dry-run` を先に提案する。personal install は `package.json`, `AGENTS.md`, `CLAUDE.md`, `.husky/*`, `.github/workflows/*`, `.gitignore`, GitHub CLI config, repo secrets, CI settings, `.codex/hooks.json` を変更対象にしない。Claude Code向けには `.phasegate-local/phasegate.config.json`, `.phasegate-local/claude/settings.json`, `.phasegate-local/skills/`, ignored root `.claude/settings.json` / `.claude/skills` shim, `.phasegate/manifest.json`, `.git/info/exclude` の managed block を自動作成する。既存 `.claude/*` がある場合は上書きせず manual review として扱う。Codex user-level hook setup は manual action として扱う。<!-- @work-item-id WI-207 --> <!-- @work-item-id WI-208 -->
 - Claude-only / Codex-only 導入後は `phasegate doctor --agent claude --json` または `phasegate doctor --agent codex --json` を使って selected agent の readiness を読む。`scopedOutFindings` は未選択 agent の `not-applicable` 情報なので、ユーザーがその agent を導入したいと言っていない限り repair 提案にしない。`repairHint: null` / `suggestedSkill: null` は意図的な抑制で、`currentScopeRepairTarget: false` と `repairModeApplicability: "only-if-agent-selected"` は raw `repairMode` が current scope の修復指示ではないという印である。<!-- @work-item-id WI-178, WI-179, WI-180 -->
 - `repairHint` がある mechanical finding → 原則として hint のコマンドを優先し、実行前に対象ファイルと manifest の差分を確認
 - manifest parse error → `.phasegate/manifest.json` を手で修復する前に backup / uninstall / reinstall の選択肢を提示

package/skills/phasegate-toolkit-guide/SKILL.md

@@ -130,6 +130,8 @@ docs/guide/                          # phasegate リポジトリ自体 (dogfood)
 - 既存プロジェクト導入: `docs/guide/retrofit-adoption.md`
 - setup artifact / doctor finding / legacy artifact: `docs/guide/setup-artifacts.md`
 
+チーム所有リポジトリで個人評価だけを行いたい場合は、`docs/guide/installation.md` の personal install セクションを読む。`phasegate install --personal --agent claude` は `package.json`、`AGENTS.md`、`CLAUDE.md`、`.husky/*`、`.github/workflows/*`、`.gitignore`、GitHub CLI config、repo secrets、CI settings、`.codex/hooks.json` を変更せず、`.phasegate-local/phasegate.config.json`、`.phasegate-local/claude/settings.json`、`.phasegate-local/skills/`、ignored root `.claude/settings.json` / `.claude/skills` shim、`.git/info/exclude` の managed block を使う。Codex user-level hook setup は manual action として説明する。<!-- @work-item-id WI-207 --> <!-- @work-item-id WI-208 -->
+
 `setup-artifacts.md` は managed target / generated artifact / runtime state / legacy artifact / user-level setting の分類を持つ。`doctor --report-out` は明示 path への出力で、`.phasegate/last-doctor-report.json` は固定生成物ではない点もここを参照する。<!-- @work-item-id WI-153 -->
 
 Claude-only / Codex-only setup の確認では、full `phasegate doctor` と scoped doctor を区別する。ユーザーが `setup:agent --agent claude` を選んだ場合は `phasegate doctor --agent claude --json` を優先し、`scopedOutFindings` の Codex finding は「未選択 agent の not-applicable 情報」であり修復対象ではないと説明する。`repairHint: null` / `suggestedSkill: null` は意図的な抑制で、`currentScopeRepairTarget: false` と `repairModeApplicability: "only-if-agent-selected"` は `repairMode` が current scope の修復指示ではないという印である。full doctor は両 agent を導入したい場合の診断として扱う。<!-- @work-item-id WI-178, WI-179, WI-180 -->