@bizagent/dsh 0.0.0-stage → 1.0.0

package/lib/worklog-ledger.js

@@ -0,0 +1,91 @@
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+import { z } from 'zod';
+import { HomeAddressSchema } from './domain.js';
+export const WorklogRevisionSchema = z.object({
+    schemaVersion: z.literal(1),
+    id: z.string().min(1),
+    sessionId: z.string().min(1),
+    homeAddress: HomeAddressSchema,
+    revision: z.number().int().positive(),
+    idempotencyKey: z.string().min(1).max(128),
+    description: z.string().min(1).max(240),
+    body: z.string().min(1).max(16000),
+    status: z.enum(['ongoing', 'completed', 'blocked', 'failed']),
+    origin: z.enum(['agent', 'work-result', 'session-activity']).optional(),
+    cwd: z.string().min(1).optional(),
+    evidence: z.object({
+        fromSeq: z.number().int().nonnegative(),
+        toSeq: z.number().int().nonnegative(),
+        fingerprint: z.string().regex(/^[a-f0-9]{64}$/),
+    }),
+    files: z.array(z.object({
+        path: z.string().min(1).max(500),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/),
+        bytes: z.number().int().nonnegative().max(8 * 1024 * 1024),
+        snapshot: z.literal(true).optional(),
+    })).max(10),
+    projectId: z.string().min(1).optional(),
+    workId: z.string().min(1).optional(),
+    recordedAt: z.string().min(1),
+}).superRefine((revision, context) => {
+    if (revision.evidence.fromSeq > revision.evidence.toSeq) {
+        context.addIssue({ code: 'custom', path: ['evidence'], message: 'Worklog evidence range is reversed' });
+    }
+    if (new Set(revision.files.map(file => file.path)).size !== revision.files.length) {
+        context.addIssue({ code: 'custom', path: ['files'], message: 'duplicate Worklog file reference' });
+    }
+});
+export const BIZAGENT_WORKLOG_DOMAIN = defineDomain({
+    name: 'bizagent_worklog',
+    version: 0,
+    tables: { revisions: domainTable(WorklogRevisionSchema) },
+});
+export class WorklogLedger {
+    domain;
+    mutationTail = Promise.resolve();
+    constructor(domain) {
+        this.domain = domain;
+    }
+    static async open(facility) {
+        return new WorklogLedger(await facility.open(BIZAGENT_WORKLOG_DOMAIN));
+    }
+    async withWrite(update) {
+        const task = this.mutationTail.catch(() => undefined).then(update);
+        this.mutationTail = task;
+        return task;
+    }
+    get(id) {
+        const record = this.domain.table('revisions').get(id);
+        return record === undefined ? undefined : WorklogRevisionSchema.parse(record);
+    }
+    listVersions(sessionId) {
+        return this.all().filter(item => item.sessionId === sessionId)
+            .sort((a, b) => a.revision - b.revision);
+    }
+    listLatest(homeAddress) {
+        const latest = new Map();
+        for (const item of this.all()) {
+            if (item.homeAddress !== homeAddress)
+                continue;
+            const current = latest.get(item.sessionId);
+            if (current === undefined || item.revision > current.revision)
+                latest.set(item.sessionId, item);
+        }
+        return [...latest.values()]
+            .sort((a, b) => b.recordedAt.localeCompare(a.recordedAt) || b.sessionId.localeCompare(a.sessionId));
+    }
+    async put(revision) {
+        const parsed = WorklogRevisionSchema.parse(revision);
+        if (this.get(parsed.id) !== undefined)
+            throw new Error(`Worklog revision already exists: ${parsed.id}`);
+        await this.domain.table('revisions').put(parsed.id, parsed);
+    }
+    async close() {
+        await this.domain.close();
+    }
+    all() {
+        return [...this.domain.table('revisions').entries()]
+            .map(([, record]) => WorklogRevisionSchema.parse(record));
+    }
+}
+//# sourceMappingURL=worklog-ledger.js.map

package/lib/worklog-snapshot.d.ts

@@ -0,0 +1,34 @@
+export declare const WORKLOG_SNAPSHOT_DIRECTORY = "worklog-snapshots/sha256";
+export declare const PROJECT_SNAPSHOT_DIRECTORY = "project-snapshots/sha256";
+export declare const WORK_SNAPSHOT_DIRECTORY = "work-snapshots/sha256";
+export declare const LEARNING_SNAPSHOT_DIRECTORY = "learning-snapshots/sha256";
+export declare const MAX_WORKLOG_FILE_BYTES: number;
+export declare function worklogSnapshotPath(sha256: string): string;
+export declare function projectSnapshotPath(sha256: string): string;
+export declare function workSnapshotPath(sha256: string): string;
+export declare function learningSnapshotPath(sha256: string): string;
+/** Immutable objects live under the Home root, so Home archives carry them. */
+declare class HomeSnapshotStore {
+    private readonly homeRoot;
+    private readonly directoryName;
+    constructor(homeRoot: string, directoryName: string);
+    retain(bytes: Uint8Array): Promise<{
+        sha256: string;
+        bytes: number;
+    }>;
+    read(sha256: string, expectedBytes?: number): Promise<Buffer>;
+}
+export declare class WorklogSnapshotStore extends HomeSnapshotStore {
+    constructor(homeRoot: string);
+}
+export declare class ProjectSnapshotStore extends HomeSnapshotStore {
+    constructor(homeRoot: string);
+}
+export declare class WorkSnapshotStore extends HomeSnapshotStore {
+    constructor(homeRoot: string);
+}
+export declare class LearningSnapshotStore extends HomeSnapshotStore {
+    constructor(homeRoot: string);
+}
+export {};
+//# sourceMappingURL=worklog-snapshot.d.ts.map

package/lib/worklog-snapshot.js

@@ -0,0 +1,100 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { link, lstat, mkdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+export const WORKLOG_SNAPSHOT_DIRECTORY = 'worklog-snapshots/sha256';
+export const PROJECT_SNAPSHOT_DIRECTORY = 'project-snapshots/sha256';
+export const WORK_SNAPSHOT_DIRECTORY = 'work-snapshots/sha256';
+export const LEARNING_SNAPSHOT_DIRECTORY = 'learning-snapshots/sha256';
+export const MAX_WORKLOG_FILE_BYTES = 8 * 1024 * 1024;
+const DIGEST = /^[a-f0-9]{64}$/;
+export function worklogSnapshotPath(sha256) {
+    if (!DIGEST.test(sha256))
+        throw new Error('invalid Worklog snapshot SHA-256');
+    return `${WORKLOG_SNAPSHOT_DIRECTORY}/${sha256}`;
+}
+export function projectSnapshotPath(sha256) {
+    if (!DIGEST.test(sha256))
+        throw new Error('invalid Project snapshot SHA-256');
+    return `${PROJECT_SNAPSHOT_DIRECTORY}/${sha256}`;
+}
+export function workSnapshotPath(sha256) {
+    if (!DIGEST.test(sha256))
+        throw new Error('invalid Work snapshot SHA-256');
+    return `${WORK_SNAPSHOT_DIRECTORY}/${sha256}`;
+}
+export function learningSnapshotPath(sha256) {
+    if (!DIGEST.test(sha256))
+        throw new Error('invalid Learning snapshot SHA-256');
+    return `${LEARNING_SNAPSHOT_DIRECTORY}/${sha256}`;
+}
+/** Immutable objects live under the Home root, so Home archives carry them. */
+class HomeSnapshotStore {
+    homeRoot;
+    directoryName;
+    constructor(homeRoot, directoryName) {
+        this.homeRoot = homeRoot;
+        this.directoryName = directoryName;
+    }
+    async retain(bytes) {
+        if (bytes.length > MAX_WORKLOG_FILE_BYTES)
+            throw new Error('file snapshot exceeds 8 MiB');
+        const sha256 = createHash('sha256').update(bytes).digest('hex');
+        const root = resolve(this.homeRoot);
+        if (await realpath(root) !== root)
+            throw new Error('snapshot Home root must be a real directory');
+        const directory = join(root, this.directoryName);
+        await mkdir(directory, { recursive: true });
+        if (await realpath(directory) !== directory)
+            throw new Error('snapshot directory traverses a symlink');
+        const target = join(directory, sha256);
+        const temporary = join(directory, `.${sha256}.${randomUUID()}.tmp`);
+        try {
+            await writeFile(temporary, bytes, { flag: 'wx', mode: 0o600 });
+            try {
+                await link(temporary, target);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+        await this.read(sha256, bytes.length);
+        return { sha256, bytes: bytes.length };
+    }
+    async read(sha256, expectedBytes) {
+        const root = resolve(this.homeRoot);
+        const directory = join(root, this.directoryName);
+        if (await realpath(root) !== root || await realpath(directory) !== directory) {
+            throw new Error('snapshot directory traverses a symlink');
+        }
+        if (!DIGEST.test(sha256))
+            throw new Error('invalid snapshot SHA-256');
+        const target = join(directory, sha256);
+        const info = await lstat(target);
+        if (!info.isFile() || info.isSymbolicLink() || info.size > MAX_WORKLOG_FILE_BYTES
+            || (expectedBytes !== undefined && info.size !== expectedBytes)) {
+            throw new Error('snapshot is missing, oversized, or changed');
+        }
+        const bytes = await readFile(target);
+        if (bytes.length !== info.size || createHash('sha256').update(bytes).digest('hex') !== sha256) {
+            throw new Error('snapshot checksum mismatch');
+        }
+        return bytes;
+    }
+}
+export class WorklogSnapshotStore extends HomeSnapshotStore {
+    constructor(homeRoot) { super(homeRoot, WORKLOG_SNAPSHOT_DIRECTORY); }
+}
+export class ProjectSnapshotStore extends HomeSnapshotStore {
+    constructor(homeRoot) { super(homeRoot, PROJECT_SNAPSHOT_DIRECTORY); }
+}
+export class WorkSnapshotStore extends HomeSnapshotStore {
+    constructor(homeRoot) { super(homeRoot, WORK_SNAPSHOT_DIRECTORY); }
+}
+export class LearningSnapshotStore extends HomeSnapshotStore {
+    constructor(homeRoot) { super(homeRoot, LEARNING_SNAPSHOT_DIRECTORY); }
+}
+//# sourceMappingURL=worklog-snapshot.js.map

package/lib/writer-guard.d.ts

@@ -0,0 +1,11 @@
+export declare const RUNTIME_WRITER_LOCK_NAME = ".bizagent-writer.lock";
+export declare const RUNTIME_WRITER_CLAIM_NAME = ".bizagent-writer-claim.lock";
+/** Prevent two DSH processes from using independent cached Domain snapshots for the same profile or Home root. */
+export declare class RuntimeWriterGuard {
+    private readonly locks;
+    private released;
+    private constructor();
+    static acquire(roots: string[]): Promise<RuntimeWriterGuard>;
+    release(): Promise<void>;
+}
+//# sourceMappingURL=writer-guard.d.ts.map

package/lib/writer-guard.js

@@ -0,0 +1,207 @@
+import { randomUUID } from 'node:crypto';
+import { open, mkdir, readFile, realpath, lstat, unlink } from 'node:fs/promises';
+import { hostname } from 'node:os';
+import { join, resolve } from 'node:path';
+export const RUNTIME_WRITER_LOCK_NAME = '.bizagent-writer.lock';
+export const RUNTIME_WRITER_CLAIM_NAME = '.bizagent-writer-claim.lock';
+const CLAIM_WAIT_MS = 2_000;
+const CLAIM_POLL_MS = 25;
+/** Lock and claim paths this process currently holds, so its own PID is not mistaken for a live owner. */
+const heldInProcess = new Set();
+/** Prevent two DSH processes from using independent cached Domain snapshots for the same profile or Home root. */
+export class RuntimeWriterGuard {
+    locks;
+    released = false;
+    constructor(locks) {
+        this.locks = locks;
+    }
+    static async acquire(roots) {
+        const canonical = new Set();
+        for (const root of roots) {
+            await mkdir(root, { recursive: true });
+            canonical.add(await realpath(resolve(root)));
+        }
+        const held = [];
+        try {
+            for (const root of [...canonical].sort()) {
+                const path = join(root, RUNTIME_WRITER_LOCK_NAME);
+                const claim = await acquireClaim(join(root, RUNTIME_WRITER_CLAIM_NAME));
+                try {
+                    const existing = await inspectLock(path);
+                    if (existing) {
+                        if (ownerMayBeLive(path, existing.owner)) {
+                            throw new Error(`BizAgent writer is already reserved at ${path} `
+                                + `by ${existing.owner.hostname} PID ${existing.owner.pid}`);
+                        }
+                        const current = await lstat(path);
+                        if (current.dev !== existing.device || current.ino !== existing.inode) {
+                            throw new Error(`BizAgent writer lock changed during recovery: ${path}`);
+                        }
+                        await unlink(path);
+                    }
+                    held.push(await createHeld(path));
+                }
+                finally {
+                    await releaseLocks([claim]);
+                }
+            }
+            return new RuntimeWriterGuard(held);
+        }
+        catch (error) {
+            await releaseLocks(held);
+            throw error;
+        }
+    }
+    async release() {
+        if (this.released)
+            return;
+        this.released = true;
+        await releaseLocks(this.locks);
+    }
+}
+async function acquireClaim(path) {
+    const deadline = Date.now() + CLAIM_WAIT_MS;
+    while (true) {
+        try {
+            return await createHeld(path);
+        }
+        catch (error) {
+            if (!isExists(error))
+                throw error;
+        }
+        let claim;
+        try {
+            claim = await inspectLock(path);
+        }
+        catch (error) {
+            if (Date.now() >= deadline)
+                throw error;
+            await new Promise(resolveDelay => setTimeout(resolveDelay, CLAIM_POLL_MS));
+            continue;
+        }
+        if (!claim) {
+            await new Promise(resolveDelay => setTimeout(resolveDelay, CLAIM_POLL_MS));
+            continue;
+        }
+        if (claim.owner.hostname !== hostname() || !ownerMayBeLive(path, claim.owner)) {
+            throw new Error(`BizAgent writer recovery claim is stale at ${path}; `
+                + 'verify the prior process before removing it');
+        }
+        if (Date.now() >= deadline)
+            throw new Error(`BizAgent writer acquisition is busy at ${path}`);
+        await new Promise(resolveDelay => setTimeout(resolveDelay, CLAIM_POLL_MS));
+    }
+}
+async function inspectLock(path) {
+    const info = await lstat(path).catch(error => {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    });
+    if (!info)
+        return undefined;
+    if (!info.isFile())
+        throw new Error(`BizAgent writer lock is not a regular file: ${path}`);
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw new Error(`BizAgent writer lock is unreadable at ${path}; verify before removing it`);
+    }
+    let owner;
+    try {
+        owner = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`BizAgent writer lock is unreadable at ${path}; verify before removing it`);
+    }
+    if (!validOwner(owner)) {
+        throw new Error(`BizAgent writer lock has invalid owner at ${path}; verify before removing it`);
+    }
+    return { device: info.dev, inode: info.ino, owner };
+}
+async function createHeld(path) {
+    const handle = await open(path, 'wx', 0o600);
+    try {
+        await handle.writeFile(JSON.stringify({ pid: process.pid, hostname: hostname(),
+            createdAt: new Date().toISOString(), token: randomUUID() }) + '\n');
+        await handle.sync();
+        const info = await handle.stat();
+        heldInProcess.add(path);
+        return { path, handle, device: info.dev, inode: info.ino };
+    }
+    catch (error) {
+        const info = await handle.stat().catch(() => undefined);
+        await handle.close();
+        const current = await lstat(path).catch(() => undefined);
+        if (info && current && info.dev === current.dev && info.ino === current.ino) {
+            await unlink(path).catch(() => undefined);
+        }
+        throw error;
+    }
+}
+function validOwner(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const owner = value;
+    return Number.isSafeInteger(owner['pid']) && Number(owner['pid']) > 0
+        && typeof owner['hostname'] === 'string' && owner['hostname'].length > 0
+        && typeof owner['token'] === 'string' && owner['token'].length > 0;
+}
+/**
+ * Whether a lock owner may still be running. Another host cannot be checked, so it counts as live.
+ * The current PID is live only while this process holds the path: after a crash, a restart that
+ * reuses the PID (for example PID 1 in a container) must not be blocked by its predecessor's lock.
+ */
+function ownerMayBeLive(path, owner) {
+    if (owner.hostname !== hostname())
+        return true;
+    if (owner.pid === process.pid)
+        return heldInProcess.has(path);
+    return processAlive(owner.pid);
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !(error instanceof Error && 'code' in error && error.code === 'ESRCH');
+    }
+}
+async function releaseLocks(locks) {
+    const errors = [];
+    for (const lock of [...locks].reverse()) {
+        try {
+            const current = await lstat(lock.path).catch(error => {
+                if (isMissing(error))
+                    return undefined;
+                throw error;
+            });
+            if (current && (current.dev !== lock.device || current.ino !== lock.inode)) {
+                throw new Error(`BizAgent writer lock changed while held: ${lock.path}`);
+            }
+            if (current)
+                await unlink(lock.path);
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        finally {
+            heldInProcess.delete(lock.path);
+            await lock.handle.close().catch(error => { errors.push(error); });
+        }
+    }
+    if (errors.length > 0)
+        throw new AggregateError(errors, 'BizAgent writer lock cleanup failed');
+}
+function isExists(error) {
+    return error instanceof Error && 'code' in error && error.code === 'EEXIST';
+}
+function isMissing(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}
+//# sourceMappingURL=writer-guard.js.map

package/package.json

@@ -1,6 +1,174 @@
 {
   "name": "@bizagent/dsh",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Long-term memory and teamwork for agents on DeepSeek Harness (DSH): Agent Homes, evidence-backed learning, governed sharing, Inbox, formal Work, and Projects.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/phonism/bizagent.git",
+    "directory": "packages/dsh"
+  },
+  "homepage": "https://github.com/phonism/bizagent/tree/main/packages/dsh#readme",
+  "bugs": {
+    "url": "https://github.com/phonism/bizagent/issues"
+  },
+  "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./host": {
+      "types": "./lib/host.d.ts",
+      "default": "./lib/host.js"
+    },
+    "./ui-host": {
+      "types": "./lib/ui-host.d.ts",
+      "default": "./lib/ui-host.js"
+    },
+    "./local-human-host": {
+      "types": "./lib/local-human-host.d.ts",
+      "default": "./lib/local-human-host.js"
+    },
+    "./client": {
+      "types": "./lib/client-types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "bizagent": "./lib/cli.js"
+  },
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts",
+    "cordis.patch.yml",
+    "README.md",
+    "CHANGELOG.md",
+    "docs",
+    "examples",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "node scripts/clean.mjs",
+    "build:host": "tsc -p tsconfig.json",
+    "build:client": "tsc -p tsconfig.client.json && node scripts/build-client.mjs",
+    "build": "npm run clean && npm run build:host && npm run build:client",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
+    "test": "npm run build && node --test tests/*.test.mjs",
+    "examples": "npm run build && node examples/learning-lab.mjs",
+    "smoke": "npm run build && node scripts/smoke.mjs",
+    "smoke:profile": "npm run build && node scripts/profile-smoke.mjs",
+    "smoke:local-human": "npm run build && BIZAGENT_PROFILE_SMOKE_HUMAN=1 node scripts/profile-smoke.mjs",
+    "smoke:packed": "npm run build && node scripts/profile-smoke.mjs --packed",
+    "smoke:install": "npm run build && node scripts/installed-profile-smoke.mjs --install-only",
+    "smoke:installed": "npm run build && node scripts/installed-profile-smoke.mjs",
+    "smoke:plugin-add": "npm run build && node scripts/plugin-add-smoke.mjs",
+    "smoke:agent": "npm run build && node scripts/agent-profile-smoke.mjs",
+    "smoke:work": "npm run build && node scripts/work-profile-smoke.mjs",
+    "smoke:project": "npm run build && node scripts/project-profile-smoke.mjs",
+    "smoke:learning": "npm run build && node scripts/learning-profile-smoke.mjs",
+    "smoke:session-ui": "npm run build && node scripts/session-ui-smoke.mjs",
+    "pack:check": "npm pack --dry-run",
+    "docs:tools": "npm run build && node scripts/tools-reference.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-api-workspace-controller",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-input-trigger",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-ui-workspace",
+        "@deepseek-ai/dsh-client-ui-chat"
+      ],
+      "platform": "web"
+    }
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.0.5",
+    "@deepseek-ai/dsh-agent": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-agent-default-model": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-api-session-controller": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-api-workspace-controller": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-attachment": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-locale": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-input-trigger": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-layout": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-session": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-sidebar": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-workspace": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-query": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-skill": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-storage-domain": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-chat": "^0.2.1-rc.2"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-util-values": "0.2.1-rc.2",
+    "@deepseek-ai/schemastery": "3.18.5",
+    "yaml": "2.9.0",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.5",
+    "@deepseek-ai/dsh-agent": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-agent-default-model": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-api-remotes": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-api-session-controller": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-api-workspace-controller": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-attachment": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-locale": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-store": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-chat": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-input-trigger": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-layout": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-session": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-sidebar": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-workspace": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-query": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-skill": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-storage-domain": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.1-rc.2",
+    "@types/node": "^24.3.0",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "~18.3.1",
+    "esbuild": "^0.25.9",
+    "pnpm": "11.24.0",
+    "typescript": "^5.9.2"
+  },
+  "license": "MIT",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "agent-memory",
+    "multi-agent",
+    "organizational-learning"
+  ]
+}