@bizagent/dsh 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,182 @@
+import { type DomainFacility } from '@deepseek-ai/dsh-storage-domain';
+import { z } from 'zod';
+import { type HomeAddress } from './domain.js';
+export declare const ProjectSeatSchema: z.ZodObject<{
+    id: z.ZodString;
+    address: z.ZodString;
+    homeAddress: z.ZodString;
+    responsibility: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        released: "released";
+    }>;
+    joinedAt: z.ZodString;
+    updatedAt: z.ZodString;
+    releasedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProjectSeat = Omit<z.infer<typeof ProjectSeatSchema>, 'homeAddress'> & {
+    homeAddress: HomeAddress;
+};
+export declare const FormalProjectSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    idempotencyKey: z.ZodString;
+    lead: z.ZodString;
+    driver: z.ZodOptional<z.ZodString>;
+    createdBySessionId: z.ZodString;
+    title: z.ZodString;
+    goal: z.ZodString;
+    doneWhen: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        accepted: "accepted";
+        awaiting_acceptance: "awaiting_acceptance";
+    }>;
+    revision: z.ZodNumber;
+    claims: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        summary: z.ZodString;
+        body: z.ZodString;
+        doneWhenAssessment: z.ZodString;
+        work: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                completed: "completed";
+                cancelled: "cancelled";
+            }>;
+            resultMessageId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+            bytes: z.ZodNumber;
+            snapshot: z.ZodLiteral<true>;
+        }, z.core.$strip>>>;
+        submittedBySessionId: z.ZodString;
+        submittedAt: z.ZodString;
+    }, z.core.$strip>>;
+    reviews: z.ZodArray<z.ZodObject<{
+        claimId: z.ZodString;
+        decision: z.ZodEnum<{
+            accept: "accept";
+            rework: "rework";
+        }>;
+        reason: z.ZodString;
+        reviewedBySessionId: z.ZodOptional<z.ZodString>;
+        reviewedByPrincipal: z.ZodOptional<z.ZodString>;
+        reviewedAt: z.ZodString;
+    }, z.core.$strip>>;
+    seats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        address: z.ZodString;
+        homeAddress: z.ZodString;
+        responsibility: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            released: "released";
+        }>;
+        joinedAt: z.ZodString;
+        updatedAt: z.ZodString;
+        releasedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    seatEvents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        seatAddress: z.ZodString;
+        homeAddress: z.ZodString;
+        action: z.ZodEnum<{
+            released: "released";
+            joined: "joined";
+            "responsibility-updated": "responsibility-updated";
+            rejoined: "rejoined";
+        }>;
+        responsibility: z.ZodString;
+        bySessionId: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strip>>>;
+    currentClaimId: z.ZodOptional<z.ZodString>;
+    acceptedClaimId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type FormalProject = Omit<z.infer<typeof FormalProjectSchema>, 'lead' | 'seats'> & {
+    lead: HomeAddress;
+    seats?: ProjectSeat[];
+};
+export declare const BIZAGENT_PROJECT_DOMAIN: {
+    name: string;
+    version: number;
+    tables: {
+        projects: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1;
+            id: string;
+            idempotencyKey: string;
+            lead: string;
+            createdBySessionId: string;
+            title: string;
+            goal: string;
+            doneWhen: string;
+            status: "open" | "accepted" | "awaiting_acceptance";
+            revision: number;
+            claims: {
+                id: string;
+                summary: string;
+                body: string;
+                doneWhenAssessment: string;
+                work: {
+                    id: string;
+                    status: "completed" | "cancelled";
+                    resultMessageId?: string | undefined;
+                }[];
+                submittedBySessionId: string;
+                submittedAt: string;
+                artifacts?: {
+                    path: string;
+                    sha256: string;
+                    bytes: number;
+                    snapshot: true;
+                }[] | undefined;
+            }[];
+            reviews: {
+                claimId: string;
+                decision: "accept" | "rework";
+                reason: string;
+                reviewedAt: string;
+                reviewedBySessionId?: string | undefined;
+                reviewedByPrincipal?: string | undefined;
+            }[];
+            createdAt: string;
+            updatedAt: string;
+            driver?: string | undefined;
+            seats?: {
+                id: string;
+                address: string;
+                homeAddress: string;
+                responsibility: string;
+                status: "active" | "released";
+                joinedAt: string;
+                updatedAt: string;
+                releasedAt?: string | undefined;
+            }[] | undefined;
+            seatEvents?: {
+                seatAddress: string;
+                homeAddress: string;
+                action: "released" | "joined" | "responsibility-updated" | "rejoined";
+                responsibility: string;
+                bySessionId: string;
+                at: string;
+            }[] | undefined;
+            currentClaimId?: string | undefined;
+            acceptedClaimId?: string | undefined;
+        }>;
+    };
+};
+export declare class ProjectLedger {
+    private readonly domain;
+    private mutationTail;
+    private constructor();
+    static open(facility: DomainFacility): Promise<ProjectLedger>;
+    withWrite<T>(update: () => Promise<T>): Promise<T>;
+    get(id: string): FormalProject | undefined;
+    list(): FormalProject[];
+    put(project: FormalProject): Promise<void>;
+    close(): Promise<void>;
+}

package/lib/client-types/project-seat-context.d.ts

@@ -0,0 +1,17 @@
+import type { HomeAddress, ProjectSeatAddress } from './domain.js';
+import type { FormalProject, ProjectSeat } from './project-ledger.js';
+export interface ProjectSeatContext {
+    projectId: string;
+    projectRevision: number;
+    title: string;
+    goal: string;
+    doneWhen: string;
+    status: FormalProject['status'];
+    lead: HomeAddress;
+    seatAddress: ProjectSeatAddress;
+    homeAddress: HomeAddress;
+    responsibility: string;
+}
+export declare function projectSeatContext(project: FormalProject, seat: ProjectSeat): ProjectSeatContext;
+/** Situates a Home-bound Session in one Seat without claiming a separate execution identity. */
+export declare function renderProjectSeatContext(context: ProjectSeatContext): string;

package/lib/client-types/safe-file.d.ts

@@ -0,0 +1,23 @@
+export interface RegularFileIdentity {
+    dev: number;
+    ino: number;
+}
+export interface ReadRegularFileOptions {
+    /** Reject files larger than this many bytes, checked on the open handle. */
+    maxBytes?: number;
+    /** Require the opened file to be this exact inode, e.g. one validated by an earlier path check. */
+    expected?: RegularFileIdentity;
+}
+/**
+ * Read one file without following a final symlink and without a check-then-read race: the file
+ * is opened with O_NOFOLLOW (O_NONBLOCK keeps a FIFO from blocking the open), then the open
+ * handle is checked to be a regular file and read. Platforms without O_NOFOLLOW fall back to an
+ * lstat check plus the same handle checks.
+ */
+export declare function readRegularFileNoFollow(path: string, options?: ReadRegularFileOptions): Promise<Buffer>;
+/**
+ * Replace a file so that a crash or power loss leaves either the old or the new contents, never an
+ * empty file: write a private temporary file, fsync it, rename it over the target, then fsync the
+ * directory so the rename itself is durable (best effort where directories cannot be fsynced).
+ */
+export declare function writeFileDurably(path: string, contents: string | Uint8Array): Promise<void>;

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

@@ -0,0 +1,9 @@
+import type { CreateOrganizationInput } from './home-store.js';
+/** A small growth team with real data to work on, so every BizAgent loop can be tried in minutes. */
+export declare const SAMPLE_ORGANIZATION: Omit<CreateOrganizationInput, 'owner'>;
+/** Files placed in sample Home directories. Existing files are never overwritten. */
+export declare const SAMPLE_FILES: ReadonlyArray<{
+    home: string;
+    path: string;
+    content: string;
+}>;