fix(install): make the catch-all row explicit data, not a coincidence

The generic hint was found with `shim === fallbackRow`, object identity
against the deduped catalog. That held only while uniqueShimTargets kept
the original references AND the catalog declared Agent Skills after Codex.
Making the dedupe return copies, or reordering the two .agents rows, would
have moved the hint onto Codex with no type error. ShimTarget now carries
a `generic` flag and the hint reads it, so the two rows can be reordered
freely. Verified: with the rows swapped the hint stays on Agent Skills.

Also corrects the dedupe comment, which claimed the invariant held for any
future pair of rows sharing a destination. It holds for one-entry-per-
directory; every other field still comes from the last row, so a future
pair disagreeing on `commands` would be resolved by catalog order rather
than by anyone deciding.

uniqueShimTargets is now called once in locationChoices rather than twice.

Reported by review on #208.

Author: theCodeDrift

packages/cli/src/install/install.ts

@@ -140,6 +140,18 @@ export interface ShimTarget {
   label: string;
   /** Whether this directory receives the `tskl` command stub. */
   commands: boolean;
+  /**
+   * Marks the catch-all row: the one offered to anyone whose harness this
+   * catalog does not name. At most one row carries it.
+   *
+   * It is a declared field rather than something derived, because every way
+   * of inferring it is a coincidence. "The last row for the directory" is
+   * declaration order, and "the object `uniqueShimTargets` happened to keep"
+   * is reference identity, so reordering the catalog or making the dedupe
+   * return copies would silently move the hint to a named harness with no
+   * type error anywhere.
+   */
+  generic?: boolean;
 }
 
 /**
@@ -155,7 +167,7 @@ export const SHIM_TARGETS: readonly ShimTarget[] = [
   { dir: ".agents", label: "Codex", commands: false },
   { dir: ".cursor", label: "Cursor", commands: true },
   { dir: ".opencode", label: "OpenCode", commands: false },
-  { dir: ".agents", label: "Agent Skills", commands: false },
+  { dir: ".agents", label: "Agent Skills", commands: false, generic: true },
 ];
 
 /**
@@ -164,8 +176,16 @@ export const SHIM_TARGETS: readonly ShimTarget[] = [
  * Every consumer that turns rows into directories or into install targets
  * goes through here. Without it, a single `.agents/` selection matches both
  * `.agents/` rows and the plan writes, reports, and records that directory
- * twice. Deduping on `dir` (rather than special-casing Codex) keeps the
- * invariant true for any future pair of rows that share a destination.
+ * twice. Deduping on `dir` (rather than special-casing Codex) keeps that
+ * one-entry-per-directory invariant true for any future pair of rows sharing
+ * a destination.
+ *
+ * What it does NOT do is reconcile the rows: the surviving entry is one whole
+ * row, so EVERY field comes from the last row for that directory, not just
+ * `label`. Today both `.agents/` rows agree on `commands`, so nothing is
+ * silently chosen. A future pair that disagreed on it would be resolved by
+ * catalog order rather than by anyone deciding, which is a reason to keep
+ * rows sharing a directory identical apart from `label` and `generic`.
  *
  * The LAST row for a directory wins both its position and its value. The
  * catalog is ordered named-harness first, generic-fallback last, so `.agents/`

packages/cli/src/wizard/steps/locations.ts

@@ -68,17 +68,20 @@ export function locationChoices(
   // `.agents/` row is that a Codex user sees the word "Codex". Rows sharing a
   // directory share a value, so ticking either one selects that directory
   // once, and the picker renders both as checked.
-  const fallbackRow = uniqueShimTargets().find(
-    (shim) => shim.dir === DEFAULT_SHIM_DIR
-  );
+  //
+  // The catch-all row is identified by its own `generic` flag rather than by
+  // object identity against the deduped catalog. That comparison was correct
+  // only while `uniqueShimTargets()` returned the original references AND the
+  // catalog happened to declare "Agent Skills" after "Codex"; either changing
+  // would have moved the hint onto a named harness with nothing to catch it.
   const options = SHIM_TARGETS.map((shim) => ({
     value: shim.dir,
     label: `${shim.label} (${shim.dir}/)`,
     hint: installedDirectories.has(shim.dir)
       ? "installed"
       : detectedDirectories.has(shim.dir)
         ? "detected"
-        : shim === fallbackRow
+        : shim.generic === true
           ? "generic agent skills"
           : "not detected",
   }));

packages/cli/test/wizard-steps.test.ts

@@ -55,6 +55,20 @@ describe("locationChoices", () => {
     expect(labels).toContain("Agent Skills (.agents/)");
   });
 
+  it("puts the generic hint on the catch-all row, not on Codex", async () => {
+    const { locationChoices } = await import("../src/wizard/steps/locations");
+    const byLabel = new Map(
+      locationChoices([]).options.map((o) => [o.label, o.hint])
+    );
+    // Both rows write `.agents/`, so nothing about the DIRECTORY separates
+    // them. The hint has to follow the row's own `generic` flag. Deriving it
+    // from catalog order or from object identity against the deduped catalog
+    // put it on whichever row happened to win, which is Codex the moment the
+    // two rows are reordered.
+    expect(byLabel.get("Agent Skills (.agents/)")).toBe("generic agent skills");
+    expect(byLabel.get("Codex (.agents/)")).toBe("not detected");
+  });
+
   it("pre-checks .agents/ when no tools are detected", async () => {
     const { locationChoices } = await import("../src/wizard/steps/locations");
     expect(locationChoices([]).initialValues).toEqual([".agents"]);