@wowyuarm/dsh-agent-team 0.1.12 → 0.1.13

package/packages/agent-team/lib/types/vendor/storage-sqlite/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Vendored fork of `@deepseek-ai/dsh-storage-sqlite` (`index.ts`).
+ *
+ * Source: deepseek-ai/deepseek-harness
+ * `packages/storage/storage-sqlite/src/index.ts` at version 0.1.5-rc.2
+ * (MIT per that version's package metadata and the repo root LICENSE;
+ * the stale npm `latest` tag 0.0.1-rc.1 carries BSD-3-Clause metadata).
+ * Kept identical except the `@module` tag below.
+ *
+ * Why vendored instead of depended on: DSH Desktop generation installers
+ * strip `@deepseek-ai/*` copies and resolve them from the host closure,
+ * which ships no `dsh-storage-sqlite` — a loader row naming that package
+ * blocks boot (GitHub issue #28). Resolving from our own package survives
+ * that boundary. Sync procedure: diff against the upstream file on every
+ * DSH compat round (see docs/dsh-release-compatibility.md).
+ */
+/**
+ * SQLite storage backend for the storage hub: one database file hosts every
+ * routed unit, document-per-row (`key TEXT` / `value TEXT` JSON). Registers
+ * as backend `sqlite`; the disposer unregisters first, then closes the medium.
+ * @module @wowyuarm/dsh-agent-team/sqlite-backend
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { KvFacet, StorageBackend } from '@deepseek-ai/dsh-storage';
+import { type JournalMode } from './schema.ts';
+export { STORAGE_SQLITE_SCHEMA_VERSION, type JournalMode } from './schema.ts';
+/** Cordis plugin name. */
+export declare const name = "storage-sqlite";
+/** The backend registers on the storage hub. */
+export declare const inject: string[];
+/** Plugin configuration. */
+export interface Config {
+    /**
+     * Filesystem path to the SQLite database file. The special value `:memory:`
+     * opens an in-process database (tests). On filesystems with POSIX modes,
+     * missing directories and databases are created owner-only; existing path
+     * modes are preserved. Filesystem setup errors other than an existing
+     * database fail the open. The backend does not protect confidentiality or
+     * integrity when another principal can replace the database entry in its
+     * parent directory.
+     */
+    path: string;
+    /**
+     * SQLite `journal_mode` pragma. `wal` (the default) suits local disks; pick
+     * a rollback-journal mode (`delete`/`truncate`/`persist`) on filesystems
+     * where WAL's shared-memory files do not work (network mounts). See
+     * {@link JournalMode}.
+     */
+    journalMode?: JournalMode;
+}
+/** Schemastery validator for {@link Config}. */
+export declare const Config: z<Config>;
+/**
+ * The SQLite {@link StorageBackend}. Owns one `DatabaseSync` connection and
+ * the open-unit table; `kv.open` validates names, enforces the per-unit
+ * version stamp in `units`, and ensures the unit's record tables.
+ */
+export declare class SqliteStorageBackend implements StorageBackend {
+    /** The key-value facet; the only shape this backend serves. */
+    readonly kv: KvFacet;
+    private readonly ready;
+    /** Open (or still-opening) units by name; presence is the double-open guard. */
+    private readonly units;
+    private closing;
+    /**
+     * @param config - Validated plugin configuration.
+     */
+    constructor(config: Config);
+    private openUnit;
+    private materializeUnit;
+    /**
+     * Close every open unit and release the database. Idempotent; concurrent
+     * and repeated calls resolve once teardown finishes.
+     * @returns resolution after the medium is released.
+     */
+    close(): Promise<void>;
+    private doClose;
+}
+/**
+ * Register the SQLite backend as `sqlite` on the storage hub. The disposer
+ * unregisters the name first, then closes the backend.
+ * @param ctx - Plugin context (must inject `storage`).
+ * @param config - Validated plugin configuration.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/packages/agent-team/lib/types/vendor/storage-sqlite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/vendor/storage-sqlite/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,CAAC,MAAM,0BAA0B,CAAA;AAGxC,OAAO,KAAK,EAAE,OAAO,EAA4B,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACjG,OAAO,EAAiC,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAG7E,OAAO,EAAE,6BAA6B,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAE7E,0BAA0B;AAC1B,eAAO,MAAM,IAAI,mBAAmB,CAAA;AACpC,gDAAgD;AAChD,eAAO,MAAM,MAAM,UAAc,CAAA;AAEjC,4BAA4B;AAC5B,MAAM,WAAW,MAAM;IACrB;;;;;;;;OAQG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;;;;OAKG;IACH,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,gDAAgD;AAChD,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,MAAM,CAG3B,CAAA;AAEF;;;;GAIG;AACH,qBAAa,oBAAqB,YAAW,cAAc;IACzD,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAoD;IAExE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuB;IAC7C,gFAAgF;IAChF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2C;IACjE,OAAO,CAAC,OAAO,CAA2B;IAE1C;;OAEG;gBACS,MAAM,EAAE,MAAM;IAQ1B,OAAO,CAAC,QAAQ;YAuBF,eAAe;IA2B7B;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAKR,OAAO;CAetB;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAUjD"}

package/packages/agent-team/lib/types/vendor/storage-sqlite/schema.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Vendored fork of `@deepseek-ai/dsh-storage-sqlite` (`schema.ts`).
+ *
+ * Source: deepseek-ai/deepseek-harness
+ * `packages/storage/storage-sqlite/src/schema.ts` at version 0.1.5-rc.2
+ * (MIT per that version's package metadata and the repo root LICENSE;
+ * the stale npm `latest` tag 0.0.1-rc.1 carries BSD-3-Clause metadata).
+ * Kept identical except the `@module` tag below.
+ *
+ * Why vendored instead of depended on: DSH Desktop generation installers
+ * strip `@deepseek-ai/*` copies and resolve them from the host closure,
+ * which ships no `dsh-storage-sqlite` — a loader row naming that package
+ * blocks boot (GitHub issue #28). Resolving from our own package survives
+ * that boundary. Sync procedure: diff against the upstream file on every
+ * DSH compat round (see docs/dsh-release-compatibility.md).
+ */
+/**
+ * Schema + open-time helpers for the SQLite storage backend: the physical
+ * layout version, the database open/configure sequence (permissions, pragmas,
+ * version stamp/reject), and the unit metadata tables. Unit record tables are
+ * created per descriptor in `unit.ts`.
+ * @module @wowyuarm/dsh-agent-team/sqlite-backend/schema
+ */
+import { DatabaseSync } from 'node:sqlite';
+/**
+ * The on-disk physical layout version, stored in `PRAGMA user_version`.
+ * Orthogonal to each unit's own `version` (stamped per unit in the `units`
+ * row). Bumped only on a breaking change to the table layout; any other
+ * stamped version rejects — this unreleased format has no migrations.
+ */
+export declare const STORAGE_SQLITE_SCHEMA_VERSION = 1;
+/**
+ * Journal modes the backend will run under. `wal` is the default; the
+ * rollback-journal modes (`delete`/`truncate`/`persist`) exist for
+ * filesystems where WAL's shared-memory files do not work (network mounts).
+ * `memory`/`off` are excluded: dropping journal durability silently
+ * contradicts the durability clause of the KV backend contract.
+ */
+export type JournalMode = 'wal' | 'delete' | 'truncate' | 'persist';
+/**
+ * Open the database and apply its schema and pragmas. Missing directories and
+ * database files are created owner-only (`:memory:` skips filesystem setup).
+ * A zero `user_version` is stamped with {@link STORAGE_SQLITE_SCHEMA_VERSION};
+ * every other non-current version rejects rather than being migrated in place.
+ * @param path - the SQLite database file to open, or `:memory:`.
+ * @param journalMode - validated journal pragma.
+ * @returns the open handle with pragmas applied and the unit metadata tables ensured.
+ */
+export declare function openDatabase(path: string, journalMode: JournalMode): Promise<DatabaseSync>;
+/**
+ * Physical table name for one unit table. Both segments are validated against
+ * `UNIT_NAME_RE` before reaching this, so the result is safe to interpolate
+ * into DDL and prepared-statement text.
+ * @param unit - Validated unit name.
+ * @param table - Validated table name.
+ * @returns the `u_<unit>_<table>` identifier.
+ */
+export declare function recordTableName(unit: string, table: string): string;
+//# sourceMappingURL=schema.d.ts.map

package/packages/agent-team/lib/types/vendor/storage-sqlite/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/vendor/storage-sqlite/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAK1C;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,IAAI,CAAA;AAE9C;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAA;AAsBnE;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAchG;AAmCD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnE"}

package/packages/agent-team/lib/types/vendor/storage-sqlite/unit.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Vendored fork of `@deepseek-ai/dsh-storage-sqlite` (`unit.ts`).
+ *
+ * Source: deepseek-ai/deepseek-harness
+ * `packages/storage/storage-sqlite/src/unit.ts` at version 0.1.5-rc.2
+ * (MIT per that version's package metadata and the repo root LICENSE;
+ * the stale npm `latest` tag 0.0.1-rc.1 carries BSD-3-Clause metadata).
+ * Kept identical except the `@module` tag below — see `index.ts` for why
+ * this backend is vendored and how to sync it.
+ */
+/**
+ * One opened SQLite KV unit: prepared per-table statements over the
+ * `u_<unit>_<table>` record tables plus this unit's row in the shared
+ * `unit_globals` table. Each primitive is a single statement, so atomicity
+ * comes from SQLite itself — no explicit transactions, and no write queue
+ * (write ordering is the caller's responsibility per the KV contract).
+ * @module @wowyuarm/dsh-agent-team/sqlite-backend/unit
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { KvUnit, KvUnitDescriptor } from '@deepseek-ai/dsh-storage';
+/**
+ * The SQLite {@link KvUnit}. Constructed by the backend AFTER the unit's
+ * record tables exist; statements are prepared once here and reused for every
+ * primitive. Values are stored as JSON text in the `value` column.
+ */
+export declare class SqliteKvUnit implements KvUnit {
+    private readonly descriptor;
+    private readonly onClose;
+    private readonly tables;
+    private readonly globalUpsert;
+    private readonly globalSelect;
+    private closed;
+    /**
+     * @param db - Open database handle owned by the backend (never closed here).
+     * @param descriptor - Validated descriptor whose record tables already exist.
+     * @param onClose - Backend callback releasing this unit's open-name slot.
+     */
+    constructor(db: DatabaseSync, descriptor: KvUnitDescriptor, onClose: () => void);
+    loadAll(): Promise<{
+        tables: Record<string, Record<string, unknown>>;
+        global: unknown;
+    }>;
+    /** Parse one stored value column, mapping bad JSON to `malformed-medium`. */
+    private parseValue;
+    putRecord(table: string, key: string, value: unknown): Promise<void>;
+    deleteRecord(table: string, key: string): Promise<void>;
+    setGlobal(value: unknown): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Run one synchronous primitive behind the closed guard, mapping a throw to
+     * a rejection so the Promise-returning contract never throws synchronously.
+     */
+    private settle;
+    private ensureOpen;
+    private statementsFor;
+}
+//# sourceMappingURL=unit.d.ts.map

package/packages/agent-team/lib/types/vendor/storage-sqlite/unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit.d.ts","sourceRoot":"","sources":["../../../../src/vendor/storage-sqlite/unit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAiB,MAAM,aAAa,CAAA;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAUxE;;;;GAIG;AACH,qBAAa,YAAa,YAAW,MAAM;IAavC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAb1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;IAC5D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA2B;IACxD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA2B;IACxD,OAAO,CAAC,MAAM,CAAQ;IAEtB;;;;OAIG;gBAED,EAAE,EAAE,YAAY,EACC,UAAU,EAAE,gBAAgB,EAC5B,OAAO,EAAE,MAAM,IAAI;IAwBtC,OAAO,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;IAqBxF,6EAA6E;IAC7E,OAAO,CAAC,UAAU;IAYlB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAMpE,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMvD,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IASxC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQtB;;;OAGG;IACH,OAAO,CAAC,MAAM;IAWd,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,aAAa;CAOtB"}

package/packages/agent-team/lib/vendor/storage-sqlite/index.js

@@ -0,0 +1,139 @@
+/**
+ * Vendored fork of `@deepseek-ai/dsh-storage-sqlite` (`index.ts`).
+ *
+ * Source: deepseek-ai/deepseek-harness
+ * `packages/storage/storage-sqlite/src/index.ts` at version 0.1.5-rc.2
+ * (MIT per that version's package metadata and the repo root LICENSE;
+ * the stale npm `latest` tag 0.0.1-rc.1 carries BSD-3-Clause metadata).
+ * Kept identical except the `@module` tag below.
+ *
+ * Why vendored instead of depended on: DSH Desktop generation installers
+ * strip `@deepseek-ai/*` copies and resolve them from the host closure,
+ * which ships no `dsh-storage-sqlite` — a loader row naming that package
+ * blocks boot (GitHub issue #28). Resolving from our own package survives
+ * that boundary. Sync procedure: diff against the upstream file on every
+ * DSH compat round (see docs/dsh-release-compatibility.md).
+ */
+import z from '@deepseek-ai/schemastery';
+import { StorageError, UNIT_NAME_RE, storageBackendServiceKey } from '@deepseek-ai/dsh-storage';
+import { openDatabase, recordTableName } from "./schema.js";
+import { SqliteKvUnit } from "./unit.js";
+export { STORAGE_SQLITE_SCHEMA_VERSION } from "./schema.js";
+/** Cordis plugin name. */
+export const name = 'storage-sqlite';
+/** The backend registers on the storage hub. */
+export const inject = ['storage'];
+/** Schemastery validator for {@link Config}. */
+export const Config = z.object({
+    path: z.string().required(),
+    journalMode: z.union(['wal', 'delete', 'truncate', 'persist']).default('wal'),
+});
+/**
+ * The SQLite {@link StorageBackend}. Owns one `DatabaseSync` connection and
+ * the open-unit table; `kv.open` validates names, enforces the per-unit
+ * version stamp in `units`, and ensures the unit's record tables.
+ */
+export class SqliteStorageBackend {
+    /** The key-value facet; the only shape this backend serves. */
+    kv = { open: descriptor => this.openUnit(descriptor) };
+    ready;
+    /** Open (or still-opening) units by name; presence is the double-open guard. */
+    units = new Map();
+    closing;
+    /**
+     * @param config - Validated plugin configuration.
+     */
+    constructor(config) {
+        this.ready = openDatabase(config.path, config.journalMode);
+        // Mark the rejection handled: every primitive re-awaits `ready`, so an
+        // open failure still surfaces to each caller; this guard only prevents an
+        // unhandled-rejection crash when the failure precedes the first use.
+        this.ready.catch(() => { });
+    }
+    openUnit(descriptor) {
+        if (this.closing !== undefined) {
+            return Promise.reject(new StorageError('closed', 'sqlite storage backend is closed'));
+        }
+        if (!UNIT_NAME_RE.test(descriptor.name)) {
+            return Promise.reject(new Error(`kv unit name '${descriptor.name}' violates ${UNIT_NAME_RE}`));
+        }
+        for (const table of descriptor.tables) {
+            if (!UNIT_NAME_RE.test(table)) {
+                return Promise.reject(new Error(`kv table name '${table}' in unit '${descriptor.name}' violates ${UNIT_NAME_RE}`));
+            }
+        }
+        if (this.units.has(descriptor.name)) {
+            return Promise.reject(new Error(`kv unit '${descriptor.name}' is already open (double-open is a caller bug)`));
+        }
+        // Reserve the name synchronously so a concurrent second open of the same
+        // name rejects instead of racing past the guard during the awaits below.
+        const pending = this.materializeUnit(descriptor);
+        this.units.set(descriptor.name, pending);
+        pending.catch(() => this.units.delete(descriptor.name));
+        return pending;
+    }
+    async materializeUnit(descriptor) {
+        const db = await this.ready;
+        const row = db.prepare('SELECT version FROM units WHERE name = ?').get(descriptor.name);
+        if (row === undefined) {
+            db.prepare('INSERT INTO units (name, version) VALUES (?, ?)').run(descriptor.name, descriptor.version);
+        }
+        else if (row.version !== descriptor.version) {
+            throw new StorageError('version-mismatch', `kv unit '${descriptor.name}' is stamped version ${row.version} on the medium, incompatible with descriptor version ${descriptor.version}`);
+        }
+        for (const table of descriptor.tables) {
+            // Both segments passed UNIT_NAME_RE, so the identifier is safe in DDL.
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS "${recordTableName(descriptor.name, table)}" (
+          key   TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        ) STRICT
+      `);
+        }
+        return new SqliteKvUnit(db, descriptor, () => {
+            this.units.delete(descriptor.name);
+        });
+    }
+    /**
+     * Close every open unit and release the database. Idempotent; concurrent
+     * and repeated calls resolve once teardown finishes.
+     * @returns resolution after the medium is released.
+     */
+    close() {
+        this.closing ??= this.doClose();
+        return this.closing;
+    }
+    async doClose() {
+        let db;
+        try {
+            db = await this.ready;
+        }
+        catch {
+            // The medium never opened; that failure already rejected the opener and
+            // every unit call, so there is nothing left to release here.
+            return;
+        }
+        for (const pending of [...this.units.values()]) {
+            const unit = await pending.catch(() => undefined);
+            await unit?.close();
+        }
+        db.close();
+    }
+}
+/**
+ * Register the SQLite backend as `sqlite` on the storage hub. The disposer
+ * unregisters the name first, then closes the backend.
+ * @param ctx - Plugin context (must inject `storage`).
+ * @param config - Validated plugin configuration.
+ */
+export function apply(ctx, config) {
+    const backend = new SqliteStorageBackend(config);
+    ctx.effect(() => {
+        const dispose = ctx.storage.backend.register('sqlite', backend);
+        return async () => {
+            dispose();
+            await backend.close();
+        };
+    }, 'storage-sqlite.registerBackend');
+    ctx.provide(storageBackendServiceKey('sqlite'), backend);
+}

package/packages/agent-team/lib/vendor/storage-sqlite/schema.js

@@ -0,0 +1,120 @@
+/**
+ * Vendored fork of `@deepseek-ai/dsh-storage-sqlite` (`schema.ts`).
+ *
+ * Source: deepseek-ai/deepseek-harness
+ * `packages/storage/storage-sqlite/src/schema.ts` at version 0.1.5-rc.2
+ * (MIT per that version's package metadata and the repo root LICENSE;
+ * the stale npm `latest` tag 0.0.1-rc.1 carries BSD-3-Clause metadata).
+ * Kept identical except the `@module` tag below.
+ *
+ * Why vendored instead of depended on: DSH Desktop generation installers
+ * strip `@deepseek-ai/*` copies and resolve them from the host closure,
+ * which ships no `dsh-storage-sqlite` — a loader row naming that package
+ * blocks boot (GitHub issue #28). Resolving from our own package survives
+ * that boundary. Sync procedure: diff against the upstream file on every
+ * DSH compat round (see docs/dsh-release-compatibility.md).
+ */
+/**
+ * Schema + open-time helpers for the SQLite storage backend: the physical
+ * layout version, the database open/configure sequence (permissions, pragmas,
+ * version stamp/reject), and the unit metadata tables. Unit record tables are
+ * created per descriptor in `unit.ts`.
+ * @module @wowyuarm/dsh-agent-team/sqlite-backend/schema
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { mkdir, open } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { StorageError } from '@deepseek-ai/dsh-storage';
+/**
+ * The on-disk physical layout version, stored in `PRAGMA user_version`.
+ * Orthogonal to each unit's own `version` (stamped per unit in the `units`
+ * row). Bumped only on a breaking change to the table layout; any other
+ * stamped version rejects — this unreleased format has no migrations.
+ */
+export const STORAGE_SQLITE_SCHEMA_VERSION = 1;
+/* jscpd:ignore-start -- deliberately mirrors the session-query-sqlite open
+   sequence. Each package owns a distinct database identity and schema, so a
+   shared helper would couple otherwise independent storage providers (see the
+   domain KV storage Agent Note's reuse audit). */
+/**
+ * Exclusively create a missing database file with owner-only permissions.
+ * Existing files retain their modes, and errors other than `EEXIST` propagate.
+ * `DatabaseSync` reopens by path, so this does not protect confidentiality or
+ * integrity when another principal can replace the database entry in its
+ * parent directory.
+ */
+async function createDatabaseFile(path) {
+    try {
+        const handle = await open(path, 'wx', 0o600);
+        await handle.close();
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+    }
+}
+/**
+ * Open the database and apply its schema and pragmas. Missing directories and
+ * database files are created owner-only (`:memory:` skips filesystem setup).
+ * A zero `user_version` is stamped with {@link STORAGE_SQLITE_SCHEMA_VERSION};
+ * every other non-current version rejects rather than being migrated in place.
+ * @param path - the SQLite database file to open, or `:memory:`.
+ * @param journalMode - validated journal pragma.
+ * @returns the open handle with pragmas applied and the unit metadata tables ensured.
+ */
+export async function openDatabase(path, journalMode) {
+    const actual = path === ':memory:' ? path : resolve(path);
+    if (actual !== ':memory:') {
+        await mkdir(dirname(actual), { recursive: true, mode: 0o700 });
+        await createDatabaseFile(actual);
+    }
+    const db = new DatabaseSync(actual);
+    try {
+        configureDatabase(db, actual, journalMode);
+        return db;
+    }
+    catch (error) {
+        db.close();
+        throw error;
+    }
+}
+function configureDatabase(db, path, journalMode) {
+    db.exec('PRAGMA foreign_keys = ON');
+    // The validated union is safe to interpolate into a non-bindable PRAGMA.
+    db.exec(`PRAGMA journal_mode = ${journalMode.toUpperCase()}`);
+    // `PRAGMA user_version` always returns exactly one row { user_version }.
+    const { user_version: onDisk } = db.prepare('PRAGMA user_version').get();
+    if (onDisk !== 0 && onDisk !== STORAGE_SQLITE_SCHEMA_VERSION) {
+        throw new StorageError('version-mismatch', `storage database at "${path}" has schema version ${onDisk}, incompatible with this build (${STORAGE_SQLITE_SCHEMA_VERSION})`);
+    }
+    /* jscpd:ignore-end */
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS units (
+      name    TEXT PRIMARY KEY,
+      version INTEGER NOT NULL
+    ) STRICT
+  `);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS unit_globals (
+      unit  TEXT PRIMARY KEY REFERENCES units(name),
+      value TEXT NOT NULL
+    ) STRICT
+  `);
+    if (onDisk === 0) {
+        // Stamp fresh databases LAST: the stamp asserts the layout is complete,
+        // so a failure above must leave the medium unstamped (a re-open after
+        // the obstruction is cleared retries materialization from scratch).
+        db.exec(`PRAGMA user_version = ${STORAGE_SQLITE_SCHEMA_VERSION}`);
+    }
+}
+/**
+ * Physical table name for one unit table. Both segments are validated against
+ * `UNIT_NAME_RE` before reaching this, so the result is safe to interpolate
+ * into DDL and prepared-statement text.
+ * @param unit - Validated unit name.
+ * @param table - Validated table name.
+ * @returns the `u_<unit>_<table>` identifier.
+ */
+export function recordTableName(unit, table) {
+    return `u_${unit}_${table}`;
+}

package/packages/agent-team/lib/vendor/storage-sqlite/unit.js

@@ -0,0 +1,132 @@
+/**
+ * Vendored fork of `@deepseek-ai/dsh-storage-sqlite` (`unit.ts`).
+ *
+ * Source: deepseek-ai/deepseek-harness
+ * `packages/storage/storage-sqlite/src/unit.ts` at version 0.1.5-rc.2
+ * (MIT per that version's package metadata and the repo root LICENSE;
+ * the stale npm `latest` tag 0.0.1-rc.1 carries BSD-3-Clause metadata).
+ * Kept identical except the `@module` tag below — see `index.ts` for why
+ * this backend is vendored and how to sync it.
+ */
+import { StorageError } from '@deepseek-ai/dsh-storage';
+import { recordTableName } from "./schema.js";
+/**
+ * The SQLite {@link KvUnit}. Constructed by the backend AFTER the unit's
+ * record tables exist; statements are prepared once here and reused for every
+ * primitive. Values are stored as JSON text in the `value` column.
+ */
+export class SqliteKvUnit {
+    descriptor;
+    onClose;
+    tables = new Map();
+    globalUpsert;
+    globalSelect;
+    closed = false;
+    /**
+     * @param db - Open database handle owned by the backend (never closed here).
+     * @param descriptor - Validated descriptor whose record tables already exist.
+     * @param onClose - Backend callback releasing this unit's open-name slot.
+     */
+    constructor(db, descriptor, onClose) {
+        this.descriptor = descriptor;
+        this.onClose = onClose;
+        for (const table of descriptor.tables) {
+            // Both name segments are validated against UNIT_NAME_RE by the backend,
+            // so the physical identifier is safe to interpolate into statement text.
+            const physical = recordTableName(descriptor.name, table);
+            this.tables.set(table, {
+                upsert: db.prepare(`INSERT INTO "${physical}" (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`),
+                remove: db.prepare(`DELETE FROM "${physical}" WHERE key = ?`),
+                selectAll: db.prepare(`SELECT key, value FROM "${physical}"`),
+            });
+        }
+        this.globalUpsert = descriptor.hasGlobal
+            ? db.prepare('INSERT INTO unit_globals (unit, value) VALUES (?, ?) ON CONFLICT(unit) DO UPDATE SET value = excluded.value')
+            : undefined;
+        this.globalSelect = descriptor.hasGlobal
+            ? db.prepare('SELECT value FROM unit_globals WHERE unit = ?')
+            : undefined;
+    }
+    loadAll() {
+        return this.settle(() => {
+            const tables = {};
+            for (const [name, statements] of this.tables) {
+                // Null prototype: record keys are arbitrary strings, so '__proto__'
+                // must land as an own property instead of mutating the prototype.
+                const records = Object.create(null);
+                for (const row of statements.selectAll.all()) {
+                    records[row.key] = this.parseValue(row.value, `table '${name}' key '${row.key}'`);
+                }
+                tables[name] = records;
+            }
+            let global = null;
+            if (this.globalSelect !== undefined) {
+                const row = this.globalSelect.get(this.descriptor.name);
+                if (row !== undefined)
+                    global = this.parseValue(row.value, 'global slot');
+            }
+            return { tables, global };
+        });
+    }
+    /** Parse one stored value column, mapping bad JSON to `malformed-medium`. */
+    parseValue(text, slot) {
+        try {
+            return JSON.parse(text);
+        }
+        catch (error) {
+            throw new StorageError('malformed-medium', `kv unit '${this.descriptor.name}' holds unparsable JSON at ${slot}`, { cause: error });
+        }
+    }
+    putRecord(table, key, value) {
+        return this.settle(() => {
+            this.statementsFor(table).upsert.run(key, JSON.stringify(value));
+        });
+    }
+    deleteRecord(table, key) {
+        return this.settle(() => {
+            this.statementsFor(table).remove.run(key);
+        });
+    }
+    setGlobal(value) {
+        return this.settle(() => {
+            if (this.globalUpsert === undefined) {
+                throw new Error(`kv unit '${this.descriptor.name}' declared no global slot`);
+            }
+            this.globalUpsert.run(this.descriptor.name, JSON.stringify(value));
+        });
+    }
+    close() {
+        if (!this.closed) {
+            this.closed = true;
+            this.onClose();
+        }
+        return Promise.resolve();
+    }
+    /**
+     * Run one synchronous primitive behind the closed guard, mapping a throw to
+     * a rejection so the Promise-returning contract never throws synchronously.
+     */
+    settle(operation) {
+        try {
+            this.ensureOpen();
+            return Promise.resolve(operation());
+        }
+        catch (error) {
+            // Non-Error throws can only enter through JSON.stringify propagating a
+            // value's own toJSON throw; wrap those, preserve every real Error.
+            return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    ensureOpen() {
+        if (this.closed) {
+            throw new StorageError('closed', `kv unit '${this.descriptor.name}' is closed`);
+        }
+    }
+    statementsFor(table) {
+        const statements = this.tables.get(table);
+        if (statements === undefined) {
+            throw new Error(`kv unit '${this.descriptor.name}' declared no table '${table}'`);
+        }
+        return statements;
+    }
+}

package/packages/client-agent-team/README.md

@@ -20,7 +20,7 @@ The Client uses these Host projections and mutations:
 - `archiveChannel` hides a Channel from every surface with its facts kept (no restore entry point yet).
 - `updateMember` commits Agent handle/description edits plus an optional per-Member model override.
 - `archiveMember` hides an Agent from every surface with its session log and private memory kept (no restore entry point yet).
-The Host Remote also exposes `threadObservations` and `changeAttention` for future UI and Agent workflows; the current Human Thread surface does not render these controls or observations. `changes` provides lightweight scoped invalidation: each request declares one `scope` (workspace, channel, thread, or presence) and only matching events wake its long-poll; a Thread read commits durably but wakes nobody and moves no version, because it changes no shared projection. Versions are per-scope cursors — a `presence` scope counts process-local presence edges while every other scope carries the durable ledger position of the newest shared-projection commit — so a parked client is neither woken nor answered early by a change it does not subscribe to. The client shares one abortable long-poll per scope through `TeamChangeStream`, keeps each poll's cursor in the scope it came from, and re-anchors on any answered difference, so panels and pages never open parallel `changes` requests and a stale cursor cannot park a subscription blind; the poll is aborted when the last subscriber leaves. Opening a Task Thread issues one parallel round (`readThread`, bounded history, members, channel view) with no self-triggered second wave.
+The Host Remote also exposes `threadObservations` and `changeAttention`; the current Human Thread surface does not render these controls or observations. `changes` is a scoped streaming Remote consumed through Harness `ctx.remote.$stream()`. Each page shares one logical subscription per scope and Harness multiplexes it over the page's shared WebSocket, so opening several Team pages does not reserve ordinary HTTP connections for notifications. Every opening/reconnection baseline triggers a Host reread, including unchanged versions; leaving the last subscriber cancels that scope. Opening a Thread performs parallel initial reads and may perform a baseline catch-up, but private read acknowledgments cause no shared notification loop. See [architecture](../../docs/architecture.md#host-authority) for the authoritative scope and recovery contract.
 
 Team mode, selected Workspace, and the last selected Channel or Thread are persisted in browser storage, so returning to Team restores the previous location. Attention, unread counts, revisions, observations, and Thread facts remain Host-owned. Durable mutations are refreshed from Host after commit or rejection.
 

package/packages/client-agent-team/README.zh.md

@@ -20,7 +20,7 @@ Client 使用以下 Host 接口：
 - `archiveChannel`：把频道从所有面收起，事实保留（暂无恢复入口）。
 - `updateMember`：提交 Agent 名称/说明编辑，以及可选的成员级模型覆盖。
 - `archiveMember`：把 Agent 从所有面收起，会话日志与私有记忆保留（暂无恢复入口）。
-Host Remote 仍提供 `threadObservations` 和 `changeAttention`，供后续 UI 与 Agent 工作流使用；当前 Human Thread surface 不渲染这些控制或观察。`changes` 提供轻量的范围化变更通知：每个请求声明一个 `scope`（workspace、channel、thread 或 presence），只有匹配的事件会唤醒对应 long-poll；Thread 读取会持久化提交，但既不唤醒任何 scope、也不推进任何 version，因为它不改变任何共享投影。version 是各 scope 自己的游标：`presence` scope 计进程内的 presence 边沿，其余 scope 报「最后一条改变共享投影的提交」在 ledger 上的 durable 位置。因此 parked client 不会被自己不订阅的变化唤醒，也不会被它提前应答。Client 通过 `TeamChangeStream` 在每个 scope 上共享一条可取消的 long-poll，每个 poll 的游标只留在签发它的 scope 内，任何被应答的差异都会重新锚定——面板与页面不会为同一 scope 并行发起 `changes` 请求，陈旧的游标也不会让订阅无声停靠；最后一个订阅者离开时轮询即被取消。打开 Task Thread 只发出一轮并行请求（`readThread`、有界历史、成员、频道视图），不会出现自触发的第二波请求。
+Host Remote 仍提供 `threadObservations` 和 `changeAttention`；当前 Human Thread 界面不渲染这些控制或观察。`changes` 是按 scope 订阅的流式 Remote，通过 Harness `ctx.remote.$stream()` 消费。每个页面内同 scope 共享一个逻辑订阅，Harness 将其复用到该页面的共享 WebSocket，因此多个 Team 页面不会因通知长期占用普通 HTTP 连接。每次开场或重连基线都触发重新读取 Host，包括版本未变化的情况；最后一个订阅者离开时取消该 scope。打开 Thread 时并行完成首次读取，允许基线到达后补读，但私有已读确认不会形成共享通知循环。scope 与恢复契约见[架构文档](../../docs/architecture.zh.md#host-authority)。
 
 浏览器持久化 Team mode、当前 Workspace，以及最后选中的 Channel 或 Thread，返回 Team 时会恢复之前的位置。Attention、未读数量、revision、observations 和 Thread facts 始终由 Host 管理。持久化操作提交或拒绝后，Client 会重新读取 Host 投影。