@bizagent/dsh 0.0.0-stage → 1.0.0

package/lib/client-types/shared-knowledge.d.ts

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+declare const DocumentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    scope: z.ZodEnum<{
+        line: "line";
+        common: "common";
+    }>;
+    line: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    proposalId: z.ZodString;
+    reviewerId: z.ZodString;
+    authorityRef: z.ZodString;
+    publishedAt: z.ZodString;
+    bodySha256: z.ZodString;
+}, z.core.$strict>;
+export type SharedKnowledgeTarget = {
+    scope: 'line';
+    line: string;
+} | {
+    scope: 'common';
+};
+export type SharedKnowledgeDocument = z.infer<typeof DocumentSchema> & {
+    body: string;
+    path: string;
+};
+export type PublishSharedKnowledgeInput = SharedKnowledgeTarget & {
+    id: string;
+    description: string;
+    body: string;
+    proposalId: string;
+    reviewerId: string;
+    authorityRef: string;
+    publishedAt: string;
+};
+export declare const SharedKnowledgeProposalSchema: z.ZodObject<{
+    id: z.ZodString;
+    fromAddress: z.ZodString;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scope: z.ZodLiteral<"line">;
+        line: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        scope: z.ZodLiteral<"common">;
+    }, z.core.$strict>], "scope">;
+    description: z.ZodString;
+    body: z.ZodString;
+    sourceRefs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"session-events">;
+        sessionId: z.ZodString;
+        fromSeq: z.ZodNumber;
+        toSeq: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"worklog">;
+        sessionId: z.ZodString;
+        revisionId: z.ZodString;
+        fingerprint: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool-result">;
+        sessionId: z.ZodString;
+        eventSeq: z.ZodNumber;
+        toolCallId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"artifact">;
+        uri: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"document">;
+        uri: z.ZodString;
+        digest: z.ZodString;
+        authority: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"asset">;
+        ownerAddress: z.ZodString;
+        assetId: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"user-confirmation">;
+        sessionId: z.ZodString;
+        eventSeq: z.ZodNumber;
+    }, z.core.$strip>], "type">>;
+    status: z.ZodEnum<{
+        rejected: "rejected";
+        pending: "pending";
+        accepted: "accepted";
+    }>;
+    humanReview: z.ZodOptional<z.ZodObject<{
+        reviewerId: z.ZodString;
+        authorityRef: z.ZodString;
+        action: z.ZodEnum<{
+            accept: "accept";
+            reject: "reject";
+        }>;
+        decision: z.ZodString;
+        reviewedAt: z.ZodString;
+    }, z.core.$strict>>;
+    targetDocumentId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    decidedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SharedKnowledgeProposal = z.infer<typeof SharedKnowledgeProposalSchema>;
+/** File-backed shared sources. PMO Agent Home knowledge stays in its separate Home directory. */
+export declare class SharedKnowledgeStore {
+    readonly root: string;
+    constructor(root: string);
+    pathFor(target: SharedKnowledgeTarget): string;
+    publish(input: PublishSharedKnowledgeInput): Promise<SharedKnowledgeDocument>;
+    read(target: SharedKnowledgeTarget, idInput: string): Promise<SharedKnowledgeDocument | undefined>;
+    /**
+     * Search the shared layers. A document that fails its safety or integrity checks is skipped and
+     * reported through `onSkip`, so one hand-edited file cannot break retrieval for every Home.
+     */
+    search(targets: readonly SharedKnowledgeTarget[], query?: string, onSkip?: (path: string, error: unknown) => void): Promise<SharedKnowledgeDocument[]>;
+    private ensureDirectory;
+    private safeExistingDirectory;
+}
+export {};

package/lib/client-types/ui-contract.d.ts

@@ -0,0 +1,276 @@
+import type { AgentHome, AssetKind, AssetStatus, EvidenceRef, FitnessSignal, FrameMode, HomeAddress, HomeType, InboxMessage, InboxDelivery, InboxHumanNotification, HumanNotificationPreference, MemoryProposal, Organization } from './domain.js';
+import type { FormalProject } from './project-ledger.js';
+import type { FormalWork } from './work-ledger.js';
+import type { MemoryUseOutcomePage } from './service.js';
+import type { LearningScheduleStatus } from './learning-scheduler.js';
+import type { HomeDirectoryEntry } from './home-directory.js';
+export declare const BIZAGENT_UI_API = "/api/bizagent/v1";
+/** Organization id of the one-click sample team; the UI shows a getting-started guide for it. */
+export declare const BIZAGENT_SAMPLE_ORGANIZATION_ID = "sample-shop";
+export declare const BIZAGENT_AGENT_DIRECTORY_API = "/api/bizagent/v1/agents";
+export declare const BIZAGENT_PROJECT_REVIEW_API = "/api/bizagent/project-review";
+export declare const BIZAGENT_LOCAL_HUMAN_STATUS_API = "/api/bizagent/local-human/status";
+export declare const BIZAGENT_AGENT_SESSION_API = "/api/bizagent/agent-session";
+export interface UiProjectReviewAccess {
+    canReview: boolean;
+    revision: number;
+    claimId: string | null;
+    outcomeReworkNotification?: {
+        claimId: string;
+        state: 'pending' | 'delivered';
+    };
+}
+export interface UiProjectOutcomeReviewInbox {
+    items: Array<{
+        projectId: string;
+        projectTitle: string;
+        lead: string;
+        goal: string;
+        doneWhen: string;
+        revision: number;
+        claimId: string;
+        submittedAt: string;
+        summary: string;
+        body: string;
+        doneWhenAssessment: string;
+        work: Array<{
+            id: string;
+            status: 'completed' | 'cancelled';
+            resultSubject?: string;
+            resultBody?: string;
+            resultArtifacts?: Array<{
+                path: string;
+                sha256: string;
+                bytes: number;
+            }>;
+        }>;
+        artifacts: Array<{
+            path: string;
+            sha256: string;
+            bytes: number;
+        }>;
+    }>;
+    nextOffset?: number;
+}
+export declare const BIZAGENT_FRAME_STATUS_API = "/api/bizagent/v1/frames";
+export declare const BIZAGENT_HUMAN_INBOX_API = "/api/bizagent/human-inbox";
+export declare const BIZAGENT_SESSION_CONTEXT_API = "/api/bizagent/v1/session-context";
+export declare const BIZAGENT_SESSION_CATALOG_API = "/api/bizagent/v1/sessions";
+export type UiSessionKind = 'conversation' | 'principal' | 'project-main' | 'work' | 'learning' | 'inbox';
+export type UiAgentRuntime = 'running' | 'idle' | 'unloaded';
+export interface UiSessionSummary {
+    sessionId: string;
+    home: UiFrameParticipation['primaryHome'];
+    kind: UiSessionKind;
+    runtime: UiAgentRuntime;
+    projectId?: string;
+    projectTitle?: string;
+    workId?: string;
+    workGoal?: string;
+    workStatus?: FormalWork['status'];
+}
+export interface UiSessionActivity {
+    id: string;
+    turn: number;
+    seq: number;
+    kind: 'memory' | 'proposal' | 'work' | 'project' | 'frame' | 'learning';
+    action: string;
+    title: string;
+    status?: string;
+    entityId?: string;
+}
+export interface UiSessionContext {
+    summary: UiSessionSummary;
+    frames: UiFrameParticipation['frames'];
+    home: {
+        activeAssets: number;
+        candidates: number;
+        pendingProposals: number;
+    };
+    work: Array<Pick<FormalWork, 'id' | 'goal' | 'requester' | 'assignee' | 'status' | 'updatedAt' | 'workerSessionId' | 'returnToSessionId' | 'projectId' | 'resultSubject' | 'resultBody' | 'resultArtifacts'> & {
+        runtime: UiAgentRuntime;
+        requesterName: string;
+        assigneeName: string;
+    }>;
+    projects: Array<Pick<FormalProject, 'id' | 'title' | 'status' | 'goal'>>;
+    activity: UiSessionActivity[];
+    moreWork: boolean;
+}
+export type UiHumanInboxSummary = Pick<InboxMessage, 'id' | 'fromAddress' | 'to' | 'cc' | 'subject' | 'kind' | 'priority' | 'due' | 'replyTo' | 'humanAction' | 'sentAt'> & {
+    delivery?: InboxDelivery;
+    notification?: InboxHumanNotification;
+};
+export interface UiHumanInboxList {
+    address: string;
+    notificationPreference: Pick<HumanNotificationPreference, 'recipient' | 'enabled' | 'revision'> & {
+        updatedAt?: string;
+    };
+    messages: UiHumanInboxSummary[];
+    nextBeforeMessageId?: string;
+}
+export interface UiHumanInboxDetail {
+    message: InboxMessage;
+    delivery?: InboxDelivery;
+    notification?: InboxHumanNotification;
+}
+export type LearningKind = Exclude<AssetKind, 'identity'>;
+export type UiLearningSchedule = LearningScheduleStatus;
+export type UiMemoryUseOutcomes = MemoryUseOutcomePage;
+export type UiAgentDirectory = {
+    count: number;
+    homes: HomeDirectoryEntry[];
+};
+export type UiAgentTarget = HomeDirectoryEntry;
+export interface UiFrameParticipation {
+    sessionId: string;
+    primaryHome: {
+        address: HomeAddress;
+        displayName: string;
+        scope: UiHomeSummary['scope'];
+    };
+    frames: Array<{
+        address: HomeAddress;
+        displayName: string;
+        mode: FrameMode;
+        focused: boolean;
+        refreshRequired: boolean;
+    }>;
+}
+export interface UiAssetCounts {
+    memory: number;
+    insight: number;
+    knowledge: number;
+    method: number;
+}
+export interface UiHomeSummary {
+    address: HomeAddress;
+    /** Host-known Workspace for an explicitly bound Business Home chat. */
+    chatWorkspacePath?: string;
+    /** `personal` for the person's own Homes in the data root, outside any organization. */
+    scope: 'personal' | 'organization';
+    type: HomeType;
+    displayName: string;
+    revision: number;
+    status: AgentHome['status'];
+    updatedAt: string;
+    assetCount: number;
+    activeAssetCount: number;
+    counts: UiAssetCounts;
+    incomingPending: number;
+    outgoingPending: number;
+    episodes: number;
+}
+export interface UiAsset {
+    id: string;
+    ownerAddress: HomeAddress;
+    kind: LearningKind;
+    title?: string;
+    description: string;
+    body: string;
+    tags: string[];
+    sourceRefs: EvidenceRef[];
+    confidence: number;
+    fitness: number;
+    status: AssetStatus;
+    revision: number;
+    proposalId?: string;
+    proposalApplications?: Array<{
+        proposalId: string;
+        revision: number;
+        bodySha256: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+    receiptCount: number;
+    lastSignal?: FitnessSignal;
+}
+export interface UiHomeDetail {
+    home: AgentHome;
+    identity: string;
+    assets: UiAsset[];
+    proposals: MemoryProposal[];
+    episodes: number;
+    worklogCount: number;
+    worklogs: Array<{
+        id: string;
+        sessionId: string;
+        revision: number;
+        description: string;
+        body: string;
+        status: 'ongoing' | 'completed' | 'blocked' | 'failed';
+        origin?: 'agent' | 'work-result' | 'session-activity';
+        recordedAt: string;
+        files: string[];
+        workId?: string;
+        projectId?: string;
+    }>;
+}
+export interface UiOverview {
+    generatedAt: string;
+    /** BizAgent data root: the personal space, with organizations under `orgs/`. */
+    homeRoot: string;
+    organizationLocation?: {
+        organizationId: string;
+        organizationRoot: string;
+        /** Set for an organization still at its pre-1.0 place, `<workspace>/bizagent/<id>`. */
+        legacyWorkspacePath?: string;
+    };
+    organization?: Organization;
+    homes: UiHomeSummary[];
+    proposals: MemoryProposal[];
+    totals: {
+        homes: number;
+        assets: number;
+        activeAssets: number;
+        pendingProposals: number;
+        episodes: number;
+    };
+    health: {
+        ok: boolean;
+        issues: string[];
+    };
+}
+export interface UiCreateHomeRequest {
+    address: string;
+    displayName?: string;
+    owner?: string;
+    identity?: string;
+}
+export interface UiCreateOrganizationRequest {
+    id: string;
+    name: string;
+    mission: string;
+    members: Array<{
+        id: string;
+        displayName: string;
+        roleId: string;
+        roleName: string;
+        responsibility: string;
+    }>;
+    capabilities: Array<{
+        id: string;
+        displayName: string;
+        responsibility: string;
+    }>;
+}
+export interface UiProposalDecisionRequest {
+    ownerAddress: string;
+    proposalId: string;
+    action: 'accept' | 'reject';
+    decision: string;
+}
+export interface UiApiError {
+    error: {
+        code: string;
+        message: string;
+    };
+}
+export interface UiProjectList {
+    homeAddress: HomeAddress;
+    projects: FormalProject[];
+    nextBeforeProjectId?: string;
+}
+export interface UiProjectDetail {
+    project: FormalProject;
+    work: FormalWork[];
+}

package/lib/client-types/untrusted-text.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Helpers for text that another Home, Agent, or person wrote and that this plugin places in
+ * model-facing messages. Single-line fields stay on one line; multi-line content is fenced as data.
+ */
+/** Render one foreign field on a single line; line breaks and control characters become visible escapes. */
+export declare function inlineText(value: string): string;
+/**
+ * Place multi-line foreign content in a clearly delimited data block. The fence is longer than any
+ * backtick run inside the content, so the content cannot close it and continue as plugin text.
+ */
+export declare function untrustedBlock(label: string, content: string): string;
+/** Write-time check for subjects, goals, titles, and other single-line fields. */
+export declare function assertSingleLineText(value: string, label: string): void;
+/** Write-time check for multi-line bodies: newline and tab are the only allowed control characters. */
+export declare function assertBodyText(value: string, label: string): void;

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

@@ -0,0 +1,108 @@
+import { type DomainFacility } from '@deepseek-ai/dsh-storage-domain';
+import { z } from 'zod';
+import { type HomeAddress } from './domain.js';
+export declare const FormalWorkSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    idempotencyKey: z.ZodString;
+    requester: z.ZodString;
+    assignee: z.ZodString;
+    returnToSessionId: z.ZodString;
+    goal: z.ZodString;
+    acceptanceCriteria: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        open: "open";
+        completed: "completed";
+        accepted: "accepted";
+        cancelled: "cancelled";
+        completing: "completing";
+    }>;
+    requestMessageId: z.ZodString;
+    autoStart: z.ZodOptional<z.ZodBoolean>;
+    workerSessionId: z.ZodOptional<z.ZodString>;
+    workerCwd: z.ZodOptional<z.ZodString>;
+    workerOptions: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    acceptedAt: z.ZodOptional<z.ZodString>;
+    resultMessageId: z.ZodOptional<z.ZodString>;
+    resultSubject: z.ZodOptional<z.ZodString>;
+    resultBody: z.ZodOptional<z.ZodString>;
+    resultSessionId: z.ZodOptional<z.ZodString>;
+    resultArtifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        snapshot: z.ZodLiteral<true>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+    cancelledAt: z.ZodOptional<z.ZodString>;
+    cancelMessageId: z.ZodOptional<z.ZodString>;
+    cancelReason: z.ZodOptional<z.ZodString>;
+    cancelledBySessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FormalWork = Omit<z.infer<typeof FormalWorkSchema>, 'requester' | 'assignee'> & {
+    requester: HomeAddress;
+    assignee: HomeAddress;
+};
+export declare const BIZAGENT_WORK_DOMAIN: {
+    name: string;
+    version: number;
+    tables: {
+        works: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1;
+            id: string;
+            idempotencyKey: string;
+            requester: string;
+            assignee: string;
+            returnToSessionId: string;
+            goal: string;
+            acceptanceCriteria: string;
+            status: "open" | "completed" | "accepted" | "cancelled" | "completing";
+            requestMessageId: string;
+            createdAt: string;
+            updatedAt: string;
+            projectId?: string | undefined;
+            autoStart?: boolean | undefined;
+            workerSessionId?: string | undefined;
+            workerCwd?: string | undefined;
+            workerOptions?: {
+                provider?: string | undefined;
+                model?: string | undefined;
+                maxTokens?: number | undefined;
+            } | undefined;
+            acceptedAt?: string | undefined;
+            resultMessageId?: string | undefined;
+            resultSubject?: string | undefined;
+            resultBody?: string | undefined;
+            resultSessionId?: string | undefined;
+            resultArtifacts?: {
+                path: string;
+                sha256: string;
+                bytes: number;
+                snapshot: true;
+            }[] | undefined;
+            completedAt?: string | undefined;
+            cancelledAt?: string | undefined;
+            cancelMessageId?: string | undefined;
+            cancelReason?: string | undefined;
+            cancelledBySessionId?: string | undefined;
+        }>;
+    };
+};
+export declare class WorkLedger {
+    private readonly domain;
+    private mutationTail;
+    private constructor();
+    static open(facility: DomainFacility): Promise<WorkLedger>;
+    withWrite<T>(update: () => Promise<T>): Promise<T>;
+    get(id: string): FormalWork | undefined;
+    list(): FormalWork[];
+    put(work: FormalWork): Promise<void>;
+    close(): Promise<void>;
+}

package/lib/client-types/work-output-eval.d.ts

@@ -0,0 +1,15 @@
+export type WorkOutputVerdict = {
+    checker: 'empty-content' | 'placeholder-leak';
+    result: 'pass' | 'fail' | 'skip';
+    reason?: string;
+    evidence?: string;
+};
+export type WorkOutputSourceEvaluation = {
+    kind: 'artifact' | 'result-body';
+    path?: string;
+    sha256: string;
+    bytes: number;
+    verdicts: WorkOutputVerdict[];
+};
+/** Deterministic assertions on a frozen Work result. Verdicts are observations, not acceptance decisions. */
+export declare function evaluateWorkOutput(kind: 'artifact' | 'result-body', bytes: Uint8Array, path?: string): WorkOutputSourceEvaluation;

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

@@ -0,0 +1,88 @@
+import { type DomainFacility } from '@deepseek-ai/dsh-storage-domain';
+import { z } from 'zod';
+import { type HomeAddress } from './domain.js';
+export declare const WorklogRevisionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    sessionId: z.ZodString;
+    homeAddress: z.ZodString;
+    revision: z.ZodNumber;
+    idempotencyKey: z.ZodString;
+    description: z.ZodString;
+    body: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        ongoing: "ongoing";
+        blocked: "blocked";
+    }>;
+    origin: z.ZodOptional<z.ZodEnum<{
+        "work-result": "work-result";
+        agent: "agent";
+        "session-activity": "session-activity";
+    }>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodObject<{
+        fromSeq: z.ZodNumber;
+        toSeq: z.ZodNumber;
+        fingerprint: z.ZodString;
+    }, z.core.$strip>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        snapshot: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>>;
+    projectId: z.ZodOptional<z.ZodString>;
+    workId: z.ZodOptional<z.ZodString>;
+    recordedAt: z.ZodString;
+}, z.core.$strip>;
+export type WorklogRevision = Omit<z.infer<typeof WorklogRevisionSchema>, 'homeAddress'> & {
+    homeAddress: HomeAddress;
+};
+export declare const BIZAGENT_WORKLOG_DOMAIN: {
+    name: string;
+    version: number;
+    tables: {
+        revisions: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1;
+            id: string;
+            sessionId: string;
+            homeAddress: string;
+            revision: number;
+            idempotencyKey: string;
+            description: string;
+            body: string;
+            status: "completed" | "failed" | "ongoing" | "blocked";
+            evidence: {
+                fromSeq: number;
+                toSeq: number;
+                fingerprint: string;
+            };
+            files: {
+                path: string;
+                sha256: string;
+                bytes: number;
+                snapshot?: true | undefined;
+            }[];
+            recordedAt: string;
+            origin?: "work-result" | "agent" | "session-activity" | undefined;
+            cwd?: string | undefined;
+            projectId?: string | undefined;
+            workId?: string | undefined;
+        }>;
+    };
+};
+export declare class WorklogLedger {
+    private readonly domain;
+    private mutationTail;
+    private constructor();
+    static open(facility: DomainFacility): Promise<WorklogLedger>;
+    withWrite<T>(update: () => Promise<T>): Promise<T>;
+    get(id: string): WorklogRevision | undefined;
+    listVersions(sessionId: string): WorklogRevision[];
+    listLatest(homeAddress: HomeAddress): WorklogRevision[];
+    put(revision: WorklogRevision): Promise<void>;
+    close(): Promise<void>;
+    private all;
+}

package/lib/client-types/worklog-snapshot.d.ts

@@ -0,0 +1,33 @@
+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 {};