auriga-cli 1.18.4 → 1.18.5

package/dist/api-types.d.ts

@@ -1,4 +1,10 @@
-export type ItemStatus = "installed" | "update-available" | "not-installed";
+export type ItemStatus = "installed" | "update-available" | "not-installed"
+/** Dual-Agent plugin where some target Agents have the plugin installed
+ *  and some don't (e.g. Claude side installed, Codex side missing). Distinct
+ *  from `update-available` because the action is "install on the missing
+ *  side", not "upgrade to a newer version". The missing agents are
+ *  enumerated in `PluginState.missingAgents`. */
+ | "partial-install";
 /**
  * Per-category scan scope. Each category (workflow / skills / plugins / hooks)
  * can be independently scanned in either user scope (~/.claude/, ~/.codex/)
@@ -53,9 +59,15 @@ export interface PluginState {
      *  `agents.length === 2` the UI shows a BOTH badge and Apply installs to
      *  each agent in turn. Status is aggregated across all targeted agents:
      *  `installed` ⇔ all agents installed; `not-installed` ⇔ all not-installed;
-     *  any partial state (one side installed, other not) → `update-available`
-     *  so a single Apply backfills the missing side. */
+     *  partial state (some installed, some not) → `partial-install`; agent-
+     *  uniform version drift → `update-available`. */
     agents: ApplyAgent[];
+    /** Agents that target this plugin but don't have it installed. Populated
+     *  iff `status === "partial-install"`. Lets the UI render per-agent
+     *  ✓/✗ marks and tell the user exactly which side needs `auriga-cli`
+     *  to backfill. Always omitted for `installed` / `not-installed` /
+     *  `update-available`. */
+    missingAgents?: ApplyAgent[];
     currentVersion?: string;
     expectedVersion?: string;
     versionSource: "upstream-live" | "catalog";
@@ -80,7 +92,12 @@ export interface HookState {
     observedScope?: ScanScope;
 }
 export interface StateWarning {
-    code: "claude-cli-missing" | "codex-cli-missing" | "marketplace-offline" | "claude-code-not-installed" | "settings-unreadable" | "skill-malformed" | "workflow-unknown-version";
+    code: "claude-cli-missing" | "codex-cli-missing" | "marketplace-offline" | "claude-code-not-installed" | "settings-unreadable" | "skill-malformed"
+    /** Project-scope CLAUDE.md (or the user-scope fallback when scanning
+     *  user scope) is present but has no recognizable `# auriga Workflow (vX.Y.Z)`
+     *  header. The row reports `not-installed`; install will back up the
+     *  existing file to `CLAUDE.md.bak` and write ours. */
+     | "workflow-foreign-claudemd";
     message: string;
 }
 export type ApplyCategory = "workflow" | "skill" | "recommended-skill" | "plugin" | "hook";

package/dist/catalog.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-05-12T15:14:34.188Z",
+  "generatedAt": "2026-05-12T16:35:23.439Z",
   "workflowVersion": "1.7.0",
   "workflowSkills": [
     {

package/dist/state.d.ts

@@ -71,23 +71,6 @@ export interface ScanOptions {
     homeDir?: string;
 }
 export declare function scanState(projectRoot: string, catalog: Catalog, opts?: ScanOptions): Promise<StateReport>;
-/**
- * Dedupe plugins by `id`, merging dual-Agent records into a single
- * multi-agent row. Aggregation rules:
- *
- *   agents:  union of all agent arrays for this id (claude before codex).
- *   status:  installed     ⇔ every agent's record is installed
- *            not-installed ⇔ every agent's record is not-installed
- *            otherwise     → update-available (partial install or any agent
- *                            with a pending update). One Apply covers all
- *                            gaps because the handler iterates `agents`.
- *
- * Non-status fields (description, currentVersion, expectedVersion,
- * versionSource) come from the first record we see. Today both sides report
- * the same description (catalog-driven) and the same versions for any
- * registry-pinned plugin, so this is safe; if a future divergence appears
- * we'll need a deliberate merge policy.
- */
 export declare function mergePluginsById(records: PluginState[]): PluginState[];
 /** Default: run `claude plugins list --json` (no scope flag — the CLI
  *  doesn't expose one) plus the `--available` variant, then filter the

package/dist/state.js

@@ -94,31 +94,27 @@ function dirExists(p) {
         return false;
     }
 }
-/**
- * Dedupe plugins by `id`, merging dual-Agent records into a single
- * multi-agent row. Aggregation rules:
- *
- *   agents:  union of all agent arrays for this id (claude before codex).
- *   status:  installed     ⇔ every agent's record is installed
- *            not-installed ⇔ every agent's record is not-installed
- *            otherwise     → update-available (partial install or any agent
- *                            with a pending update). One Apply covers all
- *                            gaps because the handler iterates `agents`.
- *
- * Non-status fields (description, currentVersion, expectedVersion,
- * versionSource) come from the first record we see. Today both sides report
- * the same description (catalog-driven) and the same versions for any
- * registry-pinned plugin, so this is safe; if a future divergence appears
- * we'll need a deliberate merge policy.
- */
 export function mergePluginsById(records) {
     const byId = new Map();
-    const statusByIdPerAgent = new Map();
+    // Per-agent (agent, status, version) tuples preserved across the fold so
+    // the aggregation step can emit `partial-install` + `missingAgents` when
+    // one side is installed and the other isn't, AND pick the *stale* side's
+    // currentVersion when status === "update-available" (otherwise the merge
+    // inherited Claude's version, producing the misleading `vX → vX` display
+    // in the v1.18.4 verification).
+    const perAgentByIdEntries = new Map();
     for (const rec of records) {
+        // Pre-merge records are per-agent: their `agents[]` array contains the
+        // single Agent this row was scanned for. The merge step below unions
+        // those into the final dual-Agent record.
+        const recAgent = rec.agents[0];
+        const perAgentEntry = recAgent
+            ? { agent: recAgent, status: rec.status, currentVersion: rec.currentVersion }
+            : null;
         const existing = byId.get(rec.id);
         if (!existing) {
             byId.set(rec.id, { ...rec });
-            statusByIdPerAgent.set(rec.id, [rec.status]);
+            perAgentByIdEntries.set(rec.id, perAgentEntry ? [perAgentEntry] : []);
             continue;
         }
         // Union agents preserving order: existing first, then any new ones.
@@ -129,28 +125,58 @@ export function mergePluginsById(records) {
                 seen.add(a);
             }
         }
-        statusByIdPerAgent.get(rec.id).push(rec.status);
+        if (perAgentEntry) {
+            perAgentByIdEntries.get(rec.id).push(perAgentEntry);
+        }
     }
-    // Fold each id's per-agent status list into the aggregated status.
-    for (const [id, statuses] of statusByIdPerAgent) {
+    // Fold per-agent tuples into the aggregated status, missingAgents, and
+    // (when applicable) the corrected currentVersion.
+    for (const [id, perAgent] of perAgentByIdEntries) {
         const rec = byId.get(id);
         if (!rec)
             continue;
-        rec.status = aggregateStatus(statuses);
+        const aggregated = aggregateStatus(perAgent);
+        rec.status = aggregated.status;
+        if (aggregated.missingAgents && aggregated.missingAgents.length > 0) {
+            rec.missingAgents = aggregated.missingAgents;
+        }
+        else {
+            delete rec.missingAgents;
+        }
+        // When status is update-available, surface the version of the *stale*
+        // agent (one whose own status was update-available). Otherwise we'd
+        // keep whichever agent's version was merged first — Claude's, which
+        // may already be at the expected version, producing a `vX → vX`
+        // pseudo-upgrade display.
+        if (rec.status === "update-available") {
+            const stale = perAgent.find((r) => r.status === "update-available");
+            if (stale?.currentVersion) {
+                rec.currentVersion = stale.currentVersion;
+            }
+        }
     }
     return Array.from(byId.values());
 }
-function aggregateStatus(statuses) {
-    if (statuses.length === 0)
-        return "not-installed";
-    if (statuses.every((s) => s === "installed"))
-        return "installed";
-    if (statuses.every((s) => s === "not-installed"))
-        return "not-installed";
-    // Anything else — partial install, pending updates on any agent, mixed
-    // — falls through to update-available so a single Apply backfills the
-    // missing pieces.
-    return "update-available";
+function aggregateStatus(records) {
+    if (records.length === 0)
+        return { status: "not-installed" };
+    if (records.every((r) => r.status === "installed"))
+        return { status: "installed" };
+    if (records.every((r) => r.status === "not-installed"))
+        return { status: "not-installed" };
+    // Mixed. If ANY agent reports not-installed, the row is partially installed
+    // — the user-facing action is "install on the missing side". Surfaces as a
+    // distinct status from version-drift `update-available` so the UI doesn't
+    // render misleading `vX → vX` upgrades (the v1.18.4 deep-review symptom).
+    const missingAgents = records
+        .filter((r) => r.status === "not-installed")
+        .map((r) => r.agent);
+    if (missingAgents.length > 0) {
+        return { status: "partial-install", missingAgents };
+    }
+    // Otherwise version drift on at least one targeted agent — single Apply
+    // upgrades the stale side(s).
+    return { status: "update-available" };
 }
 // ---------------------------------------------------------------------------
 // Workflow
@@ -160,11 +186,12 @@ function workflowPathsForScope(scope, projectRoot, home) {
     if (scope === "user") {
         return [path.join(home, ".claude", "CLAUDE.md")];
     }
-    // Project: <proj>/CLAUDE.md preferred, .claude/CLAUDE.md as fallback.
-    return [
-        path.join(projectRoot, "CLAUDE.md"),
-        path.join(projectRoot, ".claude", "CLAUDE.md"),
-    ];
+    // Project: only `<proj>/CLAUDE.md` — the auriga workflow installer
+    // (src/workflow.ts) writes here and never to `<proj>/.claude/CLAUDE.md`.
+    // The old fallback collapsed onto `$HOME/.claude/CLAUDE.md` when
+    // projectRoot === $HOME (user runs `web-ui` from home dir), leaking
+    // user-scope content into the project-scope row.
+    return [path.join(projectRoot, "CLAUDE.md")];
 }
 function scanWorkflow(scope, projectRoot, home, catalog, warnings) {
     const expectedVersion = catalog.workflowVersion;
@@ -197,14 +224,18 @@ function scanWorkflow(scope, projectRoot, home, catalog, warnings) {
         if (line.trim().length > 0)
             break;
     }
-    // CLAUDE.md exists but no recognizable auriga marker. Per spec degraded
-    // path: status remains "installed" (don't clobber user content on apply)
-    // and emit a workflow-unknown-version warning.
+    // CLAUDE.md exists but no recognizable auriga marker. The file is foreign
+    // — not our workflow. Report `not-installed` honestly; the install path
+    // (src/workflow.ts) already protects user content by backing it up to
+    // `CLAUDE.md.bak` before overwriting. Conflating "something exists here"
+    // with "auriga workflow installed" caused the v1.18.4 verification bug
+    // where running web-ui from `~` reported the user's `# Global`-headed
+    // `~/.claude/CLAUDE.md` as an installed workflow.
     warnings.push({
-        code: "workflow-unknown-version",
-        message: `CLAUDE.md present but no auriga-workflow header found; cannot determine installed version.`,
+        code: "workflow-foreign-claudemd",
+        message: `Foreign CLAUDE.md detected at the workflow path — no auriga-workflow header. Install will back up to CLAUDE.md.bak.`,
     });
-    return { status: "installed", expectedVersion, observedScope: scope };
+    return { status: "not-installed", expectedVersion, observedScope: scope };
 }
 // ---------------------------------------------------------------------------
 // Skills + recommendedSkills

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auriga-cli",
-  "version": "1.18.4",
+  "version": "1.18.5",
   "description": "Interactive CLI to install Claude Code harness modules (Workflow, Skills, Recommended Skills, Plugins, Hooks)",
   "license": "MIT",
   "repository": {