@khorsheed/dsh-capability-catalog 0.1.95

package/lib/types/types.d.ts

@@ -0,0 +1,315 @@
+/**
+ * Wire types of the capability catalog: the snapshot the host half collects,
+ * the model-facing tool output, and the Remote data contract. The browser
+ * card parses the tool's JSON text result or the Remote response back into
+ * these shapes, so they stay plain JSON-safe objects with no class identity.
+ * @module @khorsheed/dsh-capability-catalog/types
+ */
+/** Arbitrary JSON value — a locally-declared recursive type the typert Remote
+ * boundary accepts (arbitrary tool parameter schemas are unconstrained JSON). */
+export type CatalogJsonValue = null | boolean | number | string | readonly CatalogJsonValue[] | {
+    readonly [key: string]: CatalogJsonValue;
+};
+/** One skill row in the catalog (summary layer — no body / metadata / rank). */
+export interface CatalogSkillRow {
+    readonly name: string;
+    /** Short routing description. */
+    readonly description: string;
+    /** Registration source bucket: project-dsh / project-agents / runtime / user-dsh / user-agents / custom / bundled. */
+    readonly source: string;
+    /** Provider that owns the skill body (e.g. `filesystem`, `skill-badge`, plugin name). */
+    readonly provider: string;
+    /** Whether the model may load it (in catalog). */
+    readonly modelInvocable: boolean;
+    /** Whether a user may invoke it via `/name`. */
+    readonly userInvocable: boolean;
+    /** Optional extra routing guidance. */
+    readonly whenToUse?: string;
+    /** Last-modified time (epoch ms) of the skill body, when a local bundle exists. */
+    readonly updatedAt?: number;
+    /**
+     * sha256 of the skill's SKILL.md body — the one part of a skill that IS a
+     * capability (the procedure the model executes), carried so the capability
+     * fingerprint can be taken from a snapshot alone. Absent when the body
+     * could not be read (a remote/opaque skill, or a registry that declines
+     * the load).
+     */
+    readonly bodySha?: string;
+}
+/** Credential declared by a skill's metadata (the plugin-defined convention). */
+export interface CatalogCredentialDecl {
+    /** credential key, e.g. `wechat-reading/api-key`. */
+    readonly key: string;
+    /** Human label shown in the config block. */
+    readonly label?: string;
+}
+/** Credential config state for one declared credential. */
+export interface CatalogCredentialState {
+    readonly key: string;
+    readonly label?: string;
+    /** Whether a value has been configured (never the value itself). */
+    readonly configured: boolean;
+}
+/** Channel attribution for one tool row. */
+export type CatalogToolChannel = 'builtin' | 'plugin' | 'mcp' | 'unknown';
+/** One tool row in the catalog. */
+export interface CatalogToolRow {
+    /** Wire tool name as registered. */
+    readonly name: string;
+    /** Model-facing description. */
+    readonly description: string;
+    /** Attribution result. */
+    readonly channel: CatalogToolChannel;
+    /** Attribution confidence: exact for prefix/whitelist hits, inferred for baseline-diff hits. */
+    readonly confidence: 'exact' | 'inferred';
+    /** MCP server name when channel === 'mcp' (longest-match resolved). */
+    readonly serverName?: string;
+    /** Model-facing input parameters (JSON value), for the detail view. */
+    readonly parameters?: CatalogJsonValue;
+    /** Registrant package/owner when known. */
+    readonly owner?: string;
+}
+/** One MCP server observed in the profile patch layers. */
+/** MCP transport kind (matches dsh-mcp-client). */
+export type McpTransport = 'stdio' | 'streamable-http';
+/** One detected credential declared by an MCP server config (env/header/query). */
+export interface CatalogMcpCredentialDecl {
+    /** Config key that holds the secret (env var name, header name, or 'query:key'). */
+    readonly ref: string;
+    /** Human label (e.g. the env var / header / query param name). */
+    readonly label: string;
+    /** Whether the credential has been configured (never the value). */
+    readonly configured: boolean;
+}
+/** A configured MCP server (the catalog's persisted form). */
+export interface CatalogMcpServerConfig {
+    readonly serverName: string;
+    readonly transport: McpTransport;
+    /** stdio */
+    readonly command?: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string;
+    /** streamable-http */
+    readonly url?: string;
+    readonly headers?: readonly [string, string][];
+    /** env (value is a secretRef marker if it came from a secret). */
+    readonly env?: readonly [string, string][];
+    /** Whether the server is enabled (connected + injected). */
+    readonly enabled: boolean;
+}
+/** One discovered tool of an MCP server. */
+export interface CatalogMcpTool {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters?: CatalogJsonValue;
+    /** Per-tool enable/disable. */
+    readonly enabled: boolean;
+}
+/** The catalog's own MCP server management snapshot. */
+export interface CatalogMcpSnapshot {
+    readonly servers: readonly CatalogMcpServerConfig[];
+    readonly tools: Readonly<Record<string, readonly CatalogMcpTool[]>>;
+    readonly credentials: readonly CatalogMcpCredentialDecl[];
+}
+export interface CatalogMcpServerRow {
+    readonly name: string;
+    readonly toolCount: number;
+}
+/** Channel-count summary. */
+export interface CatalogChannelSummary {
+    readonly channel: string;
+    readonly count: number;
+}
+/** Full catalog snapshot. */
+export interface CapabilityCatalogSnapshot {
+    readonly skills: readonly CatalogSkillRow[];
+    readonly tools: readonly CatalogToolRow[];
+    readonly mcpServers: readonly CatalogMcpServerRow[];
+    readonly channels: readonly CatalogChannelSummary[];
+    /**
+     * The capability hash of this snapshot (`hashOf`), filled by the host half.
+     * It is NOT part of the canonical form it digests — a snapshot carrying it
+     * and the same snapshot without it hash alike.
+     */
+    readonly sha?: string;
+    /** The agent preset this snapshot was taken under; absent when none resolved. */
+    readonly preset?: string;
+}
+/** Fresh detail of one skill (body + metadata), loaded on demand. */
+export interface CatalogSkillDetail {
+    readonly name: string;
+    readonly description: string;
+    readonly source: string;
+    readonly provider: string;
+    readonly modelInvocable: boolean;
+    readonly userInvocable: boolean;
+    readonly path?: string;
+    readonly whenToUse?: string;
+    /** Full SKILL.md body. */
+    readonly content: string;
+    /** Parsed frontmatter metadata, serialized to JSON text (typert boundary is strict JSON). */
+    readonly metadataText?: string;
+    /** Declared credentials + their configured state (metadata.credentials only). */
+    readonly credentials?: readonly CatalogCredentialState[];
+    /** Env-var references detected in the skill body (read-only, informational —
+     * typically provided by the runtime/caller, NOT user-configurable here). */
+    readonly environmentRefs?: readonly string[];
+    /** Bundle-relative file paths (SKILL.md + scripts/assets/references) for a directory side. */
+    readonly files?: readonly string[];
+}
+/** One skill bundle file's text content, read on demand. */
+export interface CatalogSkillFileRead {
+    readonly content: string;
+}
+/** One skill found inside a local skill container dir.
+ * `kind:'self'` is the picked directory itself (a single skill bundle), so it is
+ * installed with `repo=<dir>` and no `skills`; `'child'` is a sub-directory of a
+ * container, installed with `repo=<dir>` + `skills:[name]`. */
+export interface CatalogDirSkillInfo {
+    readonly name: string;
+    readonly description: string;
+    readonly kind?: 'self' | 'child';
+}
+/** One managed skill's preset-scoped delivery state. */
+export interface CatalogScopedSkillRow {
+    readonly name: string;
+    readonly description: string;
+    readonly modelInvocable: boolean;
+    readonly userInvocable: boolean;
+    /** The managed `SKILL.md` path. */
+    readonly path: string;
+    /** The preset ids its frontmatter declares; empty means "every preset". */
+    readonly presets: readonly string[];
+    /** Whether a delivery provider currently serves it in at least one preset. */
+    readonly delivered: boolean;
+    /** The default-root path already supplying this name, when delivery is refused. */
+    readonly conflict?: string;
+}
+/** One preset's scoped-delivery state. */
+export interface CatalogScopedPresetRow {
+    readonly presetId: string;
+    readonly skills: readonly string[];
+    /** Why this preset's standing scope could not be used. */
+    readonly error?: string;
+}
+/** Preset-scoped skill delivery status, as the settings surface reads it.
+ * This is a discovery policy for one instance, not an authorization boundary. */
+export interface CatalogPresetScopeStatus {
+    /** Whether any preset is currently served. */
+    readonly enabled: boolean;
+    /** Why delivery is off, or reduced — absent when fully operational. */
+    readonly reason?: string;
+    /** The plugin-owned root the delivered skills live in. */
+    readonly root: string;
+    /** Whether the managed root is currently watched for changes. */
+    readonly watching: boolean;
+    readonly skills: readonly CatalogScopedSkillRow[];
+    readonly presets: readonly CatalogScopedPresetRow[];
+    /** True because custom skill roots are configured in host compositions this
+     * plugin cannot read: a duplicate there would not be detected. */
+    readonly customRootsUnverifiable: boolean;
+}
+/** One preset a scope picker may choose. */
+export interface CatalogPresetOption {
+    readonly id: string;
+    readonly name?: string;
+    readonly description?: string;
+    /** Why this preset cannot compose a session, when it cannot. */
+    readonly broken?: string;
+    /** Whether a session naming no preset composes this one (the deployment default). */
+    readonly isDefault?: boolean;
+}
+/**
+ * One mode's capability face: what the model sees when a session runs this
+ * agent preset. The rows are the same shape the default read returns, so a
+ * viewer renders a mode card with the grid it already has.
+ */
+export interface CatalogModeFace {
+    /** The preset id this face was read at. */
+    readonly preset: string;
+    /** The preset's published display name, when it has one. */
+    readonly name?: string;
+    /** One sentence on what the preset is for, when it publishes one. */
+    readonly description?: string;
+    /** Whether this is the deployment's default mode. */
+    readonly isDefault: boolean;
+    readonly skills: readonly CatalogSkillRow[];
+    readonly tools: readonly CatalogToolRow[];
+    /**
+     * Why this mode has no face; when set, both lists are empty. Present for a
+     * preset discovery already refused and for one whose standing scope would
+     * not resolve — neither is evidence that the mode loads nothing.
+     */
+    readonly unavailable?: string;
+}
+/** Request to declare which presets one skill is delivered to. */
+export interface CatalogPresetScopeSetRequest {
+    readonly name: string;
+    readonly presets: readonly string[];
+}
+/** Request to adopt an installed skill into the managed, preset-scoped root. */
+export interface CatalogPresetScopeAdoptRequest {
+    readonly name: string;
+    readonly presets: readonly string[];
+    readonly workdir?: string;
+}
+/** Outcome of one preset-scope write; `error` is present exactly when it failed. */
+export interface CatalogPresetScopeEditResult {
+    readonly ok: boolean;
+    readonly error?: string;
+}
+/** Add-skill channel. */
+export type AddSkillChannel = 'zip' | 'github' | 'command';
+/** Request to add a skill (upload a zip or clone a GitHub repo). */
+export interface CatalogAddSkillRequest {
+    readonly channel: AddSkillChannel;
+    /** Base64-encoded zip/tgz bytes for `zip`; opaque for `github`. */
+    readonly payload: string;
+    /** owner/repo, a git URL (a host-prefixed or pasted link and an in-repo subpath resolve to the same clone), or a local dir path for `command`. */
+    readonly repo?: string;
+    /** Selected skill sub-directory names when `repo` is a multi-skill container dir. */
+    readonly skills?: readonly string[];
+    /** Whether the added skill is model-invocable (written as disable-model-invocation inversely). */
+    readonly modelInvocable: boolean;
+    /** Target root: user (`$DSH_HOME/skills`) or project (`.agents/skills`). */
+    readonly root: 'user' | 'project';
+    /** When true, an existing same-name skill in the target root is replaced instead of prompting. */
+    readonly overwrite?: boolean;
+}
+/** Add-skill result. */
+export interface CatalogAddSkillResult {
+    readonly ok: boolean;
+    readonly error?: string;
+    readonly name?: string;
+    /** Set on a soft "skill already exists" refusal (ok:false) so the UI can offer overwrite. */
+    readonly exists?: boolean;
+}
+/** Delete-skill result (delete only applies to catalog-owned file skills). */
+export interface CatalogDeleteSkillResult {
+    readonly ok: boolean;
+    readonly error?: string;
+}
+/** Wire form of one credential's configured state. */
+export interface CatalogCredentialSetRequest {
+    readonly key: string;
+    readonly value: string;
+}
+/** Remote surface the browser card binds through. */
+export interface CapabilityCatalogRemote {
+    readonly snapshot: (workdir?: string) => Promise<CapabilityCatalogSnapshot>;
+    /** The capability face of one preset, with its `sha` (see the host half). */
+    readonly snapshotFor: (presetId?: string, workdir?: string) => Promise<CapabilityCatalogSnapshot>;
+    /** The capability face of one mode as a LISTING (no fingerprint work). */
+    readonly snapshotAt: (presetId?: string, workdir?: string) => Promise<CapabilityCatalogSnapshot>;
+    /** Every mode's face in one call, for the cross-mode comparison view. */
+    readonly modeFaces: (workdir?: string) => Promise<readonly CatalogModeFace[]>;
+    /** Read one capability at a mode's scope, or the default mode when omitted. */
+    readonly detail: (name: string, workdir?: string, presetId?: string) => Promise<CatalogSkillDetail | undefined>;
+    readonly readSkillFile: (name: string, filePath: string, workdir?: string, presetId?: string) => Promise<CatalogSkillFileRead | undefined>;
+    readonly listDirSkills: (dirPath: string) => Promise<readonly CatalogDirSkillInfo[]>;
+    readonly setCredential: (request: CatalogCredentialSetRequest) => Promise<boolean>;
+    readonly addSkill: (request: CatalogAddSkillRequest) => Promise<CatalogAddSkillResult>;
+    readonly deleteSkill: (name: string, workdir?: string, presetId?: string) => Promise<CatalogDeleteSkillResult>;
+    readonly pickDirectory: () => Promise<string | null>;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,8 @@
+/**
+ * Wire types of the capability catalog: the snapshot the host half collects,
+ * the model-facing tool output, and the Remote data contract. The browser
+ * card parses the tool's JSON text result or the Remote response back into
+ * these shapes, so they stay plain JSON-safe objects with no class identity.
+ * @module @khorsheed/dsh-capability-catalog/types
+ */
+export {};

package/lib/types/zip.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Minimal, dependency-free ZIP reader: enough to unpack a skill archive
+ * (dirs, stored and deflated entries) into `{ path, data }` pairs.
+ *
+ * Why hand-rolled: the host face is analyzed by the typert generator against a
+ * scratch overlay that only resolves `@deepseek-ai/*` source-plane packages and
+ * the harness's own node_modules — a third-party zip library resolves there but
+ * not at publish time, and no host edit is allowed. Using only node:zlib keeps
+ * the boundary to node built-ins, which the overlay resolves natively, and
+ * keeps the published package free of a zip runtime dependency.
+ *
+ * Skips directories; throws on a malformed or unsupported (e.g. zip64, encrypted,
+ * or data-descriptor-only) archive. Skill zips are small and conventional, so
+ * the classic (non-zip64) central directory is the only layout needed.
+ * @module @khorsheed/dsh-capability-catalog/zip
+ */
+/** One extracted file entry: a relative path and its contents. */
+export interface ZipEntry {
+    readonly path: string;
+    readonly data: Buffer;
+}
+/** Unpack a zip archive into its non-directory entries. */
+export declare function extractZip(buf: Buffer): ZipEntry[];
+//# sourceMappingURL=zip.d.ts.map

package/lib/types/zip.js

@@ -0,0 +1,80 @@
+/**
+ * Minimal, dependency-free ZIP reader: enough to unpack a skill archive
+ * (dirs, stored and deflated entries) into `{ path, data }` pairs.
+ *
+ * Why hand-rolled: the host face is analyzed by the typert generator against a
+ * scratch overlay that only resolves `@deepseek-ai/*` source-plane packages and
+ * the harness's own node_modules — a third-party zip library resolves there but
+ * not at publish time, and no host edit is allowed. Using only node:zlib keeps
+ * the boundary to node built-ins, which the overlay resolves natively, and
+ * keeps the published package free of a zip runtime dependency.
+ *
+ * Skips directories; throws on a malformed or unsupported (e.g. zip64, encrypted,
+ * or data-descriptor-only) archive. Skill zips are small and conventional, so
+ * the classic (non-zip64) central directory is the only layout needed.
+ * @module @khorsheed/dsh-capability-catalog/zip
+ */
+import { inflateRawSync } from 'node:zlib';
+const SIG_LOCAL = 0x04034b50; // PK\03\04
+const SIG_CENTRAL = 0x02014b50; // PK\01\02
+const SIG_EOCD = 0x06054b50; // PK\05\06
+/** Unpack a zip archive into its non-directory entries. */
+export function extractZip(buf) {
+    const eocd = findEocd(buf);
+    if (eocd === undefined)
+        throw new Error('end of central directory not found');
+    const count = buf.readUInt16LE(eocd + 10);
+    if (count === 0xffff)
+        throw new Error('zip64 archives are not supported');
+    let offset = buf.readUInt32LE(eocd + 16);
+    const entries = [];
+    for (let i = 0; i < count; i++) {
+        offset = readCentralDirEntry(buf, offset, entries);
+    }
+    return entries;
+}
+/** Walk one central-directory entry, appending it when it is a file. */
+function readCentralDirEntry(buf, offset, entries) {
+    if (buf.readUInt32LE(offset) !== SIG_CENTRAL)
+        throw new Error('bad central directory entry');
+    const method = buf.readUInt16LE(offset + 10);
+    const compSize = buf.readUInt32LE(offset + 20);
+    if (compSize === 0xffffffff)
+        throw new Error('zip64 entries are not supported');
+    const nameLen = buf.readUInt16LE(offset + 28);
+    const extraLen = buf.readUInt16LE(offset + 30);
+    const commentLen = buf.readUInt16LE(offset + 32);
+    const localOffset = buf.readUInt32LE(offset + 42);
+    const name = buf.toString('utf8', offset + 46, offset + 46 + nameLen);
+    if (!name.endsWith('/')) {
+        const { dataOffset } = readLocalHeader(buf, localOffset);
+        entries.push({ path: name, data: inflateEntry(buf, dataOffset, method, compSize) });
+    }
+    return offset + 46 + nameLen + extraLen + commentLen;
+}
+/** Read a local file header, returning the offset where the data begins. */
+function readLocalHeader(buf, offset) {
+    if (buf.readUInt32LE(offset) !== SIG_LOCAL)
+        throw new Error('bad local file header');
+    const nameLen = buf.readUInt16LE(offset + 26);
+    const extraLen = buf.readUInt16LE(offset + 28);
+    return { dataOffset: offset + 30 + nameLen + extraLen };
+}
+/** Decompress one entry: stored (0) or raw-deflated (8). */
+function inflateEntry(buf, dataOffset, method, compSize) {
+    const compressed = buf.subarray(dataOffset, dataOffset + compSize);
+    if (method === 0)
+        return Buffer.from(compressed);
+    if (method === 8)
+        return inflateRawSync(compressed);
+    throw new Error(`unsupported compression method ${method}`);
+}
+/** Locate the end-of-central-directory record (last 64 KiB window). */
+function findEocd(buf) {
+    const min = Math.max(0, buf.length - 22 - 0xffff);
+    for (let i = buf.length - 22; i >= min; i--) {
+        if (buf.readUInt32LE(i) === SIG_EOCD)
+            return i;
+    }
+    return undefined;
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Capability Catalog",
+    "description": "Enumerate every skill and tool with its registration channel."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "能力目录",
+    "description": "列出实例中所有技能与工具，标注各自的注册渠道。"
+  }
+}

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@khorsheed/dsh-capability-catalog",
+  "description": "Capability catalog: enumerate every skill and tool in the running instance with its registration channel (official builtin, project, user, custom, plugin runtime). A standalone settings tab (工具与技能) lists skills as a three-column preview grid — click for a modal with full detail, SKILL.md source, metadata, and per-credential config (e.g. an API key). An add-skill modal installs a skill from an uploaded zip or a pasted SKILL.md into the user or project skill root (the skill-filesystem watcher discovers it). Tools are listed by channel attribution.",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "cordis",
+    "capabilities",
+    "catalog",
+    "skills"
+  ],
+  "version": "0.1.95",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./typert": {
+      "types": "./lib/typert.host.d.ts",
+      "default": "./lib/typert.host.js"
+    },
+    "./remote": {
+      "types": "./lib/typert.remote-client.d.ts",
+      "default": "./lib/typert.remote-client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ],
+      "platform": "web"
+    },
+    "compat": {
+      "minHost": "0.1.5-rc.1",
+      "notes": "0.1.5-rc.1 full-line boot-verified 2026-09-25 (42 packages including capture) through the three compat layers: preset-registry dual-name probe, dual-shape typert codecs, and typert faces carrying zod@4; 0.1.7-rc.1 is the 3080 production-verified line",
+      "verifiedHost": "0.1.7-rc.1"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent-presets": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings-plugins": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-skill": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.6",
+    "react": "^18.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-agent-presets": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-primitives": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-settings": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-settings-plugins": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-slots": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-credentials": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-skill": {
+      "optional": true
+    }
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "lib/typert.host.d.ts",
+    "lib/typert.host.js",
+    "lib/typert.remote-client.d.ts",
+    "lib/typert.remote-client.js",
+    "scripts/gen-official-tools.mts",
+    "README.md",
+    "README.zh.md",
+    "LICENSE"
+  ]
+}

package/scripts/gen-official-tools.mts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/** Generate official-tools.ts by scanning the pinned harness checkout. */
+import { readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const HARNESS = process.env.DSH_HARNESS ?? join(homedir(), 'code/deepseek-harness')
+const PACKAGES = join(HARNESS, 'packages')
+const OUT = new URL('../src/official-tools.ts', import.meta.url)
+
+function toolNamesFromSource(source: string): string[] {
+  const names: string[] = []
+  // Allow marker wrappers between register( and defineTool( — 0.1.2 registers
+  // send_message as register(markAdjacentAgentSendMessageTool(defineTool({…}).
+  const re = /ctx\.tools\.register\(\s*(?:[A-Za-z_$][\w$]*\(\s*)*defineTool\(\s*\{/g
+  let m: RegExpExecArray | null
+  while ((m = re.exec(source)) !== null) {
+    const start = m.index + m[0].length
+    let depth = 1
+    let i = start
+    for (; i < source.length && depth > 0; i++) {
+      const ch = source[i]
+      if (ch === '{') depth++
+      else if (ch === '}') depth--
+    }
+    const block = source.slice(start, i)
+    const nm = /name:\s*'([^']+)'/.exec(block)
+    if (nm?.[1]) names.push(nm[1])
+  }
+  return names
+}
+
+function collect(dir: string): string[] {
+  const out: string[] = []
+  for (const entry of readdirSync(dir)) {
+    if (entry === 'node_modules' || entry === 'lib' || entry === 'tests') continue
+    const full = join(dir, entry)
+    const st = statSync(full)
+    if (st.isDirectory()) out.push(...collect(full))
+    else if (entry.endsWith('.ts') || entry.endsWith('.tsx')) out.push(full)
+  }
+  return out
+}
+
+const names = new Set<string>()
+for (const p of collect(PACKAGES)) {
+  for (const n of toolNamesFromSource(readFileSync(p, 'utf8'))) names.add(n)
+}
+const sorted = [...names].sort()
+const content = '/** Generated from the pinned harness checkout — do not edit by hand. Run scripts/gen-official-tools.mts. */\nexport const OFFICIAL_TOOLS: readonly string[] = ' + JSON.stringify(sorted, null, 2) + '\n'
+writeFileSync(OUT, content)
+console.log(`official-tools: ${sorted.length} names -> ${OUT.pathname}`)