@bizagent/dsh 0.0.0-stage → 1.0.0

package/lib/agent-preset.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { AgentOptions, AgentRegistry } from '@deepseek-ai/dsh-agent';
+import type { SessionQueryEngine } from '@deepseek-ai/dsh-session-query';
+type Agents = Pick<AgentRegistry, 'get' | 'create' | 'resume'>;
+type Sessions = Pick<SessionQueryEngine, 'listSessions'>;
+/**
+ * Wrap the Agent factory so plugin-created Sessions join a DSH agent preset, as Sessions created
+ * by the DSH host do. The preset supplies the model-facing built-in tools (files, shell, search,
+ * subagents); without joining one, an Agent sees only globally registered tools and cannot read
+ * or change its Workspace. A new Session records the resolved preset on its header, and a resumed
+ * Session rejoins the preset it recorded (or the current default for Sessions created before this
+ * existed). A deployment with no preset roster keeps the plain host composition.
+ *
+ * A caller that names no model gets the host's current default, which is also what DSH's own
+ * session controller passes. DSH does not restore a resumed Session's model by itself, and an
+ * Agent without one fails every turn while assembling its system prompt.
+ */
+export declare function withAgentPreset(ctx: Context, agents: Agents, sessions: Sessions, defaultModel: () => AgentOptions): Agents;
+export {};
+//# sourceMappingURL=agent-preset.d.ts.map

package/lib/agent-preset.js

@@ -0,0 +1,46 @@
+/**
+ * Wrap the Agent factory so plugin-created Sessions join a DSH agent preset, as Sessions created
+ * by the DSH host do. The preset supplies the model-facing built-in tools (files, shell, search,
+ * subagents); without joining one, an Agent sees only globally registered tools and cannot read
+ * or change its Workspace. A new Session records the resolved preset on its header, and a resumed
+ * Session rejoins the preset it recorded (or the current default for Sessions created before this
+ * existed). A deployment with no preset roster keeps the plain host composition.
+ *
+ * A caller that names no model gets the host's current default, which is also what DSH's own
+ * session controller passes. DSH does not restore a resumed Session's model by itself, and an
+ * Agent without one fails every turn while assembling its system prompt.
+ */
+export function withAgentPreset(ctx, agents, sessions, defaultModel) {
+    const compose = async (presetId, setup) => {
+        const roster = ctx.get('agentPresets');
+        if (roster === undefined)
+            return { setup };
+        const id = (await roster.resolve(presetId)).id;
+        const joined = async (agentCtx, agent) => {
+            await roster.mount(agentCtx, id);
+            return setup?.(agentCtx, agent);
+        };
+        return { id, setup: joined };
+    };
+    return {
+        get: id => agents.get(id),
+        create: async (options) => {
+            const composed = await compose(options.meta?.agentPreset, options.setup);
+            return agents.create({
+                agentOptions: defaultModel(),
+                ...options,
+                ...(composed.id === undefined ? {} : { meta: { ...options.meta, agentPreset: composed.id } }),
+                ...(composed.setup === undefined ? {} : { setup: composed.setup }),
+            });
+        },
+        resume: async (options) => {
+            const record = (await sessions.listSessions())
+                .find(item => String(item.header.id) === String(options.resumeSessionId));
+            const recorded = record?.header?.agentPreset;
+            const composed = await compose(typeof recorded === 'string' ? recorded : undefined, options.setup);
+            return agents.resume({ agentOptions: defaultModel(), ...options,
+                ...(composed.setup === undefined ? {} : { setup: composed.setup }) });
+        },
+    };
+}
+//# sourceMappingURL=agent-preset.js.map

package/lib/agent-session-address.d.ts

@@ -0,0 +1,14 @@
+import { type HomeAddress } from './domain.js';
+/** One durable Principal per long-term Home. Ordinary DSH Sessions are not Principals. */
+export declare function principalSessionId(address: string): string;
+export declare function projectMainAddress(projectId: string): `project:${string}`;
+/** The Main is a separate Session and reuses the lead Agent's Home. */
+export declare function projectMainSessionId(projectId: string): string;
+export interface AgentSessionAddress {
+    kind: 'principal' | 'project-main';
+    homeAddress: HomeAddress;
+    sessionId: string;
+    logicalAddress: string;
+    projectId?: string;
+}
+//# sourceMappingURL=agent-session-address.d.ts.map

package/lib/agent-session-address.js

@@ -0,0 +1,15 @@
+import { parseHomeAddress, stableId } from './domain.js';
+/** One durable Principal per long-term Home. Ordinary DSH Sessions are not Principals. */
+export function principalSessionId(address) {
+    return stableId('principal-session', parseHomeAddress(address));
+}
+export function projectMainAddress(projectId) {
+    if (!/^project-[a-f0-9]{20}$/.test(projectId))
+        throw new Error('invalid Project ID');
+    return `project:${projectId}`;
+}
+/** The Main is a separate Session and reuses the lead Agent's Home. */
+export function projectMainSessionId(projectId) {
+    return stableId('project-main-session', projectMainAddress(projectId));
+}
+//# sourceMappingURL=agent-session-address.js.map

package/lib/agent-session-coordinator.d.ts

@@ -0,0 +1,24 @@
+import type { AgentOptions, AgentRegistry } from '@deepseek-ai/dsh-agent';
+import type { SessionQueryEngine } from '@deepseek-ai/dsh-session-query';
+import { type AgentSessionAddress } from './agent-session-address.js';
+import type { BizAgentService } from './service.js';
+type Agents = Pick<AgentRegistry, 'get' | 'create' | 'resume'>;
+type Sessions = Pick<SessionQueryEngine, 'listSessions'>;
+/** Owns only the runtime handles it opens. Session IDs and Home bindings survive process restarts. */
+export declare class AgentSessionCoordinator {
+    private readonly agents;
+    private readonly sessions;
+    private readonly service;
+    private readonly creationModel?;
+    private readonly handles;
+    private readonly pending;
+    private closing;
+    constructor(agents: Agents, sessions: Sessions, service: BizAgentService, creationModel?: (() => AgentOptions) | undefined);
+    openPrincipal(homeInput: string): Promise<AgentSessionAddress>;
+    openProjectMain(projectId: string): Promise<AgentSessionAddress>;
+    private open;
+    private openOne;
+    close(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=agent-session-coordinator.d.ts.map

package/lib/agent-session-coordinator.js

@@ -0,0 +1,101 @@
+import { nowIso, parseHomeAddress } from './domain.js';
+import { principalSessionId, projectMainAddress, projectMainSessionId } from './agent-session-address.js';
+/** Owns only the runtime handles it opens. Session IDs and Home bindings survive process restarts. */
+export class AgentSessionCoordinator {
+    agents;
+    sessions;
+    service;
+    creationModel;
+    handles = new Map();
+    pending = new Map();
+    closing = false;
+    constructor(agents, sessions, service, creationModel) {
+        this.agents = agents;
+        this.sessions = sessions;
+        this.service = service;
+        this.creationModel = creationModel;
+    }
+    openPrincipal(homeInput) {
+        const homeAddress = parseHomeAddress(homeInput);
+        return this.open({ kind: 'principal', homeAddress,
+            logicalAddress: homeAddress, sessionId: principalSessionId(homeAddress) });
+    }
+    openProjectMain(projectId) {
+        const project = this.service.projectLedger?.get(projectId);
+        if (!project || project.driver !== projectMainAddress(projectId)) {
+            throw new Error('Project has no current Main address');
+        }
+        return this.open({ kind: 'project-main', homeAddress: project.lead,
+            logicalAddress: project.driver, sessionId: projectMainSessionId(projectId), projectId });
+    }
+    open(address) {
+        if (this.closing)
+            throw new Error('Agent Session coordinator is closing');
+        const pending = this.pending.get(address.sessionId);
+        if (pending)
+            return pending;
+        const task = this.openOne(address);
+        this.pending.set(address.sessionId, task);
+        void task.finally(() => { if (this.pending.get(address.sessionId) === task)
+            this.pending.delete(address.sessionId); })
+            .catch(() => undefined);
+        return task;
+    }
+    async openOne(address) {
+        const home = this.service.store.getHome(address.homeAddress);
+        if (home.status !== 'active')
+            throw new Error('Agent Home is not active');
+        const workspace = this.service.store.homeWorkspacePath(address.homeAddress);
+        const binding = this.service.ledger.getBinding(address.sessionId);
+        if (binding && (binding.homeAddress !== address.homeAddress || binding.cwd !== workspace)) {
+            throw new Error('Agent Session is bound to a different Home or Workspace');
+        }
+        if (!binding)
+            await this.service.ledger.putBinding({ sessionId: address.sessionId,
+                homeAddress: address.homeAddress, cwd: workspace, boundAt: nowIso() });
+        const sessionId = address.sessionId;
+        const record = (await this.sessions.listSessions())
+            .find(item => String(item.header.id) === address.sessionId);
+        if (record && record.header.cwd !== workspace) {
+            throw new Error('persisted Agent Session Workspace differs from its Home');
+        }
+        if (record && !record.persisted && !this.agents.get(sessionId)) {
+            throw new Error('Agent Session exists but cannot be resumed');
+        }
+        let agent = this.agents.get(sessionId);
+        if (!agent) {
+            const setup = (agentCtx) => {
+                agentCtx.systemPrompt.section({ name: 'bizagent:agent-session-mode', order: 50,
+                    text: address.kind === 'principal'
+                        ? `This is the unique long-term Principal for ${address.homeAddress}. Keep its conversation continuous. A Principal turn does not require a worklog.`
+                        : `This is the dedicated Project Main for ${address.logicalAddress}, acting as ${address.homeAddress}. Use this execution conversation to coordinate this Project, read its current record before decisions, and keep project work separate from the long-term Principal. The Home's AGENTS.md is the execution guide when present; record work in the Project and Worklog as appropriate.`,
+                });
+            };
+            const handle = record
+                ? await this.agents.resume({ resumeSessionId: sessionId, setup })
+                : await this.agents.create({ sessionId, meta: { cwd: workspace }, setup,
+                    ...(this.creationModel === undefined ? {} : { agentOptions: this.creationModel() }) });
+            this.handles.set(address.sessionId, handle);
+            agent = handle.agent;
+        }
+        if (String(agent.id) !== address.sessionId
+            || String(agent.session.header.id) !== address.sessionId
+            || agent.session.header.cwd !== workspace) {
+            const handle = this.handles.get(address.sessionId);
+            if (handle) {
+                this.handles.delete(address.sessionId);
+                await handle.dispose();
+            }
+            throw new Error('Agent Session identity or Workspace differs from the durable address');
+        }
+        return address;
+    }
+    async close() {
+        this.closing = true;
+        await Promise.allSettled(this.pending.values());
+        const handles = [...this.handles.values()];
+        this.handles.clear();
+        await Promise.all(handles.map(handle => handle.dispose()));
+    }
+}
+//# sourceMappingURL=agent-session-coordinator.js.map

package/lib/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/lib/cli.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { defaultHomeRoot } from './config.js';
+import { HomeStore } from './home-store.js';
+import { exportHomeArchive, importHomeArchive, verifyHomeArchive } from './home-archive.js';
+const args = process.argv.slice(2);
+try {
+    await main(args);
+}
+catch (error) {
+    process.stderr.write(`bizagent: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+}
+async function main(argv) {
+    const parsed = parseGlobalOptions(argv);
+    const [command, ...rest] = parsed.args;
+    if (command === undefined || command === 'help' || command === '--help' || command === '-h') {
+        printHelp();
+        return;
+    }
+    if (command === 'archive') {
+        const [action, path] = rest;
+        if (!path || rest.length !== 2)
+            throw new Error('archive requires one source or destination path');
+        if (action === 'export') {
+            const manifest = await exportHomeArchive(parsed.root, path);
+            print({ archive: resolve(path), rootDigest: manifest.rootDigest, files: manifest.files.length });
+            return;
+        }
+        if (action === 'verify') {
+            const manifest = await verifyHomeArchive(path);
+            print({ verified: true, archive: resolve(path), rootDigest: manifest.rootDigest, files: manifest.files.length });
+            return;
+        }
+        if (action === 'import') {
+            const manifest = await importHomeArchive(path, parsed.root);
+            print({ imported: true, root: parsed.root, rootDigest: manifest.rootDigest, files: manifest.files.length });
+            return;
+        }
+        throw new Error(`unknown archive action: ${action ?? '(missing)'}`);
+    }
+    const store = new HomeStore(parsed.root);
+    await store.initialize();
+    switch (command) {
+        case 'init': {
+            const address = option(rest, '--default-home') ?? 'personal:default';
+            const identityFile = option(rest, '--identity-file');
+            const identity = identityFile === undefined ? undefined : await readFile(resolve(identityFile), 'utf8');
+            const home = await store.createHome({ address, ...(identity !== undefined ? { identity } : {}) });
+            print({ root: store.root, home });
+            return;
+        }
+        case 'home': {
+            await homeCommand(store, rest);
+            return;
+        }
+        case 'doctor': {
+            const report = await store.doctor();
+            print(report);
+            if (!report.ok)
+                process.exitCode = 2;
+            return;
+        }
+        case 'reindex': {
+            await store.reload();
+            print({ reindexed: true, root: store.root, homes: store.listHomes().length });
+            return;
+        }
+        default:
+            throw new Error(`unknown command: ${command}`);
+    }
+}
+async function homeCommand(store, argv) {
+    const [subcommand, address] = argv;
+    switch (subcommand) {
+        case 'list':
+            print({ homes: store.listHomes() });
+            return;
+        case 'create': {
+            if (address === undefined || address.startsWith('--')) {
+                throw new Error('home create requires a canonical address');
+            }
+            const name = option(argv.slice(2), '--name');
+            const owner = option(argv.slice(2), '--owner');
+            const identityFile = option(argv.slice(2), '--identity-file');
+            const identity = identityFile === undefined ? undefined : await readFile(resolve(identityFile), 'utf8');
+            const home = await store.createHome({
+                address,
+                ...(name !== undefined ? { displayName: name } : {}),
+                ...(owner !== undefined ? { owner } : {}),
+                ...(identity !== undefined ? { identity } : {}),
+            });
+            print({ home });
+            return;
+        }
+        default:
+            throw new Error(`unknown home command: ${subcommand ?? '(missing)'}`);
+    }
+}
+function parseGlobalOptions(argv) {
+    const result = [];
+    let root;
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === '--root') {
+            root = argv[index + 1];
+            if (root === undefined)
+                throw new Error('--root requires a path');
+            index += 1;
+        }
+        else if (value !== undefined) {
+            result.push(value);
+        }
+    }
+    return { root: resolve(root ?? defaultHomeRoot()), args: result };
+}
+function option(argv, name) {
+    const index = argv.indexOf(name);
+    if (index < 0)
+        return undefined;
+    const value = argv[index + 1];
+    if (value === undefined || value.startsWith('--'))
+        throw new Error(`${name} requires a value`);
+    return value;
+}
+function print(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function printHelp() {
+    process.stdout.write(`BizAgent v0.1-alpha.2\n\n`);
+    process.stdout.write(`Usage:\n`);
+    process.stdout.write(`  bizagent [--root PATH] init [--default-home ADDRESS] [--identity-file FILE]\n`);
+    process.stdout.write(`  bizagent [--root PATH] home create ADDRESS [--name NAME] [--owner OWNER] [--identity-file FILE]\n`);
+    process.stdout.write(`  bizagent [--root PATH] home list\n`);
+    process.stdout.write(`  bizagent [--root PATH] doctor\n`);
+    process.stdout.write(`  bizagent [--root PATH] reindex\n`);
+    process.stdout.write(`  bizagent [--root PATH] archive export DIRECTORY\n`);
+    process.stdout.write(`  bizagent archive verify DIRECTORY\n`);
+    process.stdout.write(`  bizagent --root NEW_EMPTY_HOME_ROOT archive import DIRECTORY\n`);
+}
+//# sourceMappingURL=cli.js.map

package/lib/client-types/agent-session-address.d.ts

@@ -0,0 +1,13 @@
+import { type HomeAddress } from './domain.js';
+/** One durable Principal per long-term Home. Ordinary DSH Sessions are not Principals. */
+export declare function principalSessionId(address: string): string;
+export declare function projectMainAddress(projectId: string): `project:${string}`;
+/** The Main is a separate Session and reuses the lead Agent's Home. */
+export declare function projectMainSessionId(projectId: string): string;
+export interface AgentSessionAddress {
+    kind: 'principal' | 'project-main';
+    homeAddress: HomeAddress;
+    sessionId: string;
+    logicalAddress: string;
+    projectId?: string;
+}

package/lib/client-types/client/agent-mentions.d.ts

@@ -0,0 +1,3 @@
+import type { InputTriggerSource } from '@deepseek-ai/dsh-client-ui-input-trigger/client';
+import type { BizAgentUiPort } from './api.js';
+export declare function createAgentMentionSource(api: Pick<BizAgentUiPort, 'agentDirectory' | 'resolveAgentTarget'>): InputTriggerSource;

package/lib/client-types/client/api.d.ts

@@ -0,0 +1,180 @@
+import { type UiSessionContext, type UiSessionSummary, type UiAgentDirectory, type UiAgentTarget, type UiCreateHomeRequest, type UiCreateOrganizationRequest, type UiFrameParticipation, type UiHomeDetail, type UiLearningSchedule, type UiMemoryUseOutcomes, type UiOverview, type UiProjectList, type UiProjectDetail, type UiProjectReviewAccess, type UiProjectOutcomeReviewInbox, type UiProposalDecisionRequest, type UiHumanInboxList, type UiHumanInboxDetail } from '../ui-contract.js';
+export interface UiSharedKnowledgeReviews {
+    count: number;
+    proposals: Array<{
+        proposal: {
+            id: string;
+            fromAddress: string;
+            target: {
+                scope: 'common';
+            } | {
+                scope: 'line';
+                line: string;
+            };
+            description: string;
+            body: string;
+            status: 'pending' | 'accepted' | 'rejected';
+        };
+        actions: {
+            accept: boolean;
+            reject: boolean;
+        };
+    }>;
+}
+export interface BizAgentUiPort {
+    sessionContext(sessionId: string, signal?: AbortSignal): Promise<UiSessionContext>;
+    sessionCatalog(signal?: AbortSignal): Promise<{
+        sessions: UiSessionSummary[];
+    }>;
+    /** `viaToken` is false when DSH's own browser login already identifies the person. */
+    localHumanStatus?(signal?: AbortSignal): Promise<{
+        available: boolean;
+        authenticated: boolean;
+        viaToken?: boolean;
+    }>;
+    setLocalHumanToken?(token: string | undefined): Promise<boolean>;
+    openAgentSession?(input: {
+        homeAddress: string;
+    } | {
+        projectId: string;
+    }): Promise<{
+        kind: 'principal' | 'project-main';
+        homeAddress: string;
+        logicalAddress: string;
+        sessionId: string;
+        workspacePath: string;
+        projectId?: string;
+    }>;
+    agentDirectory(sessionId: string, query: string, signal?: AbortSignal): Promise<UiAgentDirectory>;
+    resolveAgentTarget(sessionId: string, target: string, signal?: AbortSignal): Promise<UiAgentTarget>;
+    frameParticipation(sessionId: string, signal?: AbortSignal): Promise<UiFrameParticipation>;
+    overview(signal?: AbortSignal): Promise<UiOverview>;
+    humanInbox(direction: 'incoming' | 'outgoing', pendingOnly: boolean, beforeMessageId?: string, signal?: AbortSignal): Promise<UiHumanInboxList | undefined>;
+    humanInboxDetail(messageId: string, signal?: AbortSignal): Promise<UiHumanInboxDetail>;
+    setHumanNotificationPreference(enabled: boolean, expectedRevision: number): Promise<{
+        preference: UiHumanInboxList['notificationPreference'];
+    }>;
+    handleHumanInbox(messageId: string): Promise<unknown>;
+    replyHumanInbox(messageId: string, subject: string, body: string, idempotencyKey: string): Promise<unknown>;
+    home(address: string, signal?: AbortSignal): Promise<UiHomeDetail>;
+    revealSession(sessionId: string): Promise<{
+        sessionId: string;
+        workspacePath?: string;
+    }>;
+    learningSchedule(home: string, signal?: AbortSignal): Promise<UiLearningSchedule>;
+    memoryUseOutcomes(sessionId: string, assetId: string, beforeWorkId?: string, signal?: AbortSignal): Promise<UiMemoryUseOutcomes>;
+    configureLearningSchedule(home: string, expectedRevision: number, enabled: boolean, cron: string, dailyRuns: number): Promise<UiLearningSchedule>;
+    createHome(request: UiCreateHomeRequest, signal?: AbortSignal): Promise<UiHomeDetail>;
+    createOrganization(request: UiCreateOrganizationRequest, signal?: AbortSignal): Promise<UiOverview>;
+    createSampleOrganization?(signal?: AbortSignal): Promise<UiOverview>;
+    decideProposal(request: UiProposalDecisionRequest, signal?: AbortSignal): Promise<UiHomeDetail>;
+    proposalReviewActions?(ownerAddress: string, proposalId: string, signal?: AbortSignal): Promise<{
+        accept: boolean;
+        reject: boolean;
+    }>;
+    sharedKnowledgeReviews?(signal?: AbortSignal): Promise<UiSharedKnowledgeReviews | undefined>;
+    decideSharedKnowledge?(input: {
+        proposalId: string;
+        action: 'accept' | 'reject';
+        decision: string;
+    }): Promise<unknown>;
+    projects(sessionId: string, beforeProjectId?: string, signal?: AbortSignal): Promise<UiProjectList>;
+    projectDetail(sessionId: string, projectId: string, signal?: AbortSignal): Promise<UiProjectDetail>;
+    projectReviewAccess?(projectId: string, signal?: AbortSignal): Promise<UiProjectReviewAccess | undefined>;
+    projectOutcomeReviewInbox?(offset?: number, signal?: AbortSignal): Promise<UiProjectOutcomeReviewInbox | undefined>;
+    reviewProjectAsHuman?(input: {
+        projectId: string;
+        claimId: string;
+        expectedRevision: number;
+        decision: 'accept' | 'rework';
+        reason: string;
+    }): Promise<unknown>;
+    downloadProjectReviewArtifact?(input: {
+        projectId: string;
+        claimId: string;
+        artifactPath: string;
+        workId?: string;
+    }): Promise<Blob>;
+}
+export declare class BizAgentUiHttpError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(message: string, status: number, code?: string | undefined);
+}
+export declare class BizAgentUiHttpPort implements BizAgentUiPort {
+    private localHumanToken;
+    sessionContext(sessionId: string, signal?: AbortSignal): Promise<UiSessionContext>;
+    sessionCatalog(signal?: AbortSignal): Promise<{
+        sessions: UiSessionSummary[];
+    }>;
+    private humanHeaders;
+    localHumanStatus(signal?: AbortSignal): Promise<{
+        available: boolean;
+        authenticated: boolean;
+        viaToken?: boolean;
+    }>;
+    /** Hosts without DSH's browser login: verify a local Bearer token and keep it in page memory. */
+    setLocalHumanToken(token: string | undefined): Promise<boolean>;
+    openAgentSession(input: {
+        homeAddress: string;
+    } | {
+        projectId: string;
+    }): Promise<{
+        kind: 'principal' | 'project-main';
+        homeAddress: string;
+        logicalAddress: string;
+        sessionId: string;
+        workspacePath: string;
+        projectId?: string;
+    }>;
+    revealSession(sessionId: string): Promise<{
+        sessionId: string;
+        workspacePath?: string;
+    }>;
+    agentDirectory(sessionId: string, query: string, signal?: AbortSignal): Promise<UiAgentDirectory>;
+    resolveAgentTarget(sessionId: string, target: string, signal?: AbortSignal): Promise<UiAgentTarget>;
+    frameParticipation(sessionId: string, signal?: AbortSignal): Promise<UiFrameParticipation>;
+    overview(signal?: AbortSignal): Promise<UiOverview>;
+    humanInbox(direction: 'incoming' | 'outgoing', pendingOnly: boolean, beforeMessageId?: string, signal?: AbortSignal): Promise<UiHumanInboxList | undefined>;
+    humanInboxDetail(messageId: string, signal?: AbortSignal): Promise<UiHumanInboxDetail>;
+    setHumanNotificationPreference(enabled: boolean, expectedRevision: number): Promise<{
+        preference: UiHumanInboxList['notificationPreference'];
+    }>;
+    handleHumanInbox(messageId: string): Promise<unknown>;
+    replyHumanInbox(messageId: string, subject: string, body: string, idempotencyKey: string): Promise<unknown>;
+    home(address: string, signal?: AbortSignal): Promise<UiHomeDetail>;
+    learningSchedule(home: string, signal?: AbortSignal): Promise<UiLearningSchedule>;
+    memoryUseOutcomes(sessionId: string, assetId: string, beforeWorkId?: string, signal?: AbortSignal): Promise<UiMemoryUseOutcomes>;
+    configureLearningSchedule(home: string, expectedRevision: number, enabled: boolean, cron: string, dailyRuns: number): Promise<UiLearningSchedule>;
+    createHome(input: UiCreateHomeRequest, signal?: AbortSignal): Promise<UiHomeDetail>;
+    createSampleOrganization(signal?: AbortSignal): Promise<UiOverview>;
+    createOrganization(input: UiCreateOrganizationRequest, signal?: AbortSignal): Promise<UiOverview>;
+    decideProposal(input: UiProposalDecisionRequest, signal?: AbortSignal): Promise<UiHomeDetail>;
+    proposalReviewActions(ownerAddress: string, proposalId: string, signal?: AbortSignal): Promise<{
+        accept: boolean;
+        reject: boolean;
+    }>;
+    sharedKnowledgeReviews(signal?: AbortSignal): Promise<UiSharedKnowledgeReviews | undefined>;
+    decideSharedKnowledge(input: {
+        proposalId: string;
+        action: 'accept' | 'reject';
+        decision: string;
+    }): Promise<unknown>;
+    projects(sessionId: string, beforeProjectId?: string, signal?: AbortSignal): Promise<UiProjectList>;
+    projectDetail(sessionId: string, projectId: string, signal?: AbortSignal): Promise<UiProjectDetail>;
+    projectReviewAccess(projectId: string, signal?: AbortSignal): Promise<UiProjectReviewAccess | undefined>;
+    projectOutcomeReviewInbox(offset?: number, signal?: AbortSignal): Promise<UiProjectOutcomeReviewInbox | undefined>;
+    reviewProjectAsHuman(input: {
+        projectId: string;
+        claimId: string;
+        expectedRevision: number;
+        decision: 'accept' | 'rework';
+        reason: string;
+    }): Promise<unknown>;
+    downloadProjectReviewArtifact(input: {
+        projectId: string;
+        claimId: string;
+        artifactPath: string;
+        workId?: string;
+    }): Promise<Blob>;
+}

package/lib/client-types/client/components.d.ts

@@ -0,0 +1,22 @@
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { BizAgentUiPort } from './api.js';
+import type { BizAgentUiController, DashboardTarget } from './controller.js';
+export interface BizAgentUiFace {
+    controller: BizAgentUiController;
+    api: BizAgentUiPort;
+    openDashboard: (target?: DashboardTarget) => void;
+    closeDashboard: () => void;
+    openAgentSession: (input: {
+        homeAddress: string;
+    } | {
+        projectId: string;
+    }) => Promise<void>;
+    /** Start a new chat in the DSH Workspace for this folder, adding the Workspace if needed. */
+    openWorkspaceChat: (path: string) => Promise<void>;
+}
+type LauncherProps = PropsRuntime<'sidebar.footer.action'> & InjectFace<BizAgentUiFace> & PropsLocale<'bizagent'>;
+type DashboardProps = PropsRuntime<'main'> & InjectFace<BizAgentUiFace> & PropsLocale<'bizagent'>;
+export declare function BizAgentMark(): import("react").JSX.Element;
+export declare function BizAgentLauncher({ wide, controller, api, openDashboard, t }: LauncherProps): import("react").JSX.Element;
+export declare function BizAgentDashboard({ controller, api, openAgentSession, openWorkspaceChat, closeDashboard, t, useSessions, useWorkspaces }: DashboardProps): import("react").JSX.Element | null;
+export {};

package/lib/client-types/client/controller.d.ts

@@ -0,0 +1,23 @@
+export type DashboardView = 'organization' | 'learning' | 'projects' | 'humanInbox';
+export interface DashboardTarget {
+    view?: DashboardView;
+    homeAddress?: string;
+    projectId?: string;
+    sessionId?: string;
+    assetId?: string;
+}
+export interface BizAgentUiSnapshot {
+    readonly open: boolean;
+    readonly revision: number;
+    readonly target?: DashboardTarget;
+}
+export declare class BizAgentUiController {
+    private snapshot;
+    private readonly listeners;
+    getSnapshot: () => BizAgentUiSnapshot;
+    subscribe: (listener: () => void) => (() => void);
+    open(target?: DashboardTarget): void;
+    close(): void;
+    toggle(): void;
+    private setOpen;
+}

package/lib/client-types/client/frame-participants.d.ts

@@ -0,0 +1,5 @@
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SessionSurfaceFace } from './session-surfaces.js';
+type FrameDockProps = PropsRuntime<'conversation.input.dock'> & InjectFace<Pick<SessionSurfaceFace, 'surfaces' | 'openDashboard'>> & PropsLocale<'bizagent'>;
+export declare function FrameParticipationDock({ sessionId, useSession, surfaces, openDashboard, t }: FrameDockProps): import("react").JSX.Element | null;
+export {};

package/lib/client-types/client/home-name.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The name to show for a Home. BizAgent creates the person's default Home with its address as its
+ * name; a personal Home nobody has named is the person's own and shows as such.
+ */
+export declare function homeName(home: {
+    address: string;
+    displayName: string;
+    scope?: 'personal' | 'organization' | undefined;
+}, t: (key: 'session.personal') => string): string;

package/lib/client-types/client/human-inbox.d.ts

@@ -0,0 +1,8 @@
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { BizAgentUiPort } from './api.js';
+type T = PropsLocale<'bizagent'>['t'];
+export declare function HumanInboxDashboard({ api, t }: {
+    api: BizAgentUiPort;
+    t: T;
+}): import("react").JSX.Element;
+export {};