@aiwayds/dsh-topics-memory 0.18.1 → 0.18.2

package/lib/index.js

@@ -898,23 +898,26 @@ export async function apply(ctx, config = {}) {
     // The 0.1.7 host imports the old settings.yaml ONCE by "section name =
     // entry id" and renames it settings.yaml.imported — this plugin's legacy
     // section was named `topics`, so the host's import silently dropped it.
-    // Recover it here (see legacy-import.ts). Awaited as apply()'s LAST step:
-    // every registration above stays synchronous (fake-ctx tests dispatch
-    // immediately), while a real boot — whose loader awaits the fiber setup —
-    // also settles the import before activation completes. Fully contained:
-    // any failure only warns and leaves the audit marker unwritten, so the
-    // next boot retries; activation never depends on this.
-    try {
-        await runLegacySettingsImport({
+    // Recover it here (see legacy-import.ts). Wired through
+    // ctx.inject(['settings'], …) instead of a direct `ctx.settings` read: a
+    // real boot can run apply() before the settings service is mounted, the
+    // direct read came up undefined, and the import then took the silent
+    // no-settings exit EVERY boot (no marker, nothing ever recovered). The
+    // inject callback fires the moment the service exists (immediately when
+    // it already does — fake-ctx tests stay synchronous), fire-and-forget so
+    // activation never waits on it. Fully contained: any failure only warns
+    // and leaves the audit marker unwritten, so the next boot retries;
+    // activation never depends on this.
+    ctx.inject(['settings'], (sctx) => {
+        void runLegacySettingsImport({
             home: paths.resolveDshHome(),
-            settings: ctx.settings,
+            settings: sctx.settings,
             logger: ctx.logger,
             getCurrent: (key) => cfgNow()[key],
+        }).catch((error) => {
+            warn(`dsh-topics-memory 旧 settings 迁移失败（不影响启动，下次启动重试）：${error instanceof Error ? error.message : String(error)}`);
         });
-    }
-    catch (error) {
-        warn(`dsh-topics-memory 旧 settings 迁移失败（不影响启动，下次启动重试）：${error instanceof Error ? error.message : String(error)}`);
-    }
+    });
 }
 /** Config defaults for harnesses that skip schemastery's default application. */
 const DEFAULTS = {

package/lib/legacy-import.d.ts

@@ -50,6 +50,21 @@ export interface LegacyImportInput {
     logger?: LegacyImportLogger | undefined;
     /** Current effective value for one legacy key (Volatile ref `.get()` at the call site). */
     getCurrent(key: LegacyKey): unknown;
+    /**
+     * Retry budget for `settings.update`. The host serializes profile writes
+     * (settings.update → dsh-config-editor) behind the `<profile>/package.json`
+     * writer lock with a 2s per-call deadline, and during BOOT the host itself
+     * holds that lock while preparing the profile — a single bare call almost
+     * always times out (2026-09-25 incident: the import failed EVERY boot and
+     * the migration never converged). Defaults to 5 attempts 2s apart; a
+     * permanently orphaned lock (a SIGKILLed host never releases it — orphan
+     * recovery is an operator action) still exhausts the budget and stays
+     * retry-worthy. Tests shrink this to keep the suite fast.
+     */
+    updateRetry?: {
+        attempts: number;
+        delayMs: number;
+    } | undefined;
 }
 export type LegacyImportOutcome = 'imported' | 'no-op' | 'no-legacy' | 'no-section' | 'marker-exists' | 'no-settings' | 'update-failed';
 export interface LegacyImportResult {

package/lib/legacy-import.js

@@ -160,8 +160,11 @@ export async function runLegacySettingsImport(input) {
     // A settings seam that cannot accept the patch is a retry-worthy state:
     // return WITHOUT reading/marking, so a host that mounts the service later
     // (and a test harness pointing at a real home) neither imports nor writes.
+    // Not silent: the 2026-09-24 incident hid exactly behind this quiet exit —
+    // the warn is what makes a never-mounting seam observable in a boot log.
     const settings = input.settings;
     if (settings === undefined || typeof settings.update !== 'function') {
+        warn(`${ENTRY_ID}: legacy settings import deferred: settings seam unusable (no-settings; will retry next boot)`);
         return { outcome: 'no-settings', imported, skipped };
     }
     // Locate the legacy document.
@@ -198,12 +201,28 @@ export async function runLegacySettingsImport(input) {
         info(`${ENTRY_ID}: legacy settings import (${LEGACY_SECTION} → ${ENTRY_ID}): nothing to import (all values equal or unknown)`);
         return { outcome: 'no-op', imported, skipped };
     }
-    try {
-        await settings.update(ENTRY_ID, imported);
+    // The update contends on the host's profile writer lock (see
+    // {@link LegacyImportInput.updateRetry}): retry with a fixed gap before
+    // conceding. Every failed attempt warns — a silent loss here cost a full
+    // day of "the migration never runs" debugging (2026-09-25).
+    const retry = input.updateRetry ?? { attempts: 5, delayMs: 2_000 };
+    let updateFailed;
+    for (let attempt = 1; attempt <= retry.attempts; attempt++) {
+        try {
+            await settings.update(ENTRY_ID, imported);
+            updateFailed = undefined;
+            break;
+        }
+        catch (error) {
+            updateFailed = error;
+            warn(`${ENTRY_ID}: legacy settings import: settings.update attempt ${attempt}/${retry.attempts} failed: ${error instanceof Error ? error.message : String(error)}`);
+            if (attempt < retry.attempts)
+                await new Promise((resolve) => setTimeout(resolve, retry.delayMs));
+        }
     }
-    catch (error) {
+    if (updateFailed !== undefined) {
+        warn(`${ENTRY_ID}: legacy settings import failed (will retry next boot): ${updateFailed instanceof Error ? updateFailed.message : String(updateFailed)}`);
         // No marker: the next boot retries the import.
-        warn(`${ENTRY_ID}: legacy settings import failed (will retry next boot): ${error instanceof Error ? error.message : String(error)}`);
         return { outcome: 'update-failed', imported, skipped };
     }
     writeMarker(markerPath, { at: new Date().toISOString(), outcome: 'imported', source: sourceName, imported, skipped });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwayds/dsh-topics-memory",
-  "version": "0.18.1",
+  "version": "0.18.2",
   "description": "dsh-plugin: quality-first topic memory for dsh — a topic keeps the starting question, conclusion, impact and dependencies, not the process; local-first git-traced OKF bundle, budgeted LLM-free injection",
   "type": "module",
   "main": "lib/index.js",

package/src/index.ts

@@ -1016,22 +1016,26 @@ export async function apply(ctx: Context, config: TopicsRuntimeConfig = {}): Pro
   // The 0.1.7 host imports the old settings.yaml ONCE by "section name =
   // entry id" and renames it settings.yaml.imported — this plugin's legacy
   // section was named `topics`, so the host's import silently dropped it.
-  // Recover it here (see legacy-import.ts). Awaited as apply()'s LAST step:
-  // every registration above stays synchronous (fake-ctx tests dispatch
-  // immediately), while a real boot — whose loader awaits the fiber setup —
-  // also settles the import before activation completes. Fully contained:
-  // any failure only warns and leaves the audit marker unwritten, so the
-  // next boot retries; activation never depends on this.
-  try {
-    await runLegacySettingsImport({
+  // Recover it here (see legacy-import.ts). Wired through
+  // ctx.inject(['settings'], …) instead of a direct `ctx.settings` read: a
+  // real boot can run apply() before the settings service is mounted, the
+  // direct read came up undefined, and the import then took the silent
+  // no-settings exit EVERY boot (no marker, nothing ever recovered). The
+  // inject callback fires the moment the service exists (immediately when
+  // it already does — fake-ctx tests stay synchronous), fire-and-forget so
+  // activation never waits on it. Fully contained: any failure only warns
+  // and leaves the audit marker unwritten, so the next boot retries;
+  // activation never depends on this.
+  ctx.inject(['settings'], (sctx) => {
+    void runLegacySettingsImport({
       home: paths.resolveDshHome(),
-      settings: ctx.settings as SettingsUpdateSeam,
+      settings: (sctx as unknown as { settings?: SettingsUpdateSeam }).settings,
       logger: (ctx as unknown as { logger?: LegacyImportLogger }).logger,
       getCurrent: (key) => cfgNow()[key],
+    }).catch((error) => {
+      warn(`dsh-topics-memory 旧 settings 迁移失败（不影响启动，下次启动重试）：${error instanceof Error ? error.message : String(error)}`)
     })
-  } catch (error) {
-    warn(`dsh-topics-memory 旧 settings 迁移失败（不影响启动，下次启动重试）：${error instanceof Error ? error.message : String(error)}`)
-  }
+  })
 }
 
 /** Config defaults for harnesses that skip schemastery's default application. */

package/src/legacy-import.ts

@@ -61,6 +61,18 @@ export interface LegacyImportInput {
   logger?: LegacyImportLogger | undefined
   /** Current effective value for one legacy key (Volatile ref `.get()` at the call site). */
   getCurrent(key: LegacyKey): unknown
+  /**
+   * Retry budget for `settings.update`. The host serializes profile writes
+   * (settings.update → dsh-config-editor) behind the `<profile>/package.json`
+   * writer lock with a 2s per-call deadline, and during BOOT the host itself
+   * holds that lock while preparing the profile — a single bare call almost
+   * always times out (2026-09-25 incident: the import failed EVERY boot and
+   * the migration never converged). Defaults to 5 attempts 2s apart; a
+   * permanently orphaned lock (a SIGKILLed host never releases it — orphan
+   * recovery is an operator action) still exhausts the budget and stays
+   * retry-worthy. Tests shrink this to keep the suite fast.
+   */
+  updateRetry?: { attempts: number; delayMs: number } | undefined
 }
 
 export type LegacyImportOutcome =
@@ -200,8 +212,11 @@ export async function runLegacySettingsImport(input: LegacyImportInput): Promise
   // A settings seam that cannot accept the patch is a retry-worthy state:
   // return WITHOUT reading/marking, so a host that mounts the service later
   // (and a test harness pointing at a real home) neither imports nor writes.
+  // Not silent: the 2026-09-24 incident hid exactly behind this quiet exit —
+  // the warn is what makes a never-mounting seam observable in a boot log.
   const settings = input.settings
   if (settings === undefined || typeof settings.update !== 'function') {
+    warn(`${ENTRY_ID}: legacy settings import deferred: settings seam unusable (no-settings; will retry next boot)`)
     return { outcome: 'no-settings', imported, skipped }
   }
 
@@ -241,11 +256,26 @@ export async function runLegacySettingsImport(input: LegacyImportInput): Promise
     return { outcome: 'no-op', imported, skipped }
   }
 
-  try {
-    await settings.update(ENTRY_ID, imported)
-  } catch (error) {
+  // The update contends on the host's profile writer lock (see
+  // {@link LegacyImportInput.updateRetry}): retry with a fixed gap before
+  // conceding. Every failed attempt warns — a silent loss here cost a full
+  // day of "the migration never runs" debugging (2026-09-25).
+  const retry = input.updateRetry ?? { attempts: 5, delayMs: 2_000 }
+  let updateFailed: unknown
+  for (let attempt = 1; attempt <= retry.attempts; attempt++) {
+    try {
+      await settings.update(ENTRY_ID, imported)
+      updateFailed = undefined
+      break
+    } catch (error) {
+      updateFailed = error
+      warn(`${ENTRY_ID}: legacy settings import: settings.update attempt ${attempt}/${retry.attempts} failed: ${error instanceof Error ? error.message : String(error)}`)
+      if (attempt < retry.attempts) await new Promise((resolve) => setTimeout(resolve, retry.delayMs))
+    }
+  }
+  if (updateFailed !== undefined) {
+    warn(`${ENTRY_ID}: legacy settings import failed (will retry next boot): ${updateFailed instanceof Error ? updateFailed.message : String(updateFailed)}`)
     // No marker: the next boot retries the import.
-    warn(`${ENTRY_ID}: legacy settings import failed (will retry next boot): ${error instanceof Error ? error.message : String(error)}`)
     return { outcome: 'update-failed', imported, skipped }
   }