dsh-mnemon 0.5.40 → 0.5.41

package/lib/bundle.js

@@ -1,4 +1,4 @@
-import { t as prepareStarterResolution } from "./starter-resolution-C5nNk-cs.js";
+import { t as prepareStarterResolution } from "./starter-resolution-xVjONc6g.js";
 //#region src/bundle.ts
 const groupKey = Symbol.for("cordis.group");
 const init = Symbol.for("cordis.init");

package/lib/client.js

@@ -318,6 +318,8 @@ window.__ModuleLoader__.load({
 			allowUpdate: true,
 			targetScope: "user",
 			autoBacktest: true,
+			draftMaxTokens: 32768,
+			draftRetryMaxTokens: 65536,
 			hints: true,
 			sidebar: false,
 			reviewThreshold: 5,
@@ -3145,6 +3147,10 @@ window.__ModuleLoader__.load({
 			"skills.autoBacktest": "草案自动回测",
 			"skills.autoBacktestHint": "草案写好后，用测试用例与当前版本对比",
 			"skills.parameters": "复盘参数",
+			"skills.draftGeneration": "草案生成",
+			"skills.draftMaxTokens": "草案输出 token 上限",
+			"skills.draftRetryMaxTokens": "重试输出 token 上限",
+			"skills.draftBudgetHint": "预算包含推理与完整 SKILL.md。截断时仅在重试上限更大时重新生成一次；设为相同或更小值可关闭扩容重试。两项均需符合模型提供方的输出限制，保存后用于下一次草案。",
 			"skills.reviewThreshold": "复盘阈值",
 			"skills.idleSeconds": "空闲等待（秒）",
 			"skills.cooldownSeconds": "复盘间隔（秒）",
@@ -3965,6 +3971,10 @@ window.__ModuleLoader__.load({
 			"skills.autoBacktest": "Backtest drafts",
 			"skills.autoBacktestHint": "Compare a new draft with the current version on its test cases",
 			"skills.parameters": "Review parameters",
+			"skills.draftGeneration": "Draft generation",
+			"skills.draftMaxTokens": "Draft output token limit",
+			"skills.draftRetryMaxTokens": "Retry output token limit",
+			"skills.draftBudgetHint": "Budgets include reasoning and the complete SKILL.md. Truncation triggers one fresh attempt only when the retry limit is higher; an equal or lower value disables it. Keep both within the model provider’s output limit. Saved changes apply to the next draft.",
 			"skills.reviewThreshold": "Review threshold",
 			"skills.idleSeconds": "Idle wait (s)",
 			"skills.cooldownSeconds": "Review interval (s)",
@@ -12032,6 +12042,17 @@ window.__ModuleLoader__.load({
 				integer: true
 			}
 		];
+		const DRAFT_PARAMETERS = [{
+			key: "draftMaxTokens",
+			min: 128,
+			max: 131072,
+			integer: true
+		}, {
+			key: "draftRetryMaxTokens",
+			min: 128,
+			max: 131072,
+			integer: true
+		}];
 		/** The value a parameter stores, or undefined when the Host would refuse it. */
 		function parameterValue(field, text) {
 			if (text.trim() === "") return void 0;
@@ -12072,8 +12093,16 @@ window.__ModuleLoader__.load({
 				const changed = PARAMETERS.filter((field) => parameterValue(field, draft[field.key]) !== saved[field.key]);
 				if (changed.length > 0) await scope.mutate(changed.map((field) => set(field.key, parameterValue(field, draft[field.key]))));
 			});
+			const draftBudgets = useStaged({
+				draftMaxTokens: String(saved.draftMaxTokens),
+				draftRetryMaxTokens: String(saved.draftRetryMaxTokens)
+			}, async (draft) => {
+				const changed = DRAFT_PARAMETERS.filter((field) => parameterValue(field, draft[field.key]) !== saved[field.key]);
+				if (changed.length > 0) await scope.mutate(changed.map((field) => set(field.key, parameterValue(field, draft[field.key]))));
+			});
 			const disabled = !page.writable || snapshot.status === "loading" || !snapshot.writable;
 			const invalid = PARAMETERS.find((field) => parameterValue(field, parameters.draft[field.key]) === void 0);
+			const invalidDraft = DRAFT_PARAMETERS.find((field) => parameterValue(field, draftBudgets.draft[field.key]) === void 0);
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 				className: MnemonSettingsCard_module_css_default.panelSection,
 				"aria-label": t("skills.label"),
@@ -12133,6 +12162,47 @@ window.__ModuleLoader__.load({
 								destination.apply();
 							}
 						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("details", {
+							className: MnemonSettingsCard_module_css_default.advanced,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("summary", { children: [t("skills.draftGeneration"), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconChevronDownOutlineRegular, { size: 12 })] }),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+									className: MnemonSettingsCard_module_css_default.panelNote,
+									children: t("skills.draftBudgetHint")
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+									className: MnemonSettingsCard_module_css_default.fieldGrid,
+									children: DRAFT_PARAMETERS.map((field) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: [t(`skills.${field.key}`), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+										type: "number",
+										step: 1,
+										min: field.min,
+										max: field.max,
+										inputMode: "numeric",
+										value: draftBudgets.draft[field.key],
+										disabled: disabled || draftBudgets.saving,
+										"aria-invalid": parameterValue(field, draftBudgets.draft[field.key]) === void 0,
+										onChange: (event) => draftBudgets.edit({ [field.key]: event.target.value })
+									})] }, field.key))
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(PanelActions, {
+									dirty: draftBudgets.dirty,
+									saving: draftBudgets.saving,
+									applied: draftBudgets.applied,
+									failed: draftBudgets.failed,
+									disabled,
+									t,
+									invalid: invalidDraft === void 0 ? null : t("skills.invalid", {
+										field: t(`skills.${invalidDraft.key}`),
+										min: invalidDraft.min,
+										max: invalidDraft.max
+									}),
+									onDiscard: draftBudgets.discard,
+									onApply: () => {
+										draftBudgets.apply();
+									}
+								})
+							]
+						}),
 						evolution.value && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ToggleRow, {
 							id: "mnemon-skills-backtest",
 							label: t("skills.autoBacktest"),

package/lib/index.js

@@ -389,6 +389,8 @@ const DEFAULT_SKILLS_CONFIG = Object.freeze({
 	allowUpdate: true,
 	targetScope: "user",
 	autoBacktest: true,
+	draftMaxTokens: 32768,
+	draftRetryMaxTokens: 65536,
 	hints: true,
 	sidebar: false,
 	reviewThreshold: 5,
@@ -481,6 +483,8 @@ const SkillsConfig = z.object({
 		"project"
 	]).default(DEFAULT_SKILLS_CONFIG.targetScope),
 	autoBacktest: z.boolean().default(DEFAULT_SKILLS_CONFIG.autoBacktest),
+	draftMaxTokens: z.number().step(1).min(128).max(131072).default(DEFAULT_SKILLS_CONFIG.draftMaxTokens),
+	draftRetryMaxTokens: z.number().step(1).min(128).max(131072).default(DEFAULT_SKILLS_CONFIG.draftRetryMaxTokens),
 	hints: z.boolean().default(DEFAULT_SKILLS_CONFIG.hints),
 	sidebar: z.boolean().default(DEFAULT_SKILLS_CONFIG.sidebar),
 	reviewThreshold: z.number().step(1).min(1).max(50).default(DEFAULT_SKILLS_CONFIG.reviewThreshold),
@@ -640,6 +644,7 @@ const Config = z.object({
 	skills: SkillsConfig.default({ ...DEFAULT_SKILLS_CONFIG }),
 	persistenceStrategy: MemoryPersistenceStrategySchema,
 	taskAgentModel: TaskAgentModelSchema,
+	subagentProviderNames: z.array(z.string()).default([]),
 	syncEnabled: z.boolean().default(false)
 });
 function resolveInteractionConfig(config = {}) {
@@ -689,6 +694,11 @@ function resolveCustomPacks(value, legacyDataDir) {
 	}
 	return packs;
 }
+function resolveSubagentProviderNames(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.length > 32 || value.some((name) => typeof name !== "string" || !name.trim() || name.length > 128)) throw new Error("dsh-mnemon: subagentProviderNames must contain at most 32 nonempty provider names of at most 128 characters");
+	return [...new Set(value.map((name) => name.trim()))];
+}
 function resolveTaskAgentModel(value) {
 	const mode = value?.mode ?? "inherit";
 	if (mode !== "inherit" && mode !== "fixed") throw new Error(`dsh-mnemon: unsupported task Agent model mode: ${String(mode)}`);
@@ -813,6 +823,7 @@ function resolveConfig(config = {}) {
 		},
 		persistenceStrategy: resolvePersistenceStrategy(config.persistenceStrategy),
 		taskAgentModel: resolveTaskAgentModel(config.taskAgentModel),
+		subagentProviderNames: resolveSubagentProviderNames(config.subagentProviderNames),
 		syncEnabled: config.syncEnabled ?? false
 	};
 }
@@ -7187,9 +7198,9 @@ var MemoryExecutions = class {
 	constructor(runtime) {
 		this.runtime = runtime;
 	}
-	async turn(agent, turn, signal, delegation) {
+	async turn(agent, turn, signal, delegation, independent = false) {
 		signal.throwIfAborted();
-		const slot = this.open(agent, "turn", `${agent.id}:${turn}`, "agent.root-turn", delegation);
+		const slot = this.open(agent, "turn", `${agent.id}:${turn}`, "agent.root-turn", delegation, independent);
 		const abort = () => slot.controller.abort(signal.reason);
 		signal.addEventListener("abort", abort, { once: true });
 		try {
@@ -7272,7 +7283,7 @@ var MemoryExecutions = class {
 			if (slot.kind === "turn") slot.close();
 		}
 	}
-	open(agent, kind, turnId, purpose, delegation) {
+	open(agent, kind, turnId, purpose, delegation, independent = false) {
 		this.assertOpen();
 		const previous = this.slots.get(agent.id);
 		const done = deferred();
@@ -7307,7 +7318,7 @@ var MemoryExecutions = class {
 			await previous?.done;
 			slot.controller.signal.throwIfAborted();
 			this.assertOpen();
-			const graph = delegation?.graph ?? this.runtime.forAgent(agent);
+			const graph = delegation?.graph ?? (independent ? this.runtime.forAgent(agent, { independent: true }) : this.runtime.forAgent(agent));
 			const manager = graph.composableTurns;
 			const scope = delegation === void 0 ? agentScope(agent, graph.config) : {
 				...delegation.scope,
@@ -7619,13 +7630,15 @@ var LiveMnemonRuntime = class {
 		for (const graph of graphs) graph.dispose();
 	}
 	/** Resolve the runtime that must serve one Agent execution. */
-	forAgent(agent) {
+	forAgent(agent, options = {}) {
 		this.assertOpen();
-		const pinned = this.agentGraphs.get(agent.id);
-		if (pinned !== void 0) return pinned.graph;
-		const parentSession = agent.session.header?.origin === "subagent" ? agent.session.header.parentSession?.trim() : void 0;
-		const inherited = parentSession === void 0 || parentSession === "" ? void 0 : this.agentGraphs.get(parentSession);
-		if (inherited !== void 0) return inherited.graph;
+		if (!options.independent) {
+			const pinned = this.agentGraphs.get(agent.id);
+			if (pinned !== void 0) return pinned.graph;
+			const parentSession = agent.session.header?.origin === "subagent" ? agent.session.header.parentSession?.trim() : void 0;
+			const inherited = parentSession === void 0 || parentSession === "" ? void 0 : this.agentGraphs.get(parentSession);
+			if (inherited !== void 0) return inherited.graph;
+		}
 		if (!isWorkspaceStorageScope(this.current.config.storageScope)) return this.current;
 		const cwd = agent.session.header?.cwd?.trim();
 		if (cwd === void 0 || cwd === "") throw new Error("the current DSH session has no workspace for Mnemon");
@@ -8461,6 +8474,72 @@ async function applyReconcileOperations(operations, applier, signal, selection)
 	};
 }
 //#endregion
+//#region src/host/agent-compat.ts
+function configuredProviderNames(host) {
+	const names = /* @__PURE__ */ new Set();
+	for (const runtime of host?.registry?.values() ?? []) for (const fiber of runtime.fibers) {
+		const config = fiber.effectiveConfig;
+		if (config && typeof config === "object" && "providerName" in config && typeof config.providerName === "string") names.add(config.providerName);
+	}
+	return [...names];
+}
+/** Official 0.2.2-rc.1 has registry ownership; master fcc0ad4 moved it into Subagent. */
+function activationOwned(subagents) {
+	return typeof subagents?.rootOf === "function";
+}
+/** Only live registry instances can be adopted; persisted lineage is not authority. */
+function isRootAgent(agents, subagents, agent) {
+	if (agents.get(agent.id) !== agent) return false;
+	if (typeof agents.roots === "function") return agents.roots().includes(agent);
+	try {
+		return subagents.rootOf?.(agent) === agent;
+	} catch {
+		return false;
+	}
+}
+function rootAgents(agents, subagents) {
+	if (typeof agents.roots === "function") return agents.roots();
+	return (agents.list?.() ?? []).filter((agent) => isRootAgent(agents, subagents, agent));
+}
+/** Persisted IDs keep completed internal sessions out of conversation automation after restart. */
+function isTaskRecord(id) {
+	return /^mnemon-(?:task|run)-v1-[0-9a-f-]{36}$/.test(id);
+}
+function titleTask(agent, title) {
+	(agent.ctx.get?.("sessionTitle"))?.rename?.(agent.session, title);
+}
+const creatingChild = new AsyncLocalStorage();
+/** Share one reservation across guard, continuation and composition wrappers, never across nested runs. */
+function withReservedChild(parent, operation, fresh = false) {
+	const current = creatingChild.getStore();
+	if (!fresh && current?.parent === parent && !current.claimed) return operation();
+	return creatingChild.run({
+		parent,
+		id: `mnemon-run-v1-${randomUUID()}`
+	}, operation);
+}
+function reservedChildId(parent) {
+	const current = creatingChild.getStore();
+	return current?.parent === parent && !current.claimed ? current.id : void 0;
+}
+function claimReservedChild(parent) {
+	const current = creatingChild.getStore();
+	if (current?.parent !== parent || current.claimed) return void 0;
+	current.claimed = true;
+	return current.id;
+}
+function isCreatingChild(agents, child) {
+	const current = creatingChild.getStore();
+	return current !== void 0 && isReservedChild(agents, current.parent, child);
+}
+/** A lineage string or same-tree relationship is not a creation capability. */
+function isReservedChild(agents, parent, child) {
+	const current = creatingChild.getStore();
+	if (current?.parent !== parent || !current.claimed || current.id !== child.id || agents?.get?.(parent.id) !== parent || agents.get(child.id) !== child || current.child !== void 0 && current.child !== child) return false;
+	current.child = child;
+	return true;
+}
+//#endregion
 //#region src/host/review-tools.ts
 const startingChild$1 = new AsyncLocalStorage();
 /**
@@ -8470,7 +8549,11 @@ const startingChild$1 = new AsyncLocalStorage();
 * still requires startGuardedReview; it never removes another plugin's policy.
 */
 function idleReviewBlockReason(parent, agentTeams = "pause") {
-	return agentTeams !== "scoped" && parent.ctx?.get?.("agentTeams") !== void 0 && parent.ctx.tools?.get?.("spawn_teammate", parent) !== void 0 ? "agent-team" : void 0;
+	if (agentTeams === "scoped") return void 0;
+	const teams = parent.ctx?.get?.("agentTeams");
+	if (teams === void 0) return void 0;
+	const tools = parent.ctx.tools;
+	return tools?.get?.("spawn_teammate", parent) !== void 0 || typeof teams?.isEnabled === "function" && teams.isEnabled(parent) && tools?.get?.("team_task_create", parent) !== void 0 ? "agent-team" : void 0;
 }
 /** The two writes an idle review can make, one per layer; both are rows of the tool table. */
 const DOCUMENT_WRITE = "mnemon_document_create";
@@ -8522,20 +8605,24 @@ function startGuardedReview(host, parent, toolNames, start, published, policy) {
 async function startGuardedChild(host, parent, start, guard, options) {
 	const { purpose, published } = options;
 	const agents = host.agents;
-	if (typeof agents?.isOwnedBy !== "function") {
+	const reserved = activationOwned(host.subagents);
+	if (reserved && typeof agents?.get !== "function") throw new Error(`Mnemon ${purpose} requires exact live Agent lookup`);
+	if (!reserved && typeof agents?.isOwnedBy !== "function") {
 		if (options.optional === true) return start();
 		throw new Error(`Mnemon ${purpose} requires DSH Agent ownership and scoped tool guard support`);
 	}
 	const pending = Symbol(`Mnemon ${purpose} publication`);
 	const guards = /* @__PURE__ */ new Map();
 	let attachmentError;
+	let expectedChildId;
 	let run;
 	const listener = host.on("agent/created", (({ agent }) => {
-		if (startingChild$1.getStore() !== pending || !agents.isOwnedBy(agent.id, parent)) return;
+		if (startingChild$1.getStore() !== pending) return;
+		if (reserved ? agent.id !== expectedChildId || !isReservedChild(agents, parent, agent) : !agents.isOwnedBy(agent.id, parent)) return;
 		try {
 			const tools = agent.ctx?.tools;
 			if (typeof tools?.guard !== "function") {
-				if (options.optional === true) return;
+				if (options.optional === true && !reserved) return;
 				throw new Error(`Mnemon ${purpose} requires DSH scoped tool guard support`);
 			}
 			const dispose = tools.guard(guard);
@@ -8563,13 +8650,16 @@ async function startGuardedChild(host, parent, start, guard, options) {
 		if (failed.length) throw new AggregateError(failed.map((outcome) => outcome.reason), `Mnemon ${purpose} guard cleanup failed`);
 	};
 	try {
-		run = await startingChild$1.run(pending, start);
+		run = await startingChild$1.run(pending, () => reserved ? withReservedChild(parent, () => {
+			expectedChildId = reservedChildId(parent);
+			return start();
+		}, true) : start());
 		if (attachmentError !== void 0) throw attachmentError;
 		const runId = run.id;
 		const child = run.localAgent ?? [...guards.keys()].find((agent) => agent.id === runId);
 		if (child === void 0 || !guards.has(child)) {
-			const local = run.localAgent ?? agents.get?.(runId);
-			if (options.optional === true && guards.size === 0 && typeof local?.ctx?.tools?.guard !== "function") {
+			const local = run.localAgent ?? agents?.get?.(runId);
+			if (!reserved && options.optional === true && guards.size === 0 && typeof local?.ctx?.tools?.guard !== "function") {
 				await closeObserver();
 				return run;
 			}
@@ -8719,10 +8809,13 @@ function continueAfterRefusal(agent) {
 * that does not report creation leaves the child as it was.
 */
 async function startWithContinuationTurns(host, parent, start) {
+	const reserved = activationOwned(host.subagents);
 	const pending = Symbol("Mnemon delegated start");
 	const stops = [];
+	let expectedChildId;
 	const listener = host.on("agent/created", (({ agent }) => {
 		if (startingChild.getStore() !== pending) return;
+		if (reserved && (agent.id !== expectedChildId || !isReservedChild(host.agents, parent, agent))) return;
 		if (typeof host.agents?.isOwnedBy === "function" && !host.agents.isOwnedBy(agent.id, parent)) return;
 		for (const stop of continueAfterRefusal(agent)) if (typeof stop === "function") stops.push(stop);
 	}));
@@ -8731,7 +8824,10 @@ async function startWithContinuationTurns(host, parent, start) {
 	};
 	let run;
 	try {
-		run = await startingChild.run(pending, start);
+		run = await startingChild.run(pending, () => reserved ? withReservedChild(parent, () => {
+			expectedChildId = reservedChildId(parent);
+			return start();
+		}) : start());
 	} catch (error) {
 		await release();
 		throw error;
@@ -8790,6 +8886,7 @@ function childComposition(subagents, provider) {
 * step, which needs `publications`.
 */
 async function startSubagent(subagents, agents, provider, request, publications) {
+	if (typeof subagents.startActivation === "function" && reservedChildId(request.parent) === void 0) return withReservedChild(request.parent, () => startSubagent(subagents, agents, provider, request, publications));
 	const { toolFilter, persona, ...task } = request;
 	if (toolFilter === void 0 && persona === void 0 || childComposition(subagents, subagents.getProvider(provider)) !== "publication") return startOnHost(subagents, agents, provider, request);
 	if (publications === void 0) throw new Error("This DSH takes no subagent persona or tool filter at start, and dsh-mnemon cannot observe the child it publishes");
@@ -8797,14 +8894,26 @@ async function startSubagent(subagents, agents, provider, request, publications)
 		...toolFilter === void 0 ? {} : { toolFilter },
 		...persona === void 0 ? {} : { persona }
 	};
-	return startComposed(publications, agents, request.parent, composition, () => startOnHost(subagents, agents, provider, task));
+	return startComposed(publications, agents, request.parent, composition, () => startOnHost(subagents, agents, provider, task), activationOwned(subagents));
 }
 async function startOnHost(subagents, agents, provider, request) {
 	if (typeof subagents.startActivation === "function") {
 		const { label, signal, ...task } = request;
-		const activation = await subagents.startActivation({
+		const modern = activationOwned(subagents);
+		const childId = claimReservedChild(request.parent);
+		if (modern && (childId === void 0 || agents?.get?.(request.parent.id) !== request.parent)) throw new Error("Mnemon requires an exact live parent and reserved child identity on an activation-owned DSH");
+		const startCurrent = subagents.startActivation;
+		const activation = modern ? await startCurrent.call(subagents, {
+			...task,
+			provider,
+			label,
+			signal,
+			childId,
+			delivery: "caller"
+		}) : await subagents.startActivation({
 			provider,
 			label,
+			...childId === void 0 ? {} : { childId },
 			request: task,
 			signal,
 			delivery: "caller"
@@ -8818,7 +8927,9 @@ async function startOnHost(subagents, agents, provider, request) {
 			activation.result.then(release, release);
 			if (signal.aborted) stop();
 			const child = agents?.get?.(activation.childId);
-			const localAgent = child !== void 0 && (typeof agents?.isOwnedBy !== "function" || agents.isOwnedBy(child.id, request.parent)) ? child : void 0;
+			if (modern && (activation.childId !== childId || child === void 0 || !isReservedChild(agents, request.parent, child))) throw new Error("DSH did not return the reserved live Mnemon child");
+			if (modern && child !== void 0) titleTask(child, label.startsWith("Mnemon ") ? label : `Mnemon · ${label}`);
+			const localAgent = child !== void 0 && (modern || typeof agents?.isOwnedBy !== "function" || agents.isOwnedBy(child.id, request.parent)) ? child : void 0;
 			return {
 				id: activation.childId,
 				...localAgent === void 0 ? {} : { localAgent },
@@ -8858,12 +8969,14 @@ function compose(agent, { toolFilter, persona }) {
 * check confirms the parent. A failed composition makes DSH roll the child
 * back; a child that was not seen published is disposed and refused.
 */
-async function startComposed(publications, agents, parent, composition, start) {
+async function startComposed(publications, agents, parent, composition, start, reserved = false) {
 	const pending = Symbol("Mnemon child composition");
+	const expectedChildId = reserved ? reservedChildId(parent) : void 0;
 	const composed = /* @__PURE__ */ new Set();
 	let failure;
 	const listener = publications.on("agent/created", (({ agent }) => {
 		if (composingChild.getStore() !== pending) return;
+		if (reserved && (agent.id !== expectedChildId || !isReservedChild(agents, parent, agent))) return;
 		if (typeof agents?.isOwnedBy === "function" && !agents.isOwnedBy(agent.id, parent)) return;
 		try {
 			compose(agent, composition);
@@ -10332,6 +10445,7 @@ var AgentMemoryTurn = class {
 	agent;
 	runtime;
 	delegation;
+	independent;
 	pinned;
 	/** A turn that runs without memory because no composition was serving when it began. */
 	unavailable;
@@ -10342,10 +10456,11 @@ var AgentMemoryTurn = class {
 	lastInspection;
 	lastWorkspace;
 	releaseDelegation;
-	constructor(agent, runtime, delegation) {
+	constructor(agent, runtime, delegation, independent = false) {
 		this.agent = agent;
 		this.runtime = runtime;
 		this.delegation = delegation;
+		this.independent = independent;
 		if (delegation === void 0) return;
 		this.releaseDelegation = runtime.executions.retain(agent, delegation);
 	}
@@ -10437,7 +10552,7 @@ var AgentMemoryTurn = class {
 		}
 	}
 	async pin(turn, generation, signal) {
-		const execution = await this.runtime.executions.turn(this.agent, turn, signal, this.delegation);
+		const execution = await this.runtime.executions.turn(this.agent, turn, signal, this.delegation, this.independent);
 		const { graph, context } = execution;
 		try {
 			if (this.closed || this.generation !== generation) throw new Error("memory turn ended during View preparation");
@@ -10581,6 +10696,136 @@ var AutomaticReviewAdmission = class {
 	}
 };
 //#endregion
+//#region src/host/subagent-errors.ts
+/** A provider stop, kept separate from schema, startup and cancellation errors. */
+var SubagentStoppedError = class extends Error {
+	stopReason;
+	maxTokens;
+	constructor(stopReason, maxTokens, detail) {
+		super(`memory subagent stopped with ${stopReason}${detail === void 0 ? "" : `: ${detail}`}`);
+		this.stopReason = stopReason;
+		this.maxTokens = maxTokens;
+		this.name = "SubagentStoppedError";
+	}
+};
+//#endregion
+//#region src/host/task-continuation.ts
+const FINISHED_TASK_REFUSAL = "This Mnemon task has finished. Send a new user message in this conversation to continue working with memory.";
+const CONTINUATION_GUIDANCE = "This is a new user request in a completed Mnemon task conversation. The previous task stays completed. Use the current memory View and ordinary memory tools for this request; require receipts for changes. Do not repeat the previous task or submit its expired completion request.";
+/** Older workers have no reserved ID: require their own Host descriptor and task contract. */
+function isLegacyMemoryTask(agent) {
+	if (agent.session.header?.origin !== "subagent") return false;
+	const events = agent.session.snapshotEvents(agent.session.inheritedEventCount ?? 0);
+	const descriptor = events.findLastIndex((event) => event.type === "subagent/descriptor");
+	if (descriptor < 0 || typeof events[descriptor].data.label !== "string" || !events[descriptor].data.label.startsWith("Mnemon ")) return false;
+	const own = events.slice(descriptor + 1);
+	const textOf = (value) => {
+		return value?.content?.filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n") ?? "";
+	};
+	const prompt = own.find((event) => event.type === "user/message" && (event.data.message ?? event.data).source?.kind === "user");
+	if (prompt === void 0 || !/^\[dsh-mnemon:delegated [a-z-]+\](?:\n|$)/u.test(textOf(prompt.data.message ?? prompt.data))) return false;
+	return own.some((event) => event.type === "system/message" && textOf(event.data.message).includes("Completion protocol: call `mnemon_subagent_result` exactly once with requestId `"));
+}
+/** A resumed task receives memory authority only for a newly accepted human turn. */
+var TaskContinuation = class {
+	agent;
+	runtime;
+	liveAgent;
+	memory;
+	authorizedTurn;
+	stops = [];
+	views = /* @__PURE__ */ new Map();
+	closed = false;
+	constructor(agent, runtime, liveAgent) {
+		this.agent = agent;
+		this.runtime = runtime;
+		this.liveAgent = liveAgent;
+		this.memory = new AgentMemoryTurn(agent, runtime, void 0, true);
+	}
+	start() {
+		try {
+			const guard = this.agent.ctx.tools?.guard?.((execution) => this.guard(execution));
+			if (typeof guard !== "function") throw new Error("Task continuation requires a scoped memory tool guard");
+			this.stops.push(guard);
+			this.stops.push(this.agent.ctx.on("agent/pre-step", ((step, next) => this.preStep(step, next)), { prepend: true }));
+			this.stops.push(this.agent.ctx.on("system-prompt/assemble", (async (_assembly, context, next) => {
+				const assembly = await next();
+				if (context.agent !== void 0 && context.agent !== this.agent) return assembly;
+				const pin = this.memory.current;
+				return applyMemoryViewGuidance(assembly, pin?.context.view, pin?.graph.config.routingGuidance);
+			})));
+			this.stops.push(this.agent.ctx.on("session/event", ((session, event) => {
+				if (session === this.agent.session && event.type === "turn/end" && event.data.turn === this.authorizedTurn) this.end();
+			})));
+			return () => this.dispose();
+		} catch (error) {
+			this.dispose();
+			throw error;
+		}
+	}
+	ownsHumanTurn(actor) {
+		return !this.closed && actor === this.agent && this.liveAgent(actor.id) === actor && this.authorizedTurn !== void 0 && this.memory.current?.turn === this.authorizedTurn && openAgentTurn(actor) === this.authorizedTurn;
+	}
+	guard(execution) {
+		if (!execution.name?.startsWith("mnemon_")) return void 0;
+		const actor = execution.agent;
+		if (this.closed || actor === void 0 || this.liveAgent(actor.id) !== actor) return FINISHED_TASK_REFUSAL;
+		if (actor !== this.agent) {
+			try {
+				const graph = this.runtime.forAgent(actor);
+				const pin = graph.composableTurns.activeTurn(actor.id);
+				if (pin !== void 0 && this.views.get(pin.view.id) === graph) return void 0;
+			} catch {}
+			return FINISHED_TASK_REFUSAL;
+		}
+		if (this.authorizedTurn === void 0) return FINISHED_TASK_REFUSAL;
+		if (execution.name === "mnemon_subagent_result") return "The previous Mnemon task result is already settled. Use ordinary memory tools for the new user request.";
+		if (this.memory.current?.turn !== this.authorizedTurn) return this.memory.unavailableReason ?? "Memory is unavailable for this request.";
+	}
+	async preStep(step, next) {
+		const decision = await next();
+		if (step.agent !== this.agent) return decision;
+		if (decision.kind === "reject" || step.signal.aborted || this.closed || this.liveAgent(this.agent.id) !== this.agent) {
+			this.end();
+			return decision;
+		}
+		const starting = this.authorizedTurn !== step.turn;
+		if (starting) this.end();
+		if (decision.messages.some((message) => message.source.kind === "user" && message.content.some((block) => block.type !== "text" || (block.text?.trim().length ?? 0) > 0))) this.authorizedTurn = step.turn;
+		if (this.authorizedTurn !== step.turn || openAgentTurn(this.agent) !== step.turn) return decision;
+		try {
+			await this.memory.begin(step.turn, step.signal);
+		} catch (error) {
+			this.end();
+			throw error;
+		}
+		const pin = this.memory.current;
+		for (const [id, graph] of this.views) if (graph.composableTurns.get(id) === void 0) this.views.delete(id);
+		if (pin !== void 0) this.views.set(pin.context.view.id, pin.graph);
+		if (!starting && step.step !== 1) return decision;
+		const wake = pin === void 0 ? "" : modelMemoryWake(pin.graph, pin.context).text;
+		return {
+			...decision,
+			messages: [...decision.messages, createPluginMessage(`${CONTINUATION_GUIDANCE}\n\n${wake}`, "instructions")]
+		};
+	}
+	end() {
+		this.authorizedTurn = void 0;
+		this.memory.end();
+	}
+	dispose() {
+		if (this.closed) return;
+		this.closed = true;
+		try {
+			for (const stop of this.stops.splice(0).reverse()) stop();
+		} finally {
+			this.authorizedTurn = void 0;
+			this.memory.dispose();
+			this.views.clear();
+		}
+	}
+};
+//#endregion
 //#region src/host/subagent.ts
 function evidenceInsights(evidence) {
 	return evidence.items.map((item) => {
@@ -10626,7 +10871,6 @@ const REVIEW_TOOLS = [
 const RESULT_TOOL_NAME = "mnemon_subagent_result";
 /** How many finished delegated children stay refused memory tools if DSH resumes one. */
 const FINISHED_CHILDREN = 1e3;
-const FINISHED_CHILD_REFUSAL = "This Mnemon task has finished, so it no longer reads or changes memory. Reply without memory tools.";
 const RESULT_TOOL_INPUT_SCHEMA = {
 	type: "object",
 	properties: {
@@ -10763,8 +11007,13 @@ var MnemonSubagentCoordinator = class {
 	resultRequests = /* @__PURE__ */ new Map();
 	disposeResultTool;
 	disposeResumeGuard;
+	disposeTaskNotices;
 	/** Delegated children whose run has ended, newest last, at most FINISHED_CHILDREN. */
 	finishedChildren = /* @__PURE__ */ new Set();
+	continuations = /* @__PURE__ */ new Map();
+	continuationOwners = /* @__PURE__ */ new WeakMap();
+	providerNames = /* @__PURE__ */ new Set(["spawn", "fork"]);
+	providerObservers = [];
 	disposed = false;
 	reviewAdmission = new AutomaticReviewAdmission();
 	constructor(subagents, runtimeSource, resultRuntime, taskAgentModelResolver, runtimeMaintenanceMaxTokensResolver, runtimeMaintenanceTaskRunner) {
@@ -10799,11 +11048,39 @@ var MnemonSubagentCoordinator = class {
 		});
 		if (typeof registration !== "function") throw new Error("dsh-mnemon subagent result tool registration did not return a disposer");
 		this.disposeResultTool = registration;
+		const notices = resultRuntime.on("agent/pre-step", (async (step, next) => {
+			const ignored = new Set(step.messages.filter((message) => {
+				const source = message.source;
+				return source.kind === "subagent-settled" && typeof source.senderSessionId === "string" && (isTaskRecord(source.senderSessionId) || this.finishedChildren.has(source.senderSessionId));
+			}).map((message) => message.id));
+			if (ignored.size === 0) return next();
+			if (step.step === 1 && ignored.size === step.messages.length) return {
+				kind: "enter",
+				messages: []
+			};
+			const decision = await next();
+			return decision.kind === "reject" ? decision : {
+				...decision,
+				messages: decision.messages.filter((message) => !ignored.has(message.id))
+			};
+		}), { prepend: true });
+		if (typeof notices === "function") this.disposeTaskNotices = notices;
+		if (typeof subagents.list !== "function") {
+			for (const stop of [resultRuntime.on("subagent/provider-added", ((provider) => {
+				this.providerNames.add(provider.name);
+			})), resultRuntime.on("subagent/provider-removed", ((name) => {
+				this.providerNames.delete(name);
+			}))]) if (typeof stop === "function") this.providerObservers.push(stop);
+		}
 	}
 	dispose() {
 		this.disposed = true;
 		this.reviewAdmission.dispose();
 		this.resultRequests.clear();
+		this.disposeTaskNotices?.();
+		this.disposeTaskNotices = void 0;
+		for (const stop of [...this.continuations.values()].reverse()) stop();
+		for (const stop of this.providerObservers.splice(0)) stop();
 		const resumeGuard = this.disposeResumeGuard;
 		this.disposeResumeGuard = void 0;
 		resumeGuard?.();
@@ -10814,10 +11091,68 @@ var MnemonSubagentCoordinator = class {
 	snapshot() {
 		return { ...this.counters };
 	}
+	isFinishedTask(id, agent) {
+		if (this.finishedChildren.has(id)) return true;
+		if (agent === void 0 || agent.id !== id || !isLegacyMemoryTask(agent)) return false;
+		this.finished(id);
+		return true;
+	}
+	isUserContinuation(agent) {
+		return this.continuationOwners.get(agent)?.ownsHumanTurn(agent) === true;
+	}
+	delegationLimit(parent) {
+		if (!this.isUserContinuation(parent)) return 1;
+		const depths = [parent.session.header?.delegationDepth ?? 0, parent.options?.subagentDepth ?? 0];
+		if (depths.some((depth) => !Number.isSafeInteger(depth) || depth < 0 || Object.is(depth, -0) || depth === Number.MAX_SAFE_INTEGER)) throw new Error("Cannot determine a safe delegation depth for this continued task");
+		return Math.max(...depths) + 1;
+	}
+	/** User continuation is a fresh scoped turn, never revival of a delegated run. */
+	continueTask(agent) {
+		if (this.continuations.has(agent) || this.disposed) return;
+		if (typeof agent.ctx.effect !== "function" || this.resultRuntime?.agents?.get === void 0) {
+			agent.ctx.tools?.guard?.((execution) => execution.name?.startsWith("mnemon_") ? FINISHED_TASK_REFUSAL : void 0);
+			return;
+		}
+		const continuation = new TaskContinuation(agent, this.runtimeSource, (id) => this.resultRuntime?.agents?.get?.(id));
+		let dispose;
+		dispose = agent.ctx.effect(() => {
+			const stop = continuation.start();
+			this.continuationOwners.set(agent, continuation);
+			return () => {
+				try {
+					stop();
+				} finally {
+					if (this.continuations.get(agent) === dispose) this.continuations.delete(agent);
+					this.continuationOwners.delete(agent);
+				}
+			};
+		}, "dsh-mnemon.task-continuation()");
+		this.continuations.set(agent, dispose);
+	}
+	/** Spawn may use an independent tool scope, so transfer the turn guard explicitly. */
+	inheritTaskContinuation(parent, child) {
+		const owner = this.continuationOwners.get(parent);
+		if (owner === void 0 || this.continuations.has(child)) return;
+		let dispose;
+		dispose = child.ctx.effect(() => {
+			const stop = child.ctx.tools?.guard?.((execution) => owner.guard(execution));
+			if (typeof stop !== "function") throw new Error("A continued task child requires a scoped memory tool guard");
+			this.continuationOwners.set(child, owner);
+			return () => {
+				try {
+					stop();
+				} finally {
+					if (this.continuations.get(child) === dispose) this.continuations.delete(child);
+					this.continuationOwners.delete(child);
+				}
+			};
+		}, "dsh-mnemon.task-delegation()");
+		this.continuations.set(child, dispose);
+	}
 	/**
 	* DSH 0.2.1 can resume a finished child from its saved state when another Agent sends it a
-	* message: with its persona and tools, but without the guard its run held. A delegated child
-	* never reads or changes memory once its run has ended (#387).
+	* message: with its persona and tools, but without the guard its run held. Only a fresh
+	* human turn may acquire new authority; automatic continuations remain denied (#387).
 	*/
 	finished(id) {
 		this.finishedChildren.delete(id);
@@ -10826,9 +11161,7 @@ var MnemonSubagentCoordinator = class {
 		if (this.disposeResumeGuard !== void 0 || this.disposed || this.resultRuntime === void 0) return;
 		const resumed = this.resultRuntime.on("agent/created", (({ agent }) => {
 			if (!this.finishedChildren.has(agent.id)) return;
-			try {
-				agent.ctx?.tools?.guard?.((execution) => execution.name?.startsWith("mnemon_") === true ? FINISHED_CHILD_REFUSAL : void 0);
-			} catch {}
+			this.continueTask(agent);
 		}));
 		if (typeof resumed === "function") this.disposeResumeGuard = resumed;
 	}
@@ -11267,8 +11600,8 @@ var MnemonSubagentCoordinator = class {
 	* One tool-less structured run for skill evolution: a review, a draft, a
 	* backtest step or a case derivation. The child sees only the prompt.
 	*/
-	async skillTask(parent, label, prompt, schema, persona, signal, route) {
-		const { provider, runId, result } = await this.delegate(parent, "skill", label, prompt, [], schema, signal, "spawn", persona, void 0, void 0, route);
+	async skillTask(parent, label, prompt, schema, persona, signal, route, maxTokens) {
+		const { provider, runId, result } = await this.delegate(parent, "skill", label, prompt, [], schema, signal, "spawn", persona, void 0, void 0, route, void 0, maxTokens);
 		return {
 			provider,
 			runId,
@@ -11429,9 +11762,9 @@ ${naturalRequest(request, target === void 0 ? REQUEST_LABELS : TARGETED_WRITE_LA
 			execution.release();
 		}
 	}
-	async delegate(parent, operation, label, prompt, tools, outputSchema, signal, preferredProvider = "spawn", persona = WRITE_PERSONA, recovery, guard, route, admission) {
+	async delegate(parent, operation, label, prompt, tools, outputSchema, signal, preferredProvider = "spawn", persona = WRITE_PERSONA, recovery, guard, route, admission, skillMaxTokens) {
 		if (this.disposed) throw new Error("dsh-mnemon subagent coordinator is disposed");
-		const provider = this.provider(preferredProvider);
+		const provider = this.provider(preferredProvider, this.runtimeSource.forAgent(parent).config.subagentProviderNames);
 		assertDshOutputSchema(outputSchema);
 		if (this.resultRuntime === void 0) throw new Error("dsh-mnemon subagent result tool runtime is unavailable");
 		const resultToolName = RESULT_TOOL_NAME;
@@ -11537,7 +11870,7 @@ ${naturalRequest(request, target === void 0 ? REQUEST_LABELS : TARGETED_WRITE_LA
 Completion protocol: call \`${resultToolName}\` exactly once with requestId \`${requestId}\` and result matching this JSON schema:
 ${JSON.stringify(outputSchema)}
 This is the only completion channel for this run. Do not finish with a plain-text answer. The requestId expires when this run finishes or is cancelled.`;
-			const perOpMaxTokens = operation === "migration" || operation === "compaction" || operation === "reconcile" ? this.runtimeMaintenanceMaxTokensResolver?.() ?? 8192 : operation === "document-archive" ? 8192 : operation === "metadata-maintenance" ? 4096 : operation === "review" ? this.runtimeSource.config.idleReview.maxTokens : operation === "skill" ? 16384 : void 0;
+			const perOpMaxTokens = operation === "migration" || operation === "compaction" || operation === "reconcile" ? this.runtimeMaintenanceMaxTokensResolver?.() ?? 8192 : operation === "document-archive" ? 8192 : operation === "metadata-maintenance" ? 4096 : operation === "review" ? this.runtimeSource.config.idleReview.maxTokens : operation === "skill" ? skillMaxTokens ?? 16384 : void 0;
 			const fixed = route ?? this.taskAgentModelResolver?.();
 			const baseAgentOptions = perOpMaxTokens === void 0 ? void 0 : { maxTokens: perOpMaxTokens };
 			const resolvedAgentOptions = fixed === void 0 ? baseAgentOptions : {
@@ -11560,7 +11893,7 @@ This is the only completion channel for this run. Do not finish with a plain-tex
 					parent,
 					signal,
 					...resolvedAgentOptions === void 0 ? {} : { agentOptions: resolvedAgentOptions },
-					maxDepth: 1,
+					maxDepth: this.delegationLimit(parent),
 					toolFilter: { allow: [...this.availableTools(parent, tools), resultToolName] },
 					persona: completionPersona
 				}, host);
@@ -11576,11 +11909,11 @@ This is the only completion channel for this run. Do not finish with a plain-tex
 			if (captured !== void 0 && captured.agentId !== activeRun.id) throw new Error("Mnemon subagent result was recorded by a different child");
 			let structured = captured?.value ?? result.structured;
 			if (structured === void 0 && result.stopReason === "completed") structured = recoverStructuredResult(recovery, committedReceipts.filter((receipt) => receipt.agentId === activeRun.id));
-			if (structured !== void 0) assertDshOutputValue(outputSchema, structured);
 			if (result.stopReason !== "completed") {
 				const detail = subagentFailureDetail(activeRun, result);
-				throw new Error(`memory subagent stopped with ${result.stopReason}${detail === void 0 ? "" : `: ${detail}`}`);
+				throw new SubagentStoppedError(result.stopReason, perOpMaxTokens, detail);
 			}
+			if (structured !== void 0) assertDshOutputValue(outputSchema, structured);
 			if (structured === void 0) throw new Error("memory subagent completed without recording its result");
 			if (operation === "review" && [
 				"failed",
@@ -11644,8 +11977,12 @@ This is the only completion channel for this run. Do not finish with a plain-tex
 		this.counters.lastAt = (/* @__PURE__ */ new Date()).toISOString();
 		return completed;
 	}
-	provider(preferred) {
-		const names = this.subagents.list();
+	provider(preferred, explicitNames = []) {
+		const names = this.subagents.list?.() ?? [.../* @__PURE__ */ new Set([
+			...this.providerNames,
+			...configuredProviderNames(this.resultRuntime),
+			...explicitNames
+		])].filter((name) => this.subagents.getProvider(name) !== void 0);
 		const compatible = (name) => {
 			const provider = this.subagents.getProvider(name);
 			return provider?.capabilities.depthLimit === true && childComposition(this.subagents, provider) !== void 0;
@@ -12765,7 +13102,7 @@ var MnemonLifecycle = class {
 	}
 	/** Model work for skill evolution under a fresh task Agent, outside any conversation. */
 	runSkillTask(workspaceRoot, signal, operation, route) {
-		return this.runTaskAgent("", workspaceRoot, signal, operation, route);
+		return this.runTaskAgent("", workspaceRoot, signal, operation, route, "Mnemon · Skills");
 	}
 	/**
 	* What one conversation did with skills, for the bars under its turns. A
@@ -12808,7 +13145,7 @@ var MnemonLifecycle = class {
 		const stopCreated = this.ctx.on("agent/created", (({ agent, source }) => {
 			this.install(agent, source);
 		}));
-		for (const agent of this.ctx.agents.roots()) this.install(agent, "adopted");
+		for (const agent of rootAgents(this.ctx.agents, this.ctx.subagents)) this.install(agent, "adopted");
 		return () => {
 			stopChanged?.();
 			stopCreated();
@@ -12988,7 +13325,7 @@ var MnemonLifecycle = class {
 	/** Synthesize a Web Agent Query without borrowing a conversation Agent or its history. */
 	answerTask(sessionId, query, evidence, workspaceRoot, signal = new AbortController().signal) {
 		const root = workspaceRoot?.trim() || this.workspaceRoot(sessionId);
-		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.answer(agent, query, evidence, signal));
+		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.answer(agent, query, evidence, signal), void 0, "Mnemon · Ask Agent");
 	}
 	/** A write the user sent from the page: a space they picked that is switched off comes back on (#387). */
 	remember(sessionId, request, signal = new AbortController().signal) {
@@ -13001,7 +13338,7 @@ var MnemonLifecycle = class {
 		return this.coordinator.manageSource(graph, request);
 	}
 	runRuntimeMaintenanceTask(scope, signal, operation) {
-		return this.runTaskAgent(scope.sessionId ?? "", scope.workspaceId, signal, operation);
+		return this.runTaskAgent(scope.sessionId ?? "", scope.workspaceId, signal, operation, void 0, "Mnemon · Memory maintenance");
 	}
 	/**
 	* Read the merged memory and let a model propose what a human should review.
@@ -13030,12 +13367,12 @@ var MnemonLifecycle = class {
 	mutateDocumentTask(sessionId, request, workspaceRoot, signal = new AbortController().signal) {
 		const root = workspaceRoot?.trim() || this.workspaceRoot(sessionId);
 		if (root === void 0 || root.trim() === "") throw new Error("a selected DSH workspace is required to write a Mnemon Document");
-		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.document(agent, request, signal));
+		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.document(agent, request, signal), void 0, "Mnemon · Document");
 	}
 	archiveDocument(sessionId, id, workspaceRoot, signal = new AbortController().signal) {
 		const root = workspaceRoot?.trim() || this.workspaceRoot(sessionId);
 		if (root === void 0 || root.trim() === "") throw new Error("a selected DSH workspace is required to archive a Mnemon Document");
-		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.archiveDocument(agent, id, signal));
+		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.archiveDocument(agent, id, signal), void 0, "Mnemon · Archive Document");
 	}
 	mutate(sessionId, operation, request, signal = new AbortController().signal) {
 		return this.coordinator.write(this.liveAgent(sessionId), operation, request, signal);
@@ -13046,11 +13383,11 @@ var MnemonLifecycle = class {
 	/** Choose a new Memory Space's Provider under a fresh task Agent, as Ask Agent does without a loaded conversation Agent. */
 	placeProviderTask(sessionId, body, prepared, workspaceRoot, signal = new AbortController().signal) {
 		const root = workspaceRoot?.trim() || this.workspaceRoot(sessionId);
-		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.placeProvider(agent, body, prepared, signal));
+		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.placeProvider(agent, body, prepared, signal), void 0, "Mnemon · Choose memory provider");
 	}
 	maintainMetadata(sessionId, memoryBodyIds, workspaceRoot, signal = new AbortController().signal) {
 		const root = workspaceRoot?.trim() || this.workspaceRoot(sessionId);
-		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.maintainMetadata(agent, memoryBodyIds, signal));
+		return this.runTaskAgent(sessionId, root, signal, (agent) => this.coordinator.maintainMetadata(agent, memoryBodyIds, signal), void 0, "Mnemon · Memory metadata");
 	}
 	async supervise(sessionId, content, idempotencyKey, signal = new AbortController().signal) {
 		const normalizedSessionId = sessionId.trim();
@@ -13062,7 +13399,7 @@ var MnemonLifecycle = class {
 		const normalizedSessionId = sessionId.trim();
 		const root = workspaceRoot?.trim() || this.workspaceRoot(normalizedSessionId);
 		const scopeKey = root === void 0 ? `task:${normalizedSessionId || "global"}` : `task:${resolve(root)}`;
-		return this.superviseResolved(scopeKey, normalizedSessionId, content, idempotencyKey, signal, (operation) => this.runTaskAgent(normalizedSessionId, root, signal, operation));
+		return this.superviseResolved(scopeKey, normalizedSessionId, content, idempotencyKey, signal, (operation) => this.runTaskAgent(normalizedSessionId, root, signal, operation, void 0, "Mnemon · Save to memory"));
 	}
 	async superviseResolved(replayScope, responseSessionId, content, idempotencyKey, signal, withAgent) {
 		if (!this.config.writeEnabled) throw new Error("dsh-mnemon is configured read-only (writeEnabled: false)");
@@ -13116,8 +13453,9 @@ var MnemonLifecycle = class {
 	* is the explicit Web workbench scope, so LiveMnemonRuntime resolves the same
 	* workspace graph without borrowing conversation history or ownership.
 	*/
-	async runTaskAgent(fallbackSessionId, workspaceRoot, signal, operation, route) {
-		const sessionId = randomUUID();
+	async runTaskAgent(fallbackSessionId, workspaceRoot, signal, operation, route, title = "Mnemon · Background task") {
+		const modern = activationOwned(this.ctx.subagents);
+		const sessionId = `mnemon-task-v1-${randomUUID()}`;
 		this.taskAgentIds.add(sessionId);
 		let handle;
 		let failure;
@@ -13128,6 +13466,7 @@ var MnemonLifecycle = class {
 				...creation,
 				signal
 			});
+			if (modern) titleTask(handle.agent, title);
 			if (route !== void 0) try {
 				handle.agent[TASK_ROUTE] = route;
 			} catch {}
@@ -13153,7 +13492,9 @@ var MnemonLifecycle = class {
 	* a turn only while DSH's projection cache holds a record of it, so a finished task
 	* could stay listed as an untitled Ungrouped conversation (#435). No `parentSession`
 	* or `delegationDepth`: the task belongs to no conversation, and its children stay
-	* one level deep.
+	* one level deep. Activation-owned master requires an ordinary root instead;
+	* its persistent task ID and title identify the visible record without enrolling
+	* it in conversation automation. Official rc.1 retains the hidden metadata.
 	*/
 	async taskAgentCreation(fallbackSessionId, workspaceRoot, signal, route) {
 		const baseOptions = this.taskAgentModelOptions(fallbackSessionId, workspaceRoot);
@@ -13171,7 +13512,7 @@ var MnemonLifecycle = class {
 		const workingDirectory = workFrom === void 0 ? void 0 : this.ctx.get("workingDirectory");
 		const meta = {
 			cwd,
-			origin: "subagent",
+			...activationOwned(this.ctx.subagents) ? {} : { origin: "subagent" },
 			...presetId === void 0 ? {} : { agentPreset: presetId }
 		};
 		if (presets === void 0 && typeof workingDirectory?.set !== "function") return {
@@ -13309,11 +13650,15 @@ var MnemonLifecycle = class {
 	}
 	install(agent, source) {
 		if (this.taskAgentIds.has(agent.id) || this.owners.has(agent) || this.children.has(agent)) return;
+		if ((isTaskRecord(agent.id) || this.coordinator.isFinishedTask(agent.id, agent)) && !isCreatingChild(this.ctx.agents, agent)) {
+			this.coordinator.continueTask(agent);
+			return;
+		}
 		if (agent.session.header?.origin === "subagent") {
 			this.installChild(agent);
 			return;
 		}
-		if (!this.ctx.agents.roots().includes(agent)) return;
+		if (!isRootAgent(this.ctx.agents, this.ctx.subagents, agent)) return;
 		const memoryTurn = this.runtimeSource === void 0 ? void 0 : new AgentMemoryTurn(agent, this.runtimeSource);
 		const lifecycle = new MnemonAgentLifecycle(agent, this.coordinator, this.config, this.counters, source, memoryTurn, () => this.runtimeSource?.forAgent(agent).directory);
 		let dispose;
@@ -13343,6 +13688,7 @@ var MnemonLifecycle = class {
 		const parentId = agent.session.header?.parentSession?.trim();
 		const parent = parentId === void 0 || parentId === "" ? void 0 : this.ctx.agents.get(parentId);
 		if (runtime === void 0 || parent === void 0 || parent === agent) return;
+		this.coordinator.inheritTaskContinuation(parent, agent);
 		const parentMemory = this.memoryTurns.get(parent);
 		let delegation;
 		if (parentMemory !== void 0) delegation = parentMemory.delegate();
@@ -14606,10 +14952,30 @@ var SkillEvolution = class {
 		const settings = this.host.settings();
 		const { pack, targetRoot, guidance } = prepared;
 		let prompt = skillDraftPrompt(pack, guidance, targetRoot);
+		let maxTokens = settings.draftMaxTokens;
+		const attemptedBudgets = [];
 		let draft;
 		for (let attempt = 0; draft === void 0; attempt++) {
-			const parsed = parseSkillDraft((await this.host.runTask(workspace, signal, (task) => this.host.skillTask(task, "Mnemon skill draft", prompt, SKILL_DRAFT_SCHEMA, SKILL_DRAFT_PERSONA, signal, input.route), input.route)).structured);
+			signal.throwIfAborted();
+			attemptedBudgets.push(maxTokens);
+			let answer;
+			try {
+				answer = await this.host.runTask(workspace, signal, (task) => this.host.skillTask(task, "Mnemon skill draft", prompt, SKILL_DRAFT_SCHEMA, SKILL_DRAFT_PERSONA, signal, input.route, maxTokens), input.route);
+				signal.throwIfAborted();
+			} catch (error) {
+				signal.throwIfAborted();
+				if (error instanceof SubagentStoppedError && error.maxTokens !== void 0) attemptedBudgets[attemptedBudgets.length - 1] = error.maxTokens;
+				if (error instanceof SubagentStoppedError && error.stopReason === "max-tokens" && attempt === 0 && settings.draftRetryMaxTokens > maxTokens) {
+					maxTokens = settings.draftRetryMaxTokens;
+					prompt += "\n\nThe previous attempt exhausted its output budget and was discarded. Return a complete SKILL.md from the beginning; keep notes and changes concise.";
+					continue;
+				}
+				const bytes = Buffer.byteLength(pack.skill?.content ?? "", "utf8");
+				throw new Error(`Skill draft failed. Attempted budgets: ${attemptedBudgets.join(", ")} tokens; source SKILL.md: ${bytes} bytes (UTF-8). Adjust skills.draftMaxTokens / skills.draftRetryMaxTokens in Plugins → dsh-mnemon → Skills → Draft generation. Stay within provider/model caps: lower rejected budgets, shorten the skill or use a model with a higher output cap. Reason: ${message(error).slice(0, 100)}`, { cause: error });
+			}
+			const parsed = parseSkillDraft(answer.structured);
 			try {
+				signal.throwIfAborted();
 				draft = await source.mutate("draft-record", {
 					...input.suggestionId === void 0 ? {} : { suggestionId: input.suggestionId },
 					skillName: pack.skillName,
@@ -14620,6 +14986,7 @@ var SkillEvolution = class {
 					...pack.action === "create" ? { targetRoot } : {}
 				}, signal);
 			} catch (error) {
+				signal.throwIfAborted();
 				if (attempt > 0) throw error;
 				prompt += `\n\nYour previous SKILL.md was rejected: ${message(error)}. Return a corrected complete file.`;
 			}
@@ -16415,7 +16782,7 @@ function registerDocumentTools(ctx, { requireSource, config, sourceAction }, coo
 			const agent = requireAgent(exec);
 			if (args.action === "archive") {
 				requireSource(exec, "documents", "archive");
-				if (isSubagent(agent)) throw new Error("idle document workers cannot cold-archive directly");
+				if (isSubagent(agent) && !coordinator.isUserContinuation(agent)) throw new Error("idle document workers cannot cold-archive directly");
 				if (args.id === void 0) throw new Error("document id is required for archive");
 				return Promise.resolve(coordinator.archiveDocument(agent, args.id, exec.signal)).then(documentReceipt);
 			}
@@ -18885,7 +19252,7 @@ function apply(rawContext, rawConfig = {}) {
 		settings: () => skillSettings.get(),
 		source: (agent) => skillsSourceFor(runtime, agent),
 		runTask: (workspaceRoot, signal, operation, route) => lifecycle.runSkillTask(workspaceRoot, signal, operation, route),
-		skillTask: (parent, label, prompt, schema, persona, signal) => coordinator.skillTask(parent, label, prompt, schema, persona, signal, taskRoute(parent))
+		skillTask: (parent, label, prompt, schema, persona, signal, _route, maxTokens) => coordinator.skillTask(parent, label, prompt, schema, persona, signal, taskRoute(parent), maxTokens)
 	});
 	lifecycle.useSkillEvolution(skills);
 	ctx.effect(() => {

package/lib/{starter-resolution-C5nNk-cs.js → starter-resolution-xVjONc6g.js}

@@ -17,7 +17,7 @@ var dependencies = {
 	"dsh-mnemon-source-documents": "0.5.13",
 	"dsh-mnemon-source-memory-spaces": "0.5.25",
 	"dsh-mnemon-source-runtime": "0.5.17",
-	"dsh-mnemon-source-skills": "0.5.7",
+	"dsh-mnemon-source-skills": "0.5.8",
 	"dsh-mnemon-strategy-auto-capture": "0.5.5",
 	"dsh-mnemon-strategy-default-three-tier": "0.5.12",
 	"dsh-mnemon-strategy-general": "0.5.1",

package/lib/starter.js

@@ -1,4 +1,4 @@
-import { t as prepareStarterResolution } from "./starter-resolution-C5nNk-cs.js";
+import { t as prepareStarterResolution } from "./starter-resolution-xVjONc6g.js";
 //#region src/starter.ts
 const name = "dsh-mnemon-starter";
 const provide = ["mnemonStarterReady"];

package/lib/types/src/client/locales.d.ts

@@ -793,6 +793,10 @@ export declare const zh: {
     'skills.autoBacktest': string;
     'skills.autoBacktestHint': string;
     'skills.parameters': string;
+    'skills.draftGeneration': string;
+    'skills.draftMaxTokens': string;
+    'skills.draftRetryMaxTokens': string;
+    'skills.draftBudgetHint': string;
     'skills.reviewThreshold': string;
     'skills.idleSeconds': string;
     'skills.cooldownSeconds': string;

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

@@ -307,6 +307,8 @@ export interface Config {
     persistenceStrategy?: MemoryPersistenceStrategy;
     /** Model route used by clean, session-independent maintenance Agents. */
     taskAgentModel?: TaskAgentModelConfig;
+    /** Additional provider names for Hosts without enumeration and opaque provider plugins. */
+    subagentProviderNames?: string[];
     /**
      * Whether this profile runs Git repository sync at all. It lives here rather than
      * in the data directory because the settings page has to draw the block without
@@ -367,6 +369,7 @@ export interface ResolvedConfig {
     };
     persistenceStrategy: ResolvedMemoryPersistenceStrategy;
     taskAgentModel: ResolvedTaskAgentModelConfig;
+    subagentProviderNames: string[];
     syncEnabled: boolean;
 }
 export interface ResolvedInteractionConfig {
@@ -386,6 +389,10 @@ export interface ResolvedSkillsConfig {
     targetScope: 'storage' | 'user' | 'project';
     /** Backtest a draft against the current version as soon as it is written. */
     autoBacktest: boolean;
+    /** Output budget for a complete skill draft, including model reasoning. */
+    draftMaxTokens: number;
+    /** One fresh attempt after truncation, only when larger than draftMaxTokens. */
+    draftRetryMaxTokens: number;
     /** The one-line skills bar under a finished turn. */
     hints: boolean;
     /** 技能管理 as a sidebar entry of its own instead of a Memory System page. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon",
-  "version": "0.5.40",
+  "version": "0.5.41",
   "description": "Composable, view-based context for DeepSeek Harness. Pluggable sources and strategies, with layered memory and self-evolving skills out of the box.",
   "keywords": [
     "deepseek-harness",
@@ -167,7 +167,7 @@
     "dsh-mnemon-source-documents": "0.5.13",
     "dsh-mnemon-source-memory-spaces": "0.5.25",
     "dsh-mnemon-source-runtime": "0.5.17",
-    "dsh-mnemon-source-skills": "0.5.7",
+    "dsh-mnemon-source-skills": "0.5.8",
     "dsh-mnemon-strategy-auto-capture": "0.5.5",
     "dsh-mnemon-strategy-default-three-tier": "0.5.12",
     "dsh-mnemon-strategy-general": "0.5.1",