@nurix/nustack 0.23.12 → 0.23.14

package/dist/lib/harness/mount.js

@@ -1,155 +1,223 @@
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
+import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { ensureAccessToken } from "../auth_grant.js";
+import { getProject, resolveNuStackOrigin } from "../nustack_client.js";
+import { isOriginMismatch } from "../origin_guard.js";
+import { resolveProjectId } from "../project_context.js";
+import { readProjectContract } from "../project_contract.js";
+import { hasEtnaMountHook } from "../onboarding/session_hook.js";
+import { HarnessError, HARNESS_CODES } from "./codes.js";
+import { handOverLegacyMount, mountLegacyManifest, readLegacyMountRecord, readLegacyMountRecordSync } from "./legacyMount.js";
+import { loadHarness } from "./vendor.js";
+import { fetchVersionManifest, fetchVersionObject, resolveProjectVersion, VersionsRouteError } from "./versionsClient.js";
 export const MOUNT_STATE_PATH = ".claude/state/mount.json";
-const IGNORE_START = "# etna:mount:start";
-const IGNORE_END = "# etna:mount:end";
-const ETNA_MOUNT_SPECIFIER = "@nurix/etna/mount";
-const sha256Of = (bytes) => createHash("sha256").update(bytes).digest("hex");
-export function defaultCacheDir(env = process.env) {
-    return env.ETNA_CACHE_DIR?.trim() || path.join(homedir(), ".etna", "cache");
-}
-export function isMountedPath(file) {
-    if (file.policy)
-        return file.policy === "mount";
-    const contract = ["CLAUDE.md", "AGENTS.md", ".claude/harness.json", ".claude/settings.json", ".claude/hooks/mount.mjs", ".codex/hooks.json"];
-    if (contract.includes(file.path))
-        return false;
-    return file.path.startsWith(".claude/") || file.path.startsWith(".agents/") || file.path.startsWith(".codex/");
-}
-async function readIfPresent(file) {
-    try {
-        return await readFile(file);
-    }
-    catch {
+const DIGEST_REFUSALS = new Set(["mount.digest_mismatch", "mount.expected_digest_mismatch", "mount.object_mismatch", "mount.cache_corrupt", "mount.bad_sha256"]);
+function stateOf(record) {
+    if (!record || typeof record.version !== "string" || typeof record.digest !== "string")
         return null;
-    }
+    const source = record.source === "network" || record.source === "cache" || record.source === "legacy" ? record.source : null;
+    return {
+        version: record.version,
+        digest: record.digest,
+        mountedAt: typeof record.mountedAt === "string" ? record.mountedAt : "",
+        source,
+        origin: typeof record.origin === "string" ? record.origin : null,
+    };
 }
 export async function readMountState(root) {
-    return parseMountState(await readIfPresent(path.join(root, MOUNT_STATE_PATH)));
+    const { readMountRecord } = await loadHarness("mount");
+    return stateOf(readMountRecord(root)) ?? stateOf((await readLegacyMountRecord(root)));
 }
 export function readMountStateSync(root) {
+    const file = path.join(root, MOUNT_STATE_PATH);
+    let record = null;
+    if (existsSync(file)) {
+        try {
+            const parsed = JSON.parse(readFileSync(file, "utf8"));
+            record = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+        }
+        catch {
+            record = null;
+        }
+    }
+    return stateOf(record) ?? stateOf(readLegacyMountRecordSync(root));
+}
+function coded(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+export async function readSummary(root, projectId, globals) {
+    let baseUrl;
     try {
-        return parseMountState(readFileSync(path.join(root, MOUNT_STATE_PATH)));
+        baseUrl = resolveNuStackOrigin(globals, root).url;
     }
-    catch {
-        return null;
+    catch (error) {
+        if (isOriginMismatch(error))
+            return { kind: "offline", reason: error.message, guardRefusal: error, baseUrl: null };
+        throw error;
     }
-}
-function parseMountState(raw) {
-    if (!raw)
-        return null;
+    let token;
     try {
-        const parsed = JSON.parse(raw.toString("utf8"));
-        if (typeof parsed.version !== "string" || typeof parsed.digest !== "string")
-            return null;
-        return { version: parsed.version, digest: parsed.digest, mountedAt: typeof parsed.mountedAt === "string" ? parsed.mountedAt : "", ...(typeof parsed.manifestUrl === "string" ? { manifestUrl: parsed.manifestUrl } : {}) };
+        token = await ensureAccessToken(baseUrl);
     }
-    catch {
-        return null;
+    catch (error) {
+        if (isOriginMismatch(error))
+            return { kind: "offline", reason: error.message, guardRefusal: error, baseUrl };
+        return { kind: "offline", reason: "this machine's sign-in could not be read", guardRefusal: null, baseUrl };
+    }
+    if (!token)
+        return { kind: "offline", reason: "this machine is not signed in", guardRefusal: null, baseUrl };
+    try {
+        const summary = await getProject(baseUrl, token.accessToken, projectId);
+        return { kind: "summary", summary, baseUrl, accessToken: token.accessToken };
+    }
+    catch (error) {
+        if (isOriginMismatch(error))
+            return { kind: "offline", reason: error.message, guardRefusal: error, baseUrl };
+        const code = error.code;
+        if (typeof code === "string" && code !== "UNEXPECTED" && code !== "SIGNED_OUT")
+            throw error;
+        return { kind: "offline", reason: `the Project summary could not be read (${error instanceof Error ? error.message : String(error)})`, guardRefusal: null, baseUrl };
     }
 }
-async function fetchBytes(fetchImpl, url) {
-    const response = await fetchImpl(url);
-    if (!response.ok)
-        throw new Error(`${url} answered ${response.status}`);
-    return Buffer.from(await response.arrayBuffer());
-}
-function objectUrlOf(manifestUrl, key) {
-    return `${new URL(manifestUrl).origin}/${key.replace(/^\/+/, "")}`;
+export function isProjectVersionSummary(summary) {
+    return Boolean(summary.harness?.digest || summary.harness?.versionManifestPath);
 }
-async function writeAtomic(target, bytes) {
-    await mkdir(path.dirname(target), { recursive: true });
-    const staging = `${target}.mount-${process.pid}`;
-    await writeFile(staging, bytes);
-    await rename(staging, target);
+export async function projectOf(root, flag, contractProjectId) {
+    if (flag?.trim())
+        return flag.trim();
+    if (contractProjectId)
+        return contractProjectId;
+    const resolved = await resolveProjectId(root, {});
+    if (!resolved.ok)
+        throw coded("PROJECT_CONTEXT_MISSING", resolved.message);
+    return resolved.projectId;
 }
-function ignoredNamesOf(files) {
-    const names = new Set([".claude/state/"]);
-    for (const file of files) {
-        const parts = file.path.split("/");
-        if (parts[0] === ".agents")
-            names.add(".agents/skills/");
-        else if (parts[0] === ".codex")
-            names.add(parts.length > 2 ? `.codex/${parts[1]}/` : `.codex/${parts[1]}`);
-        else if (parts.length > 3)
-            names.add(`${parts.slice(0, 3).join("/")}/`);
-        else
-            names.add(file.path);
+function outcomeOf(projectId, result, lines, offlineCode) {
+    if (result.status === "mounted" || result.status === "current") {
+        const kept = result.findings.filter((finding) => finding.code === "mount.kept_edited" || finding.code === "mount.contract_edited");
+        return {
+            projectId,
+            status: result.status,
+            source: result.source ?? "network",
+            version: result.semver,
+            digest: result.digest,
+            runtime: result.runtime,
+            written: result.written,
+            kept: result.kept,
+            removed: result.removed,
+            lines: [...lines, result.line, ...kept.map((finding) => finding.message)],
+        };
     }
-    return [...names].sort();
+    const finding = result.findings[0];
+    if (result.status === "refused" && finding && DIGEST_REFUSALS.has(finding.code))
+        throw new HarnessError(HARNESS_CODES.HARNESS_DIGEST_MISMATCH, result.line);
+    if (result.status === "unavailable" && (!finding || finding.code === "mount.no_route"))
+        throw new HarnessError(offlineCode, result.line);
+    throw new HarnessError(HARNESS_CODES.HARNESS_MOUNT_FAILED, result.line);
 }
-async function writeExcludeBlock(root, files) {
-    let excludePath;
-    try {
-        excludePath = execFileSync("git", ["rev-parse", "--git-path", "info/exclude"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+async function recordedFiles(root, runtime) {
+    const { readMountRecord } = await loadHarness("mount");
+    return new Set((readMountRecord(root)?.runtimes?.[runtime]?.files ?? []).map((file) => file.path));
+}
+async function handOver(root, runtime, outcome) {
+    const handed = await handOverLegacyMount(root, await recordedFiles(root, runtime));
+    if (!handed)
+        return outcome;
+    const lines = [...outcome.lines, ...handed.editedKept.map((file) => `kept ${file}: the legacy harness wrote it and it has been edited since`)];
+    return { ...outcome, removed: [...outcome.removed, ...handed.removed], lines };
+}
+export async function mountProjectHarness(root, options) {
+    const log = options.log ?? ((line) => process.stderr.write(`${line}\n`));
+    const report = (outcome) => {
+        for (const line of outcome.lines)
+            log(line);
+        return outcome;
+    };
+    const runtime = options.runtime ?? "claude-code";
+    if (await hasEtnaMountHook(root)) {
+        throw new HarnessError(HARNESS_CODES.ETNA_MOUNT_PRESENT, "This checkout's .claude/settings.json runs etna's mount hook (.claude/hooks/mount.mjs), and two mounters on one checkout erase each other's record. Remove etna's SessionStart entry, then run `nustack init`.");
     }
-    catch {
-        return;
+    const contract = await readProjectContract(root);
+    const projectId = await projectOf(root, options.projectId, contract.projectId);
+    const lines = [];
+    let harness = contract.harness;
+    if (!harness) {
+        harness = { track: "latest" };
+        if (contract.contractPresent)
+            lines.push("This contract names no harness version, so the newest is mounted; run `nustack init` to record one.");
     }
-    const absolute = path.isAbsolute(excludePath) ? excludePath : path.join(root, excludePath);
-    const held = (await readIfPresent(absolute))?.toString("utf8") ?? "";
-    const start = held.indexOf(IGNORE_START);
-    const end = held.indexOf(IGNORE_END);
-    const outside = start >= 0 && end > start ? held.slice(0, start) + held.slice(end + IGNORE_END.length).replace(/^\n/, "") : held;
-    const block = [IGNORE_START, ...ignoredNamesOf(files), IGNORE_END].join("\n");
-    await writeAtomic(absolute, `${outside.replace(/\n*$/, outside ? "\n" : "")}${block}\n`);
-}
-export async function mountWithAdapter(root, manifestUrl, options = {}) {
-    const fetchImpl = options.fetchImpl ?? fetch;
-    const cacheDir = options.cacheDir ?? defaultCacheDir();
-    const manifestBytes = await fetchBytes(fetchImpl, manifestUrl);
-    const digest = sha256Of(manifestBytes);
-    const manifest = JSON.parse(manifestBytes.toString("utf8"));
-    if (!manifest || !Array.isArray(manifest.files))
-        throw new Error(`the manifest at ${manifestUrl} lists no files`);
-    const version = String(manifest.version ?? "");
-    const prior = await readMountState(root);
-    const mounted = manifest.files.filter(isMountedPath);
-    let written = 0;
-    let kept = 0;
-    for (const file of mounted) {
-        if (file.path.split("/").includes("..") || path.isAbsolute(file.path))
-            throw new Error(`the manifest names an unsafe path: ${file.path}`);
-        const target = path.join(root, file.path);
-        const held = await readIfPresent(target);
-        if (held && file.sha256 && sha256Of(held) === file.sha256) {
-            kept += 1;
-            continue;
-        }
-        const cached = file.sha256 ? await readIfPresent(path.join(cacheDir, "objects", file.sha256)) : null;
-        let bytes = cached && sha256Of(cached) === file.sha256 ? cached : null;
-        if (!bytes) {
-            bytes = await fetchBytes(fetchImpl, objectUrlOf(manifestUrl, file.key));
-            if (file.sha256 && sha256Of(bytes) !== file.sha256)
-                throw new Error(`the object for ${file.path} does not match its sha256`);
-            if (file.sha256)
-                await writeAtomic(path.join(cacheDir, "objects", file.sha256), bytes);
-        }
-        await writeAtomic(target, bytes);
-        written += 1;
+    const pinned = "digest" in harness ? harness : null;
+    const { mountVersion, defaultHarnessCacheDir } = await loadHarness("mount");
+    const common = { root, cacheDir: defaultHarnessCacheDir(), runtime, projectId, writeContract: options.writeContract };
+    const noFetch = async () => {
+        throw new Error("a cached mount fetches nothing");
+    };
+    const fromCache = async (reason, guardRefusal, origin) => {
+        const result = await mountVersion({ ...common, manifest: null, fetchObject: noFetch, expectedDigest: pinned?.digest ?? null, recordExtras: origin ? { origin } : {} });
+        if (guardRefusal && result.status !== "mounted" && result.status !== "current")
+            throw new HarnessError(HARNESS_CODES.ORIGIN_MISMATCH, guardRefusal.message);
+        const notice = guardRefusal ? `harness taken from the cache, the origin was refused: ${guardRefusal.message}` : `harness taken from the cache: ${reason}`;
+        return handOver(root, runtime, outcomeOf(projectId, result, [...lines, notice], HARNESS_CODES.HARNESS_OFFLINE_NO_CACHE));
+    };
+    const read = await readSummary(root, projectId, options.globals ?? {});
+    if (read.kind === "offline")
+        return report(await fromCache(read.reason, read.guardRefusal, read.baseUrl));
+    if (!isProjectVersionSummary(read.summary)) {
+        const manifestUrl = read.summary.harness?.manifestUrl ?? null;
+        if (!manifestUrl)
+            throw new HarnessError(HARNESS_CODES.HARNESS_UNAVAILABLE, `Project ${projectId} resolves no harness version to mount.`);
+        const legacy = await mountLegacyManifest(root, manifestUrl, read.baseUrl);
+        return report({
+            projectId,
+            status: legacy.written.length > 0 ? "mounted" : "current",
+            source: "legacy",
+            version: legacy.version,
+            digest: legacy.digest,
+            runtime,
+            written: legacy.written,
+            kept: legacy.kept,
+            removed: [],
+            lines: [...lines, `harness mounted: ${legacy.version} (legacy) from ${manifestUrl}`],
+        });
     }
-    await writeExcludeBlock(root, mounted);
-    await mkdir(path.join(root, ".claude", "state"), { recursive: true });
-    if (!(await readIfPresent(path.join(root, ".claude", "state", ".gitignore"))))
-        await writeFile(path.join(root, ".claude", "state", ".gitignore"), "*\n");
-    const state = { version, digest, mountedAt: new Date().toISOString(), manifestUrl };
-    if (!prior || prior.digest !== digest || prior.version !== version || written > 0)
-        await writeAtomic(path.join(root, MOUNT_STATE_PATH), `${JSON.stringify(state, null, 2)}\n`);
-    return { version, digest, written, kept, via: "adapter" };
-}
-export async function mountHarness(root, manifestUrl, options = {}) {
-    if (options.useEtna !== false) {
-        const specifier = ETNA_MOUNT_SPECIFIER;
-        const etna = (await import(specifier).catch(() => null));
-        if (etna && typeof etna.mount === "function") {
-            await etna.mount(root, manifestUrl);
-            const state = await readMountState(root);
-            return { version: state?.version ?? "", digest: state?.digest ?? "", written: 0, kept: 0, via: "etna" };
+    let resolved;
+    try {
+        resolved = await resolveProjectVersion(read.baseUrl, read.accessToken, projectId, pinned ? { digest: pinned.digest } : { track: "latest" });
+    }
+    catch (error) {
+        if (isOriginMismatch(error))
+            return report(await fromCache(error.message, error, read.baseUrl));
+        if (error instanceof VersionsRouteError && error.status === 404) {
+            if (error.code === "PROJECT_NOT_FOUND")
+                throw coded("PROJECT_NOT_FOUND", error.message);
+            if (error.code === "VALIDATION_FAILED" && pinned) {
+                const result = await mountVersion({ ...common, manifest: null, fetchObject: noFetch, expectedDigest: pinned.digest, recordExtras: { origin: read.baseUrl } });
+                if (result.status !== "mounted" && result.status !== "current") {
+                    throw new HarnessError(HARNESS_CODES.HARNESS_DIGEST_MISMATCH, `Project ${projectId} serves no version with the pinned digest ${pinned.digest}, and none is cached.`);
+                }
+                return report(await handOver(root, runtime, outcomeOf(projectId, result, lines, HARNESS_CODES.HARNESS_DIGEST_MISMATCH)));
+            }
+            throw new HarnessError(HARNESS_CODES.HARNESS_UNAVAILABLE, `Project ${projectId} serves no harness version yet: ${error.message}`);
         }
+        if (error instanceof VersionsRouteError && (error.status === 0 || error.status >= 500))
+            return report(await fromCache(error.message, null, read.baseUrl));
+        throw new HarnessError(HARNESS_CODES.HARNESS_MOUNT_FAILED, error instanceof Error ? error.message : String(error));
+    }
+    let manifest;
+    try {
+        manifest = await fetchVersionManifest(read.baseUrl, read.accessToken, projectId, resolved.semver);
+    }
+    catch (error) {
+        if (error instanceof VersionsRouteError && (error.status === 0 || error.status >= 500))
+            return report(await fromCache(error.message, null, read.baseUrl));
+        throw new HarnessError(HARNESS_CODES.HARNESS_MOUNT_FAILED, error instanceof Error ? error.message : String(error));
     }
-    return mountWithAdapter(root, manifestUrl, options);
+    const result = await mountVersion({
+        ...common,
+        manifest,
+        fetchObject: (entry) => fetchVersionObject(read.baseUrl, read.accessToken, projectId, resolved.semver, entry),
+        expectedDigest: pinned?.digest ?? resolved.digest,
+        recordExtras: { origin: read.baseUrl },
+    });
+    return report(await handOver(root, runtime, outcomeOf(projectId, result, lines, HARNESS_CODES.HARNESS_OFFLINE_NO_CACHE)));
 }

package/dist/lib/harness/storeWaivers.js

@@ -0,0 +1,43 @@
+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) {
+    if (!projectId)
+        return [];
+    const store = await openLocalStoreReadOnly(dbPath ? { dbPath } : {}).catch(() => null);
+    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 = ?")
+            .all(projectId);
+        const subjects = new Set();
+        for (const row of rows) {
+            let payload;
+            try {
+                payload = JSON.parse(row.payload_json);
+            }
+            catch {
+                continue;
+            }
+            if (payload.type !== "documentation" || payload.state !== "discharged" || typeof payload.subject !== "string")
+                continue;
+            if (typeof payload.outcome?.verdict !== "string" || !DISCHARGED_VERDICTS.has(payload.outcome.verdict))
+                continue;
+            subjects.add(payload.subject);
+        }
+        return [...subjects].sort().map((subject) => ({
+            kind: "waived",
+            body: `bookkeeping \`${subject}\` — its documentation obligation is discharged in the local store expires=${NEVER_EXPIRES}`,
+        }));
+    }
+    catch {
+        return [];
+    }
+    finally {
+        store.close();
+    }
+}

package/dist/lib/harness/vendor.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const VENDORED = {
+    digest: "digest/index.js",
+    mount: "mount/index.js",
+    rules: "rules/index.js",
+    rulesNode: "rules/node.js",
+};
+const WORKSPACE = {
+    digest: "@nurix/harness/digest",
+    mount: "@nurix/harness/mount",
+    rules: "@nurix/harness/rules",
+    rulesNode: "@nurix/harness/rules/node",
+};
+const VENDOR_ROOT = new URL("../../vendor/harness/", import.meta.url);
+export function isSourceRun(moduleUrl = import.meta.url) {
+    const file = fileURLToPath(moduleUrl);
+    return file.split(path.sep).join("/").includes("/packages/cli/src/");
+}
+const loaded = new Map();
+export function loadHarness(name) {
+    let module = loaded.get(name);
+    if (!module) {
+        const specifier = isSourceRun() ? WORKSPACE[name] : new URL(VENDORED[name], VENDOR_ROOT).href;
+        module = import(specifier);
+        loaded.set(name, module);
+    }
+    return module;
+}

package/dist/lib/harness/versionsClient.js

@@ -0,0 +1,54 @@
+import { authorizedFetch } from "../nustack_client.js";
+import { assertSafeOpaqueId } from "../guards.js";
+const REQUEST_TIMEOUT_MS = 15_000;
+export class VersionsRouteError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.name = "VersionsRouteError";
+        this.status = status;
+        this.code = code;
+    }
+}
+function versionsPath(projectId, ...segments) {
+    const safe = assertSafeOpaqueId("The Project id", projectId);
+    return `/api/v2/projects/${encodeURIComponent(safe)}/harness-versions${segments.map((segment) => `/${encodeURIComponent(segment)}`).join("")}`;
+}
+async function request(baseUrl, accessToken, routePath) {
+    try {
+        return await authorizedFetch(`${baseUrl}${routePath}`, {
+            headers: { Authorization: `Bearer ${accessToken}` },
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        if (typeof error.code === "string" && error.code === "ORIGIN_MISMATCH")
+            throw error;
+        throw new VersionsRouteError(0, null, `${routePath} did not answer: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function enveloped(response, label) {
+    const body = (await response.json().catch(() => null));
+    if (!response.ok || body?.data === undefined) {
+        const code = typeof body?.error?.code === "string" ? body.error.code : null;
+        const message = typeof body?.error?.message === "string" ? body.error.message : `HTTP ${response.status}`;
+        throw new VersionsRouteError(response.status, code, `${label}: ${message}`);
+    }
+    return body.data;
+}
+export async function resolveProjectVersion(baseUrl, accessToken, projectId, ask) {
+    const query = "digest" in ask ? `?digest=${encodeURIComponent(ask.digest)}` : "?track=latest";
+    const response = await request(baseUrl, accessToken, `${versionsPath(projectId, "resolve")}${query}`);
+    return enveloped(response, "harness version resolve failed");
+}
+export async function fetchVersionManifest(baseUrl, accessToken, projectId, semver) {
+    const response = await request(baseUrl, accessToken, versionsPath(projectId, semver, "manifest"));
+    return enveloped(response, `harness version ${semver} manifest read failed`);
+}
+export async function fetchVersionObject(baseUrl, accessToken, projectId, semver, entry) {
+    const response = await request(baseUrl, accessToken, versionsPath(projectId, semver, "files", ...entry.path.split("/")));
+    if (!response.ok)
+        await enveloped(response, `harness file ${entry.path} read failed`);
+    return new Uint8Array(await response.arrayBuffer());
+}

package/dist/lib/local_store/database.js

@@ -54,6 +54,24 @@ export async function openLocalStore(options = {}) {
         },
     };
 }
+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();
+        },
+    };
+}
 export async function readStoreVersion(dbFile = stateDbPath()) {
     if (!existsSync(dbFile))
         return null;

package/dist/lib/local_store/routing.js

@@ -135,3 +135,29 @@ export function gatePathOnce(store, sessionId, path, now = Date.now()) {
         store.db.prepare("DELETE FROM gated_paths WHERE gated_at < ?").run(now - GATED_PATH_RETENTION_MS);
     return isInserted;
 }
+export const DIRECT_SESSION_ID = "direct";
+export function recordBulkReadOutcome(store, transact, outcome, newId, now = Date.now()) {
+    const isDirect = outcome.sessionId === DIRECT_SESSION_ID;
+    transact(() => {
+        for (const entry of outcome.paths) {
+            insertLabelRow(store, {
+                id: newId(),
+                session_id: outcome.sessionId,
+                agent_type: outcome.agentType,
+                path: entry.realPath,
+                estimated_tokens: entry.estimatedTokens,
+                returned_tokens: entry.returnedTokens,
+                handler: "digest",
+                check_result: outcome.result,
+                bypass_used: 0,
+                latency_ms: outcome.latencyMs,
+                tokens_kept_out: -entry.returnedTokens,
+                created_at: now,
+            }, isDirect ? "local" : "pending");
+            if (outcome.result !== "pass")
+                gatePathOnce(store, outcome.sessionId, entry.realPath, now);
+        }
+        if (!isDirect && outcome.miss !== null)
+            recordRoutingMiss(store, outcome.sessionId, "read.bulk", outcome.miss, now);
+    });
+}

package/dist/lib/nustack_client.js

@@ -2,10 +2,16 @@ import { assertSafeNuStackUrl, assertSafeOpaqueId } from "./guards.js";
 import { createSseParser } from "./sse_framing.js";
 import { deadCredentialCopy, DEVICE_HEADER, envToken, forgetRefusedToken, knownDeviceId, TokenRefusedError, userAgent } from "./auth_grant.js";
 import { getOrCreateDeviceId } from "./device_identity.js";
-const DEFAULT_NUSTACK_URL = "https://apps.nustack.ai";
+import { readStoredCredential } from "./auth_grant.js";
+import { readProjectContractSync } from "./project_contract.js";
+import { contractOrigins, isContractOrigin, isPlatformDefault, originMismatchError, PLATFORM_DEFAULT_ORIGIN, recordContractOrigin, refusedContractOrigin, } from "./origin_guard.js";
+const DEFAULT_NUSTACK_URL = PLATFORM_DEFAULT_ORIGIN;
+export { contractOrigins };
 const REQUEST_TIMEOUT_MS = 10_000;
 export async function authorizedFetch(input, init = {}) {
     const headers = new Headers(init.headers);
+    if (headers.has("Authorization"))
+        await assertCredentialOrigin(String(input));
     headers.set(DEVICE_HEADER, knownDeviceId() ?? (await getOrCreateDeviceId()));
     headers.set("User-Agent", userAgent());
     const response = await globalThis.fetch(input, { ...init, headers });
@@ -33,8 +39,35 @@ export function errorMessage(payload, status, label, plane) {
     const enveloped = typeof payload?.error === "object" ? payload.error?.message : undefined;
     return enveloped ?? payload?.message ?? `${label}: HTTP ${status}`;
 }
+export function resolveNuStackOrigin(options, cwd) {
+    if (options.nustackUrl)
+        return { url: assertSafeNuStackUrl(options.nustackUrl), source: "flag" };
+    if (process.env.NUSTACK_URL)
+        return { url: assertSafeNuStackUrl(process.env.NUSTACK_URL), source: "env" };
+    const origin = readProjectContractSync(cwd).origin;
+    if (origin) {
+        const url = assertSafeNuStackUrl(origin);
+        if (!isPlatformDefault(url)) {
+            recordContractOrigin(url);
+            if (process.env.NUSTACK_TOKEN?.trim())
+                throw originMismatchError(url, null, "pat");
+        }
+        return { url, source: "contract" };
+    }
+    return { url: assertSafeNuStackUrl(DEFAULT_NUSTACK_URL), source: "default" };
+}
 export function resolveNuStackUrl(options) {
-    return assertSafeNuStackUrl(options.nustackUrl ?? process.env.NUSTACK_URL ?? DEFAULT_NUSTACK_URL);
+    return resolveNuStackOrigin(options, process.cwd()).url;
+}
+export async function assertCredentialOrigin(url) {
+    if (contractOrigins.size === 0 || !isContractOrigin(url))
+        return;
+    if (process.env.NUSTACK_TOKEN?.trim())
+        throw originMismatchError(url, null, "pat");
+    const held = (await readStoredCredential().catch(() => null))?.credential ?? null;
+    const refused = refusedContractOrigin(held?.studioBaseUrl ?? null, url);
+    if (refused)
+        throw originMismatchError(refused, held?.studioBaseUrl ?? null, held ? "device" : "none");
 }
 export async function fetchCatalogue(baseUrl) {
     const response = await authorizedFetch(`${baseUrl}/api/catalog.json`, {

package/dist/lib/onboarding/attach_existing_git.js

@@ -1,7 +1,7 @@
 import { readHeadCommit } from "../git-sync/core/repository.js";
 import { readSymbolicBranch } from "../git-sync/core/repository.js";
 import { reconcileInboundBinding } from "../git-sync/inbound/index.js";
-import { fetchToolkitProfile } from "../etna/profile.js";
+import { fetchToolkitProfile, ToolkitProfileUnavailableError } from "../etna/profile.js";
 import { classifyFolder, attachRejection } from "./folder_state.js";
 import { runRepositoryOnboarding, } from "./binding.js";
 export async function attachExistingGit(ctx, options) {
@@ -24,7 +24,19 @@ export async function attachExistingGit(ctx, options) {
     if (!boundBranch) {
         return { ok: false, code: "DETACHED_HEAD", message: "HEAD is detached — check out a branch before attaching." };
     }
-    const profile = await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, options.projectId);
+    let profile;
+    try {
+        profile = await fetchToolkitProfile(ctx.baseUrl, ctx.accessToken, options.projectId);
+    }
+    catch (error) {
+        if (error instanceof ToolkitProfileUnavailableError)
+            throw error;
+        return {
+            ok: false,
+            code: "PROJECT_SUMMARY_UNREACHABLE",
+            message: `The summary of Project ${options.projectId} could not be read, so this folder was not bound: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
     const baselineCommitId = readHeadCommit(state.repository);
     const result = await runRepositoryOnboarding({
         store: ctx.store,