claudeup 4.39.1 → 4.40.1

package/src/data/styles/evidence-first.md

@@ -0,0 +1,22 @@
+---
+name: evidence-first
+axis: modifier
+summary: Every claim about the system carries the command that proved it and its real output.
+conflicts:
+---
+
+### Evidence first
+
+- A claim about how the system behaves cites the command that produced it and
+  the real output. Paraphrased output is not output.
+- "Done", "fixed", and "working" are claims. Each requires a fresh run pasted
+  in full, not a run from before the last edit.
+- A check that cannot fail is not evidence. If a test passes, show that it
+  fails without the change — otherwise the passing run proves nothing.
+- Report failures with the same prominence as successes. If two of nine tests
+  fail, say so in the first line and paste both failures.
+- Distinguish what was observed from what was inferred. "The function returns
+  null here" and "this probably means the cache is cold" are different kinds
+  of statement and must be labelled differently.
+- Never report a step as complete if it was skipped, partially applied, or
+  could not be verified. Say which, and say why.

package/src/data/styles/explanatory.md

@@ -0,0 +1,23 @@
+---
+name: explanatory
+axis: verbosity
+summary: Teach the reasoning alongside the work — for codebases people are still learning.
+conflicts: direct, terse
+---
+
+### Explanatory
+
+- Give the answer first, then the reasoning. Explanation earns its place by
+  following a conclusion, never by delaying one.
+- Explain the *specific* choice, not the general concept. "This uses a map
+  because the caller looks up by id in a loop" teaches something; "maps offer
+  O(1) lookup" does not.
+- Name the alternative that was rejected and why. A decision without its
+  discarded options reads as the only possibility, which is rarely true.
+- When touching an unfamiliar part of the system, state the mechanism you
+  relied on and how you confirmed it. That is the difference between a claim
+  the reader can check and one they must trust.
+- Explanation is capped by usefulness, not by length. If a paragraph would not
+  change what the reader does next, it does not belong.
+- Never explain the same mechanism twice in one session. Reference the earlier
+  explanation instead.

package/src/data/styles/index.ts

@@ -0,0 +1,57 @@
+/**
+ * The communication style presets, embedded in the binary.
+ *
+ * These files used to ship in `style@magus` and claudeup read them off disk,
+ * which meant the Styles tab was empty for anyone who had not installed that
+ * plugin. The plugin was retired at Marketplace 10.0.0 and the presets moved
+ * here, so they are always present and always the version this binary was
+ * built against.
+ *
+ * ## Why `.md` files rather than TypeScript string constants
+ *
+ * The frontmatter format (`name`, `title`, `axis`, `summary`, `conflicts`,
+ * `template`) is the contract `styles-manager.ts` parses, and a preset body is
+ * long instructional text full of backticks and braces. Kept as markdown it
+ * stays diffable and escape-free; `with { type: "text" }` inlines it at build
+ * time and `bun build --compile` carries it into the binary (verified against
+ * bun 1.3.10).
+ *
+ * ## Adding a preset
+ *
+ * Drop the `.md` file in this directory and add both lines below. The list is
+ * written out rather than globbed because a glob cannot be resolved at compile
+ * time — a missing entry means the preset silently does not ship, which is
+ * what `styles-manager.test.ts` counts the directory to catch.
+ */
+
+import asdSte100 from "./asd-ste100.md" with { type: "text" };
+import calibrated from "./calibrated.md" with { type: "text" };
+import direct from "./direct.md" with { type: "text" };
+import evidenceFirst from "./evidence-first.md" with { type: "text" };
+import explanatory from "./explanatory.md" with { type: "text" };
+import noSlop from "./no-slop.md" with { type: "text" };
+import plainLanguage from "./plain-language.md" with { type: "text" };
+import structured from "./structured.md" with { type: "text" };
+import terminology from "./terminology.md" with { type: "text" };
+import terse from "./terse.md" with { type: "text" };
+
+/** One preset's file name and raw contents, frontmatter included. */
+export interface EmbeddedPreset {
+	/** File name as it appears in this directory, e.g. `direct.md`. */
+	file: string;
+	/** Raw file text — frontmatter and body, exactly as authored. */
+	text: string;
+}
+
+export const EMBEDDED_PRESETS: EmbeddedPreset[] = [
+	{ file: "asd-ste100.md", text: asdSte100 },
+	{ file: "calibrated.md", text: calibrated },
+	{ file: "direct.md", text: direct },
+	{ file: "evidence-first.md", text: evidenceFirst },
+	{ file: "explanatory.md", text: explanatory },
+	{ file: "no-slop.md", text: noSlop },
+	{ file: "plain-language.md", text: plainLanguage },
+	{ file: "structured.md", text: structured },
+	{ file: "terminology.md", text: terminology },
+	{ file: "terse.md", text: terse },
+];

package/src/data/styles/no-slop.md

@@ -0,0 +1,32 @@
+---
+name: no-slop
+axis: modifier
+summary: Banned vocabulary and punctuation tics that mark text as machine-written.
+conflicts:
+---
+
+### No slop
+
+Banned words and phrases. These are not stylistic preferences — they are the
+tells that make text read as generated, and every one of them has a plainer
+replacement:
+
+- **Inflation:** delve, crucial, pivotal, robust, comprehensive, seamless,
+  nuanced, multifaceted, intricate, vibrant, landscape, tapestry, realm,
+  underscore, foster, showcase, leverage (as a verb), utilize.
+- **Connectives:** furthermore, moreover, additionally, notably, importantly.
+  Start the next sentence instead.
+- **Hedged enthusiasm:** "it's worth noting that", "it's important to
+  remember", "as we can see", "at the end of the day".
+- **Empty openers:** "In today's fast-paced world", "When it comes to",
+  "Whether you're a beginner or an expert".
+- **The not-X-but-Y frame** as a reflex: "It's not just a database, it's a
+  platform". Say what it is.
+
+Punctuation and shape:
+
+- No em dashes. Use a comma, a colon, or a full stop.
+- No rule-of-three lists that pad a two-item point to three.
+- No bold on whole sentences. Bold is for the one word the eye should land on.
+- No emoji in code, commit messages, or technical prose unless the project
+  already uses them.

package/src/data/styles/plain-language.md

@@ -0,0 +1,23 @@
+---
+name: plain-language
+axis: modifier
+summary: Gloss jargon on first use, short sentences, active voice, concrete nouns.
+conflicts: terse
+---
+
+### Plain language
+
+- Gloss a term of art the first time it appears, in one clause: "idempotent
+  (running it twice does the same thing as once)". Once per conversation, not
+  once per message.
+- Prefer the concrete noun to the abstraction. "The login page" beats "the
+  authentication surface"; "the file will not open" beats "a resource access
+  issue".
+- Active voice with a named actor. "The migration drops the column", not "the
+  column is dropped".
+- One idea per sentence. If a sentence needs a semicolon to hold together, it
+  is two sentences.
+- Close with what it means for the reader: what they will see, wait for, lose,
+  or be able to do. A technical fact with no consequence attached is trivia.
+- Expand an acronym on first use unless it is more familiar than its
+  expansion — write out "cross-site request forgery", but leave "URL" alone.

package/src/data/styles/structured.md

@@ -0,0 +1,30 @@
+---
+name: structured
+axis: modifier
+summary: When to use a table, a list, a heading, or a paragraph — and when not to.
+conflicts:
+---
+
+### Structure
+
+Match the shape to the content. The wrong container is harder to read than
+plain prose:
+
+| Content | Shape |
+|---|---|
+| Two or more things compared on the same dimensions | table |
+| Steps in order, where order matters | numbered list |
+| Items with no order and no comparison | bullets |
+| One thing explained | paragraph |
+| Reasoning that connects claims | paragraph, not bullets |
+
+- Never bullet a single item. Never build a table with one row or one column.
+- A heading is a promise about what is below it. Do not use headings to break
+  up three sentences.
+- Code identifiers, paths, commands, and literal values go in backticks —
+  every time, including in tables and headings.
+- Reference code as `path/to/file.ts:42`. The line number makes it clickable.
+- Prose carries reasoning; bullets fragment it. If the points depend on each
+  other, write sentences.
+- Length is set by the content. Do not pad a one-line answer into a section,
+  and do not compress a real trade-off into a bullet.

package/src/data/styles/terminology.md

@@ -0,0 +1,28 @@
+---
+name: terminology
+axis: modifier
+summary: Project vocabulary — one name per concept, filled in from the codebase during apply.
+conflicts:
+template: true
+---
+
+### Terminology
+
+One concept, one name, everywhere: code, comments, commit messages, docs, and
+conversation. A concept with two names reads as two concepts.
+
+| Use | Not | Because |
+|---|---|---|
+| <!-- filled during apply --> | | |
+
+Rules that hold regardless of the table above:
+
+- Use the domain's word, not the implementation's. If the business calls it a
+  "booking", the code and the conversation say booking, even where the table
+  is named `reservations`.
+- Do not invent a synonym for a term the codebase already uses. Grep before
+  naming anything new.
+- When the code and the domain disagree on a name, say which you are using and
+  which the reader will see in the file.
+- Keep abbreviations out of names people say out loud. `usr`, `mgr`, and `cfg`
+  save four characters and cost a re-read every time.

package/src/data/styles/terse.md

@@ -0,0 +1,20 @@
+---
+name: terse
+axis: verbosity
+summary: Minimum viable words. No glosses, no framing, no encouragement.
+conflicts: direct, explanatory
+---
+
+### Terse
+
+- Answer in the fewest words that stay correct. One line where one line works.
+- No framing sentences, no summaries of what was just said, no offers of
+  further help.
+- Prefer a fragment to a sentence, a table to prose, a file path to a
+  description of where something lives.
+- Do not explain unless asked. Do not justify a choice unless it is
+  surprising.
+- Omit adjectives that carry no information: "simple", "just", "quick",
+  "straightforward", "basically".
+- Terse is not curt. Answer what was asked completely — brevity comes from
+  cutting padding, never from cutting the answer short.

package/src/markdown.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Markdown imported as text.
+ *
+ * `import body from "./direct.md" with { type: "text" }` is a Bun bundler
+ * feature — the loader inlines the file as a string literal at build time, so
+ * it survives `bun build --compile`. TypeScript has no idea, hence this
+ * declaration. Without it every preset import in `data/styles/` is an
+ * implicit-any error under `strict`.
+ */
+declare module "*.md" {
+	const contents: string;
+	export default contents;
+}

package/src/services/claude-settings.ts

@@ -13,6 +13,7 @@ import type {
 } from "../types/index.js";
 import { parsePluginId } from "../utils/string-utils.js";
 import { inheritablePaths } from "./git-worktree.js";
+import { repoHeadSha } from "./content-drift.js";
 
 const CLAUDE_DIR = ".claude";
 const SETTINGS_FILE = "settings.json";
@@ -1509,19 +1510,23 @@ async function getPluginSourcePath(
 /**
  * Copy plugin files from source to cache
  * This ensures the cache is populated with the latest plugin version
+ *
+ * Returns the directory the files were copied FROM, or null if nothing was
+ * copied. The caller needs the source path, not just a success flag: that path
+ * is what identifies the commit the cached files came from.
  */
 async function copyPluginToCache(
 	pluginId: string,
 	version: string,
 	marketplace: string,
-): Promise<boolean> {
+): Promise<string | null> {
 	const { pluginName } = parsePluginId(pluginId) || {
 		pluginName: pluginId.split("@")[0],
 	};
 
 	const sourcePath = await getPluginSourcePath(pluginName, marketplace);
 	if (!sourcePath) {
-		return false;
+		return null;
 	}
 
 	const cachePath = getPluginCachePath(pluginId, version, marketplace);
@@ -1538,16 +1543,42 @@ async function copyPluginToCache(
 			errorOnExist: false,
 		});
 
-		return true;
+		return sourcePath;
 	} catch (error) {
 		console.warn(
 			`Failed to copy plugin ${pluginId} to cache:`,
 			error instanceof Error ? error.message : "Unknown error",
 		);
-		return false;
+		return null;
 	}
 }
 
+/**
+ * The commit a cache copy should be stamped with.
+ *
+ * `gitCommitSha` must describe the files sitting in the cache RIGHT NOW, which
+ * is the single thing content-drift detection reads it for. Two rules:
+ *
+ * - Files were copied → the source repo's HEAD is their provenance. Undefined
+ *   is a legitimate answer here: a directory-type marketplace has no commit,
+ *   and content-drift stays silent rather than guessing.
+ * - Nothing was copied → the cache is untouched, so whatever sha already
+ *   described it still does. Advancing it would claim the cache holds newer
+ *   files than it does, hiding real drift.
+ *
+ * The bug this replaces did neither: it preserved the pre-update sha even when
+ * fresh files HAD been copied, so the recorded commit drifted further behind
+ * with every release and drift detection reported a false positive on every
+ * plugin at once.
+ */
+export async function resolveCacheProvenance(
+	copiedFrom: string | null,
+	previousSha: string | undefined,
+): Promise<string | undefined> {
+	if (!copiedFrom) return previousSha;
+	return await repoHeadSha(copiedFrom);
+}
+
 /**
  * Read installed_plugins.json registry
  */
@@ -1632,7 +1663,7 @@ export async function updateInstalledPluginsRegistry(
 
 		// Copy plugin files from source to cache
 		// This ensures the cache has the latest plugin version
-		await copyPluginToCache(pluginId, version, marketplace);
+		const copiedFrom = await copyPluginToCache(pluginId, version, marketplace);
 
 		const installPath = getPluginCachePath(pluginId, version, marketplace);
 		const now = new Date().toISOString();
@@ -1659,10 +1690,12 @@ export async function updateInstalledPluginsRegistry(
 					? registry.plugins[pluginId][existingIndex].installedAt
 					: now,
 			lastUpdated: now,
-			gitCommitSha:
+			gitCommitSha: await resolveCacheProvenance(
+				copiedFrom,
 				existingIndex >= 0
 					? registry.plugins[pluginId][existingIndex].gitCommitSha
 					: undefined,
+			),
 		};
 
 		if (existingIndex >= 0) {

package/src/services/content-drift.ts

@@ -67,12 +67,33 @@ function git(cwd: string, args: string[]): Promise<{ code: number; out: string }
 	});
 }
 
+/**
+ * HEAD of the git repo containing `dir`, or undefined when there is none.
+ *
+ * This is what stamps provenance onto a cache copy: `copyPluginToCache` reads
+ * the plugin's files out of the marketplace clone, so that clone's HEAD is the
+ * commit those files came from. Undefined is a real answer — a directory-type
+ * marketplace has no commit to name, and inventing one would assert a
+ * provenance that is false.
+ */
+export async function repoHeadSha(dir: string): Promise<string | undefined> {
+	const r = await git(dir, ["rev-parse", "HEAD"]);
+	if (r.code !== 0) return undefined;
+	return /^[0-9a-f]{40}$/.test(r.out) ? r.out : undefined;
+}
+
 export interface DriftQuery {
 	marketplace: string;
 	/** Plugin name without the @marketplace suffix. */
 	pluginName: string;
 	/** `gitCommitSha` from the installed_plugins.json entry. */
 	installedSha: string | undefined;
+	/**
+	 * Version currently installed. Required, not optional: the sha alone cannot
+	 * be trusted, and a caller that omitted this would silently get the old
+	 * always-drifted behaviour back.
+	 */
+	installedVersion: string | undefined;
 	/**
 	 * Path of the plugin inside the marketplace repo, from the catalog `source`
 	 * field (e.g. "./plugins/dev"). Defaults to `plugins/<name>`.
@@ -80,19 +101,52 @@ export interface DriftQuery {
 	sourcePath?: string;
 }
 
+/** Strip a leading "v" so "v1.2.3" and "1.2.3" compare equal. */
+const normalize = (v: string) => v.trim().replace(/^v/, "");
+
+/**
+ * The version a plugin's manifest declared at a given commit.
+ *
+ * Both layouts are tried because both are real: magus lays plugins out as
+ * `plugins/<name>/plugin.json`, while Claude Code documents
+ * `.claude-plugin/plugin.json`. Reading only one would silence drift detection
+ * for every plugin using the other.
+ */
+async function versionAtSha(
+	repo: string,
+	sha: string,
+	rel: string,
+): Promise<string | undefined> {
+	for (const manifest of [
+		`${rel}/plugin.json`,
+		`${rel}/.claude-plugin/plugin.json`,
+	]) {
+		const r = await git(repo, ["show", `${sha}:${manifest}`]);
+		if (r.code !== 0 || !r.out) continue;
+		try {
+			const v = JSON.parse(r.out)?.version;
+			if (typeof v === "string" && v) return v;
+		} catch {
+			// Unparseable manifest is the same as no manifest: unverifiable.
+		}
+	}
+	return undefined;
+}
+
 /**
  * True when the plugin's files in the marketplace differ from the commit it was
  * installed from — i.e. a reinstall would deliver different content.
  *
  * Returns false whenever the question cannot be answered honestly: no recorded
- * sha, no clone, git unavailable, or the recorded commit is absent locally
- * (force-push, shallow clone). A false negative leaves today's behaviour; a
- * false positive would nag the user to reinstall for no reason.
+ * sha, no clone, git unavailable, the recorded commit is absent locally
+ * (force-push, shallow clone), or that commit declares a DIFFERENT version than
+ * the one installed. A false negative leaves today's behaviour; a false
+ * positive would nag the user to reinstall for no reason.
  */
 export async function hasContentDrift(q: DriftQuery): Promise<boolean> {
 	if (!q.installedSha) return false;
 
-	const key = `${q.marketplace}\0${q.pluginName}\0${q.installedSha}`;
+	const key = `${q.marketplace}\0${q.pluginName}\0${q.installedSha}\0${q.installedVersion}`;
 	const hit = cache.get(key);
 	if (hit !== undefined) return hit;
 
@@ -106,6 +160,29 @@ export async function hasContentDrift(q: DriftQuery): Promise<boolean> {
 		return false;
 	}
 
+	// The recorded sha must describe the version actually installed, or the diff
+	// answers a different question than the one asked.
+	//
+	// This is the whole reason the badge fired on every plugin at once:
+	// `updateInstalledPluginsRegistry` bumps `version` on an in-place update but
+	// carries the pre-update `gitCommitSha` forward, so the sha names whichever
+	// commit the plugin was FIRST installed from. Measured 2026-08-22 on one
+	// machine: dev recorded 4.3.0 against a sha holding 3.3.0, browser-use 1.4.1
+	// against 1.1.3. Diffing across those releases is trivially non-empty, so
+	// every plugin rendered "stale — reinstall" while its cached files were in
+	// fact byte-identical to the marketplace.
+	const shaVersion = q.installedVersion
+		? await versionAtSha(repo, q.installedSha, rel)
+		: undefined;
+	if (
+		!q.installedVersion ||
+		!shaVersion ||
+		normalize(shaVersion) !== normalize(q.installedVersion)
+	) {
+		cache.set(key, false);
+		return false;
+	}
+
 	// Exit 0 = no difference, 1 = differs, anything else = could not tell.
 	const diff = await git(repo, [
 		"diff",

package/src/services/plugin-manager.ts

@@ -722,6 +722,7 @@ async function annotateContentDrift(
 					marketplace: plugin.marketplace,
 					pluginName: plugin.name,
 					installedSha: entry.gitCommitSha,
+					installedVersion: plugin.installedVersion,
 				});
 			} catch {
 				/* leave unflagged */