@bizagent/dsh 0.0.0-stage → 1.0.0

package/lib/frame-admission.js

@@ -0,0 +1,39 @@
+import { createUserMessage, freezeMessage } from '@deepseek-ai/dsh-llm';
+import { selectedFrameAddresses, removeFrameReferences } from './frame-reference.js';
+import './message-source.js';
+/** Resolve selected references at DSH's admission boundary, before the model sees the step. */
+export async function admitFrameReferences(service, agent, decision, signal) {
+    if (decision.kind !== 'enter')
+        return decision;
+    const messages = [];
+    for (const message of decision.messages) {
+        if (message.source.kind !== 'user') {
+            messages.push(message);
+            continue;
+        }
+        const text = message.content.filter(block => block.type === 'text').map(block => block.text).join('\n');
+        // The marker belongs to transport, not the visible transcript. Preserve message identity,
+        // user text and attachments while DSH logs the actual loaded context separately.
+        messages.push(freezeMessage({ ...message, content: message.content.map(block => block.type === 'text'
+                ? { ...block, text: removeFrameReferences(block.text) } : block) }));
+        for (const address of selectedFrameAddresses(text)) {
+            if (signal.aborted)
+                return { kind: 'reject' };
+            try {
+                // Admission can be cancelled after updating the Frame ledger. Always send a complete
+                // snapshot on retry, rather than assuming an earlier, uncommitted copy reached the log.
+                const result = await service.openFrame(agent, { address, forceSnapshot: true });
+                const context = String(result.context);
+                messages.push(createUserMessage({ content: [{ type: 'text', text: context }],
+                    source: { kind: 'bizagent', form: 'snapshot', sections: [{ name: address, text: context }] } }));
+            }
+            catch (error) {
+                service.recordRuntimeError(`Frame reference ${String(agent.id)} ${address}`, error);
+                messages.push(createUserMessage({ content: [{ type: 'text', text: `The selected Home ${address} could not be loaded. Its context is unavailable; do not answer as if it was read.` }],
+                    source: { kind: 'bizagent', form: 'notice', summary: `Home unavailable: ${address}` } }));
+            }
+        }
+    }
+    return signal.aborted ? { kind: 'reject' } : { ...decision, messages };
+}
+//# sourceMappingURL=frame-admission.js.map

package/lib/frame-reference.d.ts

@@ -0,0 +1,5 @@
+/** 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;
+//# sourceMappingURL=frame-reference.d.ts.map

package/lib/frame-reference.js

@@ -0,0 +1,12 @@
+/** A selected composer reference; only user-authored, admitted messages are resolved. */
+export function frameReference(address) {
+    return `[BIZAGENT_FRAME_REQUEST:${address}]`;
+}
+export function selectedFrameAddresses(text) {
+    return [...new Set([...text.matchAll(/^\[BIZAGENT_FRAME_REQUEST:((?:business|role|capability):[a-z0-9][a-z0-9._/-]*)\]/gm)]
+            .map(match => match[1]))].slice(0, 8);
+}
+export function removeFrameReferences(text) {
+    return text.replace(/\n?^\[BIZAGENT_FRAME_REQUEST:(?:business|role|capability):[a-z0-9][a-z0-9._/-]*\]/gm, '');
+}
+//# sourceMappingURL=frame-reference.js.map

package/lib/home-archive.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const HomeArchiveManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"bizagent-dsh-home-files">;
+    capturedAt: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        bytes: z.ZodNumber;
+        sha256: z.ZodString;
+    }, z.core.$strip>>;
+    rootDigest: z.ZodString;
+}, z.core.$strip>;
+export type HomeArchiveManifest = z.infer<typeof HomeArchiveManifestSchema>;
+export declare function exportHomeArchive(sourceRoot: string, destination: string): Promise<HomeArchiveManifest>;
+export declare function verifyHomeArchive(archiveRoot: string): Promise<HomeArchiveManifest>;
+export declare function importHomeArchive(archiveRoot: string, destinationRoot: string): Promise<HomeArchiveManifest>;
+//# sourceMappingURL=home-archive.d.ts.map

package/lib/home-archive.js

@@ -0,0 +1,177 @@
+import { createHash } from 'node:crypto';
+import { copyFile, lstat, mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { z } from 'zod';
+import { HomeStore } from './home-store.js';
+import { RUNTIME_WRITER_CLAIM_NAME, RUNTIME_WRITER_LOCK_NAME } from './writer-guard.js';
+const MANIFEST = 'home-archive.json';
+const ArchiveFileSchema = z.object({
+    path: z.string().min(1),
+    bytes: z.number().int().nonnegative(),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+});
+export const HomeArchiveManifestSchema = z.object({
+    schemaVersion: z.literal(1),
+    kind: z.literal('bizagent-dsh-home-files'),
+    capturedAt: z.string().datetime(),
+    files: z.array(ArchiveFileSchema).min(1),
+    rootDigest: z.string().regex(/^[a-f0-9]{64}$/),
+}).superRefine((manifest, context) => {
+    const paths = manifest.files.map(file => file.path);
+    if (paths.some(path => !isSafePath(path) || path === MANIFEST
+        || path === RUNTIME_WRITER_LOCK_NAME || path === RUNTIME_WRITER_CLAIM_NAME)) {
+        context.addIssue({ code: 'custom', path: ['files'], message: 'unsafe archive path' });
+    }
+    if (new Set(paths).size !== paths.length || paths.join('\n') !== [...paths].sort(comparePath).join('\n')) {
+        context.addIssue({ code: 'custom', path: ['files'], message: 'archive paths must be unique and sorted' });
+    }
+    if (manifest.rootDigest !== digestFiles(manifest.files)) {
+        context.addIssue({ code: 'custom', path: ['rootDigest'], message: 'archive root digest mismatch' });
+    }
+});
+export async function exportHomeArchive(sourceRoot, destination) {
+    const source = resolve(sourceRoot);
+    const target = resolve(destination);
+    await requireRealDirectory(source);
+    requireOutside(source, target);
+    await requireAbsent(target);
+    await mkdir(dirname(target), { recursive: true });
+    const stage = await mkdtemp(join(dirname(target), `.${basename(target)}.stage-`));
+    try {
+        const files = await scanFiles(source, true);
+        if (files.length === 0)
+            throw new Error('Home root has no files to archive');
+        if (files.some(file => file.path === MANIFEST)) {
+            throw new Error(`Home root contains reserved archive filename: ${MANIFEST}`);
+        }
+        for (const file of files) {
+            const output = join(stage, file.path);
+            await mkdir(dirname(output), { recursive: true });
+            await copyFile(join(source, file.path), output);
+        }
+        const stagedFiles = await scanFiles(stage);
+        if (JSON.stringify(stagedFiles) !== JSON.stringify(files)
+            || JSON.stringify(await scanFiles(source, true)) !== JSON.stringify(files)) {
+            throw new Error('Home files changed during archive export');
+        }
+        const manifest = HomeArchiveManifestSchema.parse({
+            schemaVersion: 1, kind: 'bizagent-dsh-home-files', capturedAt: new Date().toISOString(),
+            files, rootDigest: digestFiles(files),
+        });
+        await writeFile(join(stage, MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`, { flag: 'wx' });
+        await verifyHomeArchive(stage);
+        await requireAbsent(target);
+        await rename(stage, target);
+        return manifest;
+    }
+    catch (error) {
+        await rm(stage, { recursive: true, force: true });
+        throw error;
+    }
+}
+export async function verifyHomeArchive(archiveRoot) {
+    const root = resolve(archiveRoot);
+    await requireRealDirectory(root);
+    const manifest = HomeArchiveManifestSchema.parse(JSON.parse(await readFile(join(root, MANIFEST), 'utf8')));
+    const actual = (await scanFiles(root)).filter(file => file.path !== MANIFEST);
+    if (JSON.stringify(actual) !== JSON.stringify(manifest.files)) {
+        throw new Error('Home archive file list, size, or SHA-256 mismatch');
+    }
+    return manifest;
+}
+export async function importHomeArchive(archiveRoot, destinationRoot) {
+    const archive = resolve(archiveRoot);
+    const target = resolve(destinationRoot);
+    const manifest = await verifyHomeArchive(archive);
+    requireOutside(archive, target);
+    await requireAbsent(target);
+    await mkdir(dirname(target), { recursive: true });
+    const stage = await mkdtemp(join(dirname(target), `.${basename(target)}.stage-`));
+    try {
+        for (const file of manifest.files) {
+            const output = join(stage, file.path);
+            await mkdir(dirname(output), { recursive: true });
+            await copyFile(join(archive, file.path), output);
+        }
+        if (JSON.stringify(await scanFiles(stage)) !== JSON.stringify(manifest.files)) {
+            throw new Error('Home archive changed during import');
+        }
+        const store = new HomeStore(stage);
+        await store.initialize();
+        const report = await store.doctor();
+        if (!report.ok)
+            throw new Error(`Imported Home files failed doctor: ${report.issues.join('; ')}`);
+        await requireAbsent(target);
+        await rename(stage, target);
+        return manifest;
+    }
+    catch (error) {
+        await rm(stage, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function scanFiles(root, excludeWriterLock = false) {
+    const files = [];
+    async function visit(directory) {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            if (excludeWriterLock && directory === root
+                && [RUNTIME_WRITER_LOCK_NAME, RUNTIME_WRITER_CLAIM_NAME].includes(entry.name))
+                continue;
+            const path = join(directory, entry.name);
+            const info = await lstat(path);
+            if (info.isSymbolicLink())
+                throw new Error(`Home archive rejects symlinks: ${relative(root, path)}`);
+            if (info.isDirectory()) {
+                await visit(path);
+            }
+            else if (info.isFile()) {
+                const name = relative(root, path).split('\\').join('/');
+                if (!isSafePath(name))
+                    throw new Error(`unsafe Home archive path: ${name}`);
+                const bytes = await readFile(path);
+                files.push({ path: name, bytes: bytes.length, sha256: sha256(bytes) });
+            }
+            else {
+                throw new Error(`Home archive rejects non-file entry: ${relative(root, path)}`);
+            }
+        }
+    }
+    await visit(root);
+    return files.sort((a, b) => comparePath(a.path, b.path));
+}
+function comparePath(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function isSafePath(path) {
+    return !isAbsolute(path) && !path.includes('\\') && !path.includes('\0')
+        && path.split('/').every(part => part !== '' && part !== '.' && part !== '..');
+}
+function digestFiles(files) {
+    return sha256(JSON.stringify(files.map(file => [file.path, file.bytes, file.sha256])));
+}
+function sha256(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+async function requireRealDirectory(path) {
+    const info = await lstat(path);
+    if (!info.isDirectory() || await realpath(path) !== path)
+        throw new Error(`expected a real directory: ${path}`);
+}
+async function requireAbsent(path) {
+    try {
+        await lstat(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    throw new Error(`destination already exists: ${path}`);
+}
+function requireOutside(source, target) {
+    const rel = relative(source, target);
+    if (rel === '' || (!rel.startsWith('..') && !isAbsolute(rel))) {
+        throw new Error('archive destination must be outside the source directory');
+    }
+}
+//# sourceMappingURL=home-archive.js.map

package/lib/home-directory.d.ts

@@ -0,0 +1,6 @@
+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;
+//# sourceMappingURL=home-directory.d.ts.map

package/lib/home-directory.js

@@ -0,0 +1,38 @@
+import { isHomeAddress } from './domain.js';
+function normalize(value) {
+    return value.normalize('NFKC').trim().toLowerCase();
+}
+export function visibleHomeDirectory(homes, primaryHome) {
+    return homes
+        .filter(home => home.status === 'active' && (home.type !== 'personal' || home.address === primaryHome))
+        .map(({ address, type, displayName }) => ({ address, type, displayName }))
+        .sort((a, b) => a.address.localeCompare(b.address));
+}
+export function searchHomeDirectory(homes, primaryHome, query = '', limit = 20) {
+    const needle = normalize(query);
+    return visibleHomeDirectory(homes, primaryHome)
+        .filter(home => !needle || normalize(home.address).includes(needle)
+        || normalize(home.displayName).includes(needle) || normalize(home.type).includes(needle))
+        .slice(0, limit);
+}
+export function resolveHomeDirectoryTarget(homes, primaryHome, target) {
+    const visible = visibleHomeDirectory(homes, primaryHome);
+    const name = normalize(target);
+    if (!name)
+        throw new Error('Home not found or inaccessible');
+    // Canonical addresses take precedence over a Home with the same display name.
+    const address = target.trim();
+    if (isHomeAddress(address)) {
+        if (visible.some(home => home.address === address))
+            return address;
+        throw new Error('Home not found or inaccessible');
+    }
+    const matches = visible.filter(home => normalize(home.displayName) === name);
+    if (matches.length === 1)
+        return matches[0].address;
+    if (matches.length > 1) {
+        throw new Error(`ambiguous Home name; use a canonical address: ${matches.map(home => home.address).join(', ')}`);
+    }
+    throw new Error('Home not found or inaccessible');
+}
+//# sourceMappingURL=home-directory.js.map

package/lib/home-space.d.ts

@@ -0,0 +1,50 @@
+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;
+}
+//# sourceMappingURL=home-space.d.ts.map

package/lib/home-space.js

@@ -0,0 +1,120 @@
+import { parseHomeAddress } from './domain.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 class HomeSpace {
+    personal;
+    organizationStore;
+    constructor(personal, organizationStore) {
+        this.personal = personal;
+        this.organizationStore = organizationStore;
+    }
+    /** Where organization-wide records live: the organization root, or the personal space without one. */
+    get root() { return (this.organizationStore ?? this.personal).root; }
+    get personalRoot() { return this.personal.root; }
+    get organizationRoot() { return this.organizationStore?.root; }
+    async initialize() {
+        await this.personal.initialize();
+        await this.organizationStore?.initialize();
+    }
+    async reload() {
+        await this.personal.reload();
+        await this.organizationStore?.reload();
+    }
+    /** The same personal space with another organization (or none) beside it. */
+    withOrganization(organizationStore) {
+        return new HomeSpace(this.personal, organizationStore);
+    }
+    /** The root of the store that holds this Home; its snapshots and records belong there. */
+    rootFor(address) { return this.storeFor(address).root; }
+    /** A Home from the personal space, outside any organization. */
+    isPersonalHome(address) {
+        return this.findStore(address) === this.personal;
+    }
+    listHomes() {
+        const organizationHomes = this.organizationStore?.listHomes() ?? [];
+        const shadowed = new Set(organizationHomes.map(home => home.address));
+        return [...organizationHomes, ...this.personal.listHomes().filter(home => !shadowed.has(home.address))]
+            .sort((a, b) => a.address.localeCompare(b.address));
+    }
+    hasHome(address) { return this.findStore(address) !== undefined; }
+    getHome(address) { return this.storeFor(address).getHome(address); }
+    findHome(address) { return this.findStore(address)?.findHome(address); }
+    homeWorkspacePath(address) { return this.storeFor(address).homeWorkspacePath(address); }
+    readInboxWakePolicy(address) {
+        return this.storeFor(address).readInboxWakePolicy(address);
+    }
+    getIdentity(address) { return this.storeFor(address).getIdentity(address); }
+    /** The active organization; before organizations had their own folder it could sit in the data root itself. */
+    getOrganization() {
+        return (this.organizationStore ?? this.personal).getOrganization();
+    }
+    /** New Homes join the active organization unless the personal space is asked for. */
+    async createHome(input, target = 'organization') {
+        const store = target === 'personal' ? this.personal : this.organizationStore ?? this.personal;
+        const other = store === this.personal ? this.organizationStore : this.personal;
+        if (other?.hasHome(input.address)) {
+            throw new Error(`Agent Home already exists outside this ${target === 'personal' ? 'personal space' : 'organization'}: ${input.address}`);
+        }
+        return store.createHome(input);
+    }
+    listAssets(address, status) {
+        return this.storeFor(address).listAssets(address, status);
+    }
+    searchAssets(address, input = {}) {
+        return this.storeFor(address).searchAssets(address, input);
+    }
+    readAsset(address, id) { return this.storeFor(address).readAsset(address, id); }
+    findAssetByProposalId(address, proposalId) {
+        return this.storeFor(address).findAssetByProposalId(address, proposalId);
+    }
+    createAsset(input) {
+        return this.storeFor(input.ownerAddress).createAsset(input);
+    }
+    updateAsset(address, id, input) {
+        return this.storeFor(address).updateAsset(address, id, input);
+    }
+    contextFor(address, budget, episodeCount = 0) {
+        return this.storeFor(address).contextFor(address, budget, episodeCount);
+    }
+    contextForFrame(address, budget) {
+        return this.storeFor(address).contextForFrame(address, budget);
+    }
+    async doctor() {
+        const personal = await this.personal.doctor();
+        if (this.organizationStore === undefined)
+            return personal;
+        const organization = await this.organizationStore.doctor();
+        const shadowed = this.personal.listHomes()
+            .filter(home => this.organizationStore.hasHome(home.address))
+            .map(home => `personal Home ${home.address} is hidden by the organization Home with the same address`);
+        const issues = [...organization.issues, ...personal.issues.map(issue => `personal space: ${issue}`), ...shadowed];
+        return {
+            ok: issues.length === 0,
+            root: organization.root,
+            homeCount: this.listHomes().length,
+            assetCount: organization.assetCount + personal.assetCount,
+            issues,
+        };
+    }
+    findStore(address) {
+        let parsed;
+        try {
+            parsed = parseHomeAddress(address);
+        }
+        catch {
+            return undefined;
+        }
+        if (this.organizationStore?.hasHome(parsed))
+            return this.organizationStore;
+        return this.personal.hasHome(parsed) ? this.personal : undefined;
+    }
+    /** Throws the store's own unknown-Home error when no store holds the address. */
+    storeFor(address) {
+        return this.findStore(address) ?? this.organizationStore ?? this.personal;
+    }
+}
+//# sourceMappingURL=home-space.js.map

package/lib/home-store.d.ts

@@ -0,0 +1,126 @@
+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>;
+//# sourceMappingURL=home-store.d.ts.map