@takboo/dsh-session-bin 0.0.0-stage → 0.1.0

package/dist/host/native-jsonl-files.d.ts

@@ -0,0 +1,198 @@
+import type { SessionHeader } from '@deepseek-ai/dsh-session';
+import { z } from 'zod';
+declare const fileRowSchema: z.ZodObject<{
+    resourceId: z.ZodString;
+    kind: z.ZodEnum<{
+        generation: "generation";
+        staging: "staging";
+    }>;
+    formatVersion: z.ZodNumber;
+    compression: z.ZodEnum<{
+        none: "none";
+        zstd: "zstd";
+    }>;
+    identity: z.ZodObject<{
+        dev: z.ZodString;
+        ino: z.ZodString;
+        birthtimeNs: z.ZodString;
+        size: z.ZodString;
+        mtimeNs: z.ZodString;
+        ctimeNs: z.ZodString;
+        nlink: z.ZodLiteral<"1">;
+    }, z.core.$strict>;
+    digest: z.ZodString;
+    header: z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodNumber;
+        cwd: z.ZodNullable<z.ZodString>;
+        parentSession: z.ZodNullable<z.ZodString>;
+        origin: z.ZodNullable<z.ZodLiteral<"subagent">>;
+        isSeeded: z.ZodBoolean;
+        delegationDepth: z.ZodNumber;
+        agentPreset: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    revision: z.ZodString;
+}, z.core.$strict>;
+export declare const nativeJsonlFileSchema: z.ZodObject<{
+    resourceId: z.ZodString;
+    kind: z.ZodEnum<{
+        generation: "generation";
+        staging: "staging";
+    }>;
+    formatVersion: z.ZodNumber;
+    compression: z.ZodEnum<{
+        none: "none";
+        zstd: "zstd";
+    }>;
+    identity: z.ZodObject<{
+        dev: z.ZodString;
+        ino: z.ZodString;
+        birthtimeNs: z.ZodString;
+        size: z.ZodString;
+        mtimeNs: z.ZodString;
+        ctimeNs: z.ZodString;
+        nlink: z.ZodLiteral<"1">;
+    }, z.core.$strict>;
+    digest: z.ZodString;
+    header: z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodNumber;
+        cwd: z.ZodNullable<z.ZodString>;
+        parentSession: z.ZodNullable<z.ZodString>;
+        origin: z.ZodNullable<z.ZodLiteral<"subagent">>;
+        isSeeded: z.ZodBoolean;
+        delegationDepth: z.ZodNumber;
+        agentPreset: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    revision: z.ZodString;
+}, z.core.$strict>;
+export declare const nativeJsonlInventorySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    root: z.ZodString;
+    rootIdentity: z.ZodObject<{
+        dev: z.ZodString;
+        ino: z.ZodString;
+        birthtimeNs: z.ZodString;
+    }, z.core.$strict>;
+    directory: z.ZodString;
+    directoryIdentity: z.ZodObject<{
+        dev: z.ZodString;
+        ino: z.ZodString;
+        birthtimeNs: z.ZodString;
+    }, z.core.$strict>;
+    sessionId: z.ZodString;
+    compression: z.ZodEnum<{
+        none: "none";
+        zstd: "zstd";
+    }>;
+    header: z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodNumber;
+        cwd: z.ZodNullable<z.ZodString>;
+        parentSession: z.ZodNullable<z.ZodString>;
+        origin: z.ZodNullable<z.ZodLiteral<"subagent">>;
+        isSeeded: z.ZodBoolean;
+        delegationDepth: z.ZodNumber;
+        agentPreset: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    anchor: z.ZodObject<{
+        resourceId: z.ZodString;
+        identity: z.ZodObject<{
+            dev: z.ZodString;
+            ino: z.ZodString;
+            birthtimeNs: z.ZodString;
+        }, z.core.$strict>;
+        header: z.ZodObject<{
+            id: z.ZodString;
+            createdAt: z.ZodNumber;
+            cwd: z.ZodNullable<z.ZodString>;
+            parentSession: z.ZodNullable<z.ZodString>;
+            origin: z.ZodNullable<z.ZodLiteral<"subagent">>;
+            isSeeded: z.ZodBoolean;
+            delegationDepth: z.ZodNumber;
+            agentPreset: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    lock: z.ZodUnion<readonly [z.ZodObject<{
+        dev: z.ZodString;
+        ino: z.ZodString;
+        birthtimeNs: z.ZodString;
+        size: z.ZodLiteral<"0">;
+        nlink: z.ZodLiteral<"1">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"win32-semaphore">;
+        name: z.ZodString;
+    }, z.core.$strict>]>;
+    files: z.ZodArray<z.ZodObject<{
+        resourceId: z.ZodString;
+        kind: z.ZodEnum<{
+            generation: "generation";
+            staging: "staging";
+        }>;
+        formatVersion: z.ZodNumber;
+        compression: z.ZodEnum<{
+            none: "none";
+            zstd: "zstd";
+        }>;
+        identity: z.ZodObject<{
+            dev: z.ZodString;
+            ino: z.ZodString;
+            birthtimeNs: z.ZodString;
+            size: z.ZodString;
+            mtimeNs: z.ZodString;
+            ctimeNs: z.ZodString;
+            nlink: z.ZodLiteral<"1">;
+        }, z.core.$strict>;
+        digest: z.ZodString;
+        header: z.ZodObject<{
+            id: z.ZodString;
+            createdAt: z.ZodNumber;
+            cwd: z.ZodNullable<z.ZodString>;
+            parentSession: z.ZodNullable<z.ZodString>;
+            origin: z.ZodNullable<z.ZodLiteral<"subagent">>;
+            isSeeded: z.ZodBoolean;
+            delegationDepth: z.ZodNumber;
+            agentPreset: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        revision: z.ZodString;
+    }, z.core.$strict>>;
+    revision: z.ZodString;
+}, z.core.$strict>;
+export type NativeJsonlInventory = z.infer<typeof nativeJsonlInventorySchema>;
+export type NativeJsonlFileRow = z.infer<typeof fileRowSchema>;
+type Encoding = 'none' | 'zstd';
+export declare class NativeJsonlRefusal extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/** Exact file erasure; platform kernel leases share the audited JSONL writer namespace. */
+export declare class NativeJsonlFiles {
+    private readonly provider;
+    readonly root: string;
+    readonly compression: Encoding;
+    private readonly rootIdentity;
+    private readonly leases;
+    private constructor();
+    static open(provider: unknown): Promise<NativeJsonlFiles | undefined>;
+    inspect(sessionId: string, header: SessionHeader): Promise<NativeJsonlInventory>;
+    /** Re-enumerate the entire scope without changing its original durable anchor. */
+    current(input: NativeJsonlInventory): Promise<NativeJsonlInventory>;
+    acquire(input: NativeJsonlInventory, options?: {
+        recovering?: boolean;
+    }): Promise<{
+        release(): Promise<void>;
+    }>;
+    /** Caller must have persisted the exact retirement intent before this method. */
+    erase(input: NativeJsonlInventory, inputRow: NativeJsonlFileRow): Promise<void>;
+    private eraseInner;
+    private validate;
+    private directory;
+    private assertDirectory;
+    private lockIdentity;
+    private isWindowsErasureRemainder;
+    private rows;
+    private readRow;
+    private openFile;
+    private syncDirectory;
+}
+export {};

package/dist/host/native-retirement-admission.d.ts

@@ -0,0 +1,33 @@
+export declare class NativeAdmissionError extends Error {
+    readonly code = "native/session-busy";
+}
+/** Shared per-target mutation gates and global header/migration read barriers. */
+export declare class NativeAdmission {
+    private readonly maintenance;
+    private readonly acceptedFrames;
+    private readonly activeAcceptedFrames;
+    private readonly held;
+    private readonly released;
+    private readonly pending;
+    private readonly globalReads;
+    private readonly retired;
+    private readonly candidates;
+    private closing;
+    private failed;
+    private ready;
+    requiresRecovery(): boolean;
+    activate(): void;
+    suspend(): void;
+    beginClose(): void;
+    isRetired(id: string): boolean;
+    hasTombstones(): boolean;
+    markRetired(id: string): void;
+    private isAcceptedFrame;
+    assertAllowed(id: string): void;
+    bypass<T>(id: string, work: () => T): T;
+    withoutBypass<T>(work: () => T): T;
+    track<T>(id: string, work: () => Promise<T>): Promise<T>;
+    trackGlobal<T>(work: () => Promise<T>): Promise<T>;
+    drain(id?: string): Promise<void>;
+    acquire(id: string, recovery?: boolean): Promise<() => void>;
+}

package/dist/host/native-retirement-metadata.d.ts

@@ -0,0 +1,109 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { z } from 'zod';
+import type { LifecycleKey, RetirementRequest } from '../operations/retirement.js';
+export interface NativeMetadataAdmission {
+    assertAllowed(sessionId: string): void;
+    track<T>(sessionId: string, work: () => Promise<T>): Promise<T>;
+    trackGlobal<T>(work: () => Promise<T>): Promise<T>;
+    isRetired(sessionId: string): boolean;
+    bypass<T>(sessionId: string, work: () => T): T;
+    withoutBypass<T>(work: () => T): T;
+}
+export declare class NativeMetadataRefusal extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare const nativeMetadataSnapshotSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    global: z.ZodObject<{
+        archived: z.ZodBoolean;
+        pinned: z.ZodBoolean;
+    }, z.core.$strict>;
+    workspaces: z.ZodArray<z.ZodObject<{
+        workspaceId: z.ZodString;
+        record: z.ZodObject<{
+            path: z.ZodString;
+            title: z.ZodString;
+            sessionIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@deepseek-ai/dsh-session").SessionId, string>>>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>>;
+    cache: z.ZodObject<{
+        present: z.ZodBoolean;
+        digest: z.ZodNullable<z.ZodString>;
+        location: z.ZodNullable<z.ZodString>;
+        documentDigest: z.ZodNullable<z.ZodString>;
+        memoryDigest: z.ZodNullable<z.ZodString>;
+        physicalIdentity: z.ZodOptional<z.ZodObject<{
+            dev: z.ZodString;
+            ino: z.ZodString;
+            birthtimeNs: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    queryProvider: z.ZodEnum<{
+        none: "none";
+        "sqlite-0.2.0-rc.2": "sqlite-0.2.0-rc.2";
+        "sqlite-memory-disabled-0.2.0-rc.2": "sqlite-memory-disabled-0.2.0-rc.2";
+    }>;
+    queryPath: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type NativeMetadataSnapshot = z.infer<typeof nativeMetadataSnapshotSchema>;
+/** Version-bound metadata participant. The composition verifies package/source
+ * fingerprints before open; this adapter additionally checks concrete instance
+ * shape. It neither removes files nor writes SQLite rows. */
+export declare class NativeMetadataAdapter {
+    private readonly ctx;
+    private readonly admission;
+    private readonly workspace;
+    private readonly sessions;
+    private readonly cache;
+    private readonly query;
+    private readonly controller;
+    private readonly targets;
+    private readonly retained;
+    private readonly followers;
+    private readonly operations;
+    private readonly queueTarget;
+    private readonly receivers;
+    private readonly restores;
+    private readonly guardedMethods;
+    private readonly guardedEntities;
+    private installed;
+    private disposed;
+    private detached;
+    private fallbackRetired;
+    private readonly queryConfiguration;
+    private readonly queryProvider;
+    private readonly cacheTable;
+    private readonly cacheDirectory;
+    private moveCacheDocument;
+    private clearCacheStage;
+    private removeCacheStage;
+    private constructor();
+    private static get;
+    static open(ctx: Context, admission: NativeMetadataAdmission): Promise<NativeMetadataAdapter | undefined>;
+    private assert;
+    private tracked;
+    private increment;
+    private refuse;
+    private assertInstances;
+    private assertCold;
+    private cacheView;
+    private openCacheDocument;
+    private pathAbsent;
+    private frozenCacheBytes;
+    private eraseWindowsCache;
+    private eraseCache;
+    capture(sessionId: string): Promise<NativeMetadataSnapshot>;
+    private captureInner;
+    private wrap;
+    private guardEntity;
+    private guardedObservation;
+    install(): Promise<() => Promise<void>>;
+    /** The verified owner completes all asynchronous takeover work before this
+     * synchronous restoration and installs its successor guards without yielding. */
+    forceRestore(): void;
+    converge(input: NativeMetadataSnapshot, expected: LifecycleKey, request: RetirementRequest): Promise<boolean>;
+}

package/dist/host/native-retirement-owner.d.ts

@@ -0,0 +1,305 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { z } from 'zod';
+import type { RetirementOwnerCoordinatorOptions } from './retirement-owner.js';
+import type { LifecycleKey, RetirementCapabilities, RetirementManifest, RetirementRequest, RetirementAuthorization, RetirementState } from '../operations/retirement.js';
+import type { SessionRetirementOwnerV1 } from './retirement.js';
+export declare const nativeRetirementDomainSpec: {
+    readonly name: "session_bin_jsonl_resources";
+    readonly version: 1;
+    readonly layout: "single";
+    readonly global: {
+        readonly schema: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            storeId: z.ZodNullable<z.ZodUUID>;
+            root: z.ZodNullable<z.ZodString>;
+            fingerprint: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        readonly initial: {
+            readonly schemaVersion: 1;
+            readonly storeId: null;
+            readonly root: null;
+            readonly fingerprint: null;
+        };
+    };
+    readonly tables: {
+        readonly witnesses: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1;
+            lifecycle: {
+                storeId: string;
+                sessionId: string;
+                lifecycleId: string;
+            };
+            inventory: {
+                schemaVersion: 1;
+                root: string;
+                rootIdentity: {
+                    dev: string;
+                    ino: string;
+                    birthtimeNs: string;
+                };
+                directory: string;
+                directoryIdentity: {
+                    dev: string;
+                    ino: string;
+                    birthtimeNs: string;
+                };
+                sessionId: string;
+                compression: "none" | "zstd";
+                header: {
+                    id: string;
+                    createdAt: number;
+                    cwd: string | null;
+                    parentSession: string | null;
+                    origin: "subagent" | null;
+                    isSeeded: boolean;
+                    delegationDepth: number;
+                    agentPreset: string | null;
+                };
+                anchor: {
+                    resourceId: string;
+                    identity: {
+                        dev: string;
+                        ino: string;
+                        birthtimeNs: string;
+                    };
+                    header: {
+                        id: string;
+                        createdAt: number;
+                        cwd: string | null;
+                        parentSession: string | null;
+                        origin: "subagent" | null;
+                        isSeeded: boolean;
+                        delegationDepth: number;
+                        agentPreset: string | null;
+                    };
+                };
+                lock: {
+                    dev: string;
+                    ino: string;
+                    birthtimeNs: string;
+                    size: "0";
+                    nlink: "1";
+                } | {
+                    kind: "win32-semaphore";
+                    name: string;
+                };
+                files: {
+                    resourceId: string;
+                    kind: "generation" | "staging";
+                    formatVersion: number;
+                    compression: "none" | "zstd";
+                    identity: {
+                        dev: string;
+                        ino: string;
+                        birthtimeNs: string;
+                        size: string;
+                        mtimeNs: string;
+                        ctimeNs: string;
+                        nlink: "1";
+                    };
+                    digest: string;
+                    header: {
+                        id: string;
+                        createdAt: number;
+                        cwd: string | null;
+                        parentSession: string | null;
+                        origin: "subagent" | null;
+                        isSeeded: boolean;
+                        delegationDepth: number;
+                        agentPreset: string | null;
+                    };
+                    revision: string;
+                }[];
+                revision: string;
+            };
+            metadata: {
+                schemaVersion: 1;
+                sessionId: string;
+                global: {
+                    archived: boolean;
+                    pinned: boolean;
+                };
+                workspaces: {
+                    workspaceId: string;
+                    record: {
+                        path: string;
+                        title: string;
+                        sessionIds: SessionId[];
+                        createdAt: string;
+                        updatedAt: string;
+                    };
+                }[];
+                cache: {
+                    present: boolean;
+                    digest: string | null;
+                    location: string | null;
+                    documentDigest: string | null;
+                    memoryDigest: string | null;
+                    physicalIdentity?: {
+                        dev: string;
+                        ino: string;
+                        birthtimeNs: string;
+                    } | undefined;
+                };
+                queryProvider: "none" | "sqlite-0.2.0-rc.2" | "sqlite-memory-disabled-0.2.0-rc.2";
+                queryPath: string | null;
+            };
+        }>;
+    };
+};
+export declare const nativeRetirementOwnerDomainSpec: {
+    readonly name: "session_bin_jsonl_retirement_owner";
+    readonly version: 1;
+    readonly layout: "single";
+    readonly global: {
+        readonly schema: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            capabilities: z.ZodNullable<z.ZodObject<{
+                protocolVersion: z.ZodLiteral<1>;
+                ownerId: z.ZodString;
+                hostVersion: z.ZodString;
+                providerId: z.ZodString;
+                storeId: z.ZodString;
+                participants: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly initial: {
+            readonly schemaVersion: 1;
+            readonly capabilities: null;
+        };
+    };
+    readonly tables: {
+        readonly operations: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            schemaVersion: 1;
+            state: {
+                schemaVersion: 1;
+                request: {
+                    operationId: string;
+                    expected: {
+                        storeId: string;
+                        sessionId: string;
+                        lifecycleId: string;
+                    };
+                    bin: {
+                        entryId: string;
+                        entryVersion: 1;
+                    } | {
+                        kind: "native-archive";
+                        entryId: string;
+                        entryVersion: 2;
+                    };
+                    manifestDigest: string;
+                };
+                manifest: {
+                    schemaVersion: 1;
+                    lifecycle: {
+                        storeId: string;
+                        sessionId: string;
+                        lifecycleId: string;
+                    };
+                    capabilities: {
+                        protocolVersion: 1;
+                        ownerId: string;
+                        hostVersion: string;
+                        providerId: string;
+                        storeId: string;
+                        participants: {
+                            id: string;
+                            version: string;
+                        }[];
+                    };
+                    resources: {
+                        ownerId: string;
+                        resourceId: string;
+                        revision: string;
+                        kind: "transcript" | "workspace" | "index" | "cache" | "attachment" | "spill" | "coordination";
+                        disposition: "erase" | "release-reference" | "retain-shared" | "retain-coordination";
+                        retention: {
+                            reason: "shared-reference" | "coordination-identity";
+                            retainedBy: {
+                                storeId: string;
+                                sessionId: string;
+                                lifecycleId: string;
+                            }[];
+                        } | null;
+                    }[];
+                };
+                authorizationId: string | null;
+                phase: "rejected" | "conflict" | "done" | "fenced" | "quiesced" | "erasing" | "converging";
+                reason: string | null;
+                resources: {
+                    ownerId: string;
+                    resourceId: string;
+                    status: "erased" | "reference-released" | "retained" | "failed";
+                    reason: string | null;
+                }[];
+            };
+            participants: {
+                id: string;
+                version: string;
+                fenced: boolean;
+                quiesced: boolean;
+                converged: boolean;
+            }[];
+            lifecycleQuiesced: boolean;
+            lifecycleFinalized: boolean;
+            blockedReason: string | null;
+        }>;
+    };
+};
+export interface NativeRetirementOptions {
+    /** Independent composition qualification, used by isolated candidate-platform fixtures.
+     * The production Service never takes this callback from Host configuration. */
+    platformQualification?: (runtime: {
+        platform: NodeJS.Platform;
+        arch: string;
+        node: string;
+    }) => boolean;
+    checkpoint?: RetirementOwnerCoordinatorOptions['checkpoint'];
+    canAdvance?: RetirementOwnerCoordinatorOptions['canAdvance'];
+}
+/** Actual native log erasure, limited to the audited cold JSONL/Workspace composition. */
+export declare class NativeRetirementOwner implements SessionRetirementOwnerV1 {
+    private readonly ctx;
+    private readonly files;
+    private readonly metadata;
+    private readonly admission;
+    private readonly domain;
+    private readonly journal;
+    private readonly scopes;
+    private readonly coordinator;
+    private readonly descriptor;
+    private readonly provider;
+    private readonly originalProvider;
+    private readonly restore;
+    private readonly observations;
+    private fullyClosed;
+    private observationsClosed;
+    private closing;
+    private constructor();
+    static open(ctx: Context, options?: NativeRetirementOptions): Promise<NativeRetirementOwner | undefined>;
+    capabilities(): Promise<RetirementCapabilities>;
+    eligibility(id: string): Promise<string | null>;
+    private eligibilityInner;
+    inspect(id: string): Promise<LifecycleKey | null>;
+    private inspectInner;
+    prepare(expected: LifecycleKey): Promise<RetirementManifest>;
+    retire(request: RetirementRequest, authorize: () => Promise<RetirementAuthorization>, manifest?: RetirementManifest): Promise<RetirementState>;
+    getOperation(id: string): Promise<RetirementState | null>;
+    recover(id: string): Promise<RetirementState>;
+    private acquire;
+    private observe;
+    private fileParticipant;
+    private metadataParticipant;
+    private requireScope;
+    private witness;
+    private putWitness;
+    private read;
+    private io;
+    private relinquishGuards;
+    close(): Promise<void>;
+}

package/dist/host/native-retirement-persistence.d.ts

@@ -0,0 +1,24 @@
+import type { SessionPersistence, SessionPersistenceSnapshot } from '@deepseek-ai/dsh-session-persistence';
+import { NativeAdmission } from './native-retirement-admission.js';
+export declare function nativeServiceInstance<T extends object>(value: T): T;
+/** Version-bound instance Adapter. It never patches prototypes or other Hosts. */
+export declare class NativePersistenceAdapter {
+    private readonly provider;
+    private readonly admission;
+    private readonly raw;
+    private originalStat;
+    private originalList;
+    private readonly restore;
+    private detached;
+    private active;
+    private readonly managedHandles;
+    constructor(provider: SessionPersistence, admission: NativeAdmission);
+    stat(id: string): Promise<SessionPersistenceSnapshot | undefined>;
+    list(): Promise<readonly SessionPersistenceSnapshot[]>;
+    busy(id: string): boolean;
+    forget(id: string): void;
+    install(): () => Promise<void>;
+    forceRestore(): void;
+    private originalRetired;
+    private manage;
+}