phasegate 0.340.0 → 0.341.0

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

@@ -86,7 +86,7 @@ export interface RunInstallInput {
   readonly includeCodex?: boolean;
   readonly includeHusky?: boolean;
   readonly includeCi?: boolean;
-  readonly skillSet?: "core" | "all";
+  readonly skillSet?: SkillSet;
   readonly workflow?: "standard" | "strict";
   readonly agent?: AgentTarget;
   readonly personal?: boolean;
@@ -368,7 +368,7 @@ function renderAgentContextTemplate(
   template: string,
   options: {
     readonly agent: AgentTarget;
-    readonly skillSet: "core" | "all";
+    readonly skillSet: SkillSet;
     readonly workflow: "standard" | "strict";
     readonly includeHusky: boolean;
     readonly includeCi: boolean;
@@ -388,7 +388,7 @@ function renderAgentContextTemplate(
     .replaceAll("{{PHASEGATE_HUSKY_STATE}}", options.includeHusky ? "managed" : "not managed by this setup run")
     .replaceAll("{{PHASEGATE_CI_STATE}}", options.includeCi ? "managed" : "not managed by this setup run")
     .replaceAll("{{PHASEGATE_COMMANDS}}", commands)
-    .replaceAll("{{PHASEGATE_SKILLS}}", options.skillSet === "core" ? "- `core skills`" : "- `all bundled skills`")
+    .replaceAll("{{PHASEGATE_SKILLS}}", options.skillSet === "all" ? "- `all bundled skills`" : `- \`${options.skillSet} skills\``)
     .replaceAll("{{PHASEGATE_PRESETS}}", "- `minimal`\n- `standard`\n- `full`\n- `custom`")
     .replaceAll("{{PHASEGATE_USER_SECTION}}", USER_SECTION_PLACEHOLDER);
 }
@@ -1146,13 +1146,13 @@ export class RunInstallUseCase {
   private personalSkillsVersionHashInput(
     path: string,
     version: string,
-    skillSet: "core" | "all",
+    skillSet: SkillSet,
     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 {
+  private personalSkillHashInput(path: string, skill: string, version: string, skillSet: SkillSet): string {
     return `personal-skill:${path}:${skill}:${version}:${skillSet}`;
   }
 

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

@@ -12,6 +12,7 @@
 // @work-item-id WI-331
 // @work-item-id WI-385
 // @work-item-id WI-387
+// @work-item-id WI-220
 
 import {
   access,
@@ -31,7 +32,7 @@ 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";
@@ -327,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",
@@ -339,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);
 }
@@ -407,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>;
     }> = [];
 
@@ -431,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 (
@@ -460,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);
       }
@@ -485,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);
@@ -500,16 +519,17 @@ 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 (
@@ -518,18 +538,19 @@ export class RunReconcileUseCase {
             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),
               ),
             );
           }
@@ -553,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);
@@ -567,7 +588,8 @@ 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" &&
@@ -576,6 +598,15 @@ export class RunReconcileUseCase {
         ? 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(
@@ -584,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");
@@ -598,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

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

@@ -13,6 +13,7 @@ import {
 } from "../../application/operator-notice.js";
 import type { RunInstallUseCase } from "../../application/usecases/run-install.js";
 import type { AgentTarget } from "../../domain/agent-target.js";
+import type { SkillSet } from "../../application/bundled-skill-selection.js";
 
 export interface InstallHandlerInput {
   readonly projectRoot: string;
@@ -26,7 +27,7 @@ export interface InstallHandlerInput {
   readonly includeCodex?: boolean;
   readonly includeHusky?: boolean;
   readonly includeCi?: boolean;
-  readonly skillSet?: "core" | "all";
+  readonly skillSet?: SkillSet;
   readonly workflow?: "standard" | "strict";
   readonly agent?: AgentTarget;
   readonly personal?: boolean;