@bizagent/dsh 0.0.0-stage → 1.0.0

package/lib/local-human-host.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "bizagent-local-human-host";
+export declare const inject: string[];
+/**
+ * Local single-user adapter: one person reviews Projects and proposals and answers their Inbox.
+ * In DSH Web that person is whoever is signed in to DSH in the browser (DSH's own login), and
+ * they act as the BizAgent owner (or $BIZAGENT_LOCAL_HUMAN_ID). Scripts can instead present a
+ * Bearer token from $BIZAGENT_LOCAL_HUMAN_TOKEN_FILE. BIZAGENT_LOCAL_HUMAN=off turns this off.
+ */
+export declare function apply(ctx: Context): Promise<void>;
+//# sourceMappingURL=local-human-host.d.ts.map

package/lib/local-human-host.js

@@ -0,0 +1,191 @@
+import { registerHumanInboxRoute } from './human-inbox-transport.js';
+import { isLocalUserId } from './local-owner.js';
+import { LocalHumanCredential, readLocalHumanToken } from './local-human-token.js';
+import { workspaceRegistry } from './organization-workspace.js';
+import { registerProjectReviewRoute } from './project-review-transport.js';
+import { registerProposalReviewRoute } from './proposal-review-transport.js';
+import { dshOperatorAuthentication, guardLocalRoute } from './route-guard.js';
+import { registerSharedKnowledgeReviewRoute } from './shared-knowledge-review-transport.js';
+import { BIZAGENT_AGENT_SESSION_API, BIZAGENT_LOCAL_HUMAN_STATUS_API } from './ui-contract.js';
+export const name = 'bizagent-local-human-host';
+export const inject = ['bizagent', 'bizagentAgentSessions', 'webServer'];
+/**
+ * Local single-user adapter: one person reviews Projects and proposals and answers their Inbox.
+ * In DSH Web that person is whoever is signed in to DSH in the browser (DSH's own login), and
+ * they act as the BizAgent owner (or $BIZAGENT_LOCAL_HUMAN_ID). Scripts can instead present a
+ * Bearer token from $BIZAGENT_LOCAL_HUMAN_TOKEN_FILE. BIZAGENT_LOCAL_HUMAN=off turns this off.
+ */
+export async function apply(ctx) {
+    if (process.env.BIZAGENT_LOCAL_HUMAN === 'off')
+        return;
+    const tokenFile = process.env.BIZAGENT_LOCAL_HUMAN_TOKEN_FILE?.trim();
+    const userId = process.env.BIZAGENT_LOCAL_HUMAN_ID?.trim() || ctx.bizagent.config.owner;
+    if (!isLocalUserId(userId)) {
+        throw new Error('BIZAGENT_LOCAL_HUMAN_ID must use 1-100 letters, numbers, dots, underscores, or hyphens');
+    }
+    if (ctx.webServer.host !== '127.0.0.1') {
+        // A configured token is a promise to protect review routes, so a public bind is an error.
+        if (tokenFile)
+            throw new Error('Local human review requires DSH Web to bind 127.0.0.1');
+        return;
+    }
+    const credential = tokenFile ? new LocalHumanCredential(await readLocalHumanToken(tokenFile)) : undefined;
+    const authenticate = (request) => {
+        const header = request.headers.authorization;
+        if (typeof header === 'string' && header.startsWith('Bearer ')) {
+            return credential?.matchesToken(header.slice('Bearer '.length)) ? { userId } : null;
+        }
+        const operator = dshOperatorAuthentication(ctx);
+        return operator !== undefined && operator.requestRejection(request) === undefined ? { userId } : null;
+    };
+    // DSH Web lists only Sessions attached to a Workspace. Sessions this plugin opens are created on
+    // the host, so attach them to a Workspace named after their Home, as DSH does for its own.
+    const showInSidebar = async (homeAddress, sessionId) => {
+        const path = ctx.bizagent.store.homeWorkspacePath(homeAddress);
+        const registry = workspaceRegistry(ctx);
+        if (registry !== undefined) {
+            const workspace = await registry.create(path, ctx.bizagent.store.getHome(homeAddress).displayName);
+            await workspace.attachSession(sessionId);
+        }
+        return path;
+    };
+    const ownsHome = (address) => {
+        try {
+            return ctx.bizagent.store.getHome(address).owner === userId;
+        }
+        catch {
+            return false;
+        }
+    };
+    const authorizeMutation = (_request, principal) => principal.userId === userId;
+    const disposers = [
+        ctx.webServer.register({ kind: 'exact', path: BIZAGENT_LOCAL_HUMAN_STATUS_API,
+            handler: guardLocalRoute(async (request, response) => {
+                response.setHeader('Cache-Control', 'no-store');
+                response.setHeader('Content-Type', 'application/json; charset=utf-8');
+                response.setHeader('X-Content-Type-Options', 'nosniff');
+                if (request.method !== 'GET') {
+                    response.writeHead(405, { Allow: 'GET' });
+                    response.end(JSON.stringify({ error: 'method-not-allowed' }));
+                    return;
+                }
+                const principal = authenticate(request);
+                response.statusCode = principal ? 200 : 401;
+                response.end(JSON.stringify(principal ? { userId: principal.userId } : { error: 'authentication-required' }));
+            }) }),
+        ctx.webServer.register({ kind: 'exact', path: BIZAGENT_AGENT_SESSION_API,
+            handler: guardLocalRoute(async (request, response) => {
+                response.setHeader('Cache-Control', 'no-store');
+                response.setHeader('Content-Type', 'application/json; charset=utf-8');
+                response.setHeader('X-Content-Type-Options', 'nosniff');
+                const reply = (status, body) => {
+                    response.statusCode = status;
+                    response.end(JSON.stringify(body));
+                };
+                if (request.method !== 'POST') {
+                    reply(405, { error: 'method-not-allowed' });
+                    return;
+                }
+                if (!authenticate(request)) {
+                    reply(401, { error: 'authentication-required' });
+                    return;
+                }
+                if (!String(request.headers['content-type'] ?? '').toLowerCase().startsWith('application/json')) {
+                    reply(415, { error: 'content-type' });
+                    return;
+                }
+                try {
+                    const parts = [];
+                    let total = 0;
+                    for await (const chunk of request) {
+                        const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                        total += part.byteLength;
+                        if (total > 4096) {
+                            reply(413, { error: 'body-too-large' });
+                            return;
+                        }
+                        parts.push(part);
+                    }
+                    const body = JSON.parse(Buffer.concat(parts).toString('utf8'));
+                    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+                        reply(400, { error: 'invalid-request' });
+                        return;
+                    }
+                    const input = body;
+                    const principal = typeof input.homeAddress === 'string' && input.projectId === undefined
+                        && Object.keys(input).length === 1;
+                    const main = typeof input.projectId === 'string' && input.homeAddress === undefined
+                        && Object.keys(input).length === 1;
+                    const existing = typeof input.sessionId === 'string' && input.sessionId.length > 0
+                        && Object.keys(input).length === 1;
+                    if (!principal && !main && !existing) {
+                        reply(400, { error: 'invalid-request' });
+                        return;
+                    }
+                    if (existing) {
+                        const binding = ctx.bizagent.ledger.getBinding(input.sessionId);
+                        if (!binding || !ownsHome(binding.homeAddress)) {
+                            reply(403, { error: 'session-forbidden' });
+                            return;
+                        }
+                        // Reveal a host-created worker without resuming its Agent or changing an ordinary
+                        // conversation's existing Workspace. Runtime ownership remains with its runner.
+                        const homePath = ctx.bizagent.store.homeWorkspacePath(binding.homeAddress);
+                        const workspacePath = binding.cwd === homePath
+                            ? await showInSidebar(binding.homeAddress, input.sessionId) : undefined;
+                        reply(200, { sessionId: input.sessionId, ...(workspacePath ? { workspacePath } : {}) });
+                    }
+                    else if (principal) {
+                        if (!ownsHome(input.homeAddress)) {
+                            reply(403, { error: 'home-forbidden' });
+                            return;
+                        }
+                        const result = await ctx.bizagentAgentSessions.openPrincipal(input.homeAddress);
+                        reply(200, { ...result, workspacePath: await showInSidebar(result.homeAddress, result.sessionId) });
+                    }
+                    else {
+                        const project = ctx.bizagent.projectLedger?.get(input.projectId);
+                        if (!project || !ownsHome(project.lead)) {
+                            reply(403, { error: 'project-forbidden' });
+                            return;
+                        }
+                        const result = await ctx.bizagentAgentSessions.openProjectMain(input.projectId);
+                        reply(200, { ...result, workspacePath: await showInSidebar(result.homeAddress, result.sessionId) });
+                    }
+                }
+                catch {
+                    reply(409, { error: 'agent-session-unavailable' });
+                }
+            }) }),
+        registerProjectReviewRoute(ctx.webServer, ctx.bizagent, {
+            authenticateUser: authenticate,
+            authorizeMutation,
+            authorizeReview: (principal, project) => principal.userId === userId && ownsHome(project.lead),
+        }),
+        registerProposalReviewRoute(ctx.webServer, ctx.bizagent, {
+            authenticateHuman: authenticate,
+            authorizeMutation,
+            authorizeProposal: (_request, principal, proposal, action) => principal.userId === userId && ownsHome(proposal.toAddress)
+                ? `local-human:${userId}:${proposal.id}:${action}` : null,
+        }),
+        registerSharedKnowledgeReviewRoute(ctx.webServer, ctx.bizagent, {
+            authenticateHuman: authenticate,
+            authorizeMutation,
+            authorizeProposal: (_request, principal, proposal, action) => {
+                if (principal.userId !== userId)
+                    return null;
+                const authorized = proposal.target.scope === 'line'
+                    ? ownsHome(`line:${proposal.target.line}`)
+                    : process.env.BIZAGENT_LOCAL_PLATFORM_ADMIN === '1';
+                return authorized ? `local-human:${userId}:${proposal.target.scope}:${proposal.id}:${action}` : null;
+            },
+        }),
+        registerHumanInboxRoute(ctx.webServer, ctx.bizagent, {
+            authenticateUser: authenticate,
+            authorizeMutation,
+        }),
+    ];
+    ctx.effect(() => () => { for (const dispose of disposers.reverse())
+        dispose(); });
+}
+//# sourceMappingURL=local-human-host.js.map

package/lib/local-human-token.d.ts

@@ -0,0 +1,9 @@
+/** Read a token file that must be a private regular file owned by the current user. */
+export declare function readLocalHumanToken(file: string): Promise<string>;
+/** Verifies a presented Bearer token against one local token without leaking timing. */
+export declare class LocalHumanCredential {
+    private readonly tokenDigest;
+    constructor(token: string);
+    matchesToken(candidate: string): boolean;
+}
+//# sourceMappingURL=local-human-token.d.ts.map

package/lib/local-human-token.js

@@ -0,0 +1,32 @@
+import { createHash, timingSafeEqual } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+/** Read a token file that must be a private regular file owned by the current user. */
+export async function readLocalHumanToken(file) {
+    const info = await stat(file);
+    if (!info.isFile() || (process.platform !== 'win32' && (info.mode & 0o077) !== 0)) {
+        throw new Error('Local human token file must be a private regular file (mode 0600)');
+    }
+    if (typeof process.getuid === 'function' && info.uid !== process.getuid()) {
+        throw new Error('Local human token file must belong to the current user');
+    }
+    const token = (await readFile(file, 'utf8')).trim();
+    if (!isTokenShape(token))
+        throw new Error('Local human token must contain 32-512 non-whitespace characters');
+    return token;
+}
+function isTokenShape(value) {
+    return value.length >= 32 && value.length <= 512 && !/\s/u.test(value);
+}
+/** Verifies a presented Bearer token against one local token without leaking timing. */
+export class LocalHumanCredential {
+    tokenDigest;
+    constructor(token) {
+        this.tokenDigest = createHash('sha256').update(token).digest();
+    }
+    matchesToken(candidate) {
+        if (!isTokenShape(candidate))
+            return false;
+        return timingSafeEqual(createHash('sha256').update(candidate).digest(), this.tokenDigest);
+    }
+}
+//# sourceMappingURL=local-human-token.js.map

package/lib/local-owner.d.ts

@@ -0,0 +1,8 @@
+/** 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;
+//# sourceMappingURL=local-owner.d.ts.map

package/lib/local-owner.js

@@ -0,0 +1,26 @@
+import { userInfo } from 'node:os';
+const USER_ID = /^[a-zA-Z0-9._-]{1,100}$/;
+/** Whether a string can name a local human (Home owner or reviewer). */
+export function isLocalUserId(value) {
+    return USER_ID.test(value);
+}
+/**
+ * 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 function localOwnerId(env = process.env) {
+    const configured = env['BIZAGENT_LOCAL_HUMAN_ID']?.trim();
+    if (configured) {
+        if (!isLocalUserId(configured))
+            throw new TypeError('BIZAGENT_LOCAL_HUMAN_ID must use 1-100 letters, numbers, dots, underscores, or hyphens');
+        return configured;
+    }
+    let name = '';
+    try {
+        name = userInfo().username;
+    }
+    catch { /* Some containers have no passwd entry. */ }
+    const cleaned = name.replace(/[^a-zA-Z0-9._-]/g, '').slice(0, 100);
+    return cleaned || 'local';
+}
+//# sourceMappingURL=local-owner.js.map

package/lib/message-source.d.ts

@@ -0,0 +1,10 @@
+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";
+//# sourceMappingURL=message-source.d.ts.map

package/lib/message-source.js

@@ -0,0 +1,2 @@
+export const BIZAGENT_SOURCE_KIND = 'bizagent';
+//# sourceMappingURL=message-source.js.map

package/lib/organization-location.d.ts

@@ -0,0 +1,20 @@
+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>;
+//# sourceMappingURL=organization-location.d.ts.map

package/lib/organization-location.js

@@ -0,0 +1,80 @@
+import { readFile } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import YAML from 'yaml';
+import { z } from 'zod';
+import { nowIso } from './domain.js';
+import { assertKnownFormat } from './known-format.js';
+import { writeFileDurably } from './safe-file.js';
+const ORGANIZATION_ID = z.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/);
+/** Version 1 placed an organization at `<workspacePath>/bizagent/<id>` inside a DSH Workspace. */
+const LocationV1Schema = z.object({
+    schemaVersion: z.literal(1),
+    workspacePath: z.string().min(1),
+    organizationId: ORGANIZATION_ID,
+    organizationRoot: z.string().min(1),
+    updatedAt: z.string().min(1),
+});
+/** Version 2 places every organization at `<data root>/orgs/<id>`. */
+const LocationV2Schema = z.object({
+    schemaVersion: z.literal(2),
+    organizationId: ORGANIZATION_ID,
+    organizationRoot: z.string().min(1),
+    updatedAt: z.string().min(1),
+});
+export const ActiveOrganizationLocationSchema = z.discriminatedUnion('schemaVersion', [LocationV1Schema, LocationV2Schema]);
+export function activeOrganizationLocationPath(registryRoot) {
+    return join(resolve(registryRoot), 'active-organization.yaml');
+}
+/** Where a new organization lives: `<data root>/orgs/<id>`. */
+export function organizationLocation(registryRoot, organizationId) {
+    const root = resolve(registryRoot);
+    if (!isAbsolute(root))
+        throw new Error('BizAgent data root must be absolute');
+    const id = ORGANIZATION_ID.parse(organizationId.trim().toLocaleLowerCase());
+    return LocationV2Schema.parse({
+        schemaVersion: 2,
+        organizationId: id,
+        organizationRoot: join(root, 'orgs', id),
+        updatedAt: nowIso(),
+    });
+}
+function legacyOrganizationRoot(workspacePath, organizationId) {
+    const trimmedWorkspace = workspacePath.trim();
+    if (!isAbsolute(trimmedWorkspace))
+        throw new Error('DSH Workspace path must be absolute');
+    const workspace = resolve(trimmedWorkspace);
+    const organizationRoot = resolve(workspace, 'bizagent', organizationId);
+    const rel = relative(workspace, organizationRoot);
+    if (rel.startsWith('..') || isAbsolute(rel))
+        throw new Error('organization directory escapes the DSH Workspace');
+    return organizationRoot;
+}
+export async function loadActiveOrganizationLocation(registryRoot) {
+    let raw;
+    try {
+        raw = YAML.parse(await readFile(activeOrganizationLocationPath(registryRoot), 'utf8'));
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return undefined;
+        throw error;
+    }
+    assertKnownFormat(raw, 2, 'active-organization.yaml');
+    const location = ActiveOrganizationLocationSchema.parse(raw);
+    const expected = location.schemaVersion === 1
+        ? legacyOrganizationRoot(location.workspacePath, location.organizationId)
+        : organizationLocation(registryRoot, location.organizationId).organizationRoot;
+    if (expected !== resolve(location.organizationRoot)) {
+        throw new Error(`active organization root does not match its expected location: ${location.organizationRoot}`);
+    }
+    return location.schemaVersion === 1
+        ? { ...location, organizationRoot: expected, workspacePath: resolve(location.workspacePath) }
+        : { ...location, organizationRoot: expected };
+}
+export async function saveActiveOrganizationLocation(registryRoot, location) {
+    await writeFileDurably(activeOrganizationLocationPath(registryRoot), YAML.stringify(location, { lineWidth: 0 }));
+}
+function isNotFound(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+//# sourceMappingURL=organization-location.js.map

package/lib/organization-workspace.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { BizAgentService } from './service.js';
+/** The slice of DSH's host `workspaceRegistry` BizAgent uses to show its folders in the sidebar. */
+export interface WorkspaceRegistryLike {
+    list(): ReadonlyArray<{
+        readonly id: string;
+        readonly path: string;
+    }>;
+    create(path: string, title?: string): Promise<{
+        readonly id: string;
+        attachSession(sessionId: string): Promise<void>;
+    }>;
+    insertBefore(id: string, beforeId?: string): Promise<readonly string[]>;
+}
+/** DSH's Workspace registry when this host composes one. */
+export declare function workspaceRegistry(ctx: Context): WorkspaceRegistryLike | undefined;
+/**
+ * Show the active organization's folder as a DSH Workspace named after the organization. The first
+ * time it is added it goes to the top of the sidebar; after that its place is the person's choice.
+ */
+export declare function showOrganizationWorkspace(ctx: Context, service: BizAgentService): Promise<void>;
+//# sourceMappingURL=organization-workspace.d.ts.map

package/lib/organization-workspace.js

@@ -0,0 +1,32 @@
+import { realpathSync } from 'node:fs';
+/** DSH's Workspace registry when this host composes one. */
+export function workspaceRegistry(ctx) {
+    return ctx.get('workspaceRegistry');
+}
+/**
+ * Show the active organization's folder as a DSH Workspace named after the organization. The first
+ * time it is added it goes to the top of the sidebar; after that its place is the person's choice.
+ */
+export async function showOrganizationWorkspace(ctx, service) {
+    const root = service.store.organizationRoot;
+    const organization = service.store.getOrganization();
+    const registry = workspaceRegistry(ctx);
+    if (root === undefined || organization === undefined || registry === undefined)
+        return;
+    // The registry keeps canonical paths; a temporary folder may sit behind a symlink.
+    let canonical = root;
+    try {
+        canonical = realpathSync.native(root);
+    }
+    catch { /* created on registration */ }
+    if (registry.list().some(workspace => workspace.path === canonical))
+        return;
+    const known = new Set(registry.list().map(workspace => workspace.id));
+    const workspace = await registry.create(root, organization.name);
+    if (known.has(workspace.id))
+        return;
+    const first = registry.list()[0];
+    if (first !== undefined && first.id !== workspace.id)
+        await registry.insertBefore(workspace.id, first.id);
+}
+//# sourceMappingURL=organization-workspace.js.map

package/lib/project-ledger.d.ts

@@ -0,0 +1,183 @@
+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>;
+}
+//# sourceMappingURL=project-ledger.d.ts.map