phasegate 0.335.0 → 0.341.0

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

@@ -10,6 +10,9 @@
 // @work-item-id WI-315
 // @work-item-id WI-326
 // @work-item-id WI-331
+// @work-item-id WI-385
+// @work-item-id WI-387
+// @work-item-id WI-220
 
 import {
   access,
@@ -29,7 +32,8 @@ 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 { getBundledSkillsForSet, resolveInstalledSkillSet, type SkillSet } from "../bundled-skill-selection.js";
+import { mergeNamedHookJson } from "../named-hook-json.js";
 import type { HashCalculatorPort } from "../ports/hash-calculator-port.js";
 import type { ManifestRepositoryPort } from "../ports/manifest-repository-port.js";
 import type { ModelDelegationPort } from "../ports/model-delegation-port.js";
@@ -37,10 +41,12 @@ import type { ModelDelegationPort } from "../ports/model-delegation-port.js";
 type ReconcileAction = "missing-manifest" | "update" | "add" | "link" | "skip" | "refuse" | "prune";
 type StrategyType =
   | "json"
+  | "json-named"
   | "shell"
   | "yaml-add"
   | "package-json"
   | "markdown-managed"
+  | "copy"
   | "copy-dir"
   | "symlink"
   | "unknown";
@@ -96,7 +102,7 @@ const USER_SECTION_END = "<!-- phasegate:user-section:end -->";
 const USER_SECTION_PLACEHOLDER = "Project-specific agent instructions go here.";
 const SHARED_SKILLS_VERSION_PATH = "skills/.harness-version";
 const HARNESS_VERSION_BASENAME = ".harness-version";
-const SKILL_ROOT_PREFIXES = ["skills", ".claude/skills", ".codex/skills"] as const;
+const SKILL_ROOT_PREFIXES = ["skills", ".claude/skills", ".codex/skills", ".agents/skills"] as const;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -322,7 +328,7 @@ function reconcileManagedMarkdown(existing: string | null, incoming: string): st
   return next.replace(/\s*$/, "\n");
 }
 
-function renderAgentContextTemplate(template: string): string {
+function renderAgentContextTemplate(template: string, skillSet: SkillSet): string {
   const commands = [
     "phasegate doctor",
     "phasegate phasegate:check-ready",
@@ -334,12 +340,12 @@ function renderAgentContextTemplate(template: string): string {
     .join("\n");
   return template
     .replaceAll("{{PHASEGATE_AGENT}}", "both")
-    .replaceAll("{{PHASEGATE_SKILLS_MODE}}", "all")
+    .replaceAll("{{PHASEGATE_SKILLS_MODE}}", skillSet)
     .replaceAll("{{PHASEGATE_WORKFLOW}}", "standard")
     .replaceAll("{{PHASEGATE_HUSKY_STATE}}", "managed")
     .replaceAll("{{PHASEGATE_CI_STATE}}", "managed")
     .replaceAll("{{PHASEGATE_COMMANDS}}", commands)
-    .replaceAll("{{PHASEGATE_SKILLS}}", "- `all bundled skills`")
+    .replaceAll("{{PHASEGATE_SKILLS}}", skillSet === "all" ? "- `all bundled skills`" : `- \`${skillSet} skills\``)
     .replaceAll("{{PHASEGATE_PRESETS}}", "- `minimal`\n- `standard`\n- `full`\n- `custom`")
     .replaceAll("{{PHASEGATE_USER_SECTION}}", USER_SECTION_PLACEHOLDER);
 }
@@ -387,7 +393,9 @@ export class RunReconcileUseCase {
 
     const includeHusky = input.includeHusky ?? manifest.installationFlags?.includeHusky ?? true;
     const includeCi = input.includeCi ?? manifest.installationFlags?.includeCi ?? true;
-    const targets = this.createTargets({ includeHusky, includeCi });
+    const includeAntigravity = manifest.findEntry(".agents/hooks.json") !== null;
+    const includeClaudeScripts = manifest.findEntry(".claude/settings.json") !== null;
+    const targets = this.createTargets({ includeHusky, includeCi, includeAntigravity, includeClaudeScripts });
     const targetsByPath = new Map(targets.map((target) => [target.path, target]));
     let nextManifest = DeploymentManifest.reconstitute({
       version: input.phasegateVersion,
@@ -400,11 +408,13 @@ export class RunReconcileUseCase {
     const changed: ReconcilePlanItem[] = [];
     const backupStamp = `reconcile-${new Date().toISOString().replace(/[:.]/g, "-")}`;
     let backupDir: string | null = null;
+    let repairedMetadata = false;
 
     const outcomes: Array<{
       readonly item: ReconcilePlanItem;
       readonly needsBackup: boolean;
       readonly prune?: boolean;
+      readonly recoveredContent?: string;
       readonly apply: () => Promise<string | null>;
     }> = [];
 
@@ -424,7 +434,7 @@ export class RunReconcileUseCase {
         plan.push(item);
         continue;
       }
-      const outcome = await this.planManagedEntry(input, entry, target);
+      const outcome = await this.planManagedEntry(input, entry, target, manifest.version);
       outcomes.push(outcome);
       plan.push(outcome.item);
       if (
@@ -453,16 +463,22 @@ export class RunReconcileUseCase {
     }
 
     const personalInstall = this.isPersonalManifest(manifest);
+    const skillSets = new Map<string, SkillSet>();
+    for (const root of personalInstall ? this.personalSkillPaths(manifest) : ["skills"]) {
+      skillSets.set(root, resolveInstalledSkillSet(await readTextOrNull(join(input.projectRoot, root, HARNESS_VERSION_BASENAME))));
+    }
     if (!personalInstall && this.manifestIntendsSharedSkills(manifest)) {
-      const sharedSkills = await listSelectedBundledSkills(input.harnessRoot, "all");
-      const outcome = await this.planSharedSkills(input, manifest, sharedSkills, "all");
+      const skillSet = skillSets.get("skills") ?? "all";
+      const sharedSkills = await listSelectedBundledSkills(input.harnessRoot, skillSet);
+      const outcome = await this.planSharedSkills(input, manifest, sharedSkills, skillSet);
       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");
+        const skillSet = skillSets.get(skillPath) ?? "all";
+        const personalSkills = await listSelectedBundledSkills(input.harnessRoot, skillSet);
+        const outcome = await this.planPersonalSkills(input, manifest, skillPath, personalSkills, skillSet);
         outcomes.push(outcome);
         plan.push(outcome.item);
       }
@@ -478,7 +494,17 @@ export class RunReconcileUseCase {
     }
 
     for (const outcome of outcomes) {
-      if (!outcome.item.changed) continue;
+      if (!outcome.item.changed) {
+        const previous = nextManifest.findEntry(outcome.item.path);
+        if (previous !== null && outcome.recoveredContent !== undefined) {
+          nextManifest = nextManifest.addEntry(DeploymentEntry.create({
+            ...previous,
+            hash: this.hashCalculator.compute(outcome.recoveredContent),
+          }));
+          repairedMetadata = true;
+        }
+        continue;
+      }
       if (outcome.prune === true) {
         await outcome.apply();
         nextManifest = nextManifest.removeEntry(outcome.item.path);
@@ -493,34 +519,38 @@ export class RunReconcileUseCase {
       changed.push(outcome.item);
       if (hashContent !== null) {
         if (outcome.item.strategy === "copy-dir" && outcome.item.path === "skills") {
-          const sharedSkills = await listSelectedBundledSkills(input.harnessRoot, "all");
+          const skillSet = skillSets.get("skills") ?? "all";
+          const sharedSkills = await listSelectedBundledSkills(input.harnessRoot, skillSet);
           nextManifest = nextManifest.addEntry(
             this.createdEntry(
               SHARED_SKILLS_VERSION_PATH,
-              this.sharedSkillsVersionHashInput(input.phasegateVersion, "all", sharedSkills),
+              this.sharedSkillsVersionHashInput(input.phasegateVersion, skillSet, sharedSkills),
             ),
           );
           for (const skill of sharedSkills) {
             nextManifest = nextManifest.addEntry(
-              this.createdEntry(`skills/${skill}`, this.sharedSkillHashInput(skill, input.phasegateVersion, "all")),
+              this.createdEntry(`skills/${skill}`, this.sharedSkillHashInput(skill, input.phasegateVersion, skillSet)),
             );
           }
         } else if (
           outcome.item.strategy === "copy-dir" &&
-          (outcome.item.path === ".claude/skills" || outcome.item.path === ".codex/skills")
+          (outcome.item.path === ".claude/skills" ||
+            outcome.item.path === ".codex/skills" ||
+            outcome.item.path === ".agents/skills")
         ) {
-          const personalSkills = await listSelectedBundledSkills(input.harnessRoot, "all");
+          const skillSet = skillSets.get(outcome.item.path) ?? "all";
+          const personalSkills = await listSelectedBundledSkills(input.harnessRoot, skillSet);
           nextManifest = nextManifest.addEntry(
             this.createdEntry(
               `${outcome.item.path}/.harness-version`,
-              this.personalSkillsVersionHashInput(outcome.item.path, input.phasegateVersion, "all", personalSkills),
+              this.personalSkillsVersionHashInput(outcome.item.path, input.phasegateVersion, skillSet, personalSkills),
             ),
           );
           for (const skill of personalSkills) {
             nextManifest = nextManifest.addEntry(
               this.createdEntry(
                 `${outcome.item.path}/${skill}`,
-                this.personalSkillHashInput(outcome.item.path, skill, input.phasegateVersion, "all"),
+                this.personalSkillHashInput(outcome.item.path, skill, input.phasegateVersion, skillSet),
               ),
             );
           }
@@ -544,13 +574,13 @@ export class RunReconcileUseCase {
       }
     }
 
-    if (changed.length > 0 || manifest.version !== input.phasegateVersion) {
+    if (changed.length > 0 || repairedMetadata || manifest.version !== input.phasegateVersion) {
       await this.manifestRepository.save(input.projectRoot, nextManifest);
     }
     return { plan, refused, changed, backupDir };
   }
 
-  private async planManagedEntry(input: RunReconcileInput, entry: DeploymentEntry, target: ReconcileTarget) {
+  private async planManagedEntry(input: RunReconcileInput, entry: DeploymentEntry, target: ReconcileTarget, previousVersion: string) {
     if (target.strategy === "symlink") return this.planSymlink(input.projectRoot, target.path);
     const absolutePath = this.resolveProjectPath(input.projectRoot, entry.path);
     const before = await readTextOrNull(absolutePath);
@@ -558,12 +588,25 @@ export class RunReconcileUseCase {
     const currentHash = this.hashCalculator.compute(before);
     const matchesManifest = currentHash.equals(entry.hash);
     const rawTemplate = target.templatePath ? await readFile(join(input.harnessRoot, target.templatePath), "utf8") : "";
-    const template = target.strategy === "markdown-managed" ? renderAgentContextTemplate(rawTemplate) : rawTemplate;
+    const template = target.strategy === "markdown-managed"
+      ? renderAgentContextTemplate(rawTemplate, await this.contextSkillSet(input.projectRoot, target.path)) : rawTemplate;
     const next =
-      entry.mode === "created" && target.strategy !== "package-json" && target.strategy !== "markdown-managed"
+      entry.mode === "created" &&
+      target.strategy !== "package-json" &&
+      target.strategy !== "markdown-managed" &&
+      target.strategy !== "json-named"
         ? template
         : this.reconcileContent(target, before, template, input.phasegateVersion);
     const changed = before !== next;
+    // A no-op merge alone cannot attest user-edited content. Recover only a
+    // complete canonical output, or a package version-only change whose prior
+    // bytes can be reconstructed and matched against the recorded hash.
+    const recoveredContent = !changed && !matchesManifest && (
+      target.strategy === "package-json"
+        ? this.hashCalculator.compute(this.reconcileContent(target, before, template, previousVersion)).equals(entry.hash)
+        : before === (entry.mode === "created" && target.strategy !== "markdown-managed" && target.strategy !== "json-named"
+          ? template : this.reconcileContent(target, null, template, input.phasegateVersion))
+    ) ? before : undefined;
     const repairMode: RepairMode = matchesManifest ? "mechanical" : "ai-assisted";
     return {
       item: this.item(
@@ -572,11 +615,13 @@ export class RunReconcileUseCase {
         repairMode,
         target.strategy,
         changed,
-        changed ? `${entry.path}: update managed portion` : `${entry.path}: already up to date`,
+        changed ? `${entry.path}: update managed portion` : recoveredContent !== undefined
+          ? `${entry.path}: content already current; recover interrupted manifest hash` : `${entry.path}: already up to date`,
         this.diffSummary(before, next),
         repairMode === "ai-assisted" ? SKILL_HINT : null,
       ),
       needsBackup: !matchesManifest || input.force,
+      recoveredContent,
       apply: async () => {
         await mkdir(dirname(absolutePath), { recursive: true });
         await writeFile(absolutePath, next, "utf8");
@@ -586,12 +631,20 @@ export class RunReconcileUseCase {
     };
   }
 
+  private async contextSkillSet(projectRoot: string, contextPath: string): Promise<SkillSet> {
+    const agentRoot = contextPath.includes("CLAUDE") ? ".claude/skills" : ".codex/skills";
+    const metadata = await readTextOrNull(join(projectRoot, agentRoot, HARNESS_VERSION_BASENAME))
+      ?? await readTextOrNull(join(projectRoot, SHARED_SKILLS_VERSION_PATH));
+    return resolveInstalledSkillSet(metadata);
+  }
+
   private async planMissingTarget(input: RunReconcileInput, target: ReconcileTarget) {
     if (target.strategy === "symlink") return this.planSymlink(input.projectRoot, target.path);
     const absolutePath = this.resolveProjectPath(input.projectRoot, target.path);
     const before = await readTextOrNull(absolutePath);
     const rawTemplate = target.templatePath ? await readFile(join(input.harnessRoot, target.templatePath), "utf8") : "";
-    const template = target.strategy === "markdown-managed" ? renderAgentContextTemplate(rawTemplate) : rawTemplate;
+    const template = target.strategy === "markdown-managed"
+      ? renderAgentContextTemplate(rawTemplate, await this.contextSkillSet(input.projectRoot, target.path)) : rawTemplate;
     const next =
       before === null && target.strategy !== "package-json"
         ? template
@@ -681,6 +734,7 @@ export class RunReconcileUseCase {
     return (
       manifest.findEntry(".claude/skills") !== null ||
       manifest.findEntry(".codex/skills") !== null ||
+      manifest.findEntry(".agents/skills") !== null ||
       manifest.entries.some((entry) => entry.path.startsWith("skills/"))
     );
   }
@@ -692,16 +746,23 @@ export class RunReconcileUseCase {
     return (
       manifest.findEntry(".phasegate-local/phasegate.config.json") !== null ||
       manifest.entries.some(
-        (entry) => (entry.path === ".claude/skills" || entry.path === ".codex/skills") && entry.mode === "created",
+        (entry) =>
+          (entry.path === ".claude/skills" || entry.path === ".codex/skills" || entry.path === ".agents/skills") &&
+          entry.mode === "created",
       ) ||
       manifest.entries.some(
-        (entry) => entry.path.startsWith(".claude/skills/") || entry.path.startsWith(".codex/skills/"),
+        (entry) =>
+          entry.path.startsWith(".claude/skills/") ||
+          entry.path.startsWith(".codex/skills/") ||
+          entry.path.startsWith(".agents/skills/"),
       )
     );
   }
 
-  private personalSkillPaths(manifest: DeploymentManifest): Array<".claude/skills" | ".codex/skills"> {
-    const paths = new Set<".claude/skills" | ".codex/skills">();
+  private personalSkillPaths(
+    manifest: DeploymentManifest,
+  ): Array<".claude/skills" | ".codex/skills" | ".agents/skills"> {
+    const paths = new Set<".claude/skills" | ".codex/skills" | ".agents/skills">();
     if (
       manifest.findEntry(".claude/skills") !== null ||
       manifest.entries.some((entry) => entry.path.startsWith(".claude/skills/"))
@@ -712,6 +773,11 @@ export class RunReconcileUseCase {
       manifest.entries.some((entry) => entry.path.startsWith(".codex/skills/"))
     )
       paths.add(".codex/skills");
+    if (
+      manifest.findEntry(".agents/skills") !== null ||
+      manifest.entries.some((entry) => entry.path.startsWith(".agents/skills/"))
+    )
+      paths.add(".agents/skills");
     return [...paths].sort();
   }
 
@@ -783,7 +849,7 @@ export class RunReconcileUseCase {
   private async planPersonalSkills(
     input: RunReconcileInput,
     manifest: DeploymentManifest,
-    relativePath: ".claude/skills" | ".codex/skills",
+    relativePath: ".claude/skills" | ".codex/skills" | ".agents/skills",
     skills: readonly string[],
     skillSet: SkillSet,
   ) {
@@ -936,21 +1002,61 @@ export class RunReconcileUseCase {
     if (target.strategy === "yaml-add") return template;
     if (target.strategy === "shell") return reconcileShell(before, template);
     if (target.strategy === "markdown-managed") return reconcileManagedMarkdown(before, template);
+    if (target.strategy === "copy") return before ?? template;
     if (target.strategy === "package-json") {
       const existing = before === null ? {} : (JSON.parse(before) as unknown);
       return `${JSON.stringify(reconcilePackageJson(isRecord(existing) ? existing : {}, version), null, 2)}\n`;
     }
     const existing = before === null ? {} : (JSON.parse(before) as unknown);
     const incoming = JSON.parse(template) as unknown;
+    if (target.strategy === "json-named") {
+      const merged = mergeNamedHookJson(isRecord(existing) ? existing : {}, isRecord(incoming) ? incoming : {});
+      return `${JSON.stringify(merged, null, 2)}\n`;
+    }
     return `${JSON.stringify(reconcileJsonObject(isRecord(existing) ? existing : {}, isRecord(incoming) ? incoming : {}), null, 2)}\n`;
   }
 
   private createTargets(options: {
     readonly includeHusky: boolean;
     readonly includeCi: boolean;
+    readonly includeAntigravity: boolean;
+    readonly includeClaudeScripts: boolean;
   }): readonly ReconcileTarget[] {
     return [
       { path: ".claude/settings.json", strategy: "json", templatePath: "templates/.claude/settings.json" },
+      ...(options.includeClaudeScripts
+        ? ([
+            {
+              path: ".claude/scripts/deny-check.sh",
+              strategy: "shell",
+              templatePath: "templates/.claude/scripts/deny-check.sh",
+              executable: true,
+            },
+            {
+              path: ".claude/scripts/format-settings-hook.sh",
+              strategy: "shell",
+              templatePath: "templates/.claude/scripts/format-settings-hook.sh",
+              executable: true,
+            },
+            {
+              path: ".claude/scripts/format-typescript-hook.sh",
+              strategy: "shell",
+              templatePath: "templates/.claude/scripts/format-typescript-hook.sh",
+              executable: true,
+            },
+            {
+              path: ".claude/scripts/analyze-errors-hook.sh",
+              strategy: "shell",
+              templatePath: "templates/.claude/scripts/analyze-errors-hook.sh",
+              executable: true,
+            },
+            {
+              path: ".claude/scripts/hook-config.json",
+              strategy: "copy",
+              templatePath: "templates/.claude/scripts/hook-config.json",
+            },
+          ] as const satisfies readonly ReconcileTarget[])
+        : []),
       {
         path: "CLAUDE.md",
         strategy: "markdown-managed",
@@ -958,6 +1064,11 @@ export class RunReconcileUseCase {
         block: { start: MARKDOWN_BEGIN, end: MARKDOWN_END, content: "phasegate CLAUDE.md managed section" },
       },
       { path: ".codex/hooks.json", strategy: "json", templatePath: "templates/.codex/hooks.json" },
+      ...(options.includeAntigravity
+        ? ([
+            { path: ".agents/hooks.json", strategy: "json-named", templatePath: "templates/.agents/hooks.json" },
+          ] as const)
+        : []),
       {
         path: "AGENTS.md",
         strategy: "markdown-managed",
@@ -1001,6 +1112,7 @@ export class RunReconcileUseCase {
       { path: "package.json", strategy: "package-json", templatePath: "package.json" },
       { path: ".claude/skills", strategy: "symlink" },
       { path: ".codex/skills", strategy: "symlink" },
+      ...(options.includeAntigravity ? ([{ path: ".agents/skills", strategy: "symlink" }] as const) : []),
     ];
   }
 
@@ -1014,7 +1126,12 @@ export class RunReconcileUseCase {
 
   private managedBlockFor(path: string, strategy: StrategyType): ManagedBlockInput | null {
     if (strategy === "shell") return { start: SHELL_BEGIN, end: SHELL_END, content: `phasegate ${path} managed block` };
-    if (strategy === "json" || strategy === "package-json" || strategy === "markdown-managed") {
+    if (
+      strategy === "json" ||
+      strategy === "json-named" ||
+      strategy === "package-json" ||
+      strategy === "markdown-managed"
+    ) {
       return { start: "phasegate structured merge", end: "phasegate structured merge", content: `${strategy}:${path}` };
     }
     return null;