dsh-plugin-shop 0.8.5 → 0.8.6

package/lib/types/client/restart-monitor.d.ts

@@ -30,12 +30,24 @@
  * records the request before anything is awaited, and a request whose path is
  * withdrawn mid-call is asked again through a live one. The host answers a
  * repeat with the restart it already committed.
+ *
+ * The VERDICT outlives the page, since 2026-10-06. The monitor reloads on
+ * any origin that keeps answering, and a process that never exited answers
+ * as steadily as one that replaced it: on macOS a confirmed restart reloaded
+ * into the very process it had asked to go, and the row went on showing the
+ * version before the update with nothing to say why. A commit therefore
+ * records, in this tab's sessionStorage, which process committed it (its
+ * boot identity and pid), and every version answer the reloaded page
+ * receives is judged against that record (`noteBoot`).
  */
 import type { ShopRestartResult } from '../host/index.ts';
 /** What this page is doing about a restart: waiting for the host to answer
- * the confirm, waiting for the new server once it committed, or given up on
- * that server. `logFile` is where the host said the new process writes; a
- * host older than that field sends none. */
+ * the confirm, waiting for the new server once it committed, given up on
+ * that server, or reloaded into the process that was asked to restart and
+ * found it still answering — `pid` is that process. `logFile` is where the
+ * host said the new process writes; a host older than that field sends
+ * none, and one older than the boot identity sends no `pid` and is never
+ * judged `not-restarted` at all. */
 export type RestartMonitorState = {
     kind: 'requesting';
 } | {
@@ -44,6 +56,10 @@ export type RestartMonitorState = {
 } | {
     kind: 'failed';
     logFile?: string;
+} | {
+    kind: 'not-restarted';
+    pid?: number;
+    logFile?: string;
 };
 /** How one press ended, for the panel that made it: the page follows the
  * restart from here, the host refused it, or it never reached a host that
@@ -79,6 +95,8 @@ export declare function subscribeRestartMonitor(listener: () => void): () => voi
 export declare function startRestartMonitor(options: {
     reload: () => void;
     logFile?: string;
+    bootId?: string;
+    pid?: number;
 }): void;
 /**
  * Register one module instance's path to the host; the client half's apply
@@ -107,8 +125,21 @@ export declare function requestRestart(options: {
     reload: () => void;
     restart: () => Promise<ShopRestartResult>;
 }): Promise<RestartRequestOutcome>;
-/** Stop the probe loop and forget the page's restart, its request and every
- * registered path. Nothing in the page calls this — a committed restart ends
- * in a reload or a failure — so its caller is a test isolating one case from
- * the next. */
+/**
+ * Judge this tab's last committed restart by the process answering now. The
+ * client half hands every `version()` answer here (index.ts), so the verdict
+ * is made on the first answer a reloaded page receives, before any tab opens.
+ *
+ * The same boot as the one that committed is a restart that never happened:
+ * the page says so, naming that process, for as long as it keeps answering
+ * — across reloads too, since the record stays. Any other answer, an older
+ * host's included, is a process that replaced it, and the record is spent.
+ * Nothing is judged while this page's own restart is under way: the process
+ * that committed answers until it exits, two seconds later.
+ */
+export declare function noteBoot(bootId: string | undefined): void;
+/** Stop the probe loop and forget the page's restart, its request, every
+ * registered path and the tab's record of its last commit. Nothing in the
+ * page calls this — a committed restart ends in a reload or a failure — so
+ * its caller is a test isolating one case from the next. */
 export declare function resetRestartMonitor(): void;

package/lib/types/client/useFlows.d.ts

@@ -40,6 +40,12 @@ export interface UseKeyedFlows<TArgs> {
      * registry's settle callback can supersede the other's receipt for the same
      * key without taking a dependency on that registry's output. */
     resetFlow: (key: string) => void;
+    /** Return every identity whose view `predicate` selects to `idle`, and
+     * nothing else. Stable across renders like `resetFlow`; a call selecting
+     * nothing leaves the registry — and so every flow and `pending` — exactly
+     * as it was. The tab clears the receipts dsh restarting under it settled
+     * with this (design §8, 2026-10-06 amendment). */
+    resetWhere: (predicate: (view: InstallView) => boolean) => void;
     /**
      * The identities whose flow is not `idle` — asked by the shelf, which has
      * to keep a settled uninstall's row in the Installed view after the

package/lib/types/client/useUpdateSelf.d.ts

@@ -10,6 +10,11 @@ export interface UseUpdateSelfResult {
     start: (args: {
         version: string;
     }) => Promise<void>;
+    /** Return the view to `idle` when `predicate` selects it; stable across
+     * renders. The keyed registries' `resetWhere`, for the one self-update:
+     * dsh restarting under the page settles an update that was waiting for
+     * exactly that (design §8, 2026-10-06 amendment). */
+    resetWhere: (predicate: (view: InstallView) => boolean) => void;
 }
 /** Drive one self-update: the host's business union, the shared polling
  * loop, and terminal states. The `rejected` install state never occurs. */

package/lib/types/host/index.d.ts

@@ -237,6 +237,17 @@ export interface ShopVersionResult {
      * the process running (design §7.3, 2026-09-27 amendment).
      */
     pendingVersion?: string | null;
+    /**
+     * Which process answered (own-version.ts `bootId`): fixed for its life and
+     * different in the next. The client compares it across a reconnect — a new
+     * one is dsh restarted under the page — and across a restart's reload —
+     * the same one is a restart that never happened (design §8, 2026-10-06
+     * amendment).
+     *
+     * This host always sends it. Absent, it comes from a host older than the
+     * field, and the client judges nothing by it.
+     */
+    bootId?: string;
 }
 /** `shop/updateStart` result (§7.3): the self-update spawn, or a typed
  * refusal (a version that is not plain semver). */
@@ -251,16 +262,24 @@ export type ShopUpdateResult = {
 /** `shop/installed` entry (§7.3): one installed catalog plugin. The identity
  * fields distinguish same-named npm and GitHub rows; `installed` remains the
  * manifest spec or the recorded GitHub pin, and the client never does version
- * math. */
+ * math.
+ *
+ * `shadowed` marks a row synthesized from the profile manifest for an
+ * installed GitHub dependency whose name an npm catalog entry now holds: the
+ * catalog row itself is refused `shadowed-by-npm`, so this row is the only
+ * one the user can act on. It carries no catalog `latest` (hence the union)
+ * and no `outdated` verdict, because there is no catalog truth to compare
+ * against. */
 export interface ShopInstalledEntry {
     name: string;
     source: 'npm' | 'github';
     repo?: string;
     subdir?: string;
     installed: string;
-    latest: string;
+    latest: string | null;
     outdated: boolean;
     enabled: boolean;
+    shadowed?: true;
 }
 /** How many bytes a release tarball may be at the integrity check. The
  * registry already refuses to publish a tarball over 32 MiB, so 64 MiB is

package/lib/types/host/restart.d.ts

@@ -15,10 +15,18 @@
  * manual command and `logFile`, the file the new process's output goes to:
  * where a boot that died explains itself, at a path that depends on DSH_HOME
  * and the shop row's `cacheDir`, which only the host knows. A host older than
- * the field answers without it, so the client reads it as optional. */
+ * the field answers without it, so the client reads it as optional.
+ *
+ * `bootId` and `pid` name the process that committed: its boot identity
+ * (own-version.ts) and the pid the takeover waits on. A page reloaded into a
+ * process with that same boot is a restart that never happened, and the pid
+ * is what the reader has to stop by hand (design §8, 2026-10-06 amendment).
+ * Optional for the same older-host reason as `logFile`. */
 export type RestartOutcome = {
     ok: true;
     logFile?: string;
+    bootId?: string;
+    pid?: number;
 } | {
     ok: false;
     detail: string;

package/lib/types/host/types.d.ts

@@ -109,6 +109,10 @@ export interface CatalogEntry {
      * 6,492 live github entries — which is the plugin's own cost and not the
      * repository's; registry `Entry.installSize` carries the measured caveat. */
     installSize?: number;
+    /** Whether GitHub reports the repository as archived (design 2026-10-08
+     * §1.3). github entries only, additive and optional: the shelf badges it
+     * and nothing else — install, update, and enable are unchanged. */
+    archived?: boolean;
 }
 export interface DeniedEntry {
     name: string;

package/lib/types/own-version.d.ts

@@ -1,6 +1,7 @@
 /** The shop's own published version, read from the package.json that ships
  * next to this package — the RUNNING version, not the manifest's range
- * spec. This lives at the package root (not under src/host) on purpose:
+ * spec — and the identity of the process running it (`bootId`). This lives
+ * at the package root (not under src/host) on purpose:
  * both the source tree (tests) and the bundled `lib/index.js` sit exactly
  * one level below the package root, so the same relative URL resolves in
  * both. */
@@ -21,6 +22,17 @@ export declare function versionAtLoad(read: () => string): () => string;
 /** The version of the code in this process, read when the module was first
  * evaluated — at boot, before any self-update could rewrite the file. */
 export declare const runningVersion: () => string;
+/**
+ * Which run of the code this is: drawn when the module is first evaluated,
+ * fixed for the life of the process, and different in the next one.
+ *
+ * The version cannot answer that. A restart that installed no new shop keeps
+ * it, and so does one that never happened — which is what a page reloaded
+ * into the process it asked to restart could not tell apart from success,
+ * and showed as a self-update that silently did not land (design §8,
+ * 2026-10-06 amendment).
+ */
+export declare const bootId: string;
 /**
  * The peer ranges this build declares — the input to the load-time harness
  * self-check. Read from the same shipped manifest as `runningVersion`, so the

package/lib/types/shared/zh-intents.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The Chinese → English query dictionary whose expansion the shelf search
+ * applies (design `2026-10-08-search-query-expansion.md` §2–§4, borrowing C2
+ * from `2026-09-26-market-borrowings.md`; reference: 2BingLing/dsh-market's
+ * `plugin/core/src/zh-intent.ts`).
+ *
+ * The dictionary is a curated DATA table, not code. It lives here, in
+ * `src/shared/` (mirroring `src/shared/identity.ts`), because the seam is
+ * one shared filter module and a later consumer in `host/` should not have
+ * to change paths to use it; today the only caller is `client/present.ts`.
+ *
+ * One intent is `{ key, words, terms }`:
+ * - `words` are the Chinese trigger phrases. A query containing any of them,
+ *   as a lowercase substring, fires the intent. They are always ≥ 2 Han
+ *   characters so a stray Han in an English query never fires one.
+ * - `terms` are the recall vocabulary scanned against each entry's name,
+ *   `summary.en`, `summary.zh` and category key. A term prefixed with `#`
+ *   is matched on a WORD BOUNDARY, not as a substring: `#ai` refuses to
+ *   fire on `email`, `main`, `pipeline` and fires on `ai-chat`, `AI聊天`.
+ *   The marker exists because, without it, 2BingLing measured 713 false
+ *   `ai` hits in 9,145 entries; on our own 2026-10-08 catalog (14,167
+ *   entries), `#ai` holds `AI大模型` to 2,760 hits instead of the many
+ *   thousand the bare token would match.
+ *
+ * Credit: the trigger-to-recall structure, the `#` boundary marker, and
+ * the "curated, defensive, every-term-measured" discipline are all from
+ * 2BingLing/dsh-market's `zh-intent.ts`, read live 2026-10-08. The
+ * dictionary's rows are our own, trimmed from theirs against the live
+ * catalog (`2026-10-08-search-query-expansion.md` §3): the four intents
+ * their data also shows to be dead in our ecosystem (`农历节日`, `Twitter`,
+ * `微博`, `Notion`) were dropped because their marginal recall was 3 to 7.
+ */
+/** One curated intent. UI surfaces name `key` when they cite the expansion. */
+export interface ZhIntent {
+    /** The intent's label, always a short Chinese phrase. */
+    key: string;
+    /** Trigger words: any substring match on the lowercased query fires it. */
+    words: readonly string[];
+    /**
+     * Recall terms: any substring match (or word-boundary match, for a term
+     * prefixed with `#`) on the lowercased entry fields recalls that entry.
+     */
+    terms: readonly string[];
+}
+/**
+ * The recall side of an intent that fired for a query.
+ *
+ * The result is always deduplicated and ordered by the dictionary's rows;
+ * the query itself, lowercased, is always the FIRST element of `terms`, so
+ * the 18 author-written `summary.zh` entries today are always reachable
+ * through the raw query and never depend on a dictionary expansion.
+ */
+export interface ZhExpansion {
+    /** The user's query, trimmed and lowercased. */
+    query: string;
+    /** The intent keys that fired, in dictionary order. */
+    intents: readonly string[];
+    /** The fired intents with their surviving recall terms, deduplicated. */
+    expansions: readonly {
+        intent: string;
+        terms: readonly string[];
+    }[];
+    /** Every recall term, deduplicated, query first. */
+    terms: readonly string[];
+}
+export declare function tokenInText(term: string, text: string): boolean;
+/**
+ * The curated dictionary. Ordered by design §3's measured marginal recall
+ * (largest first). Rows trimmed from 2BingLing's eighty-four to eighty by
+ * dropping the four whose marginal recall on the 2026-10-08 catalog was
+ * single-digit: `农历节日`, `Twitter`, `微博`, `Notion`.
+ *
+ * To add a row: write the intent's key in Chinese, its triggers (≥ 2 Han
+ * characters each, as a defensive rule, so an isolated Han inside someone
+ * else's name never fires the intent), its recall terms with `#` where a
+ * bare short Latin term would otherwise act like a substring, and one
+ * comment line pointing at this document's measured table.
+ */
+export declare const ZH_INTENTS: readonly ZhIntent[];
+/**
+ * Fire every intent whose trigger appears in the query (lowercase, substring),
+ * deduplicate the recall vocabulary, and return the query itself first.
+ *
+ * The call site never has to know whether expansion happened: `terms` is
+ * always at least `[query]`. The caller joins these with OR against each
+ * entry's searchable fields, in the same `includes`/`tokenInText` grammar
+ * as the raw query.
+ */
+export declare function expandZhQuery(rawQuery: string): ZhExpansion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-shop",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "description": "The DeepSeek Harness plugin shop: browse, install, enable, and update dsh plugins from a git-auditable catalog.",
   "keywords": [
     "dsh-plugin",