@nurix/nustack 0.24.0 → 0.25.2

package/dist/commands/desktopAgent.js

@@ -86,7 +86,7 @@ async function runAccepted(request) {
     const outcome = await runClaude(request, claudeArgs(request, inputs, modelEnv), modelEnv, worktreePath, composePrompt(request));
     if (request.sessionId !== null) {
         const synced = await syncRecords(env, worktreePath);
-        log(`records sync exited ${synced.code ?? "unspawned"}`);
+        log(`store sync exited ${synced.code ?? "unspawned"}`);
     }
     const shared = { vendorSessionId: outcome.vendorSessionId, costCents: outcome.costCents, engineCheck: outcome.engineCheck, mount: mounted.mount };
     if (outcome.reason) {

package/dist/commands/doctor.js

@@ -14,7 +14,6 @@ import { readDeviceState } from "../lib/local_store/device_state.js";
 import { getBindingByRepositoryRoot, listActiveBindings } from "../lib/local_store/bindings.js";
 import { listApplicationsForBinding } from "../lib/local_store/handoff_applications.js";
 import { readFilebeatState, listActivityBindings } from "../lib/local_store/filebeat_state.js";
-import { LATEST_SCHEMA_VERSION } from "../lib/local_store/migrations.js";
 import { resolveRepository, readSymbolicBranch, readHeadCommit } from "../lib/git-sync/core/repository.js";
 import { readGitOperationState } from "../lib/git-sync/core/operation_state.js";
 import { NotARepositoryError } from "../lib/git-sync/core/git_runner.js";
@@ -72,23 +71,21 @@ export async function runDoctor(options) {
         add("identity", row.check, row.status, row.detail);
     add("api", "NuStack reachability", ...(await probeReachability(baseUrl)));
     let store = null;
+    let storeError = "the Device state database could not be opened";
     try {
         store = await openLocalStore();
     }
-    catch {
+    catch (error) {
         store = null;
+        if (error instanceof Error)
+            storeError = error.message;
     }
     if (!store) {
-        add("state", "Local store", "error", "the Device state database could not be opened");
+        add("state", "Local store", "error", storeError);
     }
     else {
-        const schema = readDeviceState(store)?.schemaVersion ?? null;
-        if (schema === null)
-            add("state", "Local store schema", "info", "no Device state yet — sign in to initialize");
-        else if (schema >= LATEST_SCHEMA_VERSION)
-            add("state", "Local store schema", "ok", `v${schema}`);
-        else
-            add("state", "Local store schema", "warn", `v${schema} behind v${LATEST_SCHEMA_VERSION} — the next command migrates it`);
+        const stamp = store.db.prepare("PRAGMA user_version").get().user_version;
+        add("state", "Local store schema", "ok", `v${stamp}`);
     }
     const repository = resolveRepositoryOrNull(cwd);
     if (!repository) {
@@ -176,7 +173,7 @@ async function fetchCloudProfile(baseUrl, accessToken, projectId) {
 async function addManifestRows(add, root, cloud) {
     const manifests = await readProjectManifests(root);
     if (!manifests.projectManifest && !manifests.serviceToolkit) {
-        add("manifests", "Project binding markers", "info", "no `.nustack/app.json` or Service toolkit block — repository not attached");
+        add("manifests", "Project binding markers", "info", "no `.nustack/project.json` or Service toolkit block — repository not attached");
         return;
     }
     const diagnosis = diagnoseManifests(cloud ? { name: cloud.name, version: cloud.version } : null, manifests.projectManifest?.toolkit ?? null, manifests.serviceToolkit);

package/dist/commands/obligationList.js

@@ -1,42 +1,19 @@
-import { obligationsCachePath } from "../lib/local_store/paths.js";
+import { openLocalStore } from "../lib/local_store/database.js";
 import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
 import { resolveProjectId } from "../lib/project_context.js";
-import { getFromDoor, readCache, writeCache } from "../lib/sessions/brief.js";
-const MAX_PAGES = 100;
-const PAGE_TIMEOUT_MS = 10_000;
-function lineOf(item) {
-    if (typeof item.naturalKey !== "string")
-        return null;
-    const payload = (item.payload ?? {});
+import { listRecords } from "../lib/records/recordsTable.js";
+import { pullAll } from "../lib/sync/client.js";
+const PULL_TIMEOUT_MS = 10_000;
+function lineOf(naturalKey, payload) {
+    const fields = (payload ?? {});
     return {
-        naturalKey: item.naturalKey,
-        state: typeof payload.state === "string" ? payload.state : "unknown",
-        verdict: typeof payload.outcome?.verdict === "string" ? payload.outcome.verdict : null,
+        naturalKey,
+        state: typeof fields.state === "string" ? fields.state : "unknown",
+        verdict: typeof fields.outcome?.verdict === "string" ? fields.outcome.verdict : null,
     };
 }
-async function fetchAll(root, globals, projectId, plan) {
-    const lines = [];
-    let cursor = null;
-    for (let page = 0; page < MAX_PAGES; page += 1) {
-        const query = `/records?kind=obligation&planAnchor=${encodeURIComponent(plan)}&limit=100${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
-        const answered = await getFromDoor(root, globals, projectId, query, PAGE_TIMEOUT_MS);
-        const items = answered?.data?.items;
-        if (!answered || !Array.isArray(items))
-            return null;
-        for (const item of items) {
-            const line = lineOf(item);
-            if (line)
-                lines.push(line);
-        }
-        cursor = answered.meta?.nextCursor ?? null;
-        if (!cursor)
-            return lines;
-    }
-    return lines;
-}
 export async function runObligationList(options, globals) {
-    const root = process.cwd();
-    const project = await resolveProjectId(root, options.project ? { project: options.project } : {});
+    const project = await resolveProjectId(process.cwd(), options.project ? { project: options.project } : {});
     if (!project.ok) {
         if (options.json)
             printJsonError("obligation list", { code: "NO_PROJECT", message: project.message });
@@ -46,28 +23,25 @@ export async function runObligationList(options, globals) {
         }
         return;
     }
-    const cacheFile = obligationsCachePath(project.projectId, options.plan);
-    const fetched = await fetchAll(root, globals, project.projectId, options.plan);
+    const store = await openLocalStore();
     let obligations;
-    let source;
-    let fetchedAt = null;
-    if (fetched) {
-        writeCache(cacheFile, fetched);
-        obligations = fetched;
-        source = "server";
+    let pullError;
+    try {
+        pullError = (await pullAll(store, globals, { timeoutMs: PULL_TIMEOUT_MS })).lastError;
+        obligations = listRecords(store, { projectId: project.projectId, kind: "obligation", planAnchor: options.plan })
+            .map((record) => lineOf(record.naturalKey, record.payload))
+            .sort((a, b) => a.naturalKey.localeCompare(b.naturalKey));
     }
-    else {
-        const cached = readCache(cacheFile);
-        obligations = cached?.value ?? [];
-        fetchedAt = cached?.fetchedAt ?? null;
-        source = "cache";
+    finally {
+        store.close();
     }
+    const source = pullError === null ? "synced" : "store";
     if (options.json) {
-        printJsonSuccess("obligation list", { plan: options.plan, projectId: project.projectId, source, fetchedAt, obligations });
+        printJsonSuccess("obligation list", { plan: options.plan, projectId: project.projectId, source, pullError, obligations });
         return;
     }
-    if (source === "cache")
-        process.stderr.write(`obligation list: offline; the cached list${fetchedAt ? ` from ${fetchedAt}` : " is empty"}\n`);
+    if (pullError !== null)
+        process.stderr.write(`obligation list: could not sync (${pullError}); showing the rows as last synced\n`);
     for (const line of obligations)
         process.stdout.write(`${line.naturalKey}  ${line.state}${line.verdict ? ` ${line.verdict}` : ""}\n`);
     if (obligations.length === 0)

package/dist/commands/records.js

@@ -1,17 +1,13 @@
-import { existsSync } from "node:fs";
 import { readDesktopSettings } from "../lib/desktop_settings.js";
 import { openLocalStore } from "../lib/local_store/database.js";
-import { stateDbPath } from "../lib/local_store/paths.js";
 import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
-import { HARNESS_CODES } from "../lib/harness/codes.js";
 import { resolveProjectId } from "../lib/project_context.js";
-import { isEmitKind } from "../lib/records/door.js";
-import { acquireDrainLock, drainRecords, refreshDrainLock, releaseDrainLock, startDetachedDrain } from "../lib/records/drain.js";
-import { DEVICE_TOKEN_VARIABLE, DRAIN_CHILD_VARIABLE, SESSION_ID_VARIABLE, isFlagSet, readVariable, recordCredentialOf, } from "../lib/records/environment.js";
+import { isEmitKind } from "../lib/records/kinds.js";
+import { startDetachedDrain } from "../lib/records/drain.js";
+import { SESSION_ID_VARIABLE, readVariable, recordCredentialOf } from "../lib/records/environment.js";
 import { UNKNOWN_KIND_MESSAGE, assembleRecord, parseRowsText, translateRow, } from "../lib/records/recordInput.js";
-import { AgentOwnedError, OBLIGATION_AGENT_OWNED, countRecords, hasDueRecord, listRecords, releaseUnboundRows, writeRecords, } from "../lib/records/recordsTable.js";
+import { AgentOwnedError, OBLIGATION_AGENT_OWNED, countRecords, listRecords, releaseUnboundRows, writeRecords, } from "../lib/records/recordsTable.js";
 import { logRefusals } from "../lib/records/refusalLog.js";
-import { drainSessionLegs } from "../lib/sessions/sessionEvents.js";
 async function readStdin() {
     if (process.stdin.isTTY)
         return "";
@@ -175,65 +171,10 @@ export async function runRecordsEmit(options, globals) {
         json: options.json === true,
     }, globals);
 }
-async function drainAs(store, globals, isChild) {
-    if (!isChild) {
-        const drained = await drainRecords(store, globals, { isForeground: true });
-        await drainSessionLegs(store, globals);
-        return drained;
-    }
-    if (!acquireDrainLock())
-        return null;
-    try {
-        const drained = await drainRecords(store, globals, { onPass: () => refreshDrainLock() });
-        refreshDrainLock();
-        await drainSessionLegs(store, globals);
-        return drained;
-    }
-    finally {
-        releaseDrainLock();
-    }
-}
-export async function runRecordsSync(options, globals) {
-    const store = await openLocalStore();
-    try {
-        const root = process.cwd();
-        const project = await resolveProjectId(root, {});
-        if (project.ok)
-            releaseUnboundRows(store, root);
-        const drained = await drainAs(store, globals, isFlagSet(DRAIN_CHILD_VARIABLE));
-        if (drained?.originRefusal) {
-            if (options.json)
-                printJsonError("records sync", { code: HARNESS_CODES.ORIGIN_MISMATCH, message: drained.originRefusal });
-            else {
-                process.stderr.write(`${drained.originRefusal}\n`);
-                process.exitCode = 1;
-            }
-            return;
-        }
-        if (options.quiet)
-            return;
-        const counts = await countRecords(store);
-        const result = {
-            sent: drained?.sent ?? 0,
-            waiting: counts.waitingCount,
-            stored: counts.storeCount,
-            refused: counts.refusedCount,
-            lastError: drained?.lastError ?? counts.lastError,
-        };
-        if (options.json)
-            printJsonSuccess("records sync", result);
-        else {
-            process.stdout.write(`records sync: sent ${result.sent}; ${result.waiting} waiting, ${result.stored} kept locally, ${result.refused} refused\n`);
-        }
-    }
-    finally {
-        store.close();
-    }
-}
 export async function runRecordsList(options) {
     const store = await openLocalStore();
     try {
-        const counts = await countRecords(store, options.project);
+        const counts = countRecords(store, options.project);
         const records = listRecords(store, {
             ...(options.project ? { projectId: options.project } : {}),
             ...(options.kind ? { kind: options.kind } : {}),
@@ -260,27 +201,10 @@ export async function runRecordsList(options) {
         store.close();
     }
 }
-export async function startDrainIfDue(globals) {
-    try {
-        if (isFlagSet(DRAIN_CHILD_VARIABLE) || !existsSync(stateDbPath()))
-            return;
-        const store = await openLocalStore();
-        try {
-            if (hasDueRecord(store.db, Date.now(), readVariable(DEVICE_TOKEN_VARIABLE) !== null)) {
-                startDetachedDrain({ nustackUrl: globals.nustackUrl });
-            }
-        }
-        finally {
-            store.close();
-        }
-    }
-    catch {
-    }
-}
 export function registerRecordsCommands(recordsCommand, getGlobalOptions) {
     recordsCommand
         .command("emit")
-        .description("Write records locally and return; a background drain sends them to NuStack")
+        .description("Write records locally and return; a background store sync sends them to NuStack")
         .option("--kind <kind>", "obligation, gate_event, changelog, memory, backlog, proposal or triage")
         .option("--row <json>", "one row, an array of rows, or {kind, rows}, as JSON (default: read from stdin)")
         .option("--root <dir>", "the folder the records are about (default: the current directory)")
@@ -289,12 +213,6 @@ export function registerRecordsCommands(recordsCommand, getGlobalOptions) {
         .option("--plan <anchor>", "the plan anchor, when a row names none")
         .option("--json", "emit the versioned machine envelope")
         .action(async (options) => runRecordsEmit(options, getGlobalOptions()));
-    recordsCommand
-        .command("sync")
-        .description("Send every due record this device holds to NuStack")
-        .option("--quiet", "print nothing")
-        .option("--json", "emit the versioned machine envelope")
-        .action(async (options) => runRecordsSync(options, getGlobalOptions()));
     recordsCommand
         .command("list")
         .description("Show this device's records: what waits, what was refused, what stays local")

package/dist/commands/store.js

@@ -0,0 +1,199 @@
+import { existsSync } from "node:fs";
+import { HARNESS_CODES } from "../lib/harness/codes.js";
+import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
+import { openLocalStore } from "../lib/local_store/database.js";
+import { resolveProjectId } from "../lib/project_context.js";
+import { acquireDrainLock, refreshDrainLock, releaseDrainLock, startDetachedDrain } from "../lib/records/drain.js";
+import { DEVICE_TOKEN_VARIABLE, DRAIN_CHILD_VARIABLE, isFlagSet, readVariable } from "../lib/records/environment.js";
+import { countRecords, releaseUnboundRows } from "../lib/records/recordsTable.js";
+import { drainSessionLegs } from "../lib/sessions/sessionEvents.js";
+import { pullAll, pullCursor, pushOutbox } from "../lib/sync/client.js";
+import { countOutbox, hasDueEntry, newestOutboxError } from "../lib/sync/outbox.js";
+import { cliVersion, machineStorePath, storeStampOf } from "../lib/store/open.js";
+const CLIENT_OUTDATED = "CLIENT_OUTDATED";
+function answeredRefusal(command, options, summaries) {
+    for (const summary of summaries) {
+        if (!summary)
+            continue;
+        const refusal = summary.originRefusal
+            ? { code: HARNESS_CODES.ORIGIN_MISMATCH, message: summary.originRefusal }
+            : summary.outdated
+                ? { code: CLIENT_OUTDATED, message: summary.outdated }
+                : null;
+        if (!refusal)
+            continue;
+        if (options.json)
+            printJsonError(command, refusal);
+        else {
+            process.stderr.write(`${refusal.message}\n`);
+            process.exitCode = 1;
+        }
+        return true;
+    }
+    return false;
+}
+async function releaseHere(store) {
+    const root = process.cwd();
+    if ((await resolveProjectId(root, {})).ok)
+        releaseUnboundRows(store, root);
+}
+async function syncAs(store, globals, isChild) {
+    if (!isChild) {
+        const push = await pushOutbox(store, globals, { isForeground: true });
+        const pull = push.originRefusal || push.outdated ? null : await pullAll(store, globals);
+        await drainSessionLegs(globals);
+        return { push, pull };
+    }
+    if (!acquireDrainLock())
+        return null;
+    try {
+        const push = await pushOutbox(store, globals, { onPass: () => refreshDrainLock() });
+        refreshDrainLock();
+        const pull = push.originRefusal || push.outdated ? null : await pullAll(store, globals);
+        refreshDrainLock();
+        await drainSessionLegs(globals);
+        return { push, pull };
+    }
+    finally {
+        releaseDrainLock();
+    }
+}
+export async function runStoreSync(options, globals) {
+    const store = await openLocalStore();
+    try {
+        await releaseHere(store);
+        const synced = await syncAs(store, globals, isFlagSet(DRAIN_CHILD_VARIABLE));
+        if (answeredRefusal("store sync", options, [synced?.push ?? null, synced?.pull ?? null]))
+            return;
+        if (options.quiet)
+            return;
+        const counts = countRecords(store);
+        const result = {
+            pushed: synced?.push.sent ?? 0,
+            refused: synced?.push.refused ?? 0,
+            pulled: synced?.pull?.rows ?? 0,
+            tombstones: synced?.pull?.tombstones ?? 0,
+            cursor: pullCursor(store),
+            waiting: counts.waitingCount,
+            stored: counts.storeCount,
+            lastError: synced?.push.lastError ?? synced?.pull?.lastError ?? newestOutboxError(store.db),
+        };
+        if (options.json)
+            printJsonSuccess("store sync", result);
+        else {
+            process.stdout.write(`store sync: pushed ${result.pushed}, pulled ${result.pulled}; ${result.waiting} waiting, ${result.stored} kept locally, ${result.refused} refused\n`);
+            if (result.lastError)
+                process.stderr.write(`  last error: ${result.lastError}\n`);
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+export async function runStorePush(options, globals) {
+    const store = await openLocalStore();
+    try {
+        await releaseHere(store);
+        const push = await pushOutbox(store, globals, { isForeground: true });
+        if (answeredRefusal("store push", options, [push]))
+            return;
+        const result = { pushed: push.sent, refused: push.refused, lastError: push.lastError };
+        if (options.json)
+            printJsonSuccess("store push", result);
+        else
+            process.stdout.write(`store push: pushed ${result.pushed}, ${result.refused} refused\n`);
+    }
+    finally {
+        store.close();
+    }
+}
+export async function runStorePull(options, globals) {
+    const store = await openLocalStore();
+    try {
+        const pull = await pullAll(store, globals);
+        if (answeredRefusal("store pull", options, [pull]))
+            return;
+        const result = { pulled: pull.rows, tombstones: pull.tombstones, cursor: pull.cursor, isReset: pull.isReset, lastError: pull.lastError };
+        if (options.json)
+            printJsonSuccess("store pull", result);
+        else {
+            process.stdout.write(`store pull: ${result.pulled} row(s), ${result.tombstones} tombstone(s); cursor ${result.cursor}\n`);
+            if (result.lastError)
+                process.stderr.write(`  last error: ${result.lastError}\n`);
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+export async function runStoreStatus(options) {
+    const store = await openLocalStore();
+    try {
+        const tableCount = (name) => Number(store.db.prepare(`SELECT count(*) AS n FROM "${name}"`).get().n);
+        const result = {
+            path: machineStorePath(),
+            version: cliVersion(),
+            stamp: storeStampOf(cliVersion()),
+            cursor: pullCursor(store),
+            outbox: countOutbox(store.db, Date.now()),
+            records: tableCount("harness_records"),
+            labelRows: tableCount("session_label_rows"),
+            lastError: newestOutboxError(store.db),
+        };
+        if (options.json)
+            printJsonSuccess("store status", result);
+        else {
+            process.stdout.write(`store status: ${result.path} (NuStack ${result.version}, stamp ${result.stamp}); cursor ${result.cursor}\n`);
+            process.stdout.write(`  ${result.records} record(s), ${result.labelRows} label row(s)\n`);
+            if (result.outbox.length === 0)
+                process.stdout.write("  outbox: empty\n");
+            for (const entry of result.outbox) {
+                process.stdout.write(`  outbox ${entry.table}: ${entry.pending} pending, ${entry.due} due, ${entry.failing} failing\n`);
+            }
+            if (result.lastError)
+                process.stdout.write(`  last error: ${result.lastError}\n`);
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+export async function startDrainIfDue(globals) {
+    try {
+        if (isFlagSet(DRAIN_CHILD_VARIABLE) || !existsSync(machineStorePath()))
+            return;
+        const store = await openLocalStore();
+        try {
+            if (hasDueEntry(store.db, Date.now(), readVariable(DEVICE_TOKEN_VARIABLE) !== null))
+                startDetachedDrain({ nustackUrl: globals.nustackUrl });
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+    }
+}
+export function registerStoreCommands(storeCommand, getGlobalOptions) {
+    storeCommand
+        .command("sync")
+        .description("Push this machine's changes to NuStack, then pull what changed there")
+        .option("--quiet", "print nothing")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runStoreSync(options, getGlobalOptions()));
+    storeCommand
+        .command("push")
+        .description("Push this machine's pending changes to NuStack")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runStorePush(options, getGlobalOptions()));
+    storeCommand
+        .command("pull")
+        .description("Pull every row that changed on NuStack since the last pull")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runStorePull(options, getGlobalOptions()));
+    storeCommand
+        .command("status")
+        .description("Show the machine database: its release, the pull cursor and the outbox")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runStoreStatus(options));
+}

package/dist/commands/sync.js

@@ -45,8 +45,8 @@ export async function runSync(options) {
     spinner?.stop(`${projections.length} service credential(s) projected`);
     const managedValues = await readManagedValues(path.join(cwd, ".env"));
     const nextValues = {};
-    if (managedValues.NUSTACK_WORKSPACE_ID)
-        nextValues.NUSTACK_WORKSPACE_ID = managedValues.NUSTACK_WORKSPACE_ID;
+    if (managedValues.NUSTACK_PROJECT_ID)
+        nextValues.NUSTACK_PROJECT_ID = managedValues.NUSTACK_PROJECT_ID;
     for (const credential of [...projections].sort((a, b) => a.service.localeCompare(b.service))) {
         const prefix = toEnvPrefix(credential.service);
         nextValues[`${prefix}_ENDPOINT`] = credential.endpoint;

package/dist/commands/toolkit.js

@@ -101,10 +101,10 @@ export async function runToolkitReconcile(options, globals) {
     const binding = await withStore((store) => getBindingByRepositoryRoot(store, ctx.root));
     const manifests = await readProjectManifests(ctx.root);
     const identity = manifests.projectManifest
-        ? { projectId: manifests.projectManifest.workspaceId, organizationId: manifests.projectManifest.organizationId }
+        ? { projectId: manifests.projectManifest.projectId, organizationId: manifests.projectManifest.organizationId }
         : manifests.serviceProjectBinding;
     if (!identity) {
-        emitFail("toolkit reconcile", json, "PROJECT_CONTEXT_MISSING", "No `.nustack/app.json` binding to reconcile — attach the repository first.");
+        emitFail("toolkit reconcile", json, "PROJECT_CONTEXT_MISSING", "No `.nustack/project.json` binding to reconcile — attach the repository first.");
         return;
     }
     const plan = await buildReconcilePlan(ctx.root, binding ?? { etnaProfileJson: null }, cloud);

package/dist/lib/context/register.js

@@ -8,7 +8,7 @@ const SCALAR_FIELDS = new Set(["kind", "plane", "projects", "one-line"]);
 const SEQUENCE_FIELDS = new Set(["aliases", "tables"]);
 export function docsRootOf(root) {
     try {
-        const parsed = JSON.parse(readFileSync(path.join(root, ".nustack", "workspace.json"), "utf8"));
+        const parsed = JSON.parse(readFileSync(path.join(root, ".nustack", "project.json"), "utf8"));
         if (typeof parsed.docsRoot === "string" && parsed.docsRoot.trim() !== "")
             return parsed.docsRoot.trim();
     }

package/dist/lib/desktop-agents/checkout.js

@@ -12,7 +12,7 @@ export const DESKTOP_AGENT_BIN_DIR = ".bin";
 export const DESKTOP_AGENT_PROPOSAL_BRANCH_PREFIX = "nustack/proposal/";
 export const DESKTOP_AGENT_EXCLUDE_START = "# nustack:desktop-agent:start";
 export const DESKTOP_AGENT_EXCLUDE_END = "# nustack:desktop-agent:end";
-const MARKER_RELATIVE = ".nustack/workspace.json";
+const MARKER_RELATIVE = ".nustack/project.json";
 const FETCH_TIMEOUT_MS = 10 * 60_000;
 export function agentCheckoutsRoot(env = process.env) {
     return path.join(sessionsHome(env), DESKTOP_AGENT_CHECKOUTS_DIR);

package/dist/lib/desktop-agents/claudeRun.js

@@ -101,9 +101,9 @@ export function sandboxSettings(inputs) {
                     path.join(inputs.gitCommonDir, "refs"),
                     path.join(inputs.gitCommonDir, "logs"),
                     inputs.worktreeGitDir,
-                    path.join(nustackHome, "state.db"),
-                    path.join(nustackHome, "state.db-wal"),
-                    path.join(nustackHome, "state.db-shm"),
+                    path.join(nustackHome, "nustack.db"),
+                    path.join(nustackHome, "nustack.db-wal"),
+                    path.join(nustackHome, "nustack.db-shm"),
                     path.join(nustackHome, "locks"),
                     path.join(nustackHome, "session-events"),
                 ],
@@ -253,7 +253,7 @@ export function gitDirsOf(gitCommonDirOutput, gitDirOutput, worktree) {
 }
 export function syncRecords(env, cwd) {
     return new Promise((resolve) => {
-        const child = spawn(process.execPath, [cliEntry(), "records", "sync", "--json"], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+        const child = spawn(process.execPath, [cliEntry(), "store", "sync", "--json"], { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
         let output = "";
         child.stdout.on("data", (chunk) => (output += chunk.toString("utf8")));
         child.on("error", () => resolve({ code: null, output }));

package/dist/lib/etna/reconcile.js

@@ -41,10 +41,10 @@ export async function buildReconcilePlan(root, binding, cloud) {
     const changes = [];
     const project = manifests.projectManifest?.toolkit;
     if (project) {
-        pushIf(changes, ".nustack/workspace.json", "toolkit.name", project.name, cloud.name);
-        pushIf(changes, ".nustack/workspace.json", "toolkit.version", project.version, cloud.version);
-        pushIf(changes, ".nustack/workspace.json", "toolkit.rendererVersion", project.rendererVersion, cloud.rendererVersion);
-        pushIf(changes, ".nustack/workspace.json", "toolkit.placementMapVersion", project.placementMapVersion, cloud.placementMapVersion);
+        pushIf(changes, ".nustack/project.json", "toolkit.name", project.name, cloud.name);
+        pushIf(changes, ".nustack/project.json", "toolkit.version", project.version, cloud.version);
+        pushIf(changes, ".nustack/project.json", "toolkit.rendererVersion", project.rendererVersion, cloud.rendererVersion);
+        pushIf(changes, ".nustack/project.json", "toolkit.placementMapVersion", project.placementMapVersion, cloud.placementMapVersion);
     }
     const svc = manifests.serviceToolkit;
     if (svc) {

package/dist/lib/graph/library.js

@@ -1,4 +1,4 @@
-import { withSuppressedSqliteWarning } from "../local_store/database.js";
+import { withSuppressedSqliteWarning } from "../store/open.js";
 export class GraphLibraryMissing extends Error {
     code = "GRAPH_LIBRARY_MISSING";
     constructor() {

package/dist/lib/harness/hookCheck.js

@@ -2,9 +2,9 @@ import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
-import { openLocalStore, openLocalStoreReadOnly } from "../local_store/database.js";
+import { openLocalStore } from "../local_store/database.js";
 import { writeRecords } from "../records/recordsTable.js";
-import { RECORD_SCHEMA_VERSION } from "../records/door.js";
+import { RECORD_SCHEMA_VERSION } from "../records/kinds.js";
 import { idempotencyKeyOf } from "../records/naturalKey.js";
 import { recordCredentialOf } from "../records/environment.js";
 import { readProjectContract, CONTRACT_PATH } from "../project_contract.js";
@@ -17,7 +17,6 @@ export const HOOK_EVENTS = ["pre-tool-use", "stop"];
 export const RULE_UNAVAILABLE_GATE = "hook.rule_unavailable";
 export const DEADLINE_GATE = "hook.deadline";
 const EVENT_NAMESPACE = "3f0c9a52-6d1e-4b7a-9c2f-8e5d4a1b7c60";
-const RECORDS_STORE_VERSION = 9;
 const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
 export const COMMIT_RULES = new Set([
     "changelog",
@@ -163,11 +162,6 @@ async function writeVerdicts(root, projectId, payload, target, verdicts) {
     if (verdicts.length === 0)
         return null;
     try {
-        const held = await openLocalStoreReadOnly();
-        const version = held?.version ?? RECORDS_STORE_VERSION;
-        held?.close();
-        if (version < RECORDS_STORE_VERSION)
-            return null;
         const store = await openLocalStore();
         try {
             const now = Date.now();

package/dist/lib/harness/storeWaivers.js

@@ -1,5 +1,4 @@
 import { openLocalStoreReadOnly } from "../local_store/database.js";
-const RECORDS_STORE_VERSION = 9;
 const NEVER_EXPIRES = "9999-12-31";
 const DISCHARGED_VERDICTS = new Set(["updated", "owes_nothing"]);
 export async function readStoreDocumentationWaivers(projectId, dbPath) {
@@ -9,10 +8,8 @@ export async function readStoreDocumentationWaivers(projectId, dbPath) {
     if (!store)
         return [];
     try {
-        if (store.version < RECORDS_STORE_VERSION)
-            return [];
         const rows = store.db
-            .prepare("SELECT payload_json FROM records WHERE kind = 'obligation' AND project_id = ?")
+            .prepare("SELECT payload_json FROM harness_records WHERE kind = 'obligation' AND project_id = ?")
             .all(projectId);
         const subjects = new Set();
         for (const row of rows) {