sealkeep 0.11.1 → 0.11.3

package/dist/src/meter.js

@@ -0,0 +1,241 @@
+/**
+ * The context meter — what this session is costing you, per step.
+ *
+ * An AI coding session charges you for its own history on every request. A
+ * conversation that has been alive for months carries its whole transcript
+ * into each step, so a one-line question costs whatever the transcript costs,
+ * and an agent loop pays that once per command. Nothing tells you until the
+ * limit is gone.
+ *
+ * Sealkeep already holds the session files, so it can answer the question
+ * nobody else can: what is each live session costing per step, how much of
+ * that is re-read history, and what would the same work cost in a fresh
+ * session carrying a small context pack instead of a transcript.
+ *
+ * Everything here reads local files only. No key, no network, nothing leaves
+ * the machine to produce a number.
+ */
+import { createReadStream } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { createInterface } from "node:readline";
+/** A fork carries rules, a statement of what is true now, and the last handoff. */
+export const CONTEXT_PACK_TOKENS = 3_000;
+/**
+ * Which sessions are worth saying something about. Thresholds are deliberately
+ * boring: each one was true of a real session that ended a weekly allowance.
+ */
+export function signalsFor(input) {
+    const signals = [];
+    if (input.historyShare > 0.9 && input.perStep > 50_000)
+        signals.push("BLOATED");
+    if (input.ageDays > 7 || input.sizeMB > 200)
+        signals.push("STALE");
+    if (input.sleeps >= 5)
+        signals.push("POLLING");
+    return signals;
+}
+/** Turns raw counters into the numbers a person can act on. */
+export function scoreSession(raw) {
+    const steps = Math.max(raw.steps, 1);
+    const perStep = Math.round(raw.input / steps);
+    const historyShare = raw.input > 0 ? raw.cached / raw.input : 0;
+    // A fresh session still pays for the new work; what it stops paying for is
+    // the transcript. The pack is the small thing carried in its place.
+    const freshCost = steps * (CONTEXT_PACK_TOKENS + Math.round(raw.fresh / steps));
+    const scored = { ...raw, perStep, historyShare, freshCost, saving: Math.max(0, raw.input - freshCost), signals: [] };
+    scored.signals = signalsFor(scored);
+    return scored;
+}
+async function* jsonlFiles(root) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const path = join(root, entry.name);
+        if (entry.isDirectory())
+            yield* jsonlFiles(path);
+        else if (entry.name.endsWith(".jsonl"))
+            yield path;
+    }
+}
+async function* lines(file) {
+    // Streamed, because a session worth metering is often gigabytes.
+    const stream = createReadStream(file, { encoding: "utf8" });
+    try {
+        for await (const line of createInterface({ input: stream, crlfDelay: Infinity }))
+            yield line;
+    }
+    finally {
+        stream.destroy();
+    }
+}
+/** Claude Code transcripts report usage per message, so a window is a sum. */
+async function claudeSession(file, since) {
+    const info = await stat(file).catch(() => null);
+    if (!info || info.mtimeMs < since)
+        return null;
+    let steps = 0, cached = 0, fresh = 0, cacheWrite = 0, output = 0;
+    for await (const line of lines(file)) {
+        if (!line.includes('"usage"'))
+            continue;
+        let row;
+        try {
+            row = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!(Date.parse(row.timestamp ?? "") >= since))
+            continue;
+        const usage = row.message?.usage ?? {};
+        steps += 1;
+        cached += usage.cache_read_input_tokens ?? 0;
+        fresh += usage.input_tokens ?? 0;
+        cacheWrite += usage.cache_creation_input_tokens ?? 0;
+        output += usage.output_tokens ?? 0;
+    }
+    if (!steps)
+        return null;
+    return scoreSession({
+        tool: "claude", file,
+        project: basename(dirname(file)).replace(/^-/, "").replace(/-/g, "/"),
+        sizeMB: Math.round(info.size / 1e6),
+        ageDays: (Date.now() - info.birthtimeMs) / 864e5,
+        steps, tools: 0, sleeps: 0,
+        input: cached + fresh + cacheWrite, cached, fresh: fresh + cacheWrite, output,
+    });
+}
+/** Codex rollouts report cumulative counters, so a window is a delta. */
+async function codexSession(file, since) {
+    const info = await stat(file).catch(() => null);
+    if (!info || info.mtimeMs < since)
+        return null;
+    let cwd = "", before = null, last = null, steps = 0, tools = 0, sleeps = 0, seen = 0;
+    for await (const line of lines(file)) {
+        if (!line)
+            continue;
+        let row;
+        try {
+            row = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const payload = row.payload ?? {};
+        if (seen < 5) {
+            seen += 1;
+            const meta = payload.type === "session_meta" ? (payload.payload ?? payload) : (row.type === "session_meta" ? payload : null);
+            if (meta?.cwd)
+                cwd = meta.cwd;
+        }
+        const at = Date.parse(row.timestamp ?? "");
+        if (payload.type === "token_count") {
+            const usage = payload.info?.total_token_usage;
+            if (!usage)
+                continue;
+            if (!(at >= since)) {
+                before = usage;
+                continue;
+            }
+            before ??= usage;
+            last = usage;
+            steps += 1;
+        }
+        else if (at >= since && (payload.type === "custom_tool_call" || payload.type === "function_call")) {
+            tools += 1;
+            if (/\bsleep\b|"name"\s*:\s*"sleep"/.test(line))
+                sleeps += 1;
+        }
+    }
+    if (!last || !before || !steps)
+        return null;
+    const input = last.input_tokens - before.input_tokens;
+    const cached = last.cached_input_tokens - before.cached_input_tokens;
+    return scoreSession({
+        tool: "codex", file, project: cwd || "?",
+        sizeMB: Math.round(info.size / 1e6),
+        ageDays: (Date.now() - info.birthtimeMs) / 864e5,
+        steps, tools, sleeps,
+        input, cached, fresh: input - cached, output: last.output_tokens - before.output_tokens,
+    });
+}
+/** Reads local session files and scores every session touched in the window. */
+export async function meterSessions(options = {}) {
+    const hours = options.hours ?? 24;
+    const since = (options.now ?? Date.now()) - hours * 36e5;
+    const claudeRoot = options.roots?.claude ?? join(homedir(), ".claude", "projects");
+    const codexRoot = options.roots?.codex ?? join(homedir(), ".codex", "sessions");
+    const sessions = [];
+    for await (const file of jsonlFiles(claudeRoot)) {
+        const scored = await claudeSession(file, since).catch(() => null);
+        if (scored)
+            sessions.push(scored);
+    }
+    for await (const file of jsonlFiles(codexRoot)) {
+        const scored = await codexSession(file, since).catch(() => null);
+        if (scored)
+            sessions.push(scored);
+    }
+    sessions.sort((a, b) => b.input - a.input);
+    const totalInput = sessions.reduce((n, s) => n + s.input, 0);
+    const totalSaving = sessions.reduce((n, s) => n + s.saving, 0);
+    return {
+        hours, sessions, totalInput,
+        totalFreshCost: totalInput - totalSaving,
+        totalSaving,
+        savingShare: totalInput ? totalSaving / totalInput : 0,
+        worst: sessions.find((s) => s.signals.includes("BLOATED")) ?? sessions[0],
+        polling: sessions.filter((s) => s.signals.includes("POLLING")),
+    };
+}
+const tokens = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(Math.round(n));
+const percent = (share) => `${Math.round(share * 100)}%`;
+/** The receipt for one session, in the words a person would use. */
+export function renderReceipt(session) {
+    const lines = [
+        `${session.tool} session in ${basename(session.project) || session.project}`,
+        `  ${tokens(session.perStep)} tokens per step, ${percent(session.historyShare)} of it re-read history.`,
+        `  ${session.steps} steps cost ${tokens(session.input)}. The same work in a fresh session: about ${tokens(session.freshCost)}.`,
+    ];
+    if (session.signals.includes("STALE")) {
+        lines.push(`  ${session.sizeMB} MB on disk, ${session.ageDays.toFixed(0)} days old.`);
+    }
+    if (session.saving > 0)
+        lines.push(`  You are paying about ${tokens(session.saving)} for history you did not ask for.`);
+    return lines.join("\n");
+}
+/** The whole picture, for `sealkeep meter`. */
+export function renderMeter(summary) {
+    if (!summary.sessions.length) {
+        return `No agent sessions were touched in the last ${summary.hours}h, so there is nothing to meter.`;
+    }
+    const out = [
+        `Context cost, last ${summary.hours}h, across ${summary.sessions.length} session${summary.sessions.length === 1 ? "" : "s"}.`,
+        "Read from local session files. Nothing left this machine.",
+        "",
+        `${"tool".padEnd(7)}${"where".padEnd(22)}${"steps".padStart(6)}${"per step".padStart(10)}${"history".padStart(9)}${"total in".padStart(10)}  signals`,
+    ];
+    for (const s of summary.sessions.slice(0, 12)) {
+        out.push(`${s.tool.padEnd(7)}${(basename(s.project) || "?").slice(0, 21).padEnd(22)}${String(s.steps).padStart(6)}`
+            + `${tokens(s.perStep).padStart(10)}${percent(s.historyShare).padStart(9)}${tokens(s.input).padStart(10)}  ${s.signals.join(" ")}`);
+    }
+    out.push("", `Total sent: ${tokens(summary.totalInput)}. The same work from fresh sessions carrying a ${tokens(CONTEXT_PACK_TOKENS)}-token pack: about ${tokens(summary.totalFreshCost)}.`);
+    if (summary.totalSaving > 0) {
+        out.push(`That is roughly ${tokens(summary.totalSaving)} spent re-reading, ${percent(summary.savingShare)} of everything you sent.`);
+    }
+    if (summary.worst?.signals.includes("BLOATED")) {
+        out.push("", "Worst offender:", renderReceipt(summary.worst));
+        out.push("  Fork it: write what is true now into a short state note, start fresh, and search the rest on demand.");
+    }
+    if (summary.polling.length) {
+        out.push("", "Polling: an agent is sleeping and re-checking inside its own turn, paying the full context on every tick.");
+        out.push("  Move the wait into a shell command that returns once.");
+    }
+    return out.join("\n");
+}

package/dist/src/release-check.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The version to suggest, or null. Never throws, never blocks longer than its
+ * own timeout, and answers from cache when today's check already happened.
+ */
+export declare function newerReleaseThan(currentVersion: string, dataDir: string, options?: {
+    now?: () => number;
+    env?: NodeJS.ProcessEnv;
+    fetchLatest?: (signal: AbortSignal) => Promise<string | null>;
+}): Promise<string | null>;
+/** The one line a person sees. Kept to a fact and the command that acts on it. */
+export declare function updateNotice(latest: string, current: string): string;

package/dist/src/release-check.js

@@ -0,0 +1,117 @@
+/**
+ * "A newer Sealkeep is out."
+ *
+ * Shipping 0.11.0 taught us why this is worth having: a release that could not
+ * open archives written by its predecessor sat on the registry for two days,
+ * and nobody running it had any way to learn that the fix existed. A person
+ * finds out from the tool they already have open, or not at all.
+ *
+ * The rules this follows, because a version check is a network call the user
+ * did not ask for:
+ *  - never before the command runs, and never in its way: the check is a
+ *    background read of a cached answer, and the note prints after the work;
+ *  - at most one request a day, per machine, recorded in the vault's runtime
+ *    directory, so a scripted loop cannot turn into a traffic generator;
+ *  - never for a machine-readable run (`--json`), a hook, or a daemon;
+ *  - silent on every failure. An offline laptop, a blocked registry and a
+ *    proxy that answers with HTML all mean "no note", never an error;
+ *  - nothing is sent but the request itself: no vault id, no identifiers, no
+ *    telemetry. It reads the same public metadata `npm view` reads, and can be
+ *    turned off for good with SEALKEEP_NO_UPDATE_CHECK=1.
+ */
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+const REGISTRY_URL = "https://registry.npmjs.org/sealkeep/latest";
+const CHECK_INTERVAL_MS = 24 * 60 * 60_000;
+const REQUEST_TIMEOUT_MS = 2_000;
+const statePath = (dataDir) => join(dataDir, "runtime", "latest-release.json");
+/** A dotted release, compared numerically; anything unparseable sorts lowest. */
+function isNewer(candidate, current) {
+    const parts = (value) => {
+        const core = value.split(/[-+]/, 1)[0] ?? "";
+        const numbers = core.split(".").map((piece) => Number.parseInt(piece, 10));
+        return numbers.length === 3 && numbers.every((piece) => Number.isInteger(piece) && piece >= 0) ? numbers : null;
+    };
+    const left = parts(candidate);
+    const right = parts(current);
+    if (!left || !right)
+        return false;
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index])
+            return left[index] > right[index];
+    }
+    // A pre-release of the same numbers is not an upgrade to offer.
+    return false;
+}
+async function readCached(dataDir) {
+    try {
+        const raw = JSON.parse(await readFile(statePath(dataDir), "utf8"));
+        if (typeof raw.version !== "string" || typeof raw.at !== "string")
+            return null;
+        return { version: raw.version, at: raw.at };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCached(dataDir, value) {
+    const target = statePath(dataDir);
+    const temp = `${target}.${randomUUID()}.tmp`;
+    try {
+        await mkdir(join(dataDir, "runtime"), { recursive: true, mode: 0o700 });
+        await writeFile(temp, JSON.stringify(value, null, 2) + "\n", { mode: 0o600 });
+        await rename(temp, target);
+    }
+    catch {
+        // A read-only or full disk must never cost a command its result.
+    }
+    finally {
+        await rm(temp, { force: true }).catch(() => undefined);
+    }
+}
+async function fetchLatest(signal) {
+    try {
+        const response = await fetch(REGISTRY_URL, { signal, headers: { accept: "application/vnd.npm.install-v1+json, application/json" } });
+        if (!response.ok)
+            return null;
+        const body = await response.json();
+        return typeof body.version === "string" && /^\d+\.\d+\.\d+/.test(body.version) ? body.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The version to suggest, or null. Never throws, never blocks longer than its
+ * own timeout, and answers from cache when today's check already happened.
+ */
+export async function newerReleaseThan(currentVersion, dataDir, options = {}) {
+    const env = options.env ?? process.env;
+    if (env.SEALKEEP_NO_UPDATE_CHECK === "1" || env.NO_UPDATE_NOTIFIER === "1" || env.CI === "true")
+        return null;
+    const now = options.now ?? Date.now;
+    const cached = await readCached(dataDir);
+    const fresh = cached && now() - Date.parse(cached.at) < CHECK_INTERVAL_MS;
+    if (fresh)
+        return isNewer(cached.version, currentVersion) ? cached.version : null;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    let latest;
+    try {
+        latest = await (options.fetchLatest ?? fetchLatest)(controller.signal);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    // A failed check is recorded as "asked today" too: an offline machine must
+    // not retry on every single command.
+    await writeCached(dataDir, { version: latest ?? cached?.version ?? currentVersion, at: new Date(now()).toISOString() });
+    if (!latest)
+        return null;
+    return isNewer(latest, currentVersion) ? latest : null;
+}
+/** The one line a person sees. Kept to a fact and the command that acts on it. */
+export function updateNotice(latest, current) {
+    return `Sealkeep ${latest} is available (you have ${current}). Update with: npm i -g sealkeep@latest`;
+}

package/dist/src/search.d.ts

@@ -246,7 +246,8 @@ export declare function searchMetadata(dataDir: string, query: string, options?:
  *
  * This decrypts every archive locally, so it requires the recovery phrase. The
  * resulting index is itself encrypted with the same envelope before it touches the
- * disk, and it is never uploaded: `sealkeep upload` only ever sends archive objects.
+ * disk, and only that ciphertext ever leaves the machine — synced to the account
+ * so your other machines can search it (`pushed` in the result says whether it was).
  */
 export declare function buildContentIndex(dataDir: string, rawPhrase: string, options?: {
     sync?: boolean;

package/dist/src/search.js

@@ -397,12 +397,27 @@ export async function contentIndexNeedsPolicyUpgrade(dataDir) {
         if (!Array.isArray(raw.indexed) || raw.extractionPolicy !== INDEX_EXTRACTION_POLICY)
             return true;
         const indexed = new Set(raw.indexed.filter((id) => typeof id === "string"));
-        return (await listArchives(dataDir)).some((record) => !indexed.has(record.id));
+        return coverageGaps(await listArchives(dataDir), indexed).length > 0;
     }
     catch {
         return stat(indexPath(dataDir)).then(() => true, () => false);
     }
 }
+/**
+ * The archives the index still owes: sealed here, not superseded, not covered.
+ *
+ * One definition, because the daemon's "is the index finished" check kept its
+ * own and counted superseded snapshots too. Those are never indexed on their
+ * own — the snapshot that superseded one carries every byte of it, and the
+ * index retires its id — so they can never appear in coverage, and the check
+ * could never pass on a vault that had ever superseded one: the daemon retried
+ * `index_incomplete` forever, and disk reclaim waits for exactly that check.
+ * `sealkeep index status` and doctor read the same list.
+ */
+function coverageGaps(records, indexed) {
+    const superseded = supersededArchiveIds(records);
+    return records.filter((record) => !indexed.has(record.id) && !superseded.has(record.id));
+}
 const MIN_TOKEN = 3;
 const MAX_TOKENS_PER_ARCHIVE = 4000;
 /**
@@ -442,6 +457,12 @@ export function isRecalledMemoryLine(line) {
         return true;
     if (line.includes("Sealkeep automatically loaded preserved context for project"))
         return true;
+    if (line.includes("preserved by Sealkeep from previous sessions"))
+        return true;
+    // Pull mode says only that recall exists; it carries no history, but it is
+    // still Sealkeep's own words rather than anything the session produced.
+    if (line.includes("Nothing has been loaded into this conversation."))
+        return true;
     try {
         const row = JSON.parse(line);
         const payload = row.payload && typeof row.payload === "object" && !Array.isArray(row.payload)
@@ -785,7 +806,8 @@ export async function searchMetadata(dataDir, query, options = {}) {
  *
  * This decrypts every archive locally, so it requires the recovery phrase. The
  * resulting index is itself encrypted with the same envelope before it touches the
- * disk, and it is never uploaded: `sealkeep upload` only ever sends archive objects.
+ * disk, and only that ciphertext ever leaves the machine — synced to the account
+ * so your other machines can search it (`pushed` in the result says whether it was).
  */
 export async function buildContentIndex(dataDir, rawPhrase, options = {}) {
     const phrase = canonicalPhrase(rawPhrase);
@@ -991,10 +1013,6 @@ export async function buildContentIndex(dataDir, rawPhrase, options = {}) {
         }
     }
     const recordById = new Map(records.map((record) => [record.id, record]));
-    const deltaBases = new Set(records.flatMap((record) => {
-        const delta = deltaOf(record);
-        return delta ? [delta.baseArchiveId] : [];
-    }));
     // Once a verified child is present, its base is a dependency rather than a
     // separate stale search result. Purge those old logical postings in one
     // token-map pass. Physical archive/catalog entries stay covered so a later
@@ -1061,8 +1079,9 @@ export async function buildContentIndex(dataDir, rawPhrase, options = {}) {
     // start with them rather than making today's session wait behind months of
     // history. Posting order no longer depends on completion order; the
     // serializer sorts by sealed session metadata before applying its cap.
-    // A linear delta chain is one logical session. Only its latest leaf is
-    // scheduled; indexOneRecord authenticates the chain once and records its
+    // A linear delta chain is one logical session. Only the newest link that
+    // still needs indexing is scheduled — normally the leaf (see `awaitedBases`
+    // below); indexOneRecord authenticates the chain once and records its
     // ancestors as covered dependencies. This turns N watcher snapshots from
     // 1+2+...+N physical reads into N reads.
     // A whale goes after every ordinary session, newest-first within each
@@ -1077,8 +1096,23 @@ export async function buildContentIndex(dataDir, rawPhrase, options = {}) {
     // coverage.json (this machine's own view of the manifest, already read
     // above as `mine`) and the manifest's tombstones answer the same question.
     const segmentsTombstones = segmentsMode ? new Set((await readManifest(dataDir)).tombstones) : null;
-    const fresh = records.filter((record) => !deltaBases.has(record.id) && !superseded.has(record.id)
-        && (segmentsMode ? !mine.has(record.id) && !segmentsTombstones.has(record.id) : !index.archives[record.id]))
+    const uncovered = (record) => !superseded.has(record.id)
+        && (segmentsMode ? !mine.has(record.id) && !segmentsTombstones.has(record.id) : !index.archives[record.id]);
+    // A delta base is skipped only while one of its own children is still
+    // waiting: the newest waiting link is scheduled instead, and walking its
+    // chain to the root covers this base on the way. Skipping every base
+    // unconditionally assumed the leaf would always be walked — but a leaf
+    // indexed at seal time is never walked, and covers only the bytes it
+    // appended. Every link sealed before it, the whole beginning of the
+    // session, then sat outside every build forever while each run reported
+    // success. Measured on a real vault: 400 such links across 76 sessions;
+    // words found only in those early ranges came back in 0 of 20 searches,
+    // words from the covered tail of the same sessions in 10.
+    const awaitedBases = new Set(records.flatMap((record) => {
+        const delta = deltaOf(record);
+        return delta && uncovered(record) ? [delta.baseArchiveId] : [];
+    }));
+    const fresh = records.filter((record) => uncovered(record) && !awaitedBases.has(record.id))
         .sort((a, b) => Number(whale(a)) - Number(whale(b)) || b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id));
     let indexedNow = 0;
     let skipped = 0;
@@ -6329,14 +6363,10 @@ export async function indexCoverage(dataDir, options = {}) {
         .then((raw) => JSON.parse(raw))
         .catch(() => null);
     const indexedIds = new Set(coverage?.indexed ?? []);
-    // A superseded snapshot is intentionally never indexed on its own — the
-    // newer snapshot named by its `supersedes` field already carries every one
-    // of its bytes (see buildContentIndex's `fresh` filter) — so it is not a
-    // gap. Doctor's `search-index` check reads `missing` and must go green on a
-    // vault whose only unindexed records are superseded snapshots.
-    const superseded = supersededArchiveIds(records);
-    const missing = records
-        .filter((record) => !indexedIds.has(record.id) && !superseded.has(record.id))
+    // A superseded snapshot is intentionally never indexed on its own, so it is
+    // not a gap (see coverageGaps). Doctor's `search-index` check reads `missing`
+    // and must go green on a vault whose only unindexed records are superseded.
+    const missing = coverageGaps(records, indexedIds)
         .map((record) => ({ id: record.id, path: record.source.path, agent: record.source.agent }));
     const indexBytes = await import("node:fs/promises").then(({ stat }) => stat(indexPath(dataDir))).then((info) => info.size).catch(() => 0);
     let searchable = null;

package/dist/src/team-presence.js

@@ -454,7 +454,13 @@ export async function reconcileCloudTeamAccess(dataDir, phrase, preferred) {
     // seals it, binds the local project, then acknowledges the cloud request.
     // If the response from createTeamSpace was lost, the next list observes the
     // already-created owner space and completes the same request idempotently.
+    //
+    // The space list is read once and re-read only after this pass itself
+    // created, bound or re-listed a space. It used to be fetched three times
+    // per pass unconditionally; on an idle vault that was half of every pass's
+    // requests, and the three answers were always the same.
     let spaces = await listTeamSpaces(dataDir, preferred);
+    let spacesStale = false;
     const projectRequests = await listTeamProjectRequests(dataDir, preferred);
     for (const request of projectRequests) {
         if (request.state !== "requested")
@@ -464,6 +470,7 @@ export async function reconcileCloudTeamAccess(dataDir, phrase, preferred) {
             continue;
         let space = spaces.find((item) => item.role === "owner" && item.project_name?.trim() === project);
         if (!space) {
+            spacesStale = true;
             try {
                 const made = await createProjectTeamSpace(dataDir, project, phrase, preferred);
                 space = { space_key: made.spaceKey, role: "owner", key_version: made.keyVersion, realtime_key: made.realtimeKey, project_name: project };
@@ -486,8 +493,12 @@ export async function reconcileCloudTeamAccess(dataDir, phrase, preferred) {
             failures.push({ operation: "complete_project", code: accessFailureCode(error) });
         }
     }
-    spaces = await listTeamSpaces(dataDir, preferred);
-    bound += await reconcileTeamProjectDrafts(dataDir, phrase, spaces, preferred);
+    if (spacesStale)
+        spaces = await listTeamSpaces(dataDir, preferred);
+    const draftsBound = await reconcileTeamProjectDrafts(dataDir, phrase, spaces, preferred);
+    bound += draftsBound;
+    if (draftsBound > 0)
+        spacesStale = true;
     const config = await readConfig(dataDir);
     const localBySpace = new Map(Object.entries(config.teamSpaces ?? {}).map(([project, binding]) => [binding.spaceKey, { project, binding }]));
     const locallyDisconnected = new Set(config.teamSpaceOptOuts ?? []);
@@ -532,7 +543,8 @@ export async function reconcileCloudTeamAccess(dataDir, phrase, preferred) {
     // An accepted invitation is authoritative cloud membership. On every fresh
     // machine, recover its wrapped feed key and bind the human project label
     // without asking for an opaque space id or a local "join" command.
-    spaces = await listTeamSpaces(dataDir, preferred);
+    if (spacesStale)
+        spaces = await listTeamSpaces(dataDir, preferred);
     for (const space of spaces) {
         if (!SPACE_RE.test(space.space_key) || localBySpace.has(space.space_key) || locallyDisconnected.has(space.space_key))
             continue;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "sealkeep",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "type": "module",
-  "description": "Sealkeep by SPALA AI \u2014 your AI coding-agent history, sealed, searchable, and shared across your machines.",
+  "description": "Sealkeep by SPALA AI — your AI coding-agent history, sealed, searchable, and shared across your machines.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/spala-ai/sealkeep.git"

package/web/app.js

@@ -4485,6 +4485,15 @@ function renderSettingsForm(local, _resolvedTrashStrategy) {
   $("f-interval").value = local.schedule.intervalMinutes;
   $("f-bandwidth").value = local.bandwidth?.uploadLimitMbps ?? "";
   $("f-reserve").value = local.diskReserveMb ?? "";
+  // Undefined means a settings file written before these existed; both default
+  // on. Guarded because a shell that predates these controls must still load
+  // the rest of the form rather than stop at the first missing element.
+  const check = (id, on) => { const el = $(id); if (el) el.checked = on; };
+  const fill = (id, value) => { const el = $(id); if (el) el.value = value; };
+  check("f-auto-inject", local.recall?.autoInject !== false);
+  check("f-mcp-enabled", local.mcp?.enabled !== false);
+  fill("f-cpu", local.limits?.cpuPercent ?? "");
+  fill("f-memory", local.limits?.memoryMb ?? "");
   const cacheDays = local.localArchiveCacheDays === undefined ? 7 : local.localArchiveCacheDays;
   $("f-local-archive-cache-all").checked = cacheDays === null;
   $("f-local-archive-cache-days").value = cacheDays === null ? "7" : String(cacheDays);
@@ -4512,6 +4521,18 @@ function collectSettingsPatch() {
       const raw = $("f-reserve").value.trim();
       return raw === "" ? null : Math.min(102_400, Math.max(200, Math.round(Number(raw) || 0)));
     })(),
+    recall: { autoInject: $("f-auto-inject")?.checked !== false },
+    mcp: { enabled: $("f-mcp-enabled")?.checked !== false },
+    limits: {
+      cpuPercent: (() => {
+        const raw = ($("f-cpu")?.value ?? "").trim();
+        return raw === "" ? null : Math.min(100, Math.max(5, Math.round(Number(raw) || 30)));
+      })(),
+      memoryMb: (() => {
+        const raw = ($("f-memory")?.value ?? "").trim();
+        return raw === "" ? null : Math.min(65_536, Math.max(128, Math.round(Number(raw) || 1536)));
+      })(),
+    },
     localArchiveCacheDays: $("f-local-archive-cache-all").checked
       ? null
       : Math.min(3650, Math.max(0, Math.round(Number($("f-local-archive-cache-days").value) || 0)))

package/web/index.html

@@ -323,6 +323,17 @@
             <p class="note">Off by default. When on, this machine permanently frees only originals whose encrypted archive is verified in storage, searchable, unchanged, idle, and past the grace period. Codex keeps a tiny same-session resume pointer. Policy and timing stay in the <a href="#rules">Free up disk rules</a>.</p>
           </div>
 
+          <h3 id="machine-agent">What reaches your agent</h3>
+          <div class="field">
+            <label class="opt"><input id="f-auto-inject" type="checkbox"> Hand preserved history to an agent when a session starts</label>
+            <p class="note">On by default. Your agent opens a project and already knows where you left off, without being asked.</p>
+            <p class="note"><b>What it costs.</b> Anything placed in a conversation is re-read by the model on every later step, so a block added at the start is paid for again on every request that follows. Sealkeep sends each thing once and never repeats itself, which on a measured session cut this from 86 million tokens to 11 million, under one percent of what that session sent. Turn this off and preserved history is still written as notes your agent reads for itself, and is still searchable — it simply is not volunteered.</p>
+          </div>
+          <div class="field">
+            <label class="opt"><input id="f-mcp-enabled" type="checkbox"> Let agents search this vault themselves</label>
+            <p class="note">On by default. Runs a local tool server so Claude Code and Codex can search your sealed history on demand. Nothing is exposed to the network. Turn it off and agents keep the notes and the automatic recall, but cannot go looking for more.</p>
+          </div>
+
           <h3 id="machine-resources">Speed and resource limits</h3>
           <div class="row">
             <div class="field"><label for="f-interval">Check every (minutes)</label><input id="f-interval" type="number" min="1" max="1440"></div>
@@ -332,6 +343,16 @@
               <p class="note">Automatic shares one 8 Mbps background ceiling across Sealkeep jobs so agent calls, meetings, and normal browsing keep network headroom. This applies to unattended archive and shared-memory transfers on this machine.</p>
               <p class="note">Background sealing, indexing, and memory preparation share a low-priority CPU budget targeting 30% of one CPU core. Short bursts can exceed this target. Large index workers have a 1.5 GB RSS safety limit. Foreground MCP searches are not throttled.</p>
             </div>
+            <div class="field">
+              <label for="f-cpu">Background CPU ceiling, % of one core (blank for automatic)</label>
+              <input id="f-cpu" type="number" min="5" max="100" step="5" inputmode="numeric" placeholder="automatic · 30%">
+              <p class="note">Automatic targets 30% of one core for sealing, indexing, and memory preparation. A number here only ever makes Sealkeep gentler, never greedier, and below 5% it would stall rather than pace.</p>
+            </div>
+            <div class="field">
+              <label for="f-memory">Background memory ceiling, MB (blank for automatic)</label>
+              <input id="f-memory" type="number" min="128" max="65536" step="128" inputmode="numeric" placeholder="automatic · 1536 MB">
+              <p class="note">The ceiling a background worker may reach before it stops and retries smaller. Lower it on a small machine; it only ever tightens the automatic value.</p>
+            </div>
             <div class="field">
               <label for="f-reserve">Always keep free, MB (blank for automatic)</label>
               <input id="f-reserve" type="number" min="200" placeholder="automatic">