@nurix/nustack 0.23.34 → 0.25.1

package/dist/lib/local_store/database.js

@@ -1,52 +1,6 @@
 import { existsSync } from "node:fs";
-import { chmod, open } from "node:fs/promises";
-import path from "node:path";
-import { mkdirSecure } from "../secure_file.js";
-import { stateDbPath } from "./paths.js";
-import { migrateToLatest } from "./migrations.js";
-let sqliteModulePromise;
-async function loadSqlite() {
-    if (!sqliteModulePromise) {
-        sqliteModulePromise = importSqliteQuietly();
-    }
-    return sqliteModulePromise;
-}
-async function importSqliteQuietly() {
-    return withSuppressedSqliteWarning(() => import("node:sqlite"));
-}
-export async function withSuppressedSqliteWarning(fn) {
-    const original = process.emitWarning;
-    const filtered = (warning, ...args) => {
-        const name = warning instanceof Error
-            ? warning.name
-            : typeof args[0] === "string"
-                ? args[0]
-                : args[0]?.type;
-        const message = warning instanceof Error ? warning.message : String(warning);
-        if (name === "ExperimentalWarning" && /sqlite/i.test(message))
-            return;
-        original(warning, ...args);
-    };
-    process.emitWarning = filtered;
-    try {
-        return await fn();
-    }
-    finally {
-        process.emitWarning = original;
-    }
-}
-export async function openLocalStore(options = {}) {
-    const dbFile = options.dbPath ?? stateDbPath();
-    await mkdirSecure(path.dirname(dbFile));
-    const db = await withSuppressedSqliteWarning(async () => {
-        const { DatabaseSync } = await loadSqlite();
-        return new DatabaseSync(dbFile);
-    });
-    db.exec("PRAGMA busy_timeout = 5000");
-    db.exec("PRAGMA journal_mode = WAL");
-    db.exec("PRAGMA foreign_keys = ON");
-    migrateToLatest(db);
-    await chmod(dbFile, 0o600).catch(() => { });
+import { machineStorePath, openMachineDatabase, openMachineDatabaseReadOnly, openSqliteFile } from "../store/open.js";
+function handleOf(db) {
     return {
         db,
         close() {
@@ -54,58 +8,24 @@ export async function openLocalStore(options = {}) {
         },
     };
 }
+export async function openLocalStore(options = {}) {
+    return handleOf(await openMachineDatabase(options.dbPath ?? machineStorePath()));
+}
 export async function openLocalStoreReadOnly(options = {}) {
-    const dbFile = options.dbPath ?? stateDbPath();
-    if (!existsSync(dbFile))
-        return null;
-    const db = await withSuppressedSqliteWarning(async () => {
-        const { DatabaseSync } = await loadSqlite();
-        return new DatabaseSync(dbFile, { readOnly: true });
-    });
-    db.exec("PRAGMA busy_timeout = 2000");
-    const row = db.prepare("PRAGMA user_version").get();
-    return {
-        db,
-        version: Number(row?.user_version ?? 0),
-        close() {
-            db.close();
-        },
-    };
+    const db = await openMachineDatabaseReadOnly(options.dbPath ?? machineStorePath());
+    return db ? handleOf(db) : null;
 }
-export async function readStoreVersion(dbFile = stateDbPath()) {
+export async function readStoreVersion(dbFile = machineStorePath()) {
     if (!existsSync(dbFile))
         return null;
-    let db;
-    try {
-        db = await withSuppressedSqliteWarning(async () => {
-            const { DatabaseSync } = await loadSqlite();
-            return new DatabaseSync(dbFile, { readOnly: true });
-        });
-    }
-    catch {
-        return headerUserVersion(dbFile);
-    }
     try {
-        const row = db.prepare("PRAGMA user_version").get();
-        return typeof row?.user_version === "number" ? row.user_version : null;
-    }
-    catch {
-        return headerUserVersion(dbFile);
-    }
-    finally {
-        db.close();
-    }
-}
-async function headerUserVersion(dbFile) {
-    try {
-        const handle = await open(dbFile, "r");
+        const db = await openSqliteFile(dbFile, { readOnly: true });
         try {
-            const header = Buffer.alloc(64);
-            const { bytesRead } = await handle.read(header, 0, 64, 0);
-            return bytesRead === 64 ? header.readInt32BE(60) : null;
+            const row = db.prepare("PRAGMA user_version").get();
+            return typeof row?.user_version === "number" ? row.user_version : null;
         }
         finally {
-            await handle.close();
+            db.close();
         }
     }
     catch {

package/dist/lib/local_store/device_state.js

@@ -1,4 +1,4 @@
-import { LATEST_SCHEMA_VERSION } from "./migrations.js";
+import { cliVersion, storeStampOf } from "../store/open.js";
 import { withTransaction } from "./database.js";
 function mapRow(row) {
     return {
@@ -62,7 +62,7 @@ export function upsertDeviceState(store, patch) {
             active_organization_id: merged.activeOrganizationId,
             keychain_service: merged.keychainService,
             keychain_account: merged.keychainAccount,
-            schema_version: LATEST_SCHEMA_VERSION,
+            schema_version: storeStampOf(cliVersion()),
             last_auth_refresh_at_ms: merged.lastAuthRefreshAtMs,
             created_at_ms: merged.createdAtMs,
             updated_at_ms: now,

package/dist/lib/local_store/index.js

@@ -1,6 +1,6 @@
 export { openLocalStore, withTransaction, } from "./database.js";
-export { nustackHomeDir, stateDbPath, locksDir, cacheDir, recoveryDir, ensureNuStackLayout, } from "./paths.js";
-export { MIGRATIONS, LATEST_SCHEMA_VERSION, LocalSchemaTooNewError, migrateToLatest, } from "./migrations.js";
+export { machineStorePath } from "../store/open.js";
+export { nustackHomeDir, locksDir, cacheDir, recoveryDir, ensureNuStackLayout, } from "./paths.js";
 export { INBOUND_APPLICATION_STATES, BINDING_STATUSES, LIVE_BINDING_STATUSES, INBOUND_APPLICATION_TRANSITIONS, isLegalApplicationTransition, } from "./sync_vocabulary.js";
 export * from "./device_state.js";
 export * from "./bindings.js";

package/dist/lib/local_store/paths.js

@@ -4,9 +4,6 @@ import { mkdirSecure } from "../secure_file.js";
 export function nustackHomeDir() {
     return path.join(os.homedir(), ".nustack");
 }
-export function stateDbPath() {
-    return path.join(nustackHomeDir(), "state.db");
-}
 export function locksDir() {
     return path.join(nustackHomeDir(), "locks");
 }
@@ -28,9 +25,6 @@ export function sessionEventsDir() {
 export function briefCachePath(projectId) {
     return path.join(cacheDir(), "brief", `${projectId}.json`);
 }
-export function obligationsCachePath(projectId, planAnchor) {
-    return path.join(cacheDir(), "obligations", projectId, `${planAnchor}.json`);
-}
 export function memoryManifestPath(projectId) {
     return path.join(cacheDir(), "memory-shipped", `${projectId}.json`);
 }

package/dist/lib/local_store/routing.js

@@ -13,8 +13,8 @@ export const LABEL_ROW_HANDLERS = [
 export const LABEL_ROW_CHECK_RESULTS = ["pass", "fail", "budget", "unavailable", "latched"];
 export const LABEL_ROW_ID_MAX = 128;
 export const LABEL_ROW_PATH_MAX = 512;
-export const LABEL_ROW_SYNC_STATES = ["pending", "synced", "refused", "local"];
 export const GATED_PATH_RETENTION_MS = 14 * 24 * 60 * 60 * 1000;
+export const UNRESOLVED_PROJECT_ID = "";
 export class LabelRowRefusedError extends Error {
     code = "LABEL_ROW_REFUSED";
     constructor(message) {
@@ -38,7 +38,7 @@ function requireInteger(field, value, isSigned) {
 export function clipLabelRowPath(path) {
     return path.length <= LABEL_ROW_PATH_MAX ? path : `…${path.slice(path.length - (LABEL_ROW_PATH_MAX - 1))}`;
 }
-export function insertLabelRow(store, row, syncState = "pending") {
+export function insertLabelRow(store, row, isLocalOnly = false) {
     requireIdentifier("id", row.id);
     requireIdentifier("session_id", row.session_id);
     requireIdentifier("agent_type", row.agent_type);
@@ -47,8 +47,6 @@ export function insertLabelRow(store, row, syncState = "pending") {
     if (row.check_result !== null && !isOneOf(LABEL_ROW_CHECK_RESULTS, row.check_result)) {
         throw new LabelRowRefusedError(`unknown check result "${String(row.check_result)}"`);
     }
-    if (!isOneOf(LABEL_ROW_SYNC_STATES, syncState))
-        throw new LabelRowRefusedError(`unknown sync state "${String(syncState)}"`);
     if (row.bypass_used !== 0 && row.bypass_used !== 1)
         throw new LabelRowRefusedError("bypass_used must be 0 or 1");
     if (row.path !== null && typeof row.path !== "string")
@@ -59,46 +57,12 @@ export function insertLabelRow(store, row, syncState = "pending") {
     requireInteger("tokens_kept_out", row.tokens_kept_out, true);
     requireInteger("created_at", row.created_at, false);
     store.db
-        .prepare(`INSERT INTO label_rows (id, session_id, agent_type, path, estimated_tokens, returned_tokens, handler,
-                check_result, bypass_used, latency_ms, tokens_kept_out, created_at, sync_state)
+        .prepare(`INSERT INTO session_label_rows (id, session_id, project_id, agent_type, path, estimated_tokens, returned_tokens,
+                handler, check_result, is_bypass_used, latency_ms, tokens_kept_out, created_at)
              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(row.id, row.session_id, row.agent_type, row.path === null ? null : clipLabelRowPath(row.path), row.estimated_tokens, row.returned_tokens, row.handler, row.check_result, row.bypass_used, row.latency_ms, row.tokens_kept_out, row.created_at, syncState);
-}
-export function labelRowWire(record) {
-    return {
-        id: record.id,
-        sessionId: record.session_id,
-        agentType: record.agent_type,
-        path: record.path,
-        estimatedTokens: record.estimated_tokens,
-        returnedTokens: record.returned_tokens,
-        handler: record.handler,
-        checkResult: record.check_result,
-        isBypassUsed: record.bypass_used === 1,
-        latencyMs: record.latency_ms,
-        tokensKeptOut: record.tokens_kept_out,
-        createdAt: record.created_at,
-    };
-}
-export function listPendingLabelRows(store, limit) {
-    return store.db
-        .prepare("SELECT * FROM label_rows WHERE sync_state = 'pending' ORDER BY created_at, id LIMIT ?")
-        .all(limit);
-}
-function markPending(store, ids, state) {
-    if (ids.length === 0)
-        return 0;
-    const placeholders = ids.map(() => "?").join(", ");
-    const result = store.db
-        .prepare(`UPDATE label_rows SET sync_state = ? WHERE sync_state = 'pending' AND id IN (${placeholders})`)
-        .run(state, ...ids);
-    return Number(result.changes);
-}
-export function markLabelRowsSynced(store, ids) {
-    return markPending(store, ids, "synced");
-}
-export function markLabelRowsRefused(store, ids) {
-    return markPending(store, ids, "refused");
+        .run(row.id, row.session_id, UNRESOLVED_PROJECT_ID, row.agent_type, row.path === null ? null : clipLabelRowPath(row.path), row.estimated_tokens, row.returned_tokens, row.handler, row.check_result, row.bypass_used, row.latency_ms, row.tokens_kept_out, new Date(row.created_at).toISOString());
+    if (isLocalOnly)
+        store.db.prepare("DELETE FROM sync_outbox WHERE table_name = 'session_label_rows' AND row_key = ?").run(row.id);
 }
 export function isLatched(store, sessionId, jobKind) {
     const row = store.db
@@ -153,7 +117,7 @@ export function recordBulkReadOutcome(store, transact, outcome, newId, now = Dat
                 latency_ms: outcome.latencyMs,
                 tokens_kept_out: -entry.returnedTokens,
                 created_at: now,
-            }, isDirect ? "local" : "pending");
+            }, isDirect);
             if (outcome.result !== "pass")
                 gatePathOnce(store, outcome.sessionId, entry.realPath, now);
         }

package/dist/lib/onboarding/folder_state.js

@@ -18,7 +18,7 @@ function significantEntries(dir) {
 function readMarkerProjectId(root) {
     const v2 = read(projectJsonPath(root));
     if (v2 && v2.schemaVersion === 2) {
-        const id = trimmedField(v2.workspaceId);
+        const id = trimmedField(v2.projectId);
         if (id)
             return id;
     }
@@ -42,7 +42,7 @@ function isNestedUnderProject(root) {
     let dir = path.dirname(root);
     while (dir && dir !== path.dirname(dir)) {
         const nustack = path.join(dir, ".nustack");
-        if (existsSync(path.join(nustack, "workspace.json")) || existsSync(path.join(nustack, "app.json")))
+        if (existsSync(path.join(nustack, "project.json")) || existsSync(path.join(nustack, "app.json")))
             return true;
         dir = path.dirname(dir);
     }

package/dist/lib/onboarding/init_fresh_folder.js

@@ -9,7 +9,7 @@ import { classifyFolder } from "./folder_state.js";
 import { initGitRepository } from "./git_init.js";
 import { composeOnboardingCommit, resolveHandoffTargets, } from "./handoff_apply.js";
 import { runRepositoryOnboarding, } from "./binding.js";
-export const MANAGED_ONBOARDING_FILES = [".nustack/workspace.json", "nustack.service.json"];
+export const MANAGED_ONBOARDING_FILES = [".nustack/project.json", "nustack.service.json"];
 export async function initFreshFolder(ctx, options) {
     const state = classifyFolder(ctx.cwd);
     if (state.class === "git_worktree") {

package/dist/lib/onboarding/manifest_writer.js

@@ -8,7 +8,7 @@ const CURRENT_DOCUMENT_PROTOCOL_VERSION = 1;
 function buildProjectManifest(identity, existing) {
     const owned = {
         schemaVersion: 2,
-        workspaceId: identity.projectId,
+        projectId: identity.projectId,
         organizationId: identity.organizationId,
         bindingProtocolVersion: identity.bindingProtocolVersion ?? CURRENT_BINDING_PROTOCOL_VERSION,
         documentProtocolVersion: identity.documentProtocolVersion ?? CURRENT_DOCUMENT_PROTOCOL_VERSION,
@@ -66,7 +66,7 @@ export async function writeProjectManifests(root, identity, hooks = {}) {
     }
     const nextService = {
         ...serviceManifest,
-        nustackWorkspace: { v: 2, workspaceId: identity.projectId, organizationId: identity.organizationId },
+        nustackProject: { v: 2, projectId: identity.projectId, organizationId: identity.organizationId },
         toolkit: { name: identity.toolkit.name, version: identity.toolkit.version },
     };
     delete nextService.nustackApp;
@@ -137,7 +137,7 @@ async function readProjectJson(root) {
             return null;
         return {
             schemaVersion: 2,
-            workspaceId: marker.projectId,
+            projectId: marker.projectId,
             organizationId: marker.organizationId,
             bindingProtocolVersion: typeof raw.bindingProtocolVersion === "number" ? raw.bindingProtocolVersion : 1,
             documentProtocolVersion: typeof raw.documentProtocolVersion === "number" ? raw.documentProtocolVersion : 1,
@@ -159,10 +159,10 @@ async function readServiceBlocks(root) {
         return { binding: null, toolkit: null };
     try {
         const manifest = JSON.parse(await readFile(filePath, "utf8"));
-        const v2 = manifest.nustackWorkspace;
+        const v2 = manifest.nustackProject;
         const v1 = manifest.nustackApp;
-        const binding = typeof v2?.workspaceId === "string" && typeof v2?.organizationId === "string"
-            ? { projectId: v2.workspaceId, organizationId: v2.organizationId }
+        const binding = typeof v2?.projectId === "string" && typeof v2?.organizationId === "string"
+            ? { projectId: v2.projectId, organizationId: v2.organizationId }
             : typeof v1?.appId === "string" && typeof v1?.workspaceId === "string"
                 ? { projectId: v1.appId, organizationId: v1.workspaceId }
                 : null;

package/dist/lib/origin_guard.js

@@ -25,7 +25,7 @@ export function originMismatchError(origin, credentialOrigin, credentialKind) {
         : credentialKind === "none"
             ? "this machine is not signed in to it, and a sign-in never opens for an origin a repository names"
             : `this machine's sign-in is for ${credentialOrigin ?? "another origin"}`;
-    return new HarnessError(HARNESS_CODES.ORIGIN_MISMATCH, `This repository's .nustack/workspace.json names ${origin} as its NuStack origin, but ${held}. ` +
+    return new HarnessError(HARNESS_CODES.ORIGIN_MISMATCH, `This repository's .nustack/project.json names ${origin} as its NuStack origin, but ${held}. ` +
         `To use ${origin}, state it outside the repository: \`nustack login --nustack-url ${origin}\`, or set NUSTACK_URL=${origin}.`);
 }
 export function refusedContractOrigin(credentialOrigin, origin) {

package/dist/lib/project_context.js

@@ -4,9 +4,9 @@ import { existsSync } from "node:fs";
 import { readManagedValues } from "./env_file.js";
 import { manifestPath } from "./manifest.js";
 import { assertSafeOpaqueId } from "./guards.js";
-const NO_PROJECT_MESSAGE = "No Project id — run inside a bound repository (`.nustack/workspace.json`), pass `--project <id>`, add an `nustackWorkspace.projectId` to nustack.service.json, or set NUSTACK_WORKSPACE_ID in the managed .env block.";
+const NO_PROJECT_MESSAGE = "No Project id — run inside a bound repository (`.nustack/project.json`), pass `--project <id>`, add an `nustackProject.projectId` to nustack.service.json, or set NUSTACK_PROJECT_ID in the managed .env block.";
 export function projectJsonPath(cwd) {
-    return path.join(cwd, ".nustack", "workspace.json");
+    return path.join(cwd, ".nustack", "project.json");
 }
 export function legacyAppJsonPath(cwd) {
     return path.join(cwd, ".nustack", "app.json");
@@ -17,7 +17,7 @@ export async function readBindingMarker(cwd) {
         try {
             const marker = JSON.parse(await readFile(v2Path, "utf8"));
             if (marker.schemaVersion === 2) {
-                const projectId = trimmed(marker.workspaceId);
+                const projectId = trimmed(marker.projectId);
                 if (projectId) {
                     return { projectId, organizationId: trimmed(marker.organizationId), version: 2 };
                 }
@@ -54,7 +54,7 @@ async function readManifestProjectId(cwd) {
         return null;
     try {
         const manifest = JSON.parse(await readFile(filePath, "utf8"));
-        return trimmed(manifest.nustackWorkspace?.workspaceId) ?? trimmed(manifest.nustackApp?.appId);
+        return trimmed(manifest.nustackProject?.projectId) ?? trimmed(manifest.nustackApp?.appId);
     }
     catch {
         return null;
@@ -62,7 +62,7 @@ async function readManifestProjectId(cwd) {
 }
 async function readEnvProjectId(cwd) {
     const managed = await readManagedValues(path.join(cwd, ".env"));
-    const projectId = managed.NUSTACK_WORKSPACE_ID?.trim();
+    const projectId = managed.NUSTACK_PROJECT_ID?.trim();
     return projectId ? projectId : null;
 }
 export async function resolveProjectId(cwd, options) {

package/dist/lib/project_contract.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-export const CONTRACT_PATH = ".nustack/workspace.json";
+export const CONTRACT_PATH = ".nustack/project.json";
 export const LEGACY_HARNESS_MANIFEST_PATH = ".claude/harness.json";
 const DIGEST_PATTERN = /^[0-9a-f]{64}$/;
 function parseObject(text) {
@@ -59,7 +59,7 @@ export function parseProjectContract(contractText, legacyText) {
     const contractDoor = doorOf(contract);
     const legacyDoor = doorOf(legacyMount(legacy));
     return {
-        projectId: contract === null ? null : nonEmpty(contract.workspaceId),
+        projectId: contract === null ? null : nonEmpty(contract.projectId),
         harness: contract === null ? null : harnessOf(contract.harness),
         door: contractDoor !== undefined ? contractDoor : legacyDoor,
         doorSource: contractDoor !== undefined ? "contract" : legacyDoor !== undefined ? "legacy" : null,

package/dist/lib/records/drain.js

@@ -1,160 +1,10 @@
 import { spawn } from "node:child_process";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, utimesSync, writeSync } from "node:fs";
+import { closeSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, utimesSync, writeSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { ensureAccessToken } from "../auth_grant.js";
-import { isOriginMismatch } from "../origin_guard.js";
 import { recordsDrainLockPath } from "../local_store/paths.js";
-import { resolveNuStackUrl } from "../nustack_client.js";
-import { RECORDS_BATCH_CAP, postRecords, resolveDoor, retryDelayMs } from "./door.js";
-import { DEVICE_TOKEN_VARIABLE, DRAIN_CHILD_VARIABLE, NO_DETACHED_DRAIN_VARIABLE, isFlagSet, readVariable } from "./environment.js";
-import { envelopeOfStored } from "./recordInput.js";
-import { validateEnvelope } from "./recordValidator.js";
-import { OBLIGATION_AGENT_OWNED, markBackoff, markDeferred, markRefused, markSynced, pruneSynced, rekeyRecord, selectDueRecords, } from "./recordsTable.js";
+import { DRAIN_CHILD_VARIABLE, NO_DETACHED_DRAIN_VARIABLE, isFlagSet } from "./environment.js";
 export const DRAIN_LOCK_STALE_MS = 120_000;
-const MAX_PASSES = 50;
-const DEVICE_PROJECTION_FIELDS = ["origin", "type", "subject", "state", "outcome", "ownerAgentDefinitionId"];
-function payloadToSend(row) {
-    const payload = JSON.parse(row.payloadJson);
-    if (row.placement !== "device" || row.kind !== "obligation")
-        return payload;
-    const projection = {};
-    for (const field of DEVICE_PROJECTION_FIELDS)
-        if (payload[field] !== undefined)
-            projection[field] = payload[field];
-    return projection;
-}
-async function targetOf(store, row, globals, doors) {
-    if (row.doorUrl !== null && row.projectId !== null)
-        return { row, doorUrl: row.doorUrl, projectId: row.projectId };
-    if (row.repositoryRoot !== null && existsSync(row.repositoryRoot)) {
-        let door = doors.get(row.repositoryRoot);
-        if (!door) {
-            door = await resolveDoor(row.repositoryRoot, globals);
-            doors.set(row.repositoryRoot, door);
-        }
-        if (door.kind !== "door")
-            return null;
-        if (row.projectId !== null)
-            return { row, doorUrl: door.doorUrl, projectId: row.projectId };
-        const rekeyed = rekeyRecord(store, row, door.projectId);
-        return rekeyed ? { row: rekeyed, doorUrl: door.doorUrl, projectId: door.projectId } : "gone";
-    }
-    if (row.projectId !== null)
-        return { row, doorUrl: resolveNuStackUrl(globals), projectId: row.projectId };
-    return null;
-}
-function isRowRefusal(outcome) {
-    return outcome.status === 400 || (outcome.status === 403 && outcome.code === OBLIGATION_AGENT_OWNED);
-}
-async function drainPass(store, globals, result, shouldIgnoreBackoff) {
-    const now = Date.now();
-    const deviceToken = readVariable(DEVICE_TOKEN_VARIABLE);
-    const due = selectDueRecords(store, shouldIgnoreBackoff ? Number.MAX_SAFE_INTEGER : now, deviceToken !== null);
-    if (due.length === 0)
-        return 0;
-    const doors = new Map();
-    const groups = new Map();
-    for (const selected of due) {
-        const target = await targetOf(store, selected, globals, doors);
-        if (target === "gone")
-            continue;
-        if (target === null) {
-            markDeferred(store, selected, now + retryDelayMs(Math.max(1, selected.attempts)));
-            continue;
-        }
-        const envelope = envelopeOfStored(target.row, target.projectId, payloadToSend(target.row));
-        const verdict = validateEnvelope(envelope);
-        if (!verdict.isValid) {
-            const error = `VALIDATION_FAILED: ${verdict.errors[0] ?? "the row fails the records schema"}`;
-            if (markRefused(store, target.row, error)) {
-                result.refused += 1;
-                result.lastError = error;
-            }
-            continue;
-        }
-        const group = `${target.row.credential ?? ""}\u0000${target.doorUrl}\u0000${target.projectId}\u0000${target.row.kind}`;
-        const list = groups.get(group) ?? [];
-        list.push({ row: target.row, envelope, doorUrl: target.doorUrl, projectId: target.projectId });
-        groups.set(group, list);
-    }
-    let personToken;
-    for (const list of groups.values()) {
-        const first = list[0];
-        let bearer;
-        if (first.row.credential === "device")
-            bearer = deviceToken;
-        else {
-            if (personToken === undefined) {
-                personToken = await ensureAccessToken().then((auth) => auth?.accessToken ?? null, (error) => {
-                    if (isOriginMismatch(error))
-                        result.originRefusal = error.message;
-                    return null;
-                });
-            }
-            bearer = personToken;
-        }
-        for (let start = 0; start < list.length; start += RECORDS_BATCH_CAP) {
-            const batch = list.slice(start, start + RECORDS_BATCH_CAP);
-            if (bearer === null) {
-                backoffAll(store, batch, result.originRefusal ?? "this device is signed out", result);
-                continue;
-            }
-            await sendBatch(store, batch, first.row.kind, bearer, result);
-        }
-    }
-    return due.length;
-}
-function backoffAll(store, batch, error, result) {
-    const now = Date.now();
-    for (const item of batch)
-        markBackoff(store, item.row, error, now + retryDelayMs(item.row.attempts + 1));
-    result.lastError = error;
-}
-async function sendBatch(store, batch, kind, bearer, result) {
-    const { doorUrl, projectId } = batch[0];
-    const outcome = await postRecords(doorUrl, projectId, { kind, rows: batch.map((item) => item.envelope) }, bearer);
-    if (outcome.ok) {
-        for (const item of batch)
-            markSynced(store, item.row);
-        result.sent += batch.length;
-        return;
-    }
-    if (!isRowRefusal(outcome)) {
-        backoffAll(store, batch, outcome.message, result);
-        return;
-    }
-    if (batch.length === 1) {
-        if (markRefused(store, batch[0].row, outcome.message))
-            result.refused += 1;
-        result.lastError = outcome.message;
-        return;
-    }
-    for (const item of batch) {
-        const alone = await postRecords(doorUrl, projectId, { kind, rows: [item.envelope] }, bearer);
-        if (alone.ok) {
-            markSynced(store, item.row);
-            result.sent += 1;
-        }
-        else if (isRowRefusal(alone)) {
-            if (markRefused(store, item.row, alone.message))
-                result.refused += 1;
-            result.lastError = alone.message;
-        }
-        else
-            backoffAll(store, [item], alone.message, result);
-    }
-}
-export async function drainRecords(store, globals, options = {}) {
-    const result = { sent: 0, refused: 0, lastError: null, originRefusal: null };
-    pruneSynced(store, Date.now());
-    for (let pass = 0; pass < MAX_PASSES; pass += 1) {
-        options.onPass?.();
-        if ((await drainPass(store, globals, result, pass === 0 && options.isForeground === true)) === 0)
-            break;
-    }
-    return result;
-}
 function tryCreateLock(lockPath) {
     try {
         const fd = openSync(lockPath, "wx", 0o600);
@@ -211,7 +61,7 @@ export function startDetachedDrain(options = {}) {
     try {
         if (isFlagSet(NO_DETACHED_DRAIN_VARIABLE) || isFlagSet(DRAIN_CHILD_VARIABLE))
             return;
-        const args = [cliEntryPath(), ...(options.nustackUrl ? ["--nustack-url", options.nustackUrl] : []), "records", "sync", "--quiet"];
+        const args = [cliEntryPath(), ...(options.nustackUrl ? ["--nustack-url", options.nustackUrl] : []), "store", "sync", "--quiet"];
         const child = spawn(process.execPath, args, {
             detached: true,
             stdio: "ignore",

package/dist/lib/records/kinds.js

@@ -0,0 +1,16 @@
+export const RECORD_KINDS = ["obligation", "gate_event", "changelog", "memory", "backlog", "proposal", "triage"];
+export const LEGACY_KIND_TRANSLATION = { "backlog.remove": "backlog", bookkeeping: "obligation" };
+export const RECORDS_BATCH_CAP = 200;
+export const RECORD_SCHEMA_VERSION = 1;
+export function isRecordKind(value) {
+    return typeof value === "string" && RECORD_KINDS.includes(value);
+}
+export function isLegacyKind(value) {
+    return typeof value === "string" && Object.hasOwn(LEGACY_KIND_TRANSLATION, value);
+}
+export function isEmitKind(value) {
+    return isRecordKind(value) || isLegacyKind(value);
+}
+export function translatedKindOf(kind) {
+    return isLegacyKind(kind) ? LEGACY_KIND_TRANSLATION[kind] : kind;
+}

package/dist/lib/records/recordInput.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { RECORD_SCHEMA_VERSION, isLegacyKind, translatedKindOf } from "./door.js";
+import { RECORD_SCHEMA_VERSION, isLegacyKind, translatedKindOf } from "./kinds.js";
 import { idempotencyKeyOf, naturalKeyOf } from "./naturalKey.js";
 import { validateEnvelope } from "./recordValidator.js";
 import { scanPayload } from "./secretScan.js";