negotium 0.2.18 → 0.2.20

package/dist/types/packages/core/src/agents/archiver.d.ts

@@ -73,7 +73,7 @@ export interface ArchiverRuntime {
 export declare function createArchiverRuntime(host: ArchiverHost): ArchiverRuntime;
 /**
  * Locate the summary the archiver turn just wrote. The wiki MCP's
- * `save_wiki_entry` writes `summaries/<date>-<title>[~N].md`.
+ * `wiki_write(kind="summary")` writes `summaries/<date>-<title>[~N].md`.
  */
 export declare function findSummaryFile(storage: ArchiverStorageHost, topicTitle: string, date: string, sinceMs: number, topicId?: string): string | null;
 export declare function runArchiverTurn(params: RunArchiverTurnParams): boolean;

package/dist/types/packages/core/src/mcp/wiki-search-index.d.ts

@@ -0,0 +1,59 @@
+export type IndexedWikiKind = "article" | "summary";
+export interface WikiSearchIndexSource {
+    kind: IndexedWikiKind;
+    key: string;
+    path: string;
+    mtimeMs: number;
+    size: number;
+}
+export interface PreparedWikiSearchDocument {
+    title: string;
+    text: string;
+    tokens: string[];
+    date?: string;
+    family?: string;
+}
+export interface WikiSearchIndexDocument extends PreparedWikiSearchDocument {
+    id: string;
+    kind: IndexedWikiKind;
+    key: string;
+    path: string;
+}
+export interface WikiSearchIndexMetadata {
+    id: string;
+    kind: IndexedWikiKind;
+    key: string;
+    title: string;
+    date?: string;
+}
+export interface WikiSummaryTemporalQuery {
+    year?: string;
+    month?: string;
+    direction: "latest" | "oldest";
+    limit: number;
+}
+export interface WikiSearchIndexSyncResult {
+    added: number;
+    updated: number;
+    removed: number;
+}
+export declare class WikiSearchIndex {
+    #private;
+    readonly path: string;
+    constructor(path: string);
+    close(): void;
+    /**
+     * Record one document that was just written.
+     *
+     * The write path already holds the document text, so the index is maintained
+     * incrementally and never needs to scan the content directories. `sync` stays
+     * for the explicit backfill of documents that predate the write tool.
+     */
+    upsert(source: WikiSearchIndexSource, document: PreparedWikiSearchDocument): void;
+    sync(sources: WikiSearchIndexSource[], prepare: (source: WikiSearchIndexSource, text: string) => PreparedWikiSearchDocument): WikiSearchIndexSyncResult;
+    metadata(kinds: IndexedWikiKind[]): WikiSearchIndexMetadata[];
+    summaryMetadataByDate(query: WikiSummaryTemporalQuery): WikiSearchIndexMetadata[];
+    matchingDocumentIds(kinds: IndexedWikiKind[], terms: string[]): Set<string>;
+    documents(ids: Set<string>): WikiSearchIndexDocument[];
+}
+export declare function resetCorruptWikiSearchIndex(path: string): void;

package/dist/types/packages/core/src/storage/api-topics.d.ts

@@ -63,6 +63,21 @@ export declare function normalizeTopicState(input: {
     agent?: AgentKind;
 };
 export declare function upsertTopic(t: TopicDto): void;
+/**
+ * Apply one access mode to a set of topics as a single all-or-nothing write.
+ *
+ * A partial write is not a cosmetic glitch here: a public parent left with
+ * private subagent children (or the reverse) is exactly the half-exposed state
+ * the access-mode cascade exists to prevent, so every row commits or none do.
+ *
+ * Deliberately a narrow UPDATE instead of a loop over {@link upsertTopic}.
+ * That helper opens its own transaction, and the node:sqlite shim in
+ * `sqlite.ts` emulates transactions with bare BEGIN/COMMIT rather than
+ * savepoints — nesting one inside an outer transaction would fail outright.
+ * It also rewrites participants and browser-profile ownership, none of which
+ * an access-mode change should touch.
+ */
+export declare function setTopicAccessModes(topicIds: readonly string[], accessMode: TopicAccessMode): void;
 export declare function listTopics(): TopicDto[];
 export declare function getTopic(id: string): TopicDto | null;
 /** Return the private manager room owned by a user, excluding the retired shared General row. */

package/dist/types/packages/core/src/storage/storage-host.d.ts

@@ -5,6 +5,16 @@ type InternalStorageDatabase = InstanceType<typeof Database>;
 type StorageSchemaInitializer = (database: InternalStorageDatabase) => void;
 export declare function initializeDatabase(database: InternalStorageDatabase): void;
 export declare function resolveStorageDatabase(): InternalStorageDatabase;
+/**
+ * The host-injected connection, or null when Negotium owns its own store.
+ *
+ * Unlike {@link resolveStorageDatabase} this never opens anything. Callers that
+ * manage their own short-lived connections need to know whether a host store
+ * exists *before* deciding to open one by path: opening it anyway is how an
+ * embedded Negotium ends up writing half its state into the host's database and
+ * the other half into `~/.negotium`, with nothing reporting an error.
+ */
+export declare function configuredStorageDatabase(): InternalStorageDatabase | null;
 export declare function resolveStorageDataDir(): string;
 export declare function resolveStorageLogDir(): string;
 export declare function resolveStorageSessionAsksDir(): string;

package/dist/types/packages/core/src/version.d.ts

@@ -1 +1 @@
-export declare const NEGOTIUM_VERSION = "0.2.18";
+export declare const NEGOTIUM_VERSION = "0.2.20";

package/dist/vault.js

@@ -2,8 +2,8 @@
 var __require = import.meta.require;
 
 // ../../packages/core/src/storage/vault.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
 
 // ../../packages/core/src/platform/config.ts
 import { execFileSync } from "child_process";
@@ -125,11 +125,12 @@ function versionAtLeast(actualVersion, minimumVersion) {
   }
   return true;
 }
+var BROWSER_RS_VERSION_PROBE_TIMEOUT_MS = 15000;
 function browserRsMeetsMinimumVersion(candidate) {
   try {
     const output = execFileSync(candidate, ["--version"], {
       encoding: "utf8",
-      timeout: 2000,
+      timeout: BROWSER_RS_VERSION_PROBE_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     const match = output.match(/^browser-rs (\d+)\.(\d+)\.(\d+)$/);
@@ -340,6 +341,134 @@ if (isBun) {
   Database = NodeDatabase;
 }
 
+// ../../packages/core/src/storage/storage-host.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+var STORAGE_HOST_STATE = Symbol.for("negotium.storage-host.state.v1");
+function storageState() {
+  const holder = globalThis;
+  const existing = holder[STORAGE_HOST_STATE];
+  if (existing)
+    return existing;
+  const created = {
+    configuredHost: {},
+    fallbackDatabase: null,
+    fallbackDatabasePath: null,
+    frames: [],
+    schemaInitializers: [],
+    initializedSchemas: new WeakMap,
+    initializingDatabases: new WeakSet
+  };
+  Object.defineProperty(holder, STORAGE_HOST_STATE, {
+    value: created,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return created;
+}
+function envPath(name, fallback) {
+  const value = process.env[name]?.trim();
+  return resolve2(value || fallback);
+}
+function defaultStateDir() {
+  return envPath("NEGOTIUM_STATE_DIR", join2(homedir2(), ".negotium"));
+}
+function defaultDataDir() {
+  return envPath("NEGOTIUM_DATA_DIR", join2(defaultStateDir(), "data"));
+}
+function defaultSessionsDatabasePath() {
+  return envPath("SESSIONS_DB_PATH", join2(resolveStorageDataDir(), "sessions.db"));
+}
+var SQLITE_INIT_RETRY_MS = 25;
+var SQLITE_INIT_TIMEOUT_MS = 5000;
+var SQLITE_INIT_SLEEP = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function isSqliteBusy(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /database is (?:locked|busy)|SQLITE_(?:BUSY|LOCKED)/i.test(message);
+}
+function execWithBusyRetry(database, sql, timeoutMs = SQLITE_INIT_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    try {
+      database.exec(sql);
+      return;
+    } catch (error) {
+      if (!isSqliteBusy(error) || Date.now() >= deadline)
+        throw error;
+      Atomics.wait(SQLITE_INIT_SLEEP, 0, 0, Math.min(SQLITE_INIT_RETRY_MS, deadline - Date.now()));
+    }
+  }
+}
+function initializeDatabase(database) {
+  database.exec("PRAGMA busy_timeout = 5000");
+  execWithBusyRetry(database, "PRAGMA journal_mode = WAL");
+  database.exec("PRAGMA foreign_keys = ON");
+  database.exec("PRAGMA wal_autocheckpoint = 1000");
+  try {
+    database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  } catch {}
+}
+function defaultDatabase() {
+  const path = defaultSessionsDatabasePath();
+  const state = storageState();
+  if (state.fallbackDatabase && state.fallbackDatabasePath === path)
+    return state.fallbackDatabase;
+  if (state.fallbackDatabase)
+    state.fallbackDatabase.close();
+  mkdirSync2(dirname2(path), { recursive: true });
+  state.fallbackDatabase = new Database(path, { create: true });
+  state.fallbackDatabasePath = path;
+  initializeDatabase(state.fallbackDatabase);
+  return state.fallbackDatabase;
+}
+function resolveStorageDatabase() {
+  return storageState().configuredHost.database ?? defaultDatabase();
+}
+function resolveStorageDataDir() {
+  return storageState().configuredHost.dataDir ?? defaultDataDir();
+}
+function ensureStorageSchemas(database = resolveStorageDatabase()) {
+  const state = storageState();
+  if (state.initializingDatabases.has(database))
+    return;
+  let initialized = state.initializedSchemas.get(database);
+  if (!initialized) {
+    initialized = new Set;
+    state.initializedSchemas.set(database, initialized);
+  }
+  state.initializingDatabases.add(database);
+  try {
+    for (const entry of state.schemaInitializers) {
+      if (initialized.has(entry.initialize))
+        continue;
+      initialized.add(entry.initialize);
+      try {
+        entry.initialize(database);
+      } catch (error) {
+        initialized.delete(entry.initialize);
+        throw error;
+      }
+    }
+  } finally {
+    state.initializingDatabases.delete(database);
+  }
+}
+var internalStorageDatabase = new Proxy({}, {
+  get(_target, property) {
+    const database = resolveStorageDatabase();
+    ensureStorageSchemas(database);
+    const value = Reflect.get(database, property, database);
+    return typeof value === "function" ? value.bind(database) : value;
+  },
+  set(_target, property, value) {
+    const database = resolveStorageDatabase();
+    ensureStorageSchemas(database);
+    return Reflect.set(database, property, value, database);
+  }
+});
+
 // ../../packages/core/src/storage/vault-crypto-core.ts
 import { createCipheriv, createDecipheriv, createHash, randomBytes as randomBytes2 } from "crypto";
 var ENVELOPE_PREFIX = "otium-vault:v1:";
@@ -429,17 +558,18 @@ function initializeVaultDatabase(database) {
   }
 }
 function openVaultDatabase(dataDir) {
-  const vaultDir = join2(dataDir, "vault");
-  const path = join2(vaultDir, "vault.db");
-  mkdirSync2(vaultDir, { recursive: true, mode: 448 });
+  const vaultDir = join3(dataDir, "vault");
+  const path = join3(vaultDir, "vault.db");
+  mkdirSync3(vaultDir, { recursive: true, mode: 448 });
   const database = new Database(path, { create: true });
   chmodSync2(path, 384);
   initializeVaultDatabase(database);
   return database;
 }
 function activeVaultDatabase() {
-  if (!vaultDb)
-    vaultDb = openVaultDatabase(DATA_DIR);
+  if (!vaultDb) {
+    vaultDb = openVaultDatabase(resolveStorageDataDir());
+  }
   return vaultDb;
 }
 function configureVaultStorage(options) {
@@ -448,7 +578,7 @@ function configureVaultStorage(options) {
   }
   const previousDb = vaultDb;
   const previousMasterKey = vaultMasterKey;
-  const configuredDb = options.database ?? openVaultDatabase(options.dataDir ?? DATA_DIR);
+  const configuredDb = options.database ?? openVaultDatabase(options.dataDir ?? resolveStorageDataDir());
   if (options.database)
     initializeVaultDatabase(configuredDb);
   vaultDb = configuredDb;
@@ -626,4 +756,4 @@ export {
   VAULT_DESCRIPTION_MAX_LENGTH
 };
 
-//# debugId=BC1F6A83A7692EAF64756E2164756E21
+//# debugId=E210ECA559CC5E1164756E2164756E21