@huanlin/dsh-plugin-yet-another-subagent 0.1.2 → 0.1.4

package/lib/index.js

@@ -2,6 +2,9 @@ import z from "schemastery";
 import { assertSubagentMaxDepth, settleRun } from "@deepseek-ai/dsh-subagent";
 import { settingsNamespace } from "@deepseek-ai/dsh-settings";
 import { defineTool } from "@deepseek-ai/dsh-tools";
+import { constants, zstdCompressSync, zstdDecompressSync } from "node:zlib";
+import { copyFile, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 //#region src/types.ts
 /**
 * Coerce a possibly-stale profile shape (from an older `settings.yaml` or a
@@ -473,13 +476,7 @@ function buildTool(profiles, ctx) {
 								...request,
 								signal: controller.signal
 							});
-							start.then((run) => {
-								parent.session.append("ya-subagent/started", {
-									callId: exec.callId,
-									childId: String(run.id),
-									profileId: profile.id
-								});
-							}).catch(() => {});
+							start.catch(() => {});
 							return {
 								cancel: (reason) => {
 									controller.abort(reason ?? "background subagent task killed");
@@ -497,33 +494,21 @@ function buildTool(profiles, ctx) {
 				const spawn = ctx.subagents.getProvider("spawn");
 				if (spawn === void 0) throw new Error("subagent spawn provider not available; load @deepseek-ai/dsh-subagent-spawn-in-process");
 				if (spawn.prepareContinuable === void 0) throw new Error("subagent spawn provider does not support continuable children");
-				const started = await ctx.subagents.startContinuable({
-					provider: "spawn",
-					label: args.description,
-					request,
-					signal: exec.signal
-				});
-				parent.session.append("ya-subagent/started", {
-					callId: exec.callId,
-					childId: started.childId,
-					profileId: profile.id
-				});
 				return {
 					kind: "continuable",
-					subagentId: started.childId,
+					subagentId: (await ctx.subagents.startContinuable({
+						provider: "spawn",
+						label: args.description,
+						request,
+						signal: exec.signal
+					})).childId,
 					profileLabel: profile.label
 				};
 			}
-			const run = await ctx.subagents.start("spawn", {
+			const result = await settleForegroundRun(await ctx.subagents.start("spawn", {
 				...request,
 				signal: exec.signal
-			});
-			parent.session.append("ya-subagent/started", {
-				callId: exec.callId,
-				childId: String(run.id),
-				profileId: profile.id
-			});
-			const result = await settleForegroundRun(run);
+			}));
 			return {
 				kind: "foreground",
 				runId: result.runId,
@@ -534,6 +519,273 @@ function buildTool(profiles, ctx) {
 	});
 }
 //#endregion
+//#region src/repair.ts
+/**
+* One-shot session-log repair: stamp `"ignorable": true` onto legacy
+* `ya-subagent/started` events so the harness persistence read path
+* (`assertEventsSupported`) will skip them instead of refusing the whole log.
+*
+* Background: older plugin versions wrote `ya-subagent/started` via
+* `session.append(...)`, but `session.append` cannot set the `ignorable`
+* envelope flag, and `KNOWN_SESSION_EVENT_TYPES` is code-generated with no
+* plugin registration surface. The read path therefore refuses any log
+* containing the type unless each occurrence carries `ignorable: true`.
+* This module rewrites on-disk artifacts in place (after a `.bak` backup) to
+* add that flag to every `ya-subagent/started` row missing it.
+*
+* Two physical encodings (mirrors `session-persistence-jsonl`):
+*   - `.jsonl`        — plaintext, one JSON record per line.
+*   - `.jsonl.zstd`   — concatenated independent Zstandard frames: the first
+*                       frame holds the session header line, subsequent
+*                       frames each hold one append batch of event lines.
+*                       Each frame is independently decodable + checksummed.
+*                       Only frames whose decoded plaintext contains a target
+*                       row are recompressed; untouched frames are copied
+*                       verbatim so byte-identity is preserved where possible.
+*
+* Idempotent: rows already carrying `ignorable: true` are skipped; files with
+* no target rows are left untouched (no backup, no rewrite).
+*
+* @module @huanlin/dsh-plugin-yet-another-subagent/repair
+*/
+/** The event type this module targets. */
+const TARGET_TYPE = "ya-subagent/started";
+/** Zstandard magic number (little-endian 0xFD2FB528). */
+const ZSTD_MAGIC = 4247762216;
+/** Compression options matching the harness's `CHECKSUM_OPTIONS`. */
+const CHECKSUM_OPTIONS = { params: { [constants.ZSTD_c_checksumFlag]: 1 } };
+/**
+* Recursively repair every session log under `sessionsRoot`.
+*
+* @param sessionsRoot - absolute path to `$DSH_HOME/sessions`.
+* @returns aggregate stats. Never throws — per-file failures land in `errors`.
+*/
+async function repairSessions(sessionsRoot) {
+	const errors = [];
+	let scanned = 0;
+	let repaired = 0;
+	let skipped = 0;
+	const visit = async (dir) => {
+		let entries;
+		try {
+			entries = await readdir(dir);
+		} catch (err) {
+			errors.push({
+				path: dir,
+				message: errorMessage(err)
+			});
+			return;
+		}
+		await Promise.all(entries.map(async (name) => {
+			const path = join(dir, name);
+			let isDir;
+			let isFile;
+			try {
+				const info = await stat(path);
+				isDir = info.isDirectory();
+				isFile = info.isFile();
+			} catch (err) {
+				errors.push({
+					path,
+					message: `stat failed: ${errorMessage(err)}`
+				});
+				return;
+			}
+			if (isDir) {
+				await visit(path);
+				return;
+			}
+			if (!isFile) return;
+			const isJsonl = name.endsWith(".jsonl");
+			const isZstd = name.endsWith(".jsonl.zstd");
+			if (!isJsonl && !isZstd) return;
+			scanned += 1;
+			try {
+				const outcome = isJsonl ? await repairPlaintextFile(path) : await repairZstdFile(path);
+				if (outcome.kind === "repaired") {
+					await writeFile(path, outcome.bytes);
+					repaired += 1;
+				} else if (outcome.kind === "clean") skipped += 1;
+			} catch (err) {
+				errors.push({
+					path,
+					message: errorMessage(err)
+				});
+			}
+		}));
+	};
+	try {
+		await visit(sessionsRoot);
+	} catch (err) {
+		errors.push({
+			path: sessionsRoot,
+			message: errorMessage(err)
+		});
+	}
+	return {
+		scanned,
+		repaired,
+		skipped,
+		errors
+	};
+}
+/**
+* Repair one `.jsonl` plaintext file. Backs up to `.bak` first if a repair is
+* needed and no backup exists yet.
+*/
+async function repairPlaintextFile(path) {
+	const { lines, changed } = patchPlaintextLines(await readFile(path, "utf8"));
+	if (!changed) return { kind: "clean" };
+	await ensureBackup(path);
+	return {
+		kind: "repaired",
+		bytes: Buffer.from(lines, "utf8")
+	};
+}
+/**
+* Repair one `.jsonl.zstd` concatenated-frame file. The header frame is
+* decoded to check for a target row (current harness writes the header as its
+* own frame, so a target there is theoretically possible but unlikely); event
+* frames are decoded and patched individually. Only frames with a patch are
+* recompressed; untouched frames are copied verbatim.
+*/
+async function repairZstdFile(path) {
+	const buffer = await readFile(path);
+	const frames = scanZstdFrames(buffer);
+	if (frames.length === 0) return { kind: "clean" };
+	const rebuilt = [];
+	let changed = false;
+	for (const frame of frames) {
+		const frameBytes = buffer.subarray(frame.start, frame.end);
+		const { lines, changed: frameChanged } = patchPlaintextLines(zstdDecompressSync(frameBytes).toString("utf8"));
+		if (frameChanged) {
+			changed = true;
+			rebuilt.push(zstdCompressSync(Buffer.from(lines, "utf8"), CHECKSUM_OPTIONS));
+		} else rebuilt.push(Buffer.from(frameBytes));
+	}
+	if (!changed) return { kind: "clean" };
+	await ensureBackup(path);
+	return {
+		kind: "repaired",
+		bytes: Buffer.concat(rebuilt)
+	};
+}
+/**
+* Patch every `ya-subagent/started` line missing `ignorable` by inserting
+* `"ignorable":true` into the JSON object. Returns the new text and whether
+* any line changed. Lines that fail to parse as JSON are left untouched
+* (a corrupt line is the harness's refusal job, not ours).
+*/
+function patchPlaintextLines(text) {
+	const lines = text.split("\n");
+	let changed = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!line) continue;
+		if (!line.includes(TARGET_TYPE)) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (typeof parsed !== "object" || parsed === null) continue;
+		const record = parsed;
+		if (record["type"] !== TARGET_TYPE) continue;
+		if (record["ignorable"] === true) continue;
+		const trimmed = line.trimEnd();
+		if (trimmed.endsWith("}")) {
+			lines[i] = trimmed.slice(0, -1) + ",\"ignorable\":true}";
+			changed = true;
+		}
+	}
+	return {
+		lines: lines.join("\n"),
+		changed
+	};
+}
+/**
+* Locate complete Zstandard frames in a concatenated stream. A structurally
+* incomplete final frame (torn tail from a concurrent writer) is skipped —
+* repairing it would risk data loss, and the harness treats it as a torn tail
+* too. Mirrors `scanZstdFrames` in `session-persistence-jsonl/src/zstd.ts`.
+*/
+function scanZstdFrames(buffer) {
+	const frames = [];
+	let offset = 0;
+	while (offset < buffer.length) {
+		const start = offset;
+		if (buffer.length - offset < 4) break;
+		if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC) break;
+		offset += 4;
+		if (offset === buffer.length) break;
+		const descriptor = buffer.readUInt8(offset);
+		offset += 1;
+		if ((descriptor & 24) !== 0) break;
+		const contentSizeFlag = descriptor >>> 6;
+		const singleSegment = (descriptor & 32) !== 0;
+		const checksum = (descriptor & 4) !== 0;
+		const dictionaryFlag = descriptor & 3;
+		const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+		const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
+		const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+		if (buffer.length - offset < remainingHeaderBytes) break;
+		offset += remainingHeaderBytes;
+		let lastBlock = false;
+		while (!lastBlock) {
+			if (buffer.length - offset < 3) {
+				offset = start;
+				break;
+			}
+			const blockHeader = buffer.readUIntLE(offset, 3);
+			offset += 3;
+			lastBlock = (blockHeader & 1) !== 0;
+			const blockType = blockHeader >>> 1 & 3;
+			const blockSize = blockHeader >>> 3;
+			if (blockType === 3) {
+				offset = start;
+				break;
+			}
+			const payloadBytes = blockType === 1 ? 1 : blockSize;
+			if (buffer.length - offset < payloadBytes) {
+				offset = start;
+				break;
+			}
+			offset += payloadBytes;
+		}
+		if (offset === start) break;
+		if (checksum) {
+			if (buffer.length - offset < 4) {
+				offset = start;
+				break;
+			}
+			offset += 4;
+		}
+		frames.push({
+			start,
+			end: offset
+		});
+	}
+	return frames;
+}
+/**
+* Copy `path` to `path.bak` if no backup exists yet. A concurrent repair run
+* leaves the original backup in place; a pre-existing `.bak` from another tool
+* is also preserved.
+*/
+async function ensureBackup(path) {
+	const backup = `${path}.bak`;
+	try {
+		await stat(backup);
+		return;
+	} catch {}
+	await copyFile(path, backup);
+}
+/** Extract a human-readable message from an unknown error. */
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
 //#region src/rpc.ts
 /** Build an RPC ok branch. */
 function ok(value) {
@@ -588,6 +840,16 @@ function registerRpc(ctx, store) {
 				name: s.name,
 				description: s.description
 			})) });
+			case "sessions.repair": {
+				const dshHomePath = ctx.get("dshHomePath");
+				const sessionsRoot = dshHomePath !== void 0 ? dshHomePath("sessions") : void 0;
+				if (sessionsRoot === void 0) return fail("dshHomePath provider unavailable; cannot resolve sessions root");
+				try {
+					return ok(await repairSessions(sessionsRoot));
+				} catch (err) {
+					return fail(`session repair failed: ${err instanceof Error ? err.message : String(err)}`);
+				}
+			}
 			default: return fail(`unknown endpoint: ${endpoint}`);
 		}
 	}, { authority: "trusted-host" });

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

@@ -0,0 +1,49 @@
+/**
+ * SettingsPage — the `ya-subagent` settings section: profile list CRUD.
+ *
+ * Visual language: matches ModelsSection / GeneralSection — outlined rowCard
+ * per profile (border-l2, r12, p12/14), filled editor surface
+ * (bg-module-platform, r12, p14/16), capsule controls (h36 r18 primary,
+ * h28 r14 secondary), 32px fields with border-l2 / bg-layer-1, 12/18 caption
+ * labels. Every color resolves through --dsw-alias-* tokens.
+ *
+ * Each profile card is collapsible (chevron in the row head); the editor
+ * surface is hidden when collapsed. Builtin profiles (cordis.yml seed) carry
+ * a `builtin`/`内置` badge next to the title. The "+ Add subagent" button at
+ * the bottom reveals an inline draft card with all fields editable (including
+ * id) and Create / Cancel actions.
+ *
+ * The persona field is a radio (inherit deployment persona vs custom text);
+ * the textarea is shown only when custom. The tool filter is a select
+ * (none / allow / deny); a multi-select dropdown is shown only when allow or
+ * deny is picked, populated from `tools.list` (the host's current
+ * `ctx.tools.schemas()`).
+ *
+ * Pulls the profile list once on mount via `connection.rpc.call('/ya-subagent',
+ * 'profiles.list')`, dispatches add/update/remove through the
+ * same RPC. The toolview slot is keyed by `subagent` and registered once at
+ * plugin load, so profile mutations do not need to re-register slots.
+ *
+ * @module @huanlin/dsh-plugin-yet-another-subagent/client/SettingsPage
+ */
+import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ClientConnectionRpc } from '@deepseek-ai/dsh-client-connection/client';
+import type { SubagentProfile } from '../types.ts';
+/** Inject face: RPC handle + locale translate. */
+export interface YaSubagentSettingsInjected {
+    readonly rpc: ClientConnectionRpc;
+    /** Refetch the profile list from the host. */
+    readonly fetchProfiles: () => Promise<readonly SubagentProfile[]>;
+    /** Bound locale translator for the ya-subagent namespace. */
+    readonly t: (key: string) => string;
+}
+/** Full props: settings.section runtime share + locale seat + inject. */
+type SettingsPageProps = PropsRuntime<'settings.section'> & PropsLocale<'ya-subagent'> & YaSubagentSettingsInjected;
+/**
+ * Render the subagent profiles settings page.
+ * @param props - settings.section runtime share + locale + inject.
+ * @returns the page element.
+ */
+export declare function SettingsPage({ rpc, fetchProfiles, t }: SettingsPageProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,56 @@
+/**
+ * SubagentCard — the model-facing toolcall card for the `subagent` tool.
+ *
+ * Three display branches:
+ *   1. **Running** (block is `RunningToolCall`): the tool call is in flight.
+ *      Show "running" with a spinner dot; no child session to subscribe to.
+ *   2. **Continuable settled** (result text matches `started <label>
+ *      subagent <id>`): subscribe to the child's `yaSubagentProgress`
+ *      projection for live toolcall/token counts; clickable to open.
+ *   3. **Foreground settled** (result text is the child's output): the
+ *      one-shot child has completed; show "completed" with an output
+ *      preview. No child session survives.
+ *
+ * @module @huanlin/dsh-plugin-yet-another-subagent/client/SubagentCard
+ */
+import type { ToolCallViewProps } from '@deepseek-ai/dsh-client-ui-tool/client';
+import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+/** Sessions service shape consumed by this card (narrow face of ISessions). */
+export interface SubagentCardSessions {
+    binding(id: string): {
+        session: {
+            projections: {
+                faceOf(key: string): {
+                    getSnapshot(): unknown;
+                    subscribe(fn: () => void): () => void;
+                } | undefined;
+            };
+        };
+    } | undefined;
+    openSubagent(address: {
+        parentSessionId: string;
+        childSessionId: string;
+        mode: 'continuable' | 'one-shot';
+    }): void;
+    subagentAddress(id: string): {
+        parentSessionId: string;
+        childSessionId: string;
+        mode: 'continuable' | 'one-shot';
+    } | undefined;
+    refreshSubagents(parentSessionId: string): Promise<void>;
+}
+/** Inject face: the sessions service handle + profile label lookup. */
+export type SubagentCardInjected = {
+    sessions: SubagentCardSessions;
+    /** Resolve a profile id to its display label; undefined if unknown. */
+    profileLabelOf: (id: string) => string | undefined;
+};
+/** Full props: toolview runtime share + this package's locale seat + inject. */
+type SubagentCardProps = ToolCallViewProps & PropsLocale<'ya-subagent'> & InjectFace<SubagentCardInjected>;
+/**
+ * Render one `subagent` tool call as a compact live card.
+ * @param props - keyed toolview payload + locale seat + sessions inject.
+ * @returns the dedicated subagent card.
+ */
+export declare function SubagentCard({ block, callId, toolName, sessionId, sessions, profileLabelOf, t }: SubagentCardProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,63 @@
+/**
+ * SubagentTreeView — a `conversation.view` entry showing the root session's
+ * full subagent tree (all depths) with live progress.
+ *
+ * Uses `sessions.subagentsByParent` (the catalog) as the primary tree
+ * structure source — this works for ALL depths without needing per-session
+ * bindings. `setSubagentCatalogOpen` keeps catalogs auto-refreshing.
+ * Projections (`yaSubagentProgress`) are used additionally when a session
+ * binding is available (current session + opened children) for richer data.
+ *
+ * @module @huanlin/dsh-plugin-yet-another-subagent/client/SubagentTreeView
+ */
+import type { ConvViewProps } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+/** Catalog entry shape (narrow face of SubagentListEntry). */
+interface CatalogEntry {
+    readonly kind: string;
+    readonly id: string;
+    readonly mode?: string;
+    readonly activity?: string;
+    readonly hasChildren?: boolean;
+    readonly label?: string;
+}
+/** Sessions service shape consumed by this view. */
+interface TreeSessions {
+    binding(id: string): {
+        session: {
+            projections: {
+                faceOf(key: string): {
+                    getSnapshot(): unknown;
+                    subscribe(fn: () => void): () => void;
+                } | undefined;
+            };
+        };
+    } | undefined;
+    openSubagent(address: {
+        parentSessionId: string;
+        childSessionId: string;
+        mode: 'continuable' | 'one-shot';
+    }): void;
+    subagentAddress(id: string): {
+        parentSessionId: string;
+        childSessionId: string;
+        mode: 'continuable' | 'one-shot';
+    } | undefined;
+    refreshSubagents(parentSessionId: string): Promise<void>;
+    setSubagentCatalogOpen(parentSessionId: string, open: boolean): void;
+    subagentsByParent: Readonly<Record<string, {
+        entries: readonly CatalogEntry[];
+        parentAvailable: boolean;
+    }>>;
+}
+export type SubagentTreeViewInjected = {
+    sessions: TreeSessions;
+    profileLabelOf: (id: string) => string | undefined;
+};
+type SubagentTreeViewProps = ConvViewProps & PropsLocale<'ya-subagent'> & InjectFace<SubagentTreeViewInjected>;
+/**
+ * Render the subagent tree view. Always shows the ROOT session's full tree;
+ * highlights the current session if it is a subagent.
+ */
+export declare function SubagentTreeView({ sessionId, sessions, profileLabelOf, t }: SubagentTreeViewProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,29 @@
+/**
+ * yet-another-subagent — browser half.
+ *
+ * Single bundle, dual entry: this is the client half (exports `./client`).
+ * Host half ships via `.` (see `src/index.ts`).
+ *
+ * Two registrations:
+ *   1. `settings.section` slot — the profile editor page (SettingsPage).
+ *   2. `tool.call.toolview` keyed slot, key `subagent` — the live toolcall
+ *      card (SubagentCard). A single key covers all profiles because the
+ *      tool name is always `subagent`; the profile is a call parameter.
+ *
+ * @module @huanlin/dsh-plugin-yet-another-subagent/client
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import { type YaSubagentKey } from './locales.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The subagent settings page + tool card copy. */
+        'ya-subagent': YaSubagentKey;
+    }
+}
+/** Required services: settings/tool slots, locale, sessions, connection. */
+export declare const inject: string[];
+/**
+ * Client plugin body: register settings page + single `subagent` toolview slot.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: ClientContext): void;

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

@@ -0,0 +1,13 @@
+/**
+ * Locale dictionaries for yet-another-subagent.
+ *
+ * @module @huanlin/dsh-plugin-yet-another-subagent/client/locales
+ */
+/** All copy keys for the ya-subagent namespace. */
+export type YaSubagentKey = 'nav' | 'page.title' | 'page.empty' | 'page.add' | 'page.add.placeholder.id' | 'page.add.placeholder.label' | 'page.add.submit' | 'page.add.error' | 'page.add.cancel' | 'row.label' | 'row.id' | 'row.model.kind.auto' | 'row.model.kind.manual' | 'row.model.provider' | 'row.model.model' | 'row.model.provider.placeholder' | 'row.model.model.placeholder' | 'row.model.noModels' | 'row.persona' | 'row.persona.kind.inherit' | 'row.persona.kind.custom' | 'row.persona.text' | 'row.toolFilter' | 'row.toolFilter.kind.none' | 'row.toolFilter.kind.allow' | 'row.toolFilter.kind.deny' | 'row.toolFilter.tools' | 'row.toolFilter.tools.search' | 'row.toolFilter.tools.empty' | 'row.toolFilter.tools.selected' | 'row.toolFilter.tools.selectAll' | 'row.toolFilter.tools.clear' | 'row.maxDepth' | 'row.delete' | 'row.delete.confirm' | 'row.save' | 'row.saved' | 'row.error' | 'row.expand' | 'row.collapse' | 'badge.builtin' | 'card.starting' | 'card.waiting' | 'card.idle' | 'card.running' | 'card.completed' | 'card.child-running' | 'card.child-idle' | 'card.toolcalls' | 'card.tokens' | 'card.calling' | 'card.open' | 'card.unavailable' | 'tree.tab' | 'tree.empty' | 'tree.rootHint' | 'tree.toolcalls' | 'tree.tokens' | 'tree.calling' | 'tree.state.running' | 'tree.state.idle' | 'tree.state.settled' | 'repair.button' | 'repair.confirm.title' | 'repair.confirm.body' | 'repair.confirm.warning' | 'repair.confirm.cancel' | 'repair.confirm.proceed' | 'repair.running' | 'repair.result.title' | 'repair.result.scanned' | 'repair.result.repaired' | 'repair.result.skipped' | 'repair.result.errors' | 'repair.result.errorEntry' | 'repair.result.close' | 'repair.error';
+/** Locale namespace id. */
+export declare const NS = "ya-subagent";
+/** English dictionary. */
+export declare const en: Record<YaSubagentKey, string>;
+/** Chinese dictionary. */
+export declare const zh: Record<YaSubagentKey, string>;

package/lib/types/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * yet-another-subagent — host plugin entry.
+ *
+ * Single bundle, dual entry: this is the host half (exports `.`). The browser
+ * half ships via `./client` (see `src/client/index.ts`).
+ *
+ * Architecture (design doc §1):
+ *   - A single `subagent` tool is exposed to the model. The desired profile
+ *     is selected via the `profile` parameter (enum of profile ids). Profile
+ *     add/remove updates the enum without changing the tool name set.
+ *   - The tool reuses the official `spawn` provider via `ctx.subagents.startContinuable`.
+ *   - Profiles live in an in-memory `ProfileStore` mutated through RPC.
+ *   - Two projections (`subagentProfile` on parent, `yaSubagentProgress` on
+ *     child) bridge the single-stage client runtime so SubagentCard can
+ *     subscribe to live child progress.
+ *
+ * @module @huanlin/dsh-plugin-yet-another-subagent
+ */
+import type { Context } from 'cordis';
+import z from 'schemastery';
+import type { YaSubagentConfig } from './types.ts';
+export declare const name = "yet-another-subagent";
+export declare const inject: string[];
+export type { SubagentProfile, YaSubagentConfig } from './types.ts';
+/** Settings namespace under which profile state persists (`$DSH_HOME/settings.yaml`). */
+export declare const SETTINGS_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
+export interface Config extends YaSubagentConfig {
+}
+export declare const Config: z<Config>;
+/**
+ * Plugin body: register profile tools, RPC, and projections.
+ *
+ * Persistence: when a settings service is mounted, the profile list lives
+ * under the `ya-subagent` namespace in `$DSH_HOME/settings.yaml`. The
+ * cordis.yml `profiles` field is the composition `base` (first-boot seed);
+ * runtime mutations persist through `scope.replace()`. Headless assemblies
+ * without a settings provider fall back to in-memory state (cordis.yml seed
+ * only, no persistence).
+ * @param ctx - host context carrying `tools`, `subagents`, `sessionProjections`.
+ * @param config - resolved config (seed profiles + generalFixed).
+ */
+export declare function apply(ctx: Context, config: Config): void;

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@huanlin/dsh-plugin-yet-another-subagent`.
+ *
+ * @module @huanlin/dsh-plugin-yet-another-subagent/invariant
+ */
+import type { Context } from 'cordis';
+/** Cordis companion plugin name. */
+export declare const name = "yet-another-subagent-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;