dshmarket 1.66.16 → 1.66.17

package/lib/patch.js

@@ -421,6 +421,37 @@ function escapeRegExp(value) {
 function rowBlock(rowId, disabled) {
     return `- id: ${rowId}\n  disabled: ${disabled ? 'true' : 'false'}\n`;
 }
+/**
+ * Every two-line `- id: X` + `disabled: …` block for one row, in file order
+ * (#821). A row that goes on with more keys (`config:` and the like) is not
+ * one of these blocks: cutting its first two lines would leave the rest
+ * hanging off the entry above it. The last block of a file may lack its
+ * newline.
+ */
+function rowBlocksRe(rowId, disabled) {
+    const id = escapeRegExp(rowId);
+    const value = disabled === 'any' ? '(?:true|false)' : disabled;
+    return new RegExp(`^- id: (?:${id}|'${id}'|"${id}")[ \\t]*\\r?\\n  disabled: ${value}[ \\t]*(?:\\r?\\n(?![ \\t])|(?![\\s\\S]))`, 'gmu');
+}
+/**
+ * What the patch file finally says about one row: the flag of its last
+ * `- id: X` entry that carries one, rows with more keys included. Later
+ * entries override earlier ones.
+ */
+function lastRowFlag(text, rowId) {
+    const id = escapeRegExp(rowId);
+    const idLine = new RegExp(`^- id: (?:${id}|'${id}'|"${id}")\\s*$`, 'u');
+    const lines = text.split(/\r?\n/u);
+    let flag = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        if (!idLine.test(lines[index] ?? ''))
+            continue;
+        const value = /^ {2}disabled: (true|false)\s*$/u.exec(lines[index + 1] ?? '');
+        if (value !== null)
+            flag = value[1];
+    }
+    return flag;
+}
 /**
  * Append one top-level patch entry, refusing when the file is not a valid
  * entry list. The refusal is the point: a malformed patch layer (the
@@ -481,12 +512,48 @@ function appendPatchEntry(patchPath, block) {
     writeFileSync(patchPath, `${next}${block}`);
     return { ok: true, reason: null };
 }
-/** Disable one row: append `- id: X` + `disabled: true` (idempotent). */
+/**
+ * Disable one row: `- id: X` + `disabled: true` (idempotent).
+ *
+ * A force-enable block already there is flipped in place rather than
+ * followed by a second block (#821): the pair cancelled out by order alone,
+ * and an uninstall that cleared one of them left the other behind to switch
+ * a later reinstall off. Duplicates an older version left are folded into
+ * the one block at the same time.
+ */
 export function disableRow(patchPath, rowId) {
     return queuedWrite(async () => {
         if (!ROW_ID_RE.test(rowId)) {
             return { ok: false, reason: `行 id 含特殊字符,不支持写入补丁层 / row id ${rowId} cannot be written to the patch layer` };
         }
+        const text = (() => {
+            try {
+                return readFileSync(patchPath, 'utf8');
+            }
+            catch {
+                return '';
+            }
+        })();
+        const blocks = text.match(rowBlocksRe(rowId, 'any')) ?? [];
+        if (blocks.length > 1 || blocks.some(block => /disabled: false/u.test(block))) {
+            let kept = false;
+            const next = text.replace(rowBlocksRe(rowId, 'any'), block => {
+                if (kept)
+                    return '';
+                kept = true;
+                const flipped = rowBlock(rowId, true);
+                return block.includes('\r\n') ? flipped.replace(/\n/gu, '\r\n') : flipped;
+            });
+            writeFileSync(patchPath, next);
+            // A longer entry for the row further down still has the last word.
+            if (lastRowFlag(next, rowId) !== 'true') {
+                const result = appendPatchEntry(patchPath, rowBlock(rowId, true));
+                if (!result.ok)
+                    return result;
+            }
+            logEvent('info', 'patch', `disabled row ${rowId} in ${patchPath}`);
+            return { ok: true, reason: null };
+        }
         const state = readUserPatchState(patchPath);
         if (state.disables.includes(rowId))
             return { ok: true, reason: null };
@@ -496,7 +563,7 @@ export function disableRow(patchPath, rowId) {
         return result;
     });
 }
-/** Enable one row: remove the `disabled: true` block; force-enable with
+/** Enable one row: remove its `disabled: true` blocks; force-enable with
  * `disabled: false` when a lower layer (bundle/home patch) holds it down. */
 export function enableRow(patchPath, rowId) {
     return queuedWrite(async () => {
@@ -504,7 +571,6 @@ export function enableRow(patchPath, rowId) {
             return { ok: false, reason: `行 id 含特殊字符,不支持写入补丁层 / row id ${rowId} cannot be written to the patch layer` };
         }
         const state = readUserPatchState(patchPath);
-        const blockRe = new RegExp(`^- id: ['\"]?${escapeRegExp(rowId)}['\"]?\\r?\\n  disabled: true\\r?\\n`, 'mu');
         const text = (() => {
             try {
                 return readFileSync(patchPath, 'utf8');
@@ -513,8 +579,9 @@ export function enableRow(patchPath, rowId) {
                 return '';
             }
         })();
-        if (blockRe.test(text)) {
-            writeFileSync(patchPath, withPlaceholderRestored(text.replace(blockRe, '')));
+        const next = text.replace(rowBlocksRe(rowId, 'true'), '');
+        if (next !== text) {
+            writeFileSync(patchPath, withPlaceholderRestored(next));
             logEvent('info', 'patch', `enabled row ${rowId} in ${patchPath}`);
             return { ok: true, reason: null };
         }
@@ -555,10 +622,8 @@ export function removeRowBlocks(patchPath, rowIds) {
         return;
     }
     let next = text;
-    for (const rowId of rowIds) {
-        const blockRe = new RegExp(`^- id: ['\"]?${escapeRegExp(rowId)}['\"]?\\r?\\n  disabled: (?:true|false)\\r?\\n`, 'mu');
-        next = next.replace(blockRe, '');
-    }
+    for (const rowId of rowIds)
+        next = next.replace(rowBlocksRe(rowId, 'any'), '');
     if (next !== text) {
         writeFileSync(patchPath, withPlaceholderRestored(next));
         logEvent('info', 'patch', `removed patch rows for ${rowIds.join(', ')}`);

package/lib/routes.js

@@ -7,8 +7,8 @@
  * Security: the install route executes a shell command, so it accepts only
  * same-origin POSTs and only sources present in the curated registry.
  */
-import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { Readable } from 'node:stream';
 import { load as loadYaml } from 'js-yaml';
 import { forgetCatalog, loadRegistry, pluginCategories } from './registry.js';
@@ -30,7 +30,7 @@ import { applyBundleOrder, mergeOrder, readBundleRules, readBundleStack, validat
 import { applyPreset, deletePreset, listPresets, previewPreset, savePreset } from './presets.js';
 import { createProfileSnapshot, DEFAULT_MAX_SNAPSHOTS, deleteSnapshot, listSnapshots, restoreSnapshot } from './snapshot.js';
 import { trialValidate } from './trial.js';
-import { catalogRepoKey, codeloadAllowBuildsKey, findCatalogEntryForLocal, findInstalledAlias, gitCommitOfTarget, githubCommitOfTarget, githubTargetAtCommit, gitAllowBuildsKey, gitRefOfTarget, gitTargetAtCommit, gitUpdateTarget, hostedRepoKey, lookupRepoFromUrl, pinnedGitAllowBuildsKey, installTargetFor, isGenerationLink, isLocalSpec, NPM_NAME_RE, repoOfTarget, restoreBlockedByWorkspace, restoreTargetForLocal, sourceFallbackFor, workspaceProtocolDeps } from './sources.js';
+import { catalogRepoKey, findCatalogEntryForLocal, findInstalledAlias, gitCommitOfTarget, githubCommitOfTarget, githubTargetAtCommit, gitAllowBuildsKey, gitRefOfTarget, gitTargetAtCommit, gitUpdateTarget, hostedRepoKey, lookupRepoFromUrl, pinnedAllowBuildsKeys, installTargetFor, isGenerationLink, isLocalSpec, NPM_NAME_RE, repoOfTarget, restoreBlockedByWorkspace, restoreTargetForLocal, sourceFallbackFor, workspaceProtocolDeps } from './sources.js';
 import { failureDetail, groupConflictsByOwner, isStaleUpdate, parseIgnoredBuildEntries, parseIgnoredBuilds, parsePrepareKey, parsePrepareNotAllowed, pnpmBlockedByOpenFiles, pnpmNeverStarted, RELEASE_AGE_OVERRIDE, removeDanglingHostBridge, retargetCollections, validateAddedPlugins, withHoistRecovery } from './install.js';
 import { classifyPnpmFailure } from './pnpm-compat.js';
 import { asChannel, CHANNELS, DIST_TAG, resolveChannel } from './channels.js';
@@ -41,6 +41,7 @@ import { updateNotesFor } from './changelog.js';
 import { checkUpdates, isUpdatablePlugin, compareVersions, fetchNpmLatest, invalidateUpdates, resolveGitRemoteHead, isUpgrade, latestPublishedRecently, setUpdateRegistry, versionOnChannel } from './updates.js';
 import { createThemeManager } from './themes.js';
 import { readJsonBody, refuseUnadmitted, sameOrigin, sendJson } from './http.js';
+import { resolveDshHome } from './home-paths.js';
 import { detectedDebugger, detectedSupervisor, restartAllowed, scheduleRestart, servingPort, trustedRestartRequest, trustedDownloadRequest, restartReachableFrom } from './restart.js';
 import { activationAfterReplace, brokenClientBundles, bundlePatchIsEmpty, checkClientBundle, defaultHostRuntimeFacts, hasHostHalf, hostPeerGate, newlyBrokenBundles, peerGateRemedy, verifyActivation } from './verify.js';
 import { carrierDisableIds, disableRow, enableRow, findUserPatchPath, foreignRowIds, isProtectedModule, packagePatchFlags, readUserPatchState, removeRowBlocks, rowIdsForPackage, userPatchPackageReferences, } from './patch.js';
@@ -208,6 +209,52 @@ const PROFILE_HMR_REPLAY_WAIT_MS = 8000;
  * derived from the profile can answer during an update.
  */
 const printedBuildKeys = new Map();
+// #784: pnpm's printed key is the most authoritative spelling of what the
+// PENDING install needs allowlisted, and it used to live only in the map
+// above — a DSH restart between the failure and the "allow build scripts"
+// click dropped it, leaving the button to derive keys from the OLD installed
+// pin and the retry to fail byte-identically. Persisted best-effort under the
+// Harness home; every failure here degrades to the in-memory behavior.
+//
+// The path is resolved lazily (not at module load) so the home in force when
+// the first failure is recorded is the one the file lands under. The load is
+// also lazy — but every reader (blockedBuilds before it records, printedKeysFor
+// before it answers) goes through printedBuildKeysFile() first, so a key from
+// a previous process is on the map before this one either adds to or reads it.
+// Stored keys never overwrite a fresher in-memory one, so the order of the
+// two calls cannot resurrect a stale entry either way.
+let printedBuildKeysHome = null;
+let printedBuildKeysFilePath = null;
+function printedBuildKeysFile() {
+    const home = resolveDshHome();
+    // Cached per home, not per process: the tests swap DSH_HOME per case, and
+    // a restart handoff can change it under a long-lived process too.
+    if (printedBuildKeysHome !== home) {
+        printedBuildKeysHome = home;
+        printedBuildKeysFilePath = join(home, 'dsh-market', 'printed-build-keys.json');
+        try {
+            const stored = JSON.parse(readFileSync(printedBuildKeysFilePath, 'utf8'));
+            for (const [storedName, storedKey] of Object.entries(stored)) {
+                if (typeof storedKey === 'string' && !printedBuildKeys.has(storedName))
+                    printedBuildKeys.set(storedName, storedKey);
+            }
+        }
+        catch { /* absent or unreadable: start empty */ }
+    }
+    return printedBuildKeysFilePath;
+}
+function persistPrintedBuildKeys() {
+    try {
+        const file = printedBuildKeysFile();
+        // Bounded: one entry per package name that ever failed a build here.
+        while (printedBuildKeys.size > 500) {
+            printedBuildKeys.delete(printedBuildKeys.keys().next().value);
+        }
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, JSON.stringify(Object.fromEntries(printedBuildKeys), null, 2));
+    }
+    catch { /* best-effort: an unwritable home keeps the in-memory map */ }
+}
 function blockedBuilds(result) {
     // Record pnpm's own dep path for every ignored build BEFORE deciding what to
     // report. Both returns below hand back BARE names, so a git plugin whose
@@ -218,11 +265,15 @@ function blockedBuilds(result) {
     // back byte-identical.
     //
     // Only entries that name a source are worth recording: a registry dep's dep
-    // path IS its bare name, which the bare entry already authorizes.
+    // path IS its bare name, which the bare entry already authorizes. The
+    // persisted file is loaded FIRST (PR #822 review): a key recorded before
+    // the load ran would otherwise be replaced by the older one in the file.
+    printedBuildKeysFile();
     for (const entry of parseIgnoredBuildEntries(result.stdout, result.stderr)) {
         if (entry.key !== entry.name)
             printedBuildKeys.set(entry.name, entry.key);
     }
+    persistPrintedBuildKeys();
     if (Array.isArray(result.ignoredBuilds) && result.ignoredBuilds.length > 0)
         return result.ignoredBuilds;
     const list = parseIgnoredBuilds(result.stdout, result.stderr);
@@ -232,6 +283,7 @@ function blockedBuilds(result) {
     if (pending === null)
         return undefined;
     printedBuildKeys.set(pending, parsePrepareKey(result.stdout, result.stderr));
+    persistPrintedBuildKeys();
     return [pending];
 }
 /**
@@ -821,7 +873,9 @@ export function mountMarketRoutes(host, config, commandRuntime, agentsLookup, ho
                             if (!back.ok)
                                 logEvent('warn', 'toggle', `${name}: patch row ${rowId} could not be put back — ${back.reason}`);
                         }
-                        else {
+                        else if (prePatch === null || !prePatch.forced.includes(rowId)) {
+                            // A row already forced on before this call got nothing from
+                            // the enable; that block is the user's to keep.
                             removeRowBlocks(userPatchPath, [rowId]);
                         }
                     }
@@ -5160,10 +5214,14 @@ export function mountMarketRoutes(host, config, commandRuntime, agentsLookup, ho
                                 ?? await resolveGitRemoteHead(spec, gitRefOfTarget(spec) ?? undefined);
                         if (pinned === null || pinned === undefined)
                             return [stable];
-                        const pinnedKey = repo !== null
-                            ? codeloadAllowBuildsKey(name, spec, pinned)
-                            : pinnedGitAllowBuildsKey(name, spec, pinned);
-                        return pinnedKey === null ? [stable] : [stable, pinnedKey];
+                        // Both pinned key forms, for either fetch mode (#784): a codeload
+                        // download matches the codeload key (review-measured on 11.7.0,
+                        // empty store), while a git clone matches the commit-pinned
+                        // git+https key, in the remote's own spelling. Deriving only the
+                        // codeload form left a git-clone fetch with no key pnpm would
+                        // read.
+                        const pinnedKeys = pinnedAllowBuildsKeys(name, spec, pinned);
+                        return pinnedKeys.length === 0 ? [stable] : [stable, ...pinnedKeys];
                     };
                     /**
                      * The allowBuilds key pnpm itself printed when it refused this
@@ -5178,6 +5236,10 @@ export function mountMarketRoutes(host, config, commandRuntime, agentsLookup, ho
                      * naming the dep path it wants allowlisted.
                      */
                     const printedKeysFor = (name) => {
+                        // Load FIRST (PR #822 review): the in-memory map starts empty in a
+                        // new process, and the key pnpm printed before the restart lives
+                        // in the persisted file until this call brings it back.
+                        printedBuildKeysFile();
                         const printed = printedBuildKeys.get(name);
                         return printed === null || printed === undefined ? [] : [printed];
                     };

package/lib/sources.js

@@ -264,6 +264,21 @@ export function gitRefOfTarget(spec) {
         return null;
     return refOfFragment(spec);
 }
+/**
+ * True when the spec's `#…` fragment carries a `semver:` range selector.
+ *
+ * A semver range is a line the user chose on purpose, like a branch: pnpm
+ * re-resolves inside that range, so a raw HEAD version ABOVE the range is not
+ * installable — asking it would advertise an update forever (#446 shape).
+ * `refOfFragment` deliberately answers null for those, so the update check
+ * needs this separate probe.
+ */
+export function hasSemverSelector(spec) {
+    const fragmentAt = spec.indexOf('#');
+    if (fragmentAt === -1)
+        return false;
+    return spec.slice(fragmentAt + 1).split('&').some(s => s.startsWith('semver:'));
+}
 /** The branch or tag a `#…` fragment selects, or null for the default branch. */
 function refOfFragment(spec) {
     const fragmentAt = spec.indexOf('#');
@@ -412,6 +427,74 @@ export function pinnedGitAllowBuildsKey(name, spec, sha) {
     const remote = gitRemoteSpelling(spec);
     return remote === null ? null : `${name}@${remote}#${sha}`;
 }
+/**
+ * The repo (`owner/repo`, original case) of a GitHub remote spelled as a URL
+ * (`git+https://github.com/owner/repo.git`), or null for anything else.
+ *
+ * pnpm itself writes this spelling into the manifest for a GitHub source —
+ * the market sends `github:owner/repo`, pnpm answers with
+ * `git+https://owner/repo.git` (#803) — so the market must recognize it to
+ * keep deriving the GitHub keys for deps that only ever appear this way.
+ */
+export function githubRepoOfRemote(spec) {
+    const remote = gitRemoteSpelling(spec);
+    if (remote === null)
+        return null;
+    const url = /^git\+https:\/\/github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?$/i.exec(remote);
+    if (url === null)
+        return null;
+    return url[1].endsWith('.git') ? url[1].slice(0, -4) : url[1];
+}
+/**
+ * Every commit-pinned allowBuilds key for one git source at one known commit
+ * (#784 by @sanqi-normal follow-up).
+ *
+ * Which pinned key pnpm checks depends on HOW it fetches the dependency,
+ * not on how the spec is spelled (review-measured on 11.7.0, empty store:
+ * a codeload download passes the codeload key and refuses the git+https#sha
+ * one; the git+https#sha refusal seen on dsh-better-sidebar came from a git
+ * clone fetch):
+ * - pnpm 11.21+ matches the stable unpinned clone-URL key (`gitAllowBuildsKey`).
+ * - a codeload download matches the commit-pinned codeload tarball URL.
+ * - a git clone matches the commit-pinned `name@git+https://…#<sha>` form,
+ *   and only when it matches the remote's own spelling (`.git` or not,
+ *   #665/#695 — pnpm matches the key literally).
+ *
+ * Writing ONE pinned form was the structural gap: a GitHub source derived
+ * only its codeload key, so a git-clone fetch ran with no key pnpm would
+ * read and only pnpm's own printed key could save the retry (#784's
+ * evidence). When the commit is known, BOTH pinned forms are written — one
+ * extra line in a YAML file versus the only button that could have
+ * unblocked the user.
+ *
+ * Non-GitHub remotes keep `pinnedGitAllowBuildsKey`'s single form: one key
+ * covers their fetch mode.
+ *
+ * @param sha - the commit the install will actually fetch.
+ * @returns the pinned keys (empty for no known git shape); callers merge the
+ *   stable key from `gitAllowBuildsKey` alongside.
+ */
+export function pinnedAllowBuildsKeys(name, spec, sha) {
+    if (!/^[0-9a-f]{40}$/.test(sha))
+        return [];
+    const githubRepo = repoFromTarget(spec)?.repo ?? githubRepoOfRemote(spec);
+    if (githubRepo !== null) {
+        // The git+https pinned form keeps the remote's own spelling (`.git` or
+        // not), which is what pnpm matches literally (#665/#695): reuse the
+        // stable key when one was derived, and only fall back to the canonical
+        // `.git` spelling when it was not.
+        const stable = gitAllowBuildsKey(name, spec);
+        const gitHttps = stable !== null && stable.startsWith(`${name}@git+https://`)
+            ? `${stable}#${sha}`
+            : `${name}@git+https://github.com/${githubRepo}.git#${sha}`;
+        return [
+            `${name}@https://codeload.github.com/${githubRepo}/tar.gz/${sha}`,
+            gitHttps,
+        ];
+    }
+    const pinned = pinnedGitAllowBuildsKey(name, spec, sha);
+    return pinned === null ? [] : [pinned];
+}
 /**
  * The pnpm install target for a registry entry. Repo-verified npm packages
  * win, followed by author-supplied prebuilt GitHub Release tarballs; both avoid

package/lib/types/patch.d.ts

@@ -137,12 +137,20 @@ export declare function packagePatchFlags(host: PatchHost, profileDirectory: str
     disabled: string[];
     forced: string[];
 };
-/** Disable one row: append `- id: X` + `disabled: true` (idempotent). */
+/**
+ * Disable one row: `- id: X` + `disabled: true` (idempotent).
+ *
+ * A force-enable block already there is flipped in place rather than
+ * followed by a second block (#821): the pair cancelled out by order alone,
+ * and an uninstall that cleared one of them left the other behind to switch
+ * a later reinstall off. Duplicates an older version left are folded into
+ * the one block at the same time.
+ */
 export declare function disableRow(patchPath: string, rowId: string): Promise<{
     ok: boolean;
     reason: string | null;
 }>;
-/** Enable one row: remove the `disabled: true` block; force-enable with
+/** Enable one row: remove its `disabled: true` blocks; force-enable with
  * `disabled: false` when a lower layer (bundle/home patch) holds it down. */
 export declare function enableRow(patchPath: string, rowId: string): Promise<{
     ok: boolean;

package/lib/types/sources.d.ts

@@ -103,6 +103,16 @@ export declare function githubRefOfTarget(spec: string): string | null;
  * never moves. That is #446, reached from a different direction.
  */
 export declare function gitRefOfTarget(spec: string): string | null;
+/**
+ * True when the spec's `#…` fragment carries a `semver:` range selector.
+ *
+ * A semver range is a line the user chose on purpose, like a branch: pnpm
+ * re-resolves inside that range, so a raw HEAD version ABOVE the range is not
+ * installable — asking it would advertise an update forever (#446 shape).
+ * `refOfFragment` deliberately answers null for those, so the update check
+ * needs this separate probe.
+ */
+export declare function hasSemverSelector(spec: string): boolean;
 /**
  * An immutable GitHub commit already carried by an install target.
  *
@@ -171,6 +181,46 @@ export declare function codeloadAllowBuildsKey(name: string, spec: string, sha:
  * stable key and never instead of it.
  */
 export declare function pinnedGitAllowBuildsKey(name: string, spec: string, sha: string): string | null;
+/**
+ * The repo (`owner/repo`, original case) of a GitHub remote spelled as a URL
+ * (`git+https://github.com/owner/repo.git`), or null for anything else.
+ *
+ * pnpm itself writes this spelling into the manifest for a GitHub source —
+ * the market sends `github:owner/repo`, pnpm answers with
+ * `git+https://owner/repo.git` (#803) — so the market must recognize it to
+ * keep deriving the GitHub keys for deps that only ever appear this way.
+ */
+export declare function githubRepoOfRemote(spec: string): string | null;
+/**
+ * Every commit-pinned allowBuilds key for one git source at one known commit
+ * (#784 by @sanqi-normal follow-up).
+ *
+ * Which pinned key pnpm checks depends on HOW it fetches the dependency,
+ * not on how the spec is spelled (review-measured on 11.7.0, empty store:
+ * a codeload download passes the codeload key and refuses the git+https#sha
+ * one; the git+https#sha refusal seen on dsh-better-sidebar came from a git
+ * clone fetch):
+ * - pnpm 11.21+ matches the stable unpinned clone-URL key (`gitAllowBuildsKey`).
+ * - a codeload download matches the commit-pinned codeload tarball URL.
+ * - a git clone matches the commit-pinned `name@git+https://…#<sha>` form,
+ *   and only when it matches the remote's own spelling (`.git` or not,
+ *   #665/#695 — pnpm matches the key literally).
+ *
+ * Writing ONE pinned form was the structural gap: a GitHub source derived
+ * only its codeload key, so a git-clone fetch ran with no key pnpm would
+ * read and only pnpm's own printed key could save the retry (#784's
+ * evidence). When the commit is known, BOTH pinned forms are written — one
+ * extra line in a YAML file versus the only button that could have
+ * unblocked the user.
+ *
+ * Non-GitHub remotes keep `pinnedGitAllowBuildsKey`'s single form: one key
+ * covers their fetch mode.
+ *
+ * @param sha - the commit the install will actually fetch.
+ * @returns the pinned keys (empty for no known git shape); callers merge the
+ *   stable key from `gitAllowBuildsKey` alongside.
+ */
+export declare function pinnedAllowBuildsKeys(name: string, spec: string, sha: string): string[];
 /**
  * The pnpm install target for a registry entry. Repo-verified npm packages
  * win, followed by author-supplied prebuilt GitHub Release tarballs; both avoid

package/lib/updates.js

@@ -8,10 +8,10 @@ import { join } from 'node:path';
 import { DIST_TAG } from './channels.js';
 import { resolveHeadCommit } from './accelerate.js';
 import { marketFetch } from './net.js';
-import { activeRegion } from './regions.js';
+import { activeRegion, githubRoutesFor, rememberGithubRoute, throughProxy } from './regions.js';
 import { hasDshManifest, profileDir, readGitResolutionCommit, readInstalled, readInstalledVersion, readLockCommits, readProfileBundles } from './profile.js';
 import { userPatchPackageReferences } from './patch.js';
-import { catalogRepoKey, gitCommitOfTarget, gitRefOfTarget, gitUploadPackUrl, hostedRepoKey, githubCommitOfTarget, githubRefOfTarget, isGenerationLink, isGitHostedSpec, lookupRepoFromUrl, repoOfTarget } from './sources.js';
+import { catalogRepoKey, gitCommitOfTarget, gitRefOfTarget, gitUploadPackUrl, hasSemverSelector, hostedRepoKey, githubCommitOfTarget, githubRefOfTarget, isGenerationLink, isGitHostedSpec, lookupRepoFromUrl, parseGitHubRemote, repoOfTarget } from './sources.js';
 /**
  * Whether a direct dependency is a plugin the update channel can apply (#793).
  *
@@ -295,6 +295,108 @@ export async function fetchNpmLatest(name) {
         return null;
     }
 }
+/** How long one raw-file route may take before the next candidate is tried. */
+const RAW_VERSION_TIMEOUT_MS = 6_000;
+/**
+ * The GitHub repo a spec installs from, plus the subpath whose `package.json`
+ * describes the installed package (#824), or null when the spec is not a
+ * GitHub one.
+ *
+ * Only GitHub gets its version read over the network: `raw.githubusercontent.com`
+ * is the raw spelling this market already speaks (a plugin page's README, a
+ * restore's manifest) and the only one with a per-region escape route. A
+ * gitlab or gitee install keeps the commit comparison, because inventing
+ * another host's raw URL would buy a failed request instead of a verdict.
+ */
+function githubRawTargetOf(spec) {
+    // `github:owner/repo` and `git+https://github.com/…` — the spelling the
+    // market itself writes for a floating install, which is the #824 case —
+    // both answer here, as does the codeload archive URL older regional
+    // installs carry. GitHub matches owner/repo case-insensitively, so the
+    // normalized casing is safe in a raw URL.
+    const repo = parseGitHubRemote(spec)?.repo.toLowerCase()
+        ?? repoOfTarget(spec)?.split('#')[0]
+        ?? null;
+    if (repo === null)
+        return null;
+    const hash = spec.indexOf('#');
+    const match = hash === -1 ? null : /(?:^|&)path:\/([^&\s]+)/.exec(spec.slice(hash + 1));
+    return { repo, subpath: match === null ? null : match[1] };
+}
+/**
+ * The `version` the repository publishes at the head of its default branch,
+ * or null when it cannot be read (#824).
+ *
+ * Route handling mirrors `resolveHeadCommit`: the region's candidates in
+ * order, the last verified winner first, and that winner remembered for the
+ * next check. Every failure — no candidate answers, a repo with no
+ * `package.json`, a body that is not JSON — is null, so the caller falls back
+ * to comparing commits rather than claiming the install is current.
+ */
+async function remoteGitVersion(spec, region) {
+    const target = githubRawTargetOf(spec);
+    if (target === null)
+        return null;
+    const file = target.subpath === null ? 'package.json' : `${target.subpath}/package.json`;
+    const url = `https://raw.githubusercontent.com/${target.repo}/HEAD/${file}`;
+    for (const route of githubRoutesFor('raw', region)) {
+        try {
+            const res = await marketFetch(throughProxy(route, url), {
+                headers: { accept: 'application/json', 'user-agent': 'dsh-market' },
+                signal: AbortSignal.timeout(RAW_VERSION_TIMEOUT_MS),
+            });
+            if (!res.ok)
+                continue;
+            const doc = await res.json();
+            const version = typeof doc.version === 'string' ? doc.version.trim() : '';
+            if (version === '')
+                continue;
+            rememberGithubRoute('raw', route);
+            return version;
+        }
+        catch {
+            // This route did not answer; the next candidate may.
+        }
+    }
+    return null;
+}
+/**
+ * Whether the repository's own `version` says there is something to install,
+ * for a git install that follows whatever the default branch points at (#824).
+ *
+ * A floating git install has no release boundary: every commit the branch
+ * gains makes the commit comparison unequal, so the row advertised "有新版本"
+ * forever while pnpm would install the same version the plugin's own updater
+ * had already put on disk. That is the mirror image of #446/#597 — those
+ * compared commits against a ref the user never chose; this one degrades the
+ * ref the user did choose, where "the line moved" is not the same question as
+ * "there is something new to install".
+ *
+ * @returns true/false when both versions are readable and comparable, and
+ *   null when the question cannot be answered that way: no installed version,
+ *   a spec that names a branch or tag on purpose (that line IS the user's
+ *   choice), a non-GitHub host, an unreachable raw file, or a version on
+ *   either side that is not semver. On null the caller must compare commits —
+ *   never read null as "current", or a private host would stop reporting
+ *   updates altogether.
+ */
+async function gitVersionUpdate(spec, installedVersion, region) {
+    if (installedVersion === null)
+        return null;
+    // `#branch`, `#tag`, and `#semver:` installs chose a line of their own: a
+    // new commit on it is exactly what those users asked to hear about (#446).
+    // `refOfFragment` skips `semver:` ranges (they compare against the default
+    // branch), so they need their own probe — otherwise a range pinned at ^2
+    // with a 3.0.0 at HEAD would advertise an install the range cannot produce.
+    const explicitRef = spec.startsWith('github:') ? githubRefOfTarget(spec) : gitRefOfTarget(spec);
+    if (explicitRef !== null || hasSemverSelector(spec))
+        return null;
+    const remoteVersion = await remoteGitVersion(spec, region);
+    if (remoteVersion === null)
+        return null;
+    const compared = compareVersions(remoteVersion, installedVersion);
+    return compared === null ? null : compared > 0;
+}
 /** Per-plugin update checks; a failed check reports no update rather than failing the listing. */
 export async function checkUpdates(profile, force = false, explicitDir, 
 /**
@@ -397,9 +499,14 @@ catalogNpmByRepo = new Map()) {
                 // default branch for a `#branch` install compares two lines that
                 // never converge, so the row reported an update forever (#446).
                 const latest = await resolveHeadCommit(repo, activeRegion(), process.env, githubRefOfTarget(spec) ?? undefined);
+                // A floating install has no release boundary: the commit comparison
+                // alone advertised "有新版本" forever on a branch that moved without
+                // publishing (#824). The repository's own version decides when both
+                // sides are readable; commits decide everything else.
+                const byVersion = await gitVersionUpdate(spec, version, activeRegion());
                 result[name] = {
                     kind: 'github', version, current, latest,
-                    updateAvailable: current !== null && latest !== null && current !== latest,
+                    updateAvailable: byVersion ?? (current !== null && latest !== null && current !== latest),
                 };
             }
             else if (isGitHostedSpec(spec)) {
@@ -419,9 +526,12 @@ catalogNpmByRepo = new Map()) {
                 // Ask about the ref the install actually names, exactly as the
                 // github branch above does (#446).
                 const latest = await resolveGitRemoteHead(spec, gitRefOfTarget(spec) ?? undefined);
+                // Same rule as the github branch above (#824): the repository's own
+                // version decides when both sides are readable, commits otherwise.
+                const byVersion = await gitVersionUpdate(spec, version, activeRegion());
                 result[name] = {
                     kind: 'github', version, current, latest,
-                    updateAvailable: current !== null && latest !== null && current !== latest,
+                    updateAvailable: byVersion ?? (current !== null && latest !== null && current !== latest),
                 };
             }
             else {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dshmarket",
   "description": "Visual plugin market inside DeepSeek Harness — browse, search, and one-click install community plugins. · DSH 可视化插件市场：逛一逛，点一下，装好。",
-  "version": "1.66.16",
+  "version": "1.66.17",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/patch.ts

@@ -428,6 +428,37 @@ function rowBlock(rowId: string, disabled: boolean): string {
   return `- id: ${rowId}\n  disabled: ${disabled ? 'true' : 'false'}\n`
 }
 
+/**
+ * Every two-line `- id: X` + `disabled: …` block for one row, in file order
+ * (#821). A row that goes on with more keys (`config:` and the like) is not
+ * one of these blocks: cutting its first two lines would leave the rest
+ * hanging off the entry above it. The last block of a file may lack its
+ * newline.
+ */
+function rowBlocksRe(rowId: string, disabled: 'true' | 'false' | 'any'): RegExp {
+  const id = escapeRegExp(rowId)
+  const value = disabled === 'any' ? '(?:true|false)' : disabled
+  return new RegExp(`^- id: (?:${id}|'${id}'|"${id}")[ \\t]*\\r?\\n  disabled: ${value}[ \\t]*(?:\\r?\\n(?![ \\t])|(?![\\s\\S]))`, 'gmu')
+}
+
+/**
+ * What the patch file finally says about one row: the flag of its last
+ * `- id: X` entry that carries one, rows with more keys included. Later
+ * entries override earlier ones.
+ */
+function lastRowFlag(text: string, rowId: string): 'true' | 'false' | null {
+  const id = escapeRegExp(rowId)
+  const idLine = new RegExp(`^- id: (?:${id}|'${id}'|"${id}")\\s*$`, 'u')
+  const lines = text.split(/\r?\n/u)
+  let flag: 'true' | 'false' | null = null
+  for (let index = 0; index < lines.length; index += 1) {
+    if (!idLine.test(lines[index] ?? '')) continue
+    const value = /^ {2}disabled: (true|false)\s*$/u.exec(lines[index + 1] ?? '')
+    if (value !== null) flag = value[1] as 'true' | 'false'
+  }
+  return flag
+}
+
 /**
  * Append one top-level patch entry, refusing when the file is not a valid
  * entry list. The refusal is the point: a malformed patch layer (the
@@ -488,12 +519,41 @@ function appendPatchEntry(patchPath: string, block: string): { ok: boolean; reas
   return { ok: true, reason: null }
 }
 
-/** Disable one row: append `- id: X` + `disabled: true` (idempotent). */
+/**
+ * Disable one row: `- id: X` + `disabled: true` (idempotent).
+ *
+ * A force-enable block already there is flipped in place rather than
+ * followed by a second block (#821): the pair cancelled out by order alone,
+ * and an uninstall that cleared one of them left the other behind to switch
+ * a later reinstall off. Duplicates an older version left are folded into
+ * the one block at the same time.
+ */
 export function disableRow(patchPath: string, rowId: string): Promise<{ ok: boolean; reason: string | null }> {
   return queuedWrite(async () => {
     if (!ROW_ID_RE.test(rowId)) {
       return { ok: false, reason: `行 id 含特殊字符,不支持写入补丁层 / row id ${rowId} cannot be written to the patch layer` }
     }
+    const text = (() => {
+      try { return readFileSync(patchPath, 'utf8') } catch { return '' }
+    })()
+    const blocks = text.match(rowBlocksRe(rowId, 'any')) ?? []
+    if (blocks.length > 1 || blocks.some(block => /disabled: false/u.test(block))) {
+      let kept = false
+      const next = text.replace(rowBlocksRe(rowId, 'any'), block => {
+        if (kept) return ''
+        kept = true
+        const flipped = rowBlock(rowId, true)
+        return block.includes('\r\n') ? flipped.replace(/\n/gu, '\r\n') : flipped
+      })
+      writeFileSync(patchPath, next)
+      // A longer entry for the row further down still has the last word.
+      if (lastRowFlag(next, rowId) !== 'true') {
+        const result = appendPatchEntry(patchPath, rowBlock(rowId, true))
+        if (!result.ok) return result
+      }
+      logEvent('info', 'patch', `disabled row ${rowId} in ${patchPath}`)
+      return { ok: true, reason: null }
+    }
     const state = readUserPatchState(patchPath)
     if (state.disables.includes(rowId)) return { ok: true, reason: null }
     const result = appendPatchEntry(patchPath, rowBlock(rowId, true))
@@ -502,7 +562,7 @@ export function disableRow(patchPath: string, rowId: string): Promise<{ ok: bool
   })
 }
 
-/** Enable one row: remove the `disabled: true` block; force-enable with
+/** Enable one row: remove its `disabled: true` blocks; force-enable with
  * `disabled: false` when a lower layer (bundle/home patch) holds it down. */
 export function enableRow(patchPath: string, rowId: string): Promise<{ ok: boolean; reason: string | null }> {
   return queuedWrite(async () => {
@@ -510,12 +570,12 @@ export function enableRow(patchPath: string, rowId: string): Promise<{ ok: boole
       return { ok: false, reason: `行 id 含特殊字符,不支持写入补丁层 / row id ${rowId} cannot be written to the patch layer` }
     }
     const state = readUserPatchState(patchPath)
-    const blockRe = new RegExp(`^- id: ['\"]?${escapeRegExp(rowId)}['\"]?\\r?\\n  disabled: true\\r?\\n`, 'mu')
     const text = (() => {
       try { return readFileSync(patchPath, 'utf8') } catch { return '' }
     })()
-    if (blockRe.test(text)) {
-      writeFileSync(patchPath, withPlaceholderRestored(text.replace(blockRe, '')))
+    const next = text.replace(rowBlocksRe(rowId, 'true'), '')
+    if (next !== text) {
+      writeFileSync(patchPath, withPlaceholderRestored(next))
       logEvent('info', 'patch', `enabled row ${rowId} in ${patchPath}`)
       return { ok: true, reason: null }
     }
@@ -551,10 +611,7 @@ export function removeRowBlocks(patchPath: string, rowIds: readonly string[]): v
     text = readFileSync(patchPath, 'utf8')
   } catch { return }
   let next = text
-  for (const rowId of rowIds) {
-    const blockRe = new RegExp(`^- id: ['\"]?${escapeRegExp(rowId)}['\"]?\\r?\\n  disabled: (?:true|false)\\r?\\n`, 'mu')
-    next = next.replace(blockRe, '')
-  }
+  for (const rowId of rowIds) next = next.replace(rowBlocksRe(rowId, 'any'), '')
   if (next !== text) {
     writeFileSync(patchPath, withPlaceholderRestored(next))
     logEvent('info', 'patch', `removed patch rows for ${rowIds.join(', ')}`)

package/src/routes.ts

@@ -8,8 +8,8 @@
  * same-origin POSTs and only sources present in the curated registry.
  */
 
-import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
 import { Readable } from 'node:stream'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { load as loadYaml } from 'js-yaml'
@@ -39,7 +39,7 @@ import { applyBundleOrder, mergeOrder, readBundleRules, readBundleStack, validat
 import { applyPreset, deletePreset, listPresets, previewPreset, savePreset } from './presets.ts'
 import { createProfileSnapshot, DEFAULT_MAX_SNAPSHOTS, deleteSnapshot, listSnapshots, restoreSnapshot } from './snapshot.ts'
 import { trialValidate } from './trial.ts'
-import { catalogRepoKey, codeloadAllowBuildsKey, findCatalogEntryForLocal, findInstalledAlias, gitCommitOfTarget, githubCommitOfTarget, githubTargetAtCommit, gitAllowBuildsKey, gitRefOfTarget, gitTargetAtCommit, gitUpdateTarget, hostedRepoKey, lookupRepoFromUrl, pinnedGitAllowBuildsKey, installTargetFor, isGenerationLink, isLocalSpec, NPM_NAME_RE, repoOfTarget, restoreBlockedByWorkspace, restoreTargetForLocal, sourceFallbackFor, workspaceProtocolDeps } from './sources.ts'
+import { catalogRepoKey, findCatalogEntryForLocal, findInstalledAlias, gitCommitOfTarget, githubCommitOfTarget, githubTargetAtCommit, gitAllowBuildsKey, gitRefOfTarget, gitTargetAtCommit, gitUpdateTarget, hostedRepoKey, lookupRepoFromUrl, pinnedAllowBuildsKeys, installTargetFor, isGenerationLink, isLocalSpec, NPM_NAME_RE, repoOfTarget, restoreBlockedByWorkspace, restoreTargetForLocal, sourceFallbackFor, workspaceProtocolDeps } from './sources.ts'
 import { failureDetail, groupConflictsByOwner, isStaleUpdate, parseIgnoredBuildEntries, parseIgnoredBuilds, parsePrepareKey, parsePrepareNotAllowed, pnpmBlockedByOpenFiles, pnpmNeverStarted, RELEASE_AGE_OVERRIDE, removeDanglingHostBridge, retargetCollections, validateAddedPlugins, withHoistRecovery } from './install.ts'
 import { classifyPnpmFailure } from './pnpm-compat.ts'
 import { asChannel, CHANNELS, DIST_TAG, resolveChannel, type Channel } from './channels.ts'
@@ -53,6 +53,7 @@ import { updateNotesFor } from './changelog.ts'
 import { checkUpdates, isUpdatablePlugin, compareVersions, fetchNpmLatest, invalidateUpdates, resolveGitRemoteHead, isUpgrade, latestPublishedRecently, setUpdateRegistry, versionOnChannel } from './updates.ts'
 import { createThemeManager, type LoaderEntry } from './themes.ts'
 import { readJsonBody, refuseUnadmitted, sameOrigin, sendJson } from './http.ts'
+import { resolveDshHome } from './home-paths.ts'
 import { detectedDebugger, detectedSupervisor, restartAllowed, scheduleRestart, servingPort, trustedRestartRequest, trustedDownloadRequest, type RecoveryHandoffConfig, restartReachableFrom } from './restart.ts'
 import type { RecoveryPlugin } from './recovery.ts'
 import { activationAfterReplace, brokenClientBundles, bundlePatchIsEmpty, checkClientBundle, defaultHostRuntimeFacts, hasHostHalf, hostPeerGate, newlyBrokenBundles, peerGateRemedy, verifyActivation } from './verify.ts'
@@ -331,6 +332,51 @@ const PROFILE_HMR_REPLAY_WAIT_MS = 8000
  */
 const printedBuildKeys = new Map<string, string | null>()
 
+// #784: pnpm's printed key is the most authoritative spelling of what the
+// PENDING install needs allowlisted, and it used to live only in the map
+// above — a DSH restart between the failure and the "allow build scripts"
+// click dropped it, leaving the button to derive keys from the OLD installed
+// pin and the retry to fail byte-identically. Persisted best-effort under the
+// Harness home; every failure here degrades to the in-memory behavior.
+//
+// The path is resolved lazily (not at module load) so the home in force when
+// the first failure is recorded is the one the file lands under. The load is
+// also lazy — but every reader (blockedBuilds before it records, printedKeysFor
+// before it answers) goes through printedBuildKeysFile() first, so a key from
+// a previous process is on the map before this one either adds to or reads it.
+// Stored keys never overwrite a fresher in-memory one, so the order of the
+// two calls cannot resurrect a stale entry either way.
+let printedBuildKeysHome: string | null = null
+let printedBuildKeysFilePath: string | null = null
+function printedBuildKeysFile(): string {
+  const home = resolveDshHome()
+  // Cached per home, not per process: the tests swap DSH_HOME per case, and
+  // a restart handoff can change it under a long-lived process too.
+  if (printedBuildKeysHome !== home) {
+    printedBuildKeysHome = home
+    printedBuildKeysFilePath = join(home, 'dsh-market', 'printed-build-keys.json')
+    try {
+      const stored = JSON.parse(readFileSync(printedBuildKeysFilePath, 'utf8')) as Record<string, unknown>
+      for (const [storedName, storedKey] of Object.entries(stored)) {
+        if (typeof storedKey === 'string' && !printedBuildKeys.has(storedName)) printedBuildKeys.set(storedName, storedKey)
+      }
+    } catch { /* absent or unreadable: start empty */ }
+  }
+  return printedBuildKeysFilePath!
+}
+
+function persistPrintedBuildKeys(): void {
+  try {
+    const file = printedBuildKeysFile()
+    // Bounded: one entry per package name that ever failed a build here.
+    while (printedBuildKeys.size > 500) {
+      printedBuildKeys.delete(printedBuildKeys.keys().next().value as string)
+    }
+    mkdirSync(dirname(file), { recursive: true })
+    writeFileSync(file, JSON.stringify(Object.fromEntries(printedBuildKeys), null, 2))
+  } catch { /* best-effort: an unwritable home keeps the in-memory map */ }
+}
+
 function blockedBuilds(result: { ignoredBuilds?: unknown; stdout: string; stderr: string }): string[] | undefined {
   // Record pnpm's own dep path for every ignored build BEFORE deciding what to
   // report. Both returns below hand back BARE names, so a git plugin whose
@@ -341,16 +387,21 @@ function blockedBuilds(result: { ignoredBuilds?: unknown; stdout: string; stderr
   // back byte-identical.
   //
   // Only entries that name a source are worth recording: a registry dep's dep
-  // path IS its bare name, which the bare entry already authorizes.
+  // path IS its bare name, which the bare entry already authorizes. The
+  // persisted file is loaded FIRST (PR #822 review): a key recorded before
+  // the load ran would otherwise be replaced by the older one in the file.
+  printedBuildKeysFile()
   for (const entry of parseIgnoredBuildEntries(result.stdout, result.stderr)) {
     if (entry.key !== entry.name) printedBuildKeys.set(entry.name, entry.key)
   }
+  persistPrintedBuildKeys()
   if (Array.isArray(result.ignoredBuilds) && result.ignoredBuilds.length > 0) return result.ignoredBuilds as string[]
   const list = parseIgnoredBuilds(result.stdout, result.stderr)
   if (list.length > 0) return list
   const pending = parsePrepareNotAllowed(result.stdout, result.stderr)
   if (pending === null) return undefined
   printedBuildKeys.set(pending, parsePrepareKey(result.stdout, result.stderr))
+  persistPrintedBuildKeys()
   return [pending]
 }
 
@@ -940,7 +991,9 @@ export function mountMarketRoutes(
             if (prePatch !== null && prePatch.disables.includes(rowId)) {
               const back = await disableRow(userPatchPath, rowId)
               if (!back.ok) logEvent('warn', 'toggle', `${name}: patch row ${rowId} could not be put back — ${back.reason}`)
-            } else {
+            } else if (prePatch === null || !prePatch.forced.includes(rowId)) {
+              // A row already forced on before this call got nothing from
+              // the enable; that block is the user's to keep.
               removeRowBlocks(userPatchPath, [rowId])
             }
           }
@@ -5386,10 +5439,14 @@ sendJson(response, 200, { updates })
               : gitCommitOfTarget(spec)
                 ?? await resolveGitRemoteHead(spec, gitRefOfTarget(spec) ?? undefined)
             if (pinned === null || pinned === undefined) return [stable]
-            const pinnedKey = repo !== null
-              ? codeloadAllowBuildsKey(name, spec, pinned)
-              : pinnedGitAllowBuildsKey(name, spec, pinned)
-            return pinnedKey === null ? [stable] : [stable, pinnedKey]
+            // Both pinned key forms, for either fetch mode (#784): a codeload
+            // download matches the codeload key (review-measured on 11.7.0,
+            // empty store), while a git clone matches the commit-pinned
+            // git+https key, in the remote's own spelling. Deriving only the
+            // codeload form left a git-clone fetch with no key pnpm would
+            // read.
+            const pinnedKeys = pinnedAllowBuildsKeys(name, spec, pinned)
+            return pinnedKeys.length === 0 ? [stable] : [stable, ...pinnedKeys]
           }
           /**
            * The allowBuilds key pnpm itself printed when it refused this
@@ -5404,6 +5461,10 @@ sendJson(response, 200, { updates })
            * naming the dep path it wants allowlisted.
            */
           const printedKeysFor = (name: string): string[] => {
+            // Load FIRST (PR #822 review): the in-memory map starts empty in a
+            // new process, and the key pnpm printed before the restart lives
+            // in the persisted file until this call brings it back.
+            printedBuildKeysFile()
             const printed = printedBuildKeys.get(name)
             return printed === null || printed === undefined ? [] : [printed]
           }

package/src/sources.ts

@@ -264,6 +264,21 @@ export function gitRefOfTarget(spec: string): string | null {
   return refOfFragment(spec)
 }
 
+/**
+ * True when the spec's `#…` fragment carries a `semver:` range selector.
+ *
+ * A semver range is a line the user chose on purpose, like a branch: pnpm
+ * re-resolves inside that range, so a raw HEAD version ABOVE the range is not
+ * installable — asking it would advertise an update forever (#446 shape).
+ * `refOfFragment` deliberately answers null for those, so the update check
+ * needs this separate probe.
+ */
+export function hasSemverSelector(spec: string): boolean {
+  const fragmentAt = spec.indexOf('#')
+  if (fragmentAt === -1) return false
+  return spec.slice(fragmentAt + 1).split('&').some(s => s.startsWith('semver:'))
+}
+
 /** The branch or tag a `#…` fragment selects, or null for the default branch. */
 function refOfFragment(spec: string): string | null {
   const fragmentAt = spec.indexOf('#')
@@ -406,6 +421,73 @@ export function pinnedGitAllowBuildsKey(name: string, spec: string, sha: string)
   return remote === null ? null : `${name}@${remote}#${sha}`
 }
 
+/**
+ * The repo (`owner/repo`, original case) of a GitHub remote spelled as a URL
+ * (`git+https://github.com/owner/repo.git`), or null for anything else.
+ *
+ * pnpm itself writes this spelling into the manifest for a GitHub source —
+ * the market sends `github:owner/repo`, pnpm answers with
+ * `git+https://owner/repo.git` (#803) — so the market must recognize it to
+ * keep deriving the GitHub keys for deps that only ever appear this way.
+ */
+export function githubRepoOfRemote(spec: string): string | null {
+  const remote = gitRemoteSpelling(spec)
+  if (remote === null) return null
+  const url = /^git\+https:\/\/github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?$/i.exec(remote)
+  if (url === null) return null
+  return url[1]!.endsWith('.git') ? url[1]!.slice(0, -4) : url[1]!
+}
+
+/**
+ * Every commit-pinned allowBuilds key for one git source at one known commit
+ * (#784 by @sanqi-normal follow-up).
+ *
+ * Which pinned key pnpm checks depends on HOW it fetches the dependency,
+ * not on how the spec is spelled (review-measured on 11.7.0, empty store:
+ * a codeload download passes the codeload key and refuses the git+https#sha
+ * one; the git+https#sha refusal seen on dsh-better-sidebar came from a git
+ * clone fetch):
+ * - pnpm 11.21+ matches the stable unpinned clone-URL key (`gitAllowBuildsKey`).
+ * - a codeload download matches the commit-pinned codeload tarball URL.
+ * - a git clone matches the commit-pinned `name@git+https://…#<sha>` form,
+ *   and only when it matches the remote's own spelling (`.git` or not,
+ *   #665/#695 — pnpm matches the key literally).
+ *
+ * Writing ONE pinned form was the structural gap: a GitHub source derived
+ * only its codeload key, so a git-clone fetch ran with no key pnpm would
+ * read and only pnpm's own printed key could save the retry (#784's
+ * evidence). When the commit is known, BOTH pinned forms are written — one
+ * extra line in a YAML file versus the only button that could have
+ * unblocked the user.
+ *
+ * Non-GitHub remotes keep `pinnedGitAllowBuildsKey`'s single form: one key
+ * covers their fetch mode.
+ *
+ * @param sha - the commit the install will actually fetch.
+ * @returns the pinned keys (empty for no known git shape); callers merge the
+ *   stable key from `gitAllowBuildsKey` alongside.
+ */
+export function pinnedAllowBuildsKeys(name: string, spec: string, sha: string): string[] {
+  if (!/^[0-9a-f]{40}$/.test(sha)) return []
+  const githubRepo = repoFromTarget(spec)?.repo ?? githubRepoOfRemote(spec)
+  if (githubRepo !== null) {
+    // The git+https pinned form keeps the remote's own spelling (`.git` or
+    // not), which is what pnpm matches literally (#665/#695): reuse the
+    // stable key when one was derived, and only fall back to the canonical
+    // `.git` spelling when it was not.
+    const stable = gitAllowBuildsKey(name, spec)
+    const gitHttps = stable !== null && stable.startsWith(`${name}@git+https://`)
+      ? `${stable}#${sha}`
+      : `${name}@git+https://github.com/${githubRepo}.git#${sha}`
+    return [
+      `${name}@https://codeload.github.com/${githubRepo}/tar.gz/${sha}`,
+      gitHttps,
+    ]
+  }
+  const pinned = pinnedGitAllowBuildsKey(name, spec, sha)
+  return pinned === null ? [] : [pinned]
+}
+
 /**
  * The pnpm install target for a registry entry. Repo-verified npm packages
  * win, followed by author-supplied prebuilt GitHub Release tarballs; both avoid

package/src/updates.ts

@@ -9,10 +9,10 @@ import { join } from 'node:path'
 import { DIST_TAG, type Channel } from './channels.ts'
 import { resolveHeadCommit } from './accelerate.ts'
 import { marketFetch } from './net.ts'
-import { activeRegion } from './regions.ts'
+import { activeRegion, githubRoutesFor, rememberGithubRoute, throughProxy, type Region } from './regions.ts'
 import { hasDshManifest, profileDir, readGitResolutionCommit, readInstalled, readInstalledVersion, readLockCommits, readProfileBundles } from './profile.ts'
 import { userPatchPackageReferences } from './patch.ts'
-import { catalogRepoKey, gitCommitOfTarget, gitRefOfTarget, gitUploadPackUrl, hostedRepoKey, githubCommitOfTarget, githubRefOfTarget, isGenerationLink, isGitHostedSpec, lookupRepoFromUrl, repoOfTarget } from './sources.ts'
+import { catalogRepoKey, gitCommitOfTarget, gitRefOfTarget, gitUploadPackUrl, hasSemverSelector, hostedRepoKey, githubCommitOfTarget, githubRefOfTarget, isGenerationLink, isGitHostedSpec, lookupRepoFromUrl, parseGitHubRemote, repoOfTarget } from './sources.ts'
 
 export interface UpdateStatus {
   /**
@@ -345,6 +345,108 @@ export async function fetchNpmLatest(name: string): Promise<string | null> {
   }
 }
 
+/** How long one raw-file route may take before the next candidate is tried. */
+const RAW_VERSION_TIMEOUT_MS = 6_000
+
+/**
+ * The GitHub repo a spec installs from, plus the subpath whose `package.json`
+ * describes the installed package (#824), or null when the spec is not a
+ * GitHub one.
+ *
+ * Only GitHub gets its version read over the network: `raw.githubusercontent.com`
+ * is the raw spelling this market already speaks (a plugin page's README, a
+ * restore's manifest) and the only one with a per-region escape route. A
+ * gitlab or gitee install keeps the commit comparison, because inventing
+ * another host's raw URL would buy a failed request instead of a verdict.
+ */
+function githubRawTargetOf(spec: string): { repo: string; subpath: string | null } | null {
+  // `github:owner/repo` and `git+https://github.com/…` — the spelling the
+  // market itself writes for a floating install, which is the #824 case —
+  // both answer here, as does the codeload archive URL older regional
+  // installs carry. GitHub matches owner/repo case-insensitively, so the
+  // normalized casing is safe in a raw URL.
+  const repo = parseGitHubRemote(spec)?.repo.toLowerCase()
+    ?? repoOfTarget(spec)?.split('#')[0]
+    ?? null
+  if (repo === null) return null
+  const hash = spec.indexOf('#')
+  const match = hash === -1 ? null : /(?:^|&)path:\/([^&\s]+)/.exec(spec.slice(hash + 1))
+  return { repo, subpath: match === null ? null : match[1]! }
+}
+
+/**
+ * The `version` the repository publishes at the head of its default branch,
+ * or null when it cannot be read (#824).
+ *
+ * Route handling mirrors `resolveHeadCommit`: the region's candidates in
+ * order, the last verified winner first, and that winner remembered for the
+ * next check. Every failure — no candidate answers, a repo with no
+ * `package.json`, a body that is not JSON — is null, so the caller falls back
+ * to comparing commits rather than claiming the install is current.
+ */
+async function remoteGitVersion(spec: string, region: Region): Promise<string | null> {
+  const target = githubRawTargetOf(spec)
+  if (target === null) return null
+  const file = target.subpath === null ? 'package.json' : `${target.subpath}/package.json`
+  const url = `https://raw.githubusercontent.com/${target.repo}/HEAD/${file}`
+  for (const route of githubRoutesFor('raw', region)) {
+    try {
+      const res = await marketFetch(throughProxy(route, url), {
+        headers: { accept: 'application/json', 'user-agent': 'dsh-market' },
+        signal: AbortSignal.timeout(RAW_VERSION_TIMEOUT_MS),
+      })
+      if (!res.ok) continue
+      const doc = await res.json() as { version?: unknown }
+      const version = typeof doc.version === 'string' ? doc.version.trim() : ''
+      if (version === '') continue
+      rememberGithubRoute('raw', route)
+      return version
+    } catch {
+      // This route did not answer; the next candidate may.
+    }
+  }
+  return null
+}
+
+/**
+ * Whether the repository's own `version` says there is something to install,
+ * for a git install that follows whatever the default branch points at (#824).
+ *
+ * A floating git install has no release boundary: every commit the branch
+ * gains makes the commit comparison unequal, so the row advertised "有新版本"
+ * forever while pnpm would install the same version the plugin's own updater
+ * had already put on disk. That is the mirror image of #446/#597 — those
+ * compared commits against a ref the user never chose; this one degrades the
+ * ref the user did choose, where "the line moved" is not the same question as
+ * "there is something new to install".
+ *
+ * @returns true/false when both versions are readable and comparable, and
+ *   null when the question cannot be answered that way: no installed version,
+ *   a spec that names a branch or tag on purpose (that line IS the user's
+ *   choice), a non-GitHub host, an unreachable raw file, or a version on
+ *   either side that is not semver. On null the caller must compare commits —
+ *   never read null as "current", or a private host would stop reporting
+ *   updates altogether.
+ */
+async function gitVersionUpdate(
+  spec: string,
+  installedVersion: string | null,
+  region: Region,
+): Promise<boolean | null> {
+  if (installedVersion === null) return null
+  // `#branch`, `#tag`, and `#semver:` installs chose a line of their own: a
+  // new commit on it is exactly what those users asked to hear about (#446).
+  // `refOfFragment` skips `semver:` ranges (they compare against the default
+  // branch), so they need their own probe — otherwise a range pinned at ^2
+  // with a 3.0.0 at HEAD would advertise an install the range cannot produce.
+  const explicitRef = spec.startsWith('github:') ? githubRefOfTarget(spec) : gitRefOfTarget(spec)
+  if (explicitRef !== null || hasSemverSelector(spec)) return null
+  const remoteVersion = await remoteGitVersion(spec, region)
+  if (remoteVersion === null) return null
+  const compared = compareVersions(remoteVersion, installedVersion)
+  return compared === null ? null : compared > 0
+}
+
 /** Per-plugin update checks; a failed check reports no update rather than failing the listing. */
 export async function checkUpdates(
   profile: string,
@@ -453,9 +555,14 @@ export async function checkUpdates(
         const latest = await resolveHeadCommit(
           repo, activeRegion(), process.env, githubRefOfTarget(spec) ?? undefined,
         )
+        // A floating install has no release boundary: the commit comparison
+        // alone advertised "有新版本" forever on a branch that moved without
+        // publishing (#824). The repository's own version decides when both
+        // sides are readable; commits decide everything else.
+        const byVersion = await gitVersionUpdate(spec, version, activeRegion())
         result[name] = {
           kind: 'github', version, current, latest,
-          updateAvailable: current !== null && latest !== null && current !== latest,
+          updateAvailable: byVersion ?? (current !== null && latest !== null && current !== latest),
         }
       } else if (isGitHostedSpec(spec)) {
         // Private / self-hosted git (Gitea, GitLab, raw git+https). Never ask
@@ -474,9 +581,12 @@ export async function checkUpdates(
         // Ask about the ref the install actually names, exactly as the
         // github branch above does (#446).
         const latest = await resolveGitRemoteHead(spec, gitRefOfTarget(spec) ?? undefined)
+        // Same rule as the github branch above (#824): the repository's own
+        // version decides when both sides are readable, commits otherwise.
+        const byVersion = await gitVersionUpdate(spec, version, activeRegion())
         result[name] = {
           kind: 'github', version, current, latest,
-          updateAvailable: current !== null && latest !== null && current !== latest,
+          updateAvailable: byVersion ?? (current !== null && latest !== null && current !== latest),
         }
       } else {
         // A URL install (release archive, self-hosted tarball) has no