@bizagent/dsh 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,4 @@
+/** A selected composer reference; only user-authored, admitted messages are resolved. */
+export declare function frameReference(address: string): string;
+export declare function selectedFrameAddresses(text: string): string[];
+export declare function removeFrameReferences(text: string): string;

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

@@ -0,0 +1,5 @@
+import { type AgentHome, type HomeAddress } from './domain.js';
+export type HomeDirectoryEntry = Pick<AgentHome, 'address' | 'type' | 'displayName'>;
+export declare function visibleHomeDirectory(homes: readonly AgentHome[], primaryHome: HomeAddress): HomeDirectoryEntry[];
+export declare function searchHomeDirectory(homes: readonly AgentHome[], primaryHome: HomeAddress, query?: string, limit?: number): HomeDirectoryEntry[];
+export declare function resolveHomeDirectoryTarget(homes: readonly AgentHome[], primaryHome: HomeAddress, target: string): HomeAddress;

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

@@ -0,0 +1,49 @@
+import { type AgentHome, type AssetStatus, type ContextBudget, type Organization, type StoredAsset } from './domain.js';
+import type { InboxWakePolicy } from './inbox-wake-policy.js';
+import type { AssetSearchInput, CreateAssetInput, CreateHomeInput, DoctorReport, HomeStore, UpdateAssetInput } from './home-store.js';
+/**
+ * Every Home this host can see: the person's own Homes in the data root (the personal space), and
+ * the active organization's Homes under `<data root>/orgs/<id>`. Each Home stays in the folder of
+ * the store that holds it. When both hold the same address, the organization's Home wins and the
+ * personal one is reported by `doctor`.
+ */
+export declare class HomeSpace {
+    readonly personal: HomeStore;
+    readonly organizationStore?: HomeStore | undefined;
+    constructor(personal: HomeStore, organizationStore?: HomeStore | undefined);
+    /** Where organization-wide records live: the organization root, or the personal space without one. */
+    get root(): string;
+    get personalRoot(): string;
+    get organizationRoot(): string | undefined;
+    initialize(): Promise<void>;
+    reload(): Promise<void>;
+    /** The same personal space with another organization (or none) beside it. */
+    withOrganization(organizationStore: HomeStore | undefined): HomeSpace;
+    /** The root of the store that holds this Home; its snapshots and records belong there. */
+    rootFor(address: string): string;
+    /** A Home from the personal space, outside any organization. */
+    isPersonalHome(address: string): boolean;
+    listHomes(): AgentHome[];
+    hasHome(address: string): boolean;
+    getHome(address: string): AgentHome;
+    findHome(address: string): AgentHome | undefined;
+    homeWorkspacePath(address: string): string;
+    readInboxWakePolicy(address: string): Promise<InboxWakePolicy>;
+    getIdentity(address: string): string;
+    /** The active organization; before organizations had their own folder it could sit in the data root itself. */
+    getOrganization(): Organization | undefined;
+    /** New Homes join the active organization unless the personal space is asked for. */
+    createHome(input: CreateHomeInput, target?: 'organization' | 'personal'): Promise<AgentHome>;
+    listAssets(address: string, status?: AssetStatus): StoredAsset[];
+    searchAssets(address: string, input?: AssetSearchInput): StoredAsset[];
+    readAsset(address: string, id: string): StoredAsset;
+    findAssetByProposalId(address: string, proposalId: string): StoredAsset | undefined;
+    createAsset(input: CreateAssetInput): Promise<StoredAsset>;
+    updateAsset(address: string, id: string, input: UpdateAssetInput): Promise<StoredAsset>;
+    contextFor(address: string, budget: ContextBudget, episodeCount?: number): string;
+    contextForFrame(address: string, budget: ContextBudget): string;
+    doctor(): Promise<DoctorReport>;
+    private findStore;
+    /** Throws the store's own unknown-Home error when no store holds the address. */
+    private storeFor;
+}

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

@@ -0,0 +1,125 @@
+import { type AgentHome, type AssetKind, type AssetStatus, type ContextBudget, type EvidenceRef, type HomeAddress, type Organization, type StoredAsset } from './domain.js';
+import { type InboxWakePolicy } from './inbox-wake-policy.js';
+export interface CreateHomeInput {
+    address: string;
+    displayName?: string;
+    owner?: string;
+    identity?: string;
+}
+export interface CreateOrganizationInput {
+    id: string;
+    name: string;
+    mission: string;
+    /** Person who owns every Home in the organization. Defaults to each member id (members as people). */
+    owner?: string;
+    members: Array<{
+        id: string;
+        displayName: string;
+        roleId: string;
+        roleName: string;
+        responsibility: string;
+    }>;
+    capabilities: Array<{
+        id: string;
+        displayName: string;
+        responsibility: string;
+    }>;
+}
+export interface CreateAssetInput {
+    id: string;
+    ownerAddress: HomeAddress;
+    kind: Exclude<AssetKind, 'identity'>;
+    title?: string;
+    description: string;
+    body: string;
+    tags?: string[];
+    sourceRefs: EvidenceRef[];
+    confidence?: number;
+    fitness?: number;
+    status?: AssetStatus;
+    proposalId?: string;
+}
+export interface UpdateAssetInput {
+    /** Checked inside the serialized mutation, before reading or writing a new revision. */
+    expectedRevision?: number;
+    description?: string;
+    body?: string;
+    tags?: string[];
+    sourceRefs?: EvidenceRef[];
+    status?: AssetStatus;
+    confidence?: number;
+    fitness?: number;
+    /** Internal recovery marker, persisted in the same file revision as a proposal replacement. */
+    appliedProposalId?: string;
+}
+export interface AssetSearchInput {
+    query?: string;
+    kind?: AssetKind;
+    status?: AssetStatus;
+    limit?: number;
+}
+export interface DoctorReport {
+    ok: boolean;
+    root: string;
+    homeCount: number;
+    assetCount: number;
+    issues: string[];
+}
+export declare class HomeStore {
+    readonly root: string;
+    readonly homesRoot: string;
+    readonly organizationFile: string;
+    private readonly homes;
+    private organization;
+    private organizationLoadError;
+    private integrityIssues;
+    private mutationTail;
+    constructor(root: string);
+    initialize(): Promise<void>;
+    reload(): Promise<void>;
+    listHomes(): AgentHome[];
+    hasHome(address: string): boolean;
+    getHome(address: string): AgentHome;
+    /** Any loaded Home, including an archived one, or undefined; never throws for an unknown address. */
+    findHome(address: string): AgentHome | undefined;
+    /** The Home's fixed DSH Workspace, shared by Principal, Project Main and Seats. */
+    homeWorkspacePath(address: string): string;
+    /** Home-local receipt policy. Missing or malformed files use the 15-minute batch default. */
+    readInboxWakePolicy(address: string): Promise<InboxWakePolicy>;
+    getIdentity(address: string): string;
+    getOrganization(): Organization | undefined;
+    createHome(input: CreateHomeInput): Promise<AgentHome>;
+    createOrganization(input: CreateOrganizationInput): Promise<Organization>;
+    listAssets(address: string, status?: AssetStatus): StoredAsset[];
+    searchAssets(address: string, input?: AssetSearchInput): StoredAsset[];
+    readAsset(address: string, id: string): StoredAsset;
+    findAssetByProposalId(address: string, proposalId: string): StoredAsset | undefined;
+    createAsset(input: CreateAssetInput): Promise<StoredAsset>;
+    updateAsset(address: string, id: string, input: UpdateAssetInput): Promise<StoredAsset>;
+    contextFor(address: string, budget: ContextBudget, episodeCount?: number): string;
+    contextForFrame(address: string, budget: ContextBudget): string;
+    private renderContext;
+    private relativePath;
+    /** Error text for issues, with absolute paths under the root shown relative to it. */
+    private relativeMessage;
+    doctor(): Promise<DoctorReport>;
+    /**
+     * Owners recorded in directory.yaml when this store last wrote it. The file sits at the store
+     * root, outside each Home's own Workspace directory, so an Agent working in its Home cannot
+     * change its owner by editing home.yaml alone.
+     */
+    private readRecordedOwners;
+    /** Refuse an owner change made in agent-writable home.yaml; keep the recorded owner and report it. */
+    private keepRecordedOwner;
+    private loadHome;
+    private loadOrganization;
+    private loadOrganizationFile;
+    private createHomeUnlocked;
+    private refreshHome;
+    private assetPath;
+    private requireHome;
+    private assertWithinRoot;
+    private writeDirectory;
+    private mutate;
+}
+export declare function pathExists(path: string): Promise<boolean>;

package/lib/client-types/inbox-stalled-topic.d.ts

@@ -0,0 +1,15 @@
+import { type HomeAddress, type ProjectSeatAddress, type InboxMessage } from './domain.js';
+export declare const INBOX_STALE_ESCALATE_MS: number;
+export interface StalledInboxTopic {
+    topicId: string;
+    ordinaryCount: number;
+    maxHop: number;
+    lastSentAt: string;
+    subject: string;
+    sourceMessageId: string;
+    returnAddress: HomeAddress | ProjectSeatAddress;
+    returnToSessionId?: string;
+    projectId?: string;
+}
+/** Scan immutable letters; Work notifications and closed topics do not consume the ordinary relay budget. */
+export declare function stalledInboxTopics(messages: readonly InboxMessage[], now: number): StalledInboxTopic[];

package/lib/client-types/inbox-wake-policy.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const InboxWakePolicySchema: z.ZodObject<{
+    policy: z.ZodEnum<{
+        immediate: "immediate";
+        batch: "batch";
+        scheduled: "scheduled";
+        carried: "carried";
+    }>;
+    batchMinutes: z.ZodOptional<z.ZodNumber>;
+    cron: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type InboxWakePolicy = z.infer<typeof InboxWakePolicySchema>;
+export declare const DEFAULT_INBOX_WAKE_POLICY: InboxWakePolicy;
+/** Freeze the effective recipient schedule at delivery time. */
+export declare function inboxWakeSchedule(policy: InboxWakePolicy, priority: 'normal' | 'urgent', sentAt: string, timeZone?: string): {
+    wakePolicy: InboxWakePolicy['policy'];
+    wakeAt?: string;
+};

package/lib/client-types/known-format.d.ts

@@ -0,0 +1,2 @@
+/** Refuse files written by a newer BizAgent with a message that says so, instead of a schema error. */
+export declare function assertKnownFormat(raw: unknown, latest: number, file: string): void;

package/lib/client-types/learning-scheduler.d.ts

@@ -0,0 +1,36 @@
+import type { ResolvedConfig, ResolvedLearningSchedule } from './config.js';
+import { type HomeAddress, type LearningLaunch, type LearningScheduleCursor, type LearningSchedulePolicy } from './domain.js';
+import type { LearningSessionRunner } from './learning-session-runner.js';
+import type { BizAgentService } from './service.js';
+export interface LearningScheduleStatus {
+    homeAddress: HomeAddress;
+    hostEnabled: boolean;
+    configured: boolean;
+    timeZone: string;
+    maxDailyRuns?: number;
+    schedule?: ResolvedLearningSchedule;
+    policy?: LearningSchedulePolicy;
+    cursor?: LearningScheduleCursor;
+    nextDueAt?: number;
+    runsToday: number;
+    recentLaunches: LearningLaunch[];
+}
+/** Single-host, opt-in learning clock. Each due period is consumed at most once by its durable cursor. */
+export declare class LearningScheduler {
+    private readonly service;
+    private readonly runner;
+    private readonly config;
+    private readonly clock;
+    private pass;
+    constructor(service: BizAgentService, runner: LearningSessionRunner, config: ResolvedConfig, clock?: () => number);
+    status(homeInput: string): LearningScheduleStatus;
+    configure(homeInput: string, input: {
+        expectedRevision: number;
+        enabled: boolean;
+        cron: string;
+        dailyRuns: number;
+    }): Promise<LearningScheduleStatus>;
+    runDue(): Promise<LearningScheduleCursor[]>;
+    private tick;
+    private runsToday;
+}

package/lib/client-types/learning-session-runner.d.ts

@@ -0,0 +1,49 @@
+import type { Agent, AgentRegistry } from '@deepseek-ai/dsh-agent';
+import type { SessionQueryEngine } from '@deepseek-ai/dsh-session-query';
+import type { ResolvedConfig } from './config.js';
+import type { ResolvedLearningSchedule } from './config.js';
+import { type HomeAddress } from './domain.js';
+import type { BizAgentService } from './service.js';
+type AgentFactory = Pick<AgentRegistry, 'get' | 'create' | 'resume'>;
+type SessionCatalog = Pick<SessionQueryEngine, 'listSessions' | 'readSession'>;
+/** Explicit, Home-bound launcher for dedicated learning Sessions. Unknown creation is never retried blindly. */
+export declare class LearningSessionRunner {
+    private readonly agents;
+    private readonly sessions;
+    private readonly service;
+    private readonly config;
+    private readonly handles;
+    private readonly activating;
+    private readonly watching;
+    private readonly recoveryRetryAfter;
+    private closing;
+    constructor(agents: AgentFactory, sessions: SessionCatalog, service: BizAgentService, config: ResolvedConfig);
+    request(agent: Agent, idempotencyKey: string, model?: string): Promise<Record<string, unknown>>;
+    /** Trusted host scheduler entrypoint. The occurrence is part of the persistent launch identity. */
+    requestScheduled(schedule: ResolvedLearningSchedule, dueAt: number, scheduleFingerprint: string, requestedAt?: number, policyRevision?: number): Promise<Record<string, unknown>>;
+    private requestFor;
+    read(agent: Agent, id: string): Promise<Record<string, unknown>>;
+    abandon(agent: Agent, id: string, reason: string): Promise<Record<string, unknown>>;
+    /**
+     * Abandon launches that have needed review for longer than `maxAgeMs`, so one unresolved launch
+     * cannot block every later scheduled learning period. A live worker or an open batch keeps it.
+     */
+    retireStaleReviews(homeAddress: HomeAddress, now: number, maxAgeMs: number): Promise<string[]>;
+    /** On restart, only an already visible worker Session may be resumed. */
+    recoverBatch(limit?: number): Promise<{
+        recovered: string[];
+        needsReview: string[];
+        failed: Array<{
+            id: string;
+            error: unknown;
+        }>;
+    }>;
+    close(): Promise<void>;
+    private activateOnce;
+    private activate;
+    private watch;
+    private releaseWhenIdle;
+    private markNeedsReview;
+    private view;
+}
+export {};

package/lib/client-types/learning-trigger.d.ts

@@ -0,0 +1,17 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { EvidenceRef } from './domain.js';
+export interface LearningTriggerMatch {
+    reason: 'explicit-correction';
+    evidenceRef: Extract<EvidenceRef, {
+        type: 'session-events';
+    }>;
+    excerpt: string;
+}
+export interface LearningTrigger {
+    readonly name: string;
+    detect(events: readonly SessionEvent[], turn: number): LearningTriggerMatch | undefined;
+}
+export declare class ExplicitCorrectionTrigger implements LearningTrigger {
+    readonly name = "explicit-correction";
+    detect(events: readonly SessionEvent[], turn: number): LearningTriggerMatch | undefined;
+}

package/lib/client-types/learning-usage.d.ts

@@ -0,0 +1,17 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+/** A projection of the dedicated worker's durable model-call evidence. No price is inferred. */
+export interface LearningUsage {
+    status: 'reported' | 'partial' | 'unavailable';
+    reported?: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheWriteTokens: number;
+        reasoningTokens: number;
+    };
+    reportedSteps: number;
+    unreportedSteps: number;
+    lastEventSeq: number | null;
+    costUsd: null;
+}
+export declare function summarizeLearningUsage(events: readonly SessionEvent[]): LearningUsage;

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

@@ -0,0 +1,190 @@
+import { type DomainFacility } from '@deepseek-ai/dsh-storage-domain';
+import { type SharedKnowledgeProposal } from './shared-knowledge.js';
+import { type AgentFrameState, type InboxDelivery, type InboxHumanNotification, type HumanNotificationPreference, type UserAddress, type InboxMessage, type InboxWakeOrigin, type InboxWakePlan, type InboxReturnRoute, type FitnessReceipt, type LearningCheckpoint, type LearningMaterialObservation, type LearningMaterialReview, type LearningBatchRun, type LearningLaunch, type LearningScheduleCursor, type LearningSchedulePolicy, type MemoryProposal, type ProjectTurnParticipation, type SessionBinding } from './domain.js';
+export declare const BIZAGENT_DOMAIN: {
+    name: string;
+    version: number;
+    tables: {
+        bindings: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            sessionId: string;
+            homeAddress: string;
+            boundAt: string;
+            cwd?: string | undefined;
+        }>;
+        proposals: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            fromAddress: string;
+            toAddress: string;
+            proposedKind: "memory" | "insight" | "knowledge" | "method" | "identity";
+            description: string;
+            body: string;
+            tags: string[];
+            sourceRefs: ({
+                type: "session-events";
+                sessionId: string;
+                fromSeq: number;
+                toSeq: number;
+            } | {
+                type: "worklog";
+                sessionId: string;
+                revisionId: string;
+                fingerprint: string;
+            } | {
+                type: "tool-result";
+                sessionId: string;
+                eventSeq: number;
+                toolCallId: string;
+            } | {
+                type: "artifact";
+                uri: string;
+                digest: string;
+            } | {
+                type: "document";
+                uri: string;
+                digest: string;
+                authority?: string | undefined;
+            } | {
+                type: "asset";
+                ownerAddress: string;
+                assetId: string;
+                revision: number;
+            } | {
+                type: "user-confirmation";
+                sessionId: string;
+                eventSeq: number;
+            })[];
+            status: "rejected" | "pending" | "accepted" | "withdrawn";
+            createdAt: string;
+            baseAsset?: {
+                id: string;
+                revision: number;
+                bodySha256: string;
+            } | undefined;
+            targetAssetId?: string | undefined;
+            appliedAssetRevision?: number | undefined;
+            appliedBodySha256?: string | undefined;
+            humanReview?: {
+                reviewerId: string;
+                authorityRef: string;
+                action: "accept" | "reject";
+                decision: string;
+                reviewedAt: string;
+            } | undefined;
+            decision?: string | undefined;
+            decidedAt?: string | undefined;
+        }>;
+        receipts: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            assetId: string;
+            ownerAddress: string;
+            sessionId: string;
+            signal: "retrieved" | "applied" | "confirmed" | "contradicted" | "failed";
+            createdAt: string;
+            eventSeq?: number | undefined;
+            assetRevision?: number | undefined;
+            assetBodySha256?: string | undefined;
+            outcome?: string | undefined;
+        }>;
+        metadata: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            key: string;
+            value: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export declare class LearningLedger {
+    private readonly domain;
+    private receiptTail;
+    private learningBatchTail;
+    private readonly materialReviewWrites;
+    private readonly frameMutationTail;
+    private inboxMutationTail;
+    private projectTurnTail;
+    private proposalTail;
+    private constructor();
+    static open(facility: DomainFacility): Promise<LearningLedger>;
+    getBinding(sessionId: string): SessionBinding | undefined;
+    putBinding(binding: SessionBinding): Promise<void>;
+    /** Roll back a pre-creation reservation only after the host has verified that no Session materialized. */
+    removeUnmaterializedBinding(binding: SessionBinding): Promise<boolean>;
+    /** Forget a binding the current rules no longer make, so its Session binds afresh on its next turn. */
+    releaseBinding(binding: SessionBinding): Promise<boolean>;
+    listBindings(homeAddress?: string): SessionBinding[];
+    listProjectTurns(projectId?: string): ProjectTurnParticipation[];
+    putProjectTurn(input: Omit<ProjectTurnParticipation, 'schemaVersion' | 'recordedAt'>): Promise<ProjectTurnParticipation>;
+    getFrameState(sessionId: string): AgentFrameState | undefined;
+    updateFrameState(sessionId: string, update: (current: AgentFrameState | undefined) => AgentFrameState): Promise<AgentFrameState>;
+    withInboxWrite<T>(update: () => Promise<T>): Promise<T>;
+    getInboxMessage(id: string): InboxMessage | undefined;
+    listInboxMessages(): InboxMessage[];
+    putInboxMessage(message: InboxMessage): Promise<void>;
+    getInboxDelivery(messageId: string, recipient: string): InboxDelivery | undefined;
+    putInboxDelivery(delivery: InboxDelivery): Promise<void>;
+    getInboxHumanNotification(messageId: string, recipient: string): InboxHumanNotification | undefined;
+    getHumanNotificationPreference(recipient: string): HumanNotificationPreference | undefined;
+    setHumanNotificationPreference(recipient: string, enabled: boolean, expectedRevision: number): Promise<HumanNotificationPreference>;
+    /** The external provider was never called; this terminal record survives later opt-in. */
+    suppressInboxHumanNotification(messageId: string, recipient: string, reason: string): Promise<InboxHumanNotification>;
+    private putSuppressedHumanNotification;
+    /** Persist an opt-out while holding the same lock as preference updates and channel reservations. */
+    suppressInboxHumanNotificationIfOptedOut(messageId: string, recipient: UserAddress): Promise<InboxHumanNotification | undefined>;
+    /** Reserve before calling the channel; a crash leaves unknown and never causes an automatic resend. */
+    reserveInboxHumanNotification(messageId: string, recipient: string): Promise<{
+        notification: InboxHumanNotification;
+        reserved: boolean;
+    }>;
+    settleInboxHumanNotification(messageId: string, recipient: string, outcome: {
+        status: 'sent';
+        providerReceipt: string;
+    } | {
+        status: 'rejected';
+        reason: string;
+    }): Promise<InboxHumanNotification>;
+    /** A definite rejection permits one explicit new attempt; unknown and sent never do. */
+    retryRejectedInboxHumanNotification(messageId: string, recipient: string): Promise<InboxHumanNotification>;
+    getInboxWakeOrigin(sessionId: string): InboxWakeOrigin | undefined;
+    putInboxWakeOrigin(origin: InboxWakeOrigin): Promise<InboxWakeOrigin>;
+    getInboxWakePlan(id: string): InboxWakePlan | undefined;
+    listInboxWakePlans(): InboxWakePlan[];
+    /** Caller holds withInboxWrite so plan selection and reservation share one local writer. */
+    putInboxWakePlan(plan: InboxWakePlan): Promise<InboxWakePlan>;
+    markInboxWakeDispatched(id: string, dispatchedAt: string, retiredReason?: string): Promise<InboxWakePlan>;
+    getInboxReturnRoute(messageId: string, recipient: string): InboxReturnRoute | undefined;
+    putInboxReturnRoute(route: InboxReturnRoute): Promise<InboxReturnRoute>;
+    getMaterialObservation(id: string): LearningMaterialObservation | undefined;
+    putMaterialObservation(observation: LearningMaterialObservation): Promise<LearningMaterialObservation>;
+    getMaterialReview(materialId: string): LearningMaterialReview | undefined;
+    putMaterialReview(review: LearningMaterialReview): Promise<LearningMaterialReview>;
+    withLearningBatchWrite<T>(update: () => Promise<T>): Promise<T>;
+    getLearningBatch(id: string): LearningBatchRun | undefined;
+    listLearningBatches(homeAddress: string): LearningBatchRun[];
+    putLearningBatch(run: LearningBatchRun): Promise<LearningBatchRun>;
+    getLearningLaunch(id: string): LearningLaunch | undefined;
+    listLearningLaunches(homeAddress?: string): LearningLaunch[];
+    putLearningLaunch(launch: LearningLaunch): Promise<LearningLaunch>;
+    getLearningScheduleCursor(homeAddress: string): LearningScheduleCursor | undefined;
+    putLearningScheduleCursor(cursor: LearningScheduleCursor): Promise<LearningScheduleCursor>;
+    getLearningSchedulePolicy(homeAddress: string): LearningSchedulePolicy | undefined;
+    /** Caller holds the learning batch write lock and checks the prior revision. */
+    putLearningSchedulePolicy(policy: LearningSchedulePolicy): Promise<LearningSchedulePolicy>;
+    getProposal(id: string): MemoryProposal | undefined;
+    putProposal(proposal: MemoryProposal): Promise<void>;
+    listProposals(options?: {
+        fromAddress?: string;
+        toAddress?: string;
+        status?: MemoryProposal['status'];
+    }): MemoryProposal[];
+    getSharedKnowledgeProposal(id: string): SharedKnowledgeProposal | undefined;
+    listSharedKnowledgeProposals(status?: SharedKnowledgeProposal['status']): SharedKnowledgeProposal[];
+    putSharedKnowledgeProposal(input: SharedKnowledgeProposal): Promise<SharedKnowledgeProposal>;
+    putReceipt(receipt: FitnessReceipt): Promise<boolean>;
+    listReceipts(assetId?: string): FitnessReceipt[];
+    getCheckpoint(id: string): LearningCheckpoint | undefined;
+    putCheckpoint(checkpoint: LearningCheckpoint): Promise<void>;
+    listCheckpoints(options?: {
+        sessionId?: string;
+        homeAddress?: string;
+        status?: LearningCheckpoint['status'];
+    }): LearningCheckpoint[];
+    close(): Promise<void>;
+}

package/lib/client-types/local-owner.d.ts

@@ -0,0 +1,7 @@
+/** Whether a string can name a local human (Home owner or reviewer). */
+export declare function isLocalUserId(value: string): boolean;
+/**
+ * The person who owns Homes created by a local host: $BIZAGENT_LOCAL_HUMAN_ID when set,
+ * otherwise the operating system user name reduced to the allowed characters.
+ */
+export declare function localOwnerId(env?: NodeJS.ProcessEnv): string;

package/lib/client-types/message-source.d.ts

@@ -0,0 +1,9 @@
+import type { ContextFormed } from '@deepseek-ai/dsh-llm';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        bizagent: {
+            kind: 'bizagent';
+        } & ContextFormed;
+    }
+}
+export declare const BIZAGENT_SOURCE_KIND = "bizagent";

package/lib/client-types/organization-location.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const ActiveOrganizationLocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    workspacePath: z.ZodString;
+    organizationId: z.ZodString;
+    organizationRoot: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    organizationId: z.ZodString;
+    organizationRoot: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>], "schemaVersion">;
+export type ActiveOrganizationLocation = z.infer<typeof ActiveOrganizationLocationSchema>;
+export declare function activeOrganizationLocationPath(registryRoot: string): string;
+/** Where a new organization lives: `<data root>/orgs/<id>`. */
+export declare function organizationLocation(registryRoot: string, organizationId: string): ActiveOrganizationLocation;
+export declare function loadActiveOrganizationLocation(registryRoot: string): Promise<ActiveOrganizationLocation | undefined>;
+export declare function saveActiveOrganizationLocation(registryRoot: string, location: ActiveOrganizationLocation): Promise<void>;