dsh-mnemon-strategy-default-three-tier 0.5.8 → 0.5.10

package/README.md

@@ -1,7 +1,10 @@
 # dsh-mnemon-strategy-default-three-tier
 
-One ordinary Cordis Strategy plugin. It consumes public Source facts and proposes
-a three-tier View; it imports no Source implementation and grants no authority.
+The **Layered strategy** (分层策略 in the Chinese interface), dsh-mnemon's default
+main strategy: runtime memory stays resident, while Project Documents and Memory
+Spaces are read on demand. It is one ordinary Cordis Strategy plugin that consumes
+public Source facts and proposes that View; it imports no Source implementation
+and grants no authority. Its type id is `default-three-tier`.
 
 `compose` is pure. `createTurn` owns the executing turn's retrieval policy:
 one Documents query (4 results / 6,000 content characters), two different Recall
@@ -14,16 +17,20 @@ Source schemas and provenance are the public read protocol. This plugin formats
 the familiar compact model response; Core retains the evidence/authority envelope
 for auditing without serializing it again into every model tool result.
 
-The default plugin also owns the existing three-tier instructions and reminders.
+This plugin also owns the Layered strategy's instructions and reminders.
 They are pinned in `ViewSpec.guidance`, separately from Source projections. The
 Host renders them for the selected turn; a different Strategy does not inherit
 this plugin's instructions. DSH-assisted write/archival workflows remain Host
 adapters over Source operations; Core does not schedule autonomous maintenance.
 
-The public `threeTierActionWorkflow` policy in `./extension-sdk` identifies Runtime
-capacity maintenance only while this Strategy is selected. The DSH Host applies
-it to named tools, generic View Actions, child writes and browser management.
-The operation retains its exact Source instance, scope, revision and authority;
+Its manifest declares `workflows: ['idle-review', 'runtime-capacity']`, the
+background work the dsh-mnemon Host runs for the turns it composes: idle review,
+and Runtime capacity maintenance, which the Host applies to named tools, generic
+View Actions, child writes and browser management. A Strategy built by spreading
+this manifest copies the declaration; `workflows: []` keeps it out of both.
+`threeTierActionWorkflow` in `./extension-sdk` is kept for existing callers and
+deprecated; the Host reads the declaration instead. A maintenance operation
+retains its exact Source instance, scope, revision and authority;
 archive destinations stay within the selected writable Source and pinned
 namespaces. A browser write needs no conversation. One eligible destination
 requires no model; routing and local profile compaction use a clean workspace
@@ -55,7 +62,7 @@ Replay and Related admission include the exact Source instance identity. Writes
 still require an offered Action and Host authorization, including implicit
 capacity maintenance. Explicit operator management is a separate channel.
 
-With no extensions the original three-tier composition is retained. Disabling
+With no extensions the Layered strategy's original composition is retained. Disabling
 one extension only removes its contribution for new turns; running turns keep
 their pinned View. If disabling explicit selection leaves multiple Sources in
 the same role, the original ambiguity check applies rather than silently
@@ -71,7 +78,7 @@ no auto-activation patch; installing it does not override a configured Strategy.
 
 ## Installation and verification
 
-The default Starter already mounts and selects this Strategy. In an independent Profile, install the package, mount its Entry and explicitly select `default-three-tier`; another installed Strategy does not win by import order.
+The default Starter already mounts and selects the Layered strategy. In an independent Profile, install the package, mount its Entry and explicitly select `default-three-tier`; another installed Strategy does not win by import order.
 
 Installing an npm package is not the same as activating a contribution. From a source checkout, run `pnpm verify` with declared public peers installed; use a packed peer for unreleased SDK work.
 

package/lib/extension-sdk.d.ts

@@ -3,7 +3,10 @@ import { MemoryAvailableSource, MemoryJsonValue, MemoryStrategyContribution, Mem
 /** The three-tier slots are Core's standard View extension slots. */
 type ThreeTierExtensionValues = MemoryViewExtensionValues;
 type ThreeTierExtensionSlot = MemoryViewExtensionSlot;
-/** Pure default-product policy. The Host executes it through public Source protocols. */
+/**
+ * Pure default-product policy. The Host executes it through public Source protocols.
+ * @deprecated The Host runs the workflows a Strategy declares in its manifest's `workflows`.
+ */
 declare function threeTierActionWorkflow(strategyTypeId: string, sourceTypeId: string, actionId: string): 'runtime-capacity' | undefined;
 declare function validateThreeTierExtension<K extends ThreeTierExtensionSlot>(slot: K, value: MemoryJsonValue): ThreeTierExtensionValues[K];
 /** An extension only for this Strategy; `defineMemoryViewExtension` also follows other Strategies. */

package/lib/extension-sdk.js

@@ -1,7 +1,10 @@
 import { defineMemoryStrategyExtension, memoryViewExtensionValues, validateMemoryViewExtension } from "dsh-mnemon/extension-sdk";
 import { COMPOSABLE_MEMORY_API_VERSION } from "dsh-mnemon/contracts";
 //#region src/extension-sdk.ts
-/** Pure default-product policy. The Host executes it through public Source protocols. */
+/**
+* Pure default-product policy. The Host executes it through public Source protocols.
+* @deprecated The Host runs the workflows a Strategy declares in its manifest's `workflows`.
+*/
 function threeTierActionWorkflow(strategyTypeId, sourceTypeId, actionId) {
 	return strategyTypeId === "default-three-tier" && sourceTypeId === "runtime" && actionId === "mutate" ? "runtime-capacity" : void 0;
 }

package/lib/index.d.ts

@@ -15,6 +15,7 @@ declare const DEFAULT_THREE_TIER_VIEW_STRATEGY: {
     maxRoutes: number;
     maxActions: number;
     extensionSlots: string[];
+    workflows: ("idle-review" | "runtime-capacity")[];
   };
   compose(request: MemoryViewRequest, sources: readonly MemoryAvailableSource[], contributions?: readonly import("dsh-mnemon/extension-sdk").MemoryStrategyContribution[] | undefined): MemoryViewSpec;
 };

package/lib/index.js

@@ -196,18 +196,23 @@ var ThreeTierTurn = class {
 		const input = memoryInputRecord(request.input, "Documents search");
 		const query = String(input.query).trim();
 		const includeArchived = input.includeArchived === true;
+		if (this.state.documentSearchPending !== void 0) {
+			await Promise.allSettled([this.state.documentSearchPending]);
+			return this.documents(request, read);
+		}
 		if (this.state.documentSearchClaimed) return {
 			...this.empty(request),
 			output: {
 				query,
 				includeArchived,
 				notRun: true,
+				budgetExhausted: true,
 				results: [],
-				hint: "This Agent turn already used its Documents search slot, so no second disk query ran. Use the admitted evidence, make one focused mnemon_recall only if exact durable history is still missing, or answer with appropriate uncertainty."
+				hint: "This query did not run: this Agent turn already used its Documents search. The empty list does not mean no document matches. Use the admitted evidence, make one focused mnemon_recall where it is offered only if exact durable history is still missing, or answer with appropriate uncertainty."
 			}
 		};
 		this.state.documentSearchClaimed = true;
-		const evidence = await read({
+		const pending = read({
 			query,
 			includeArchived,
 			limit: Math.min(4, typeof input.limit === "number" ? Math.max(1, input.limit) : 4)
@@ -215,6 +220,16 @@ var ThreeTierTurn = class {
 			maxResults: 4,
 			maxCharacters: 6e3
 		});
+		this.state.documentSearchPending = pending;
+		let evidence;
+		try {
+			evidence = await pending;
+		} catch (error) {
+			this.state.documentSearchClaimed = false;
+			throw error;
+		} finally {
+			if (this.state.documentSearchPending === pending) delete this.state.documentSearchPending;
+		}
 		const metadata = optionalObject(evidence.metadata) ?? {};
 		const results = evidence.items.filter((item) => optionalObject(item.provenance)?.kind !== "suggestion").map((item) => {
 			const record = optionalObject(item.provenance) ?? {};
@@ -277,14 +292,19 @@ var ThreeTierTurn = class {
 			};
 		}
 		if (retrieval.recallAttempts.length >= MODEL_RECALL_ATTEMPT_LIMIT) {
-			const latest = retrieval.recallAttempts[retrieval.recallAttempts.length - 1];
-			const last = latest?.result ?? await latest?.pending;
-			const previous = last?.memoryEvidence?.sourceInstanceKey === authority.sourceInstanceKey ? last : void 0;
+			const inflight = retrieval.recallAttempts.flatMap((entry) => entry.pending === void 0 ? [] : [entry.pending]);
+			if (inflight.length > 0) {
+				await Promise.allSettled(inflight);
+				signal.throwIfAborted();
+				return this.recall(request, read, signal, authority);
+			}
 			return {
-				query: previous?.query ?? scoped.query,
-				mode: previous?.mode ?? scoped.mode ?? "smart",
-				...replayEvidence(previous, scoped.memoryBodyIds, authority.sourceInstanceKey),
-				hint: "The two-query turn Recall budget is exhausted. The Host replayed the latest admitted evidence without another Provider query; stop retrieval and answer from the evidence or state what remains unknown."
+				query: scoped.query,
+				mode: scoped.mode ?? "smart",
+				results: [],
+				notRun: true,
+				budgetExhausted: true,
+				hint: "The two-query turn Recall budget is exhausted, so this query did not run. It has no results; the empty list does not mean nothing matches. Answer from the evidence the other Recall calls returned, or state what remains unknown."
 			};
 		}
 		const attemptIndex = retrieval.recallAttempts.length;
@@ -346,6 +366,7 @@ var ThreeTierTurn = class {
 			query: `related:${id}`,
 			mode: "related",
 			results: [],
+			notRun: true,
 			hint: "Related traversal requires an insight admitted by the current turn's direct Recall. No Provider query was made."
 		};
 		const digest = sha256(JSON.stringify({
@@ -356,13 +377,28 @@ var ThreeTierTurn = class {
 			edge: options.edge ?? ""
 		}));
 		if (retrieval.relatedDigest !== void 0) {
+			if (retrieval.relatedDigest !== digest) {
+				if (retrieval.relatedPending !== void 0) {
+					await Promise.allSettled([retrieval.relatedPending]);
+					signal.throwIfAborted();
+					return this.related(id, memoryBodyId, read, signal, authority, options);
+				}
+				return {
+					query: `related:${id}`,
+					mode: "related",
+					results: [],
+					notRun: true,
+					budgetExhausted: true,
+					hint: "Related traversal is complete for this turn, so this one did not run. It has no results; the empty list does not mean nothing is related. Answer from the evidence the other calls returned."
+				};
+			}
 			const last = retrieval.relatedResult ?? await retrieval.relatedPending;
 			const previous = last?.memoryEvidence?.sourceInstanceKey === authority.sourceInstanceKey ? last : void 0;
 			return {
 				query: previous?.query ?? `related:${id}`,
 				mode: previous?.mode ?? "related",
 				...replayEvidence(previous, [selected], authority.sourceInstanceKey),
-				hint: retrieval.relatedDigest === digest ? "This exact Related traversal already ran. The Host replayed its admitted evidence without another Provider query; stop retrieval and answer from it." : "Related traversal is complete for this turn. The Host replayed the admitted evidence; stop retrieval and answer from it."
+				hint: "This exact Related traversal already ran. The Host replayed its admitted evidence without another Provider query; stop retrieval and answer from it."
 			};
 		}
 		retrieval.relatedDigest = digest;
@@ -496,7 +532,8 @@ const DEFAULT_THREE_TIER_VIEW_STRATEGY = defineMemoryStrategy({
 			"selection",
 			"projection",
 			"capture"
-		]
+		],
+		workflows: ["idle-review", "runtime-capacity"]
 	},
 	compose(request, sources, contributions = []) {
 		if (contributions.length === 0) return composeThreeTier(request, sources);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon-strategy-default-three-tier",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "Explicit three-tier View Strategy for Composable View Memory.",
   "license": "MIT",
   "type": "module",
@@ -36,7 +36,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "dsh-mnemon": "^0.5.25",
+    "dsh-mnemon": "^0.5.32",
     "tsdown": "^0.22.0",
     "typescript": "^5.9.0",
     "vitest": "^3.2.0"