sealkeep 0.9.0 → 0.11.0

package/dist/src/worker.js

@@ -1,25 +1,77 @@
-import { createReadStream } from "node:fs";
 import { stat } from "node:fs/promises";
-import { createHash } from "node:crypto";
 import { hostname } from "node:os";
 import { resolve } from "node:path";
 import { ArchiveQueue } from "./queue.js";
 import { archiveFile, listArchives, readConfig } from "./vault.js";
-import { isVaultlineError } from "./errors.js";
-import { roomToArchive, sealReservations, spaceNeededFor } from "./disk.js";
+import { isSealkeepError } from "./errors.js";
+import { LOCAL_SEAL_CHUNK_BYTES, roomToArchive, sealReservations, spaceNeededFor } from "./disk.js";
 import { isV2 } from "./types.js";
+import { automaticTranscriptIsEnabled, backgroundUploadBytesPerSecond, readLocalSettings } from "./machine-settings.js";
+import { hashFileRange } from "../packages/sealkeep-crypto/src/index.js";
+import { createProgressDeadline } from "./progress-deadline.js";
+import { readUntouchedCodexResumeStub } from "./resume-stub.js";
+import { createBackgroundCpuYield } from "./background-cpu.js";
 /** Parallel seals are capped whatever the config asks: sealing is disk- and CPU-bound, and a machine short of space is rarely long on either. */
 export const MAX_SEAL_CONCURRENCY = 4;
+/** Long enough for a slow local chunk, short enough to expire before the
+ * ordinary five-minute queue lease can be mistaken for useful work. */
+export const DEFAULT_SEAL_IDLE_MS = 2 * 60_000;
 /** Operational summary only: codes and messages, never transcript content. */
 function summarize(error) {
-    if (isVaultlineError(error))
+    if (isSealkeepError(error))
         return { code: error.code, message: error.message };
     return { code: "internal", message: error instanceof Error ? error.message : "Unexpected error" };
 }
-const sha256OfFile = (path) => new Promise((done, failed) => {
-    const hash = createHash("sha256");
-    createReadStream(path).on("data", (piece) => hash.update(piece)).on("end", () => done(hash.digest("hex"))).on("error", failed);
-});
+const sha256OfFile = async (path, end, onActivity, signal, onYield) => (await hashFileRange(path, 0, end, onActivity, signal, onYield)).sha256;
+/**
+ * Keeps one queue lease alive through hashing, compression, encryption and
+ * upload. Progress and renewal both rewrite the same file-backed job, so they
+ * share one promise lane: otherwise a late progress write could overwrite a
+ * newer expiry, or even put `leased` back after `complete` wrote `done`.
+ */
+function keepLeaseAlive(queue, jobId, leaseId, options) {
+    let stopped = false;
+    let writes = Promise.resolve();
+    let firstError;
+    let lastLeaseWriteAt = Date.now();
+    const deadline = createProgressDeadline({
+        operation: `Sealing queue job ${jobId}`,
+        idleMs: options.idleMs,
+        signal: options.signal,
+    });
+    const schedule = (write) => {
+        if (stopped)
+            return;
+        writes = writes.then(async () => { await write(); }).catch((error) => { firstError ??= error; });
+    };
+    const renewForActivity = () => {
+        deadline.progress();
+        const at = Date.now();
+        if (at - lastLeaseWriteAt < Math.min(15_000, queue.leaseHeartbeatMs()))
+            return;
+        lastLeaseWriteAt = at;
+        schedule(() => queue.renew(jobId, leaseId));
+    };
+    return {
+        signal: deadline.signal,
+        progress(bytes, of) {
+            deadline.progress();
+            lastLeaseWriteAt = Date.now();
+            schedule(() => queue.progress(jobId, leaseId, bytes, of));
+        },
+        activity: renewForActivity,
+        wait(work) { return deadline.wait(work); },
+        async stop() {
+            if (!stopped) {
+                stopped = true;
+                deadline.close();
+            }
+            await writes;
+            if (firstError)
+                throw firstError;
+        }
+    };
+}
 /**
  * The pressure valve: a transcript the disk cannot hold a sealed copy of
  * streams STRAIGHT into a chunk folder instead of waiting for a reclaim —
@@ -28,57 +80,60 @@ const sha256OfFile = (path) => new Promise((done, failed) => {
  * local seal, so the ordinary path (local seal, delta chains, offline
  * archiving) is untouched; under pressure, full seals beat no seals.
  */
-async function streamUnderPressure(dataDir, job, phrase) {
-    const config = await readConfig(dataDir);
-    if ((config.storageMode ?? "sealed") === "plain")
-        return { reason: "plain vaults keep readable archives on this disk" };
-    if (config.remoteStorage?.provider === "gdrive")
-        return { reason: "Google Drive stores archives as single objects, which need local room to build" };
-    // No remoteStorage entry is NOT "no storage": an enrolled managed vault
-    // carries a cloud token instead. sealToChunkFolder resolves the target the
-    // same way the rest of the product does, and its refusal becomes the reason.
-    // The dedup archiveFile would have done: an unchanged source that is
-    // already archived completes without sealing — or streaming — anything.
+async function streamUnderPressure(dataDir, job, phrase, options = {}) {
+    // Answer the free operation before provider capability. An unchanged source
+    // already represented by an archive needs no scratch space and no upload;
+    // this is equally true for plain vaults, Drive and an offline managed vault.
+    // The former order returned those provider limitations first and left exact,
+    // already-verified snapshots stuck in `ready` forever on a full disk.
     const absolute = resolve(job.sourcePath);
     const size = await stat(absolute).then((entry) => entry.size).catch(() => -1);
     const records = await listArchives(dataDir).catch(() => []);
     const candidates = records.filter(isV2).filter((record) => record.source.path === absolute && record.source.bytes === size);
     if (candidates.length > 0) {
-        const digest = await sha256OfFile(absolute).catch(() => null);
+        // Hash exactly the snapshot whose length we compared. A resumed/live
+        // transcript can keep appending faster than a low-priority reader; an
+        // unbounded stream then chases the writer forever and never reaches the
+        // actual bounded seal below.
+        const digest = await sha256OfFile(absolute, size, options.onActivity, options.signal, options.onYield).catch(() => null);
         const match = digest ? candidates.find((record) => record.source.sha256 === digest) : undefined;
         if (match)
             return { record: match, deduplicated: true };
     }
+    const config = await readConfig(dataDir);
+    if ((config.storageMode ?? "sealed") === "plain")
+        return { reason: "plain vaults keep readable archives on this disk" };
+    if (config.remoteStorage?.provider === "gdrive")
+        return { reason: "Google Drive stores archives as single objects, which need local room to build" };
+    // No remoteStorage entry is NOT "no storage": an enrolled managed vault
+    // carries a cloud token instead. sealToChunkFolder resolves the target the
+    // same way the rest of the product does, and its refusal becomes the reason.
     try {
-        const { claudeProjectFromPath, codexProjectFromRollout } = await import("./adapters.js");
-        const project = job.agent === "claude"
-            ? claudeProjectFromPath(absolute).project
-            : job.agent === "codex"
-                ? (await codexProjectFromRollout(absolute, new Date().toISOString())).project
-                : null;
+        const { projectIdentityOfRecord } = await import("./adapters.js");
+        const identity = await projectIdentityOfRecord({
+            source: { path: absolute, agent: job.agent },
+            createdAt: new Date().toISOString(),
+        });
+        const { project, projectKey } = identity;
         const { sealToChunkFolder } = await import("./chunk-store.js");
-        const outcome = await sealToChunkFolder(dataDir, absolute, phrase, job.agent, { project });
+        const { teamRecipientsForProject } = await import("./vault.js");
+        const teamRecipients = await teamRecipientsForProject(dataDir, project, projectKey);
+        const local = await readLocalSettings(dataDir);
+        const outcome = await sealToChunkFolder(dataDir, absolute, phrase, job.agent, {
+            project, projectKey, teamRecipients, signal: options.signal,
+            // Pressure streaming is automatic work on an already stressed machine.
+            // Small chunks bound the otherwise unavoidable putObject burst; the
+            // sustained rate follows the same per-machine setting as normal uploads.
+            chunkBytes: 4 * 1024 * 1024,
+            maxBytesPerSecond: backgroundUploadBytesPerSecond(local),
+            onYield: options.onYield,
+        });
         return { record: outcome.record, deduplicated: false };
     }
     catch (error) {
         return { reason: summarize(error).message };
     }
 }
-/**
- * A `sealConcurrency` in the vault's config.json, if someone put one there.
- * The field is not part of the typed config yet; readConfig parses and keeps
- * unknown fields, so a hand-added value is visible here. Anything unreadable
- * or non-numeric means the default.
- */
-async function configuredConcurrency(dataDir) {
-    try {
-        const config = (await readConfig(dataDir));
-        return typeof config.sealConcurrency === "number" ? config.sealConcurrency : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 /**
  * Encrypts queued transcripts. The recovery phrase lives only in this process:
  * it is never written to a job, a log line, or the local API.
@@ -97,18 +152,95 @@ export async function drainQueue(dataDir, phrase, options = {}) {
     const owner = options.owner ?? `${hostname()}:${process.pid}`;
     const max = options.max ?? 25;
     const reservations = options.reservations ?? sealReservations;
-    const requested = options.concurrency ?? (await configuredConcurrency(dataDir)) ?? 1;
+    const requested = options.concurrency ?? 1;
     const concurrency = Math.min(MAX_SEAL_CONCURRENCY, Math.max(1, Math.trunc(requested) || 1));
     const processed = [];
+    // One announcement pass per DRAIN, not per seal: pushing the account's
+    // index slot costs the whole slot every time (58 MB on the founder vault,
+    // ~60 s), so a two-session drain used to pay it twice. Every fresh seal in
+    // an ACTIVE project is collected here and announced once at the end.
+    const sealedByProject = new Map();
+    // Hooks are separate short-lived processes from the filesystem watcher, and
+    // a job may already be ready when someone adds an exclusion. Re-check the
+    // same machine policy before a worker claims anything. Held jobs stay ready
+    // (nothing is deleted); removing the exclusion makes them eligible again.
+    // An explicit selection from Sessions uses event="manual" and intentionally
+    // overrides the automatic watcher policy.
+    const local = await readLocalSettings(dataDir);
     const refusedIds = new Set();
+    const eligible = (job) => job.event === "manual" || automaticTranscriptIsEnabled(local, job.agent, job.sourcePath);
+    const sealIdleMs = Math.max(1, Math.trunc(options.sealIdleMs ?? DEFAULT_SEAL_IDLE_MS));
+    const cpuYield = options.backgroundCpuTarget === undefined
+        ? undefined
+        : createBackgroundCpuYield({
+            target: options.backgroundCpuTarget,
+            signal: options.signal,
+            cpuUsage: options.cpuUsage,
+            now: options.now,
+            sleep: options.sleep,
+        });
     let budget = max;
     async function work(workerOwner) {
         while (budget > 0) {
+            if (options.signal?.aborted)
+                return;
             budget -= 1;
-            const job = await queue.claim(workerOwner, refusedIds);
+            const job = await queue.claim(workerOwner, refusedIds, eligible);
             if (!job?.lease)
                 return;
             const leaseId = job.lease.id;
+            const leaseKeeper = keepLeaseAlive(queue, job.id, leaseId, { signal: options.signal, idleMs: sealIdleMs });
+            // Queue metadata describes when intent was recorded; the live path may
+            // have grown or compacted since. Reserve and report the bounded state we
+            // can actually observe now, not yesterday's stale byte count.
+            const sourceSnapshot = await stat(job.sourcePath).then((entry) => ({
+                bytes: entry.size,
+                modifiedAt: entry.mtime.toISOString(),
+                modifiedAtMs: entry.mtimeMs,
+            })).catch(() => ({
+                bytes: job.sourceBytes,
+                modifiedAt: job.sourceModifiedAt,
+                modifiedAtMs: Date.parse(job.sourceModifiedAt),
+            }));
+            // Reclaim leaves a tiny native Codex rollout behind so the vendor's own
+            // session catalog can still resolve `codex resume <id>`. It already
+            // points at an encrypted archive; sealing that untouched pointer would
+            // create a second, content-free memory and make every safety scan churn.
+            // Recognition is deliberately exact. The moment Codex appends a turn,
+            // the file no longer has the three-line stub shape and is archived as
+            // genuinely new work on the normal path below.
+            const resumeStub = job.agent === "codex"
+                ? await readUntouchedCodexResumeStub(job.sourcePath)
+                : null;
+            if (resumeStub) {
+                const archived = (await listArchives(dataDir)).find((record) => record.version === 2
+                    && record.id === resumeStub.archiveId && record.source.path === resolve(job.sourcePath)
+                    && record.reclaimed?.resumeStub?.version === 1
+                    && record.reclaimed.resumeStub.sessionId === resumeStub.sessionId
+                    && record.reclaimed.resumeStub.bytes === resumeStub.bytes
+                    && record.reclaimed.resumeStub.sha256 === resumeStub.sha256);
+                if (archived?.version === 2) {
+                    await leaseKeeper.stop();
+                    processed.push(await queue.complete(job.id, leaseId, {
+                        archiveId: archived.id,
+                        ciphertextSha256: archived.cipher.ciphertextSha256,
+                        bytes: sourceSnapshot.bytes,
+                        deduplicated: true,
+                    }, { bytes: sourceSnapshot.bytes, modifiedAt: sourceSnapshot.modifiedAt }));
+                    continue;
+                }
+            }
+            const completedSnapshot = async (record) => {
+                if (record.source.bytes !== sourceSnapshot.bytes)
+                    return undefined;
+                const after = await stat(job.sourcePath).catch(() => null);
+                // If the agent appended or rewrote while sealing, a newer queue row is
+                // real work and must survive. Only settle siblings when the exact stat
+                // observation used for capacity stayed stable through completion.
+                if (!after?.isFile() || after.size !== sourceSnapshot.bytes || after.mtimeMs !== sourceSnapshot.modifiedAtMs)
+                    return undefined;
+                return { bytes: sourceSnapshot.bytes, modifiedAt: sourceSnapshot.modifiedAt };
+            };
             // Do not start an archive there is no room to finish. Sealing writes the
             // sealed object while the original is still on disk, and the machines
             // this runs on are, by definition, the ones short of space. The claim is
@@ -117,10 +249,10 @@ export async function drainQueue(dataDir, phrase, options = {}) {
             // bytes as already spoken for.
             const guarded = options.requireSpace !== false;
             if (guarded)
-                reservations.reserve(job.id, spaceNeededFor(job.sourceBytes, 0));
+                reservations.reserve(job.id, spaceNeededFor(sourceSnapshot.bytes, 0));
             try {
                 if (guarded) {
-                    const room = await roomToArchive(dataDir, job.sourceBytes, options.reserveBytes, reservations, job.id);
+                    const room = await roomToArchive(dataDir, sourceSnapshot.bytes, options.reserveBytes, reservations, job.id);
                     if (!room.ok) {
                         // Before leaving it queued, try the pressure valve: stream the
                         // seal straight into a chunk folder, whose peak local cost is one
@@ -129,12 +261,17 @@ export async function drainQueue(dataDir, phrase, options = {}) {
                         // size would starve every sibling seal in the pass.
                         if (guarded)
                             reservations.release(job.id);
-                        const streamed = await streamUnderPressure(dataDir, job, phrase);
+                        const streamed = await leaseKeeper.wait(streamUnderPressure(dataDir, job, phrase, {
+                            signal: leaseKeeper.signal,
+                            onActivity: () => leaseKeeper.activity(),
+                            ...(cpuYield ? { onYield: async () => { leaseKeeper.activity(); await cpuYield(); } } : {}),
+                        }));
                         if ("record" in streamed) {
+                            await leaseKeeper.stop();
                             processed.push(await queue.complete(job.id, leaseId, {
                                 archiveId: streamed.record.id, ciphertextSha256: streamed.record.cipher.ciphertextSha256,
                                 bytes: streamed.record.source.bytes, deduplicated: streamed.deduplicated
-                            }));
+                            }, await completedSnapshot(streamed.record)));
                             continue;
                         }
                         // Left queued rather than failed: nothing is wrong with the
@@ -143,11 +280,22 @@ export async function drainQueue(dataDir, phrase, options = {}) {
                         // an earlier version stopped the whole loop here, and one 1.7 GB
                         // transcript at the head of a nearly-full disk's queue starved
                         // forty smaller jobs that would have fit.
+                        await leaseKeeper.stop();
+                        // Publish the refusal to sibling workers before the row becomes
+                        // claimable again; otherwise another concurrent worker can take
+                        // the same oversized row in the release/add scheduling gap.
+                        refusedIds.add(job.id);
                         processed.push(await queue.release(job.id, leaseId, {
                             code: "insufficient_disk_space",
                             message: `${room.detail} Streaming it to cloud instead was not possible: ${streamed.reason}.`
                         }));
-                        refusedIds.add(job.id);
+                        // `max` is a completion/attempt budget, not a limit on how many
+                        // capacity-held rows we may inspect. Give this slot back so one
+                        // oversized transcript cannot consume the daemon's single-item
+                        // turn and starve a smaller session behind it. `refusedIds` keeps
+                        // the pass finite: this row cannot be claimed again until a later
+                        // drain, after disk or storage conditions may have changed.
+                        budget += 1;
                         continue;
                     }
                 }
@@ -156,21 +304,65 @@ export async function drainQueue(dataDir, phrase, options = {}) {
                     // job at most every 16 MB or 5% — enough to move visibly on a 1.6 GB
                     // seal, cheap enough to be nothing on a 7 KB one. Per job, so several
                     // concurrent seals each report their own.
-                    const totalBytes = await stat(job.sourcePath).then((s) => s.size).catch(() => 0);
+                    const totalBytes = sourceSnapshot.bytes;
                     let lastMark = 0;
                     const step = Math.max(16 * 1024 * 1024, Math.floor(totalBytes / 20));
                     const onProgress = totalBytes > 0 ? (bytesRead) => {
+                        // Every actual source window resets the idle deadline. Queue-file
+                        // progress remains throttled separately so liveness does not turn
+                        // a large transcript into thousands of metadata writes.
+                        leaseKeeper.activity();
                         if (bytesRead - lastMark < step && bytesRead < totalBytes)
                             return;
                         lastMark = bytesRead;
-                        void queue.progress(job.id, leaseId, bytesRead, totalBytes).catch(() => { });
+                        leaseKeeper.progress(bytesRead, totalBytes);
                     } : undefined;
-                    const record = await archiveFile(dataDir, job.sourcePath, phrase, job.agent, { onProgress, delta: options.delta !== false });
-                    processed.push(await queue.complete(job.id, leaseId, { archiveId: record.id, ciphertextSha256: record.cipher.ciphertextSha256, bytes: record.source.bytes, deduplicated: record.deduplicated }));
+                    // The project is knowable only while the source is still on disk —
+                    // derive it NOW and store it in the record, the same answer
+                    // `projects backfill` would compute later (and cannot, once the
+                    // source is reclaimed).
+                    const { projectIdentityOfRecord } = await import("./adapters.js");
+                    const identity = await projectIdentityOfRecord({ source: { path: job.sourcePath, agent: job.agent }, createdAt: new Date().toISOString() })
+                        .catch(() => ({ project: null, projectKey: null, projectPath: null }));
+                    const { project, projectKey } = identity;
+                    const { teamRecipientsForProject } = await import("./vault.js");
+                    const teamRecipients = await teamRecipientsForProject(dataDir, project, projectKey);
+                    // Normal unattended seals use the ranged zstd layout: better
+                    // compression than gzip while preserving chunk-level search/restore.
+                    // Pressure streaming stays on its own cloud chunk path and is not
+                    // changed here because it has a separate bounded-memory protocol.
+                    const archive = options.archive ?? archiveFile;
+                    const cooperativeYield = cpuYield
+                        ? async () => { leaseKeeper.activity(); await cpuYield(); }
+                        : undefined;
+                    const record = await leaseKeeper.wait(archive(dataDir, job.sourcePath, phrase, job.agent, {
+                        onProgress, onActivity: () => leaseKeeper.activity(), delta: options.delta !== false, project, projectKey, teamRecipients,
+                        compression: "zstd-chunk", chunkBytes: LOCAL_SEAL_CHUNK_BYTES, indexInline: true,
+                        signal: leaseKeeper.signal,
+                        ...(cooperativeYield ? { onYield: cooperativeYield } : {}),
+                    }));
+                    await leaseKeeper.stop();
+                    processed.push(await queue.complete(job.id, leaseId, { archiveId: record.id, ciphertextSha256: record.cipher.ciphertextSha256, bytes: record.source.bytes, deduplicated: record.deduplicated }, await completedSnapshot(record)));
+                    if (!record.deduplicated && record.version === 2 && record.source.project) {
+                        sealedByProject.set(record.source.projectKey ?? `legacy:${record.source.project}`, {
+                            project: record.source.project,
+                            projectKey: record.source.projectKey ?? null,
+                            sourcePath: job.sourcePath,
+                        });
+                    }
                 }
                 catch (error) {
+                    await leaseKeeper.stop().catch(() => undefined);
                     try {
-                        processed.push(await queue.fail(job.id, leaseId, summarize(error)));
+                        // A service shutdown is not a failed preservation attempt. The
+                        // partial is cancelled/removed by archiveFile and the exact row is
+                        // made immediately claimable by the successor generation.
+                        if (options.signal?.aborted) {
+                            processed.push(await queue.release(job.id, leaseId, { code: "cancelled", message: "Sealkeep stopped before this seal completed; it will resume on the next pass." }));
+                        }
+                        else {
+                            processed.push(await queue.fail(job.id, leaseId, summarize(error)));
+                        }
                     }
                     catch (leaseError) {
                         processed.push({ ...job, lastError: summarize(leaseError) });
@@ -178,6 +370,7 @@ export async function drainQueue(dataDir, phrase, options = {}) {
                 }
             }
             finally {
+                await leaseKeeper.stop().catch(() => undefined);
                 // Released whatever happened: a completed seal's bytes are now real and
                 // measured by statfs, a refused or failed one never spent them.
                 if (guarded)
@@ -186,5 +379,31 @@ export async function drainQueue(dataDir, phrase, options = {}) {
         }
     }
     await Promise.all(Array.from({ length: concurrency }, (_, index) => work(concurrency > 1 ? `${owner}#${index + 1}` : owner)));
+    // ACTIVE-mode projects share at seal speed: the drain's fresh sessions
+    // become findable (one incremental index build + sync) and the team feed
+    // carries one `finished` line per project. Awaited, so "drain finished"
+    // means "announced" — and best-effort by design: a plane hiccup here must
+    // never fail seals that already completed.
+    if (sealedByProject.size > 0 && (options.announce !== false || options.onActiveSealed)) {
+        try {
+            const { readConfig, projectSharingOf } = await import("./vault.js");
+            const config = await readConfig(dataDir);
+            const active = [...sealedByProject.values()].filter(({ project, projectKey }) => projectSharingOf(config, project, projectKey) === "active");
+            options.onActiveSealed?.(active);
+            if (active.length > 0) {
+                if (options.announce !== false) {
+                    const { buildContentIndex } = await import("./search.js");
+                    await buildContentIndex(dataDir, phrase, { sync: true });
+                    const { publishPresence, finishLineFrom } = await import("./presence.js");
+                    for (const { project, projectKey, sourcePath } of active) {
+                        await publishPresence(dataDir, { project, projectKey, kind: "finished", line: await finishLineFrom(sourcePath) }, phrase);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            process.emitWarning(`active-share skipped: ${error instanceof Error ? error.message : String(error)}`, "SealkeepActiveShare");
+        }
+    }
     return processed;
 }

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "sealkeep",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "type": "module",
   "description": "Sealkeep by SPALA AI \u2014 your AI coding-agent history, sealed, searchable, and shared across your machines.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/spala-ai/sealkeep.git"
+  },
   "license": "SEE LICENSE IN LICENSE",
   "engines": {
-    "node": ">=22.6.0"
+    "node": ">=22.15.0"
   },
   "os": [
     "darwin",
@@ -13,12 +17,12 @@
     "win32"
   ],
   "bin": {
-    "sealkeep": "dist/src/cli.js",
-    "vaultline": "dist/src/cli.js"
+    "sealkeep": "dist/src/cli.js"
   },
   "files": [
     "LICENSE",
     "dist",
+    "scripts/native-reboot-rehearsal.mjs",
     "web",
     "README.md",
     "ARCHITECTURE.md",
@@ -32,28 +36,45 @@
     "typecheck": "tsc -p tsconfig.check.json",
     "prepack": "npm run build",
     "release:manifest": "node scripts/release.mjs",
+    "pretest": "node --import tsx test/global-setup.ts",
     "test": "node --import tsx --test --test-concurrency=4 \"test/**/*.test.ts\" \"packages/*/test/*.test.ts\"",
-    "vaultline": "tsx src/cli.ts",
     "mcp": "tsx src/mcp.ts",
     "api": "tsx src/cli.ts api",
     "control-plane": "tsx src/control-plane-cli.ts",
     "dashboard": "tsx src/dashboard-cli.ts",
-    "build:site": "node tools/build-site.mjs",
-    "bundle:site": "node tools/build-site.mjs && cd dist/site && zip -q -X ../site.zip index.html && cd - >/dev/null && echo \"dist/site.zip ready ($(wc -c < dist/site.zip) bytes)\"",
-    "acceptance": "node scripts/acceptance.mjs",
+    "build:visual": "npm --prefix sealkeep-visual-explanation-solid run build",
+    "build:site": "npm run build:visual && node tools/build-site.mjs",
+    "bundle:site": "npm run build:site && cd dist/site && zip -q -FS -r -X ../site.zip . && cd - >/dev/null && echo \"dist/site.zip ready ($(wc -c < dist/site.zip) bytes)\"",
+    "acceptance": "tsx scripts/acceptance.ts",
     "acceptance:managed": "node scripts/acceptance.mjs --managed",
     "tokens": "node scripts/sync-tokens.mjs",
     "browser:audit": "node scripts/browser/audit.mjs",
-    "browser:panel": "node scripts/browser/panel.mjs"
+    "browser:panel": "node scripts/browser/panel.mjs",
+    "rehearsal:company": "node scripts/company-rehearsal.mjs",
+    "rehearsal:automatic-memory": "node scripts/automatic-memory-rehearsal.mjs",
+    "rehearsal:memory-accuracy": "node --import tsx scripts/memory-accuracy-rehearsal.ts",
+    "rehearsal:team-realtime": "npm run build --silent && node --import tsx scripts/team-realtime-rehearsal.ts",
+    "rehearsal:hosted-team-realtime": "node --import tsx scripts/hosted-team-realtime-rehearsal.ts",
+    "rehearsal:install-upgrade": "node scripts/install-upgrade-rehearsal.mjs",
+    "rehearsal:vps-user-journey": "node --import tsx scripts/vps-user-journey-acceptance.ts",
+    "rehearsal:reboot-native": "node scripts/native-reboot-rehearsal.mjs",
+    "rehearsal:tiers": "node scripts/tier-matrix.mjs",
+    "verify": "npm run typecheck && npm test && npm run acceptance",
+    "mutation": "node scripts/mutation.mjs",
+    "verify:deep": "npm run verify && npm run mutation",
+    "soak:restore": "node scripts/soak-restore.mjs",
+    "test:ci": "node --import tsx --test --test-concurrency=2 \"test/**/*.test.ts\" \"packages/*/test/*.test.ts\""
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
+    "socket.io": "^4.8.3",
     "tsx": "^4.19.2",
-    "typescript": "^5.7.2",
-    "zod": "^4.3.6"
+    "typescript": "^5.7.2"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
+    "socket.io-client": "^4.8.3",
+    "undici": "6.28.0",
     "zod": "^4.4.3"
   },
   "keywords": [
@@ -67,4 +88,4 @@
     "sessions"
   ],
   "homepage": "https://sealkeep.spala.ai"
-}
+}

package/scripts/native-reboot-rehearsal.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * Real native-keystore reboot receipt.
+ *
+ * PREPARE creates a disposable vault through the shipped CLI, requires the
+ * default backend to be native, and proves it can archive without a phrase
+ * flag. VERIFY refuses unless the operating-system boot identity changed,
+ * then archives again without any secret input. No phrase, token, or key is
+ * written to the receipt. CLEANUP removes the test phrase through the public
+ * CLI and deletes only the disposable rehearsal directory.
+ */
+
+import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+
+const run = promisify(execFile);
+const here = dirname(fileURLToPath(import.meta.url));
+const repo = join(here, "..");
+const bin = process.env.SEALKEEP_REHEARSAL_BIN ?? join(repo, "dist", "src", "cli.js");
+const node = process.execPath;
+const action = process.argv[2] ?? "prepare";
+const root = process.env.SEALKEEP_REBOOT_DIR ?? join(homedir(), ".sealkeep-reboot-rehearsal");
+const dataDir = join(root, "vault");
+const receiptPath = join(root, "receipt.json");
+const expectedBackends = {
+  darwin: ["macos-keychain"],
+  linux: ["secret-service", "linux-systemd-creds"],
+  win32: ["windows-dpapi"],
+}[platform()];
+if (!expectedBackends) throw new Error(`No supported native backend for ${platform()}`);
+
+const cleanEnv = { ...process.env };
+delete cleanEnv.SEALKEEP_SECRET_BACKEND;
+delete cleanEnv.VAULTLINE_SECRET_BACKEND;
+
+async function bootId() {
+  if (platform() === "linux") return (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
+  if (platform() === "darwin") return (await run("sysctl", ["-n", "kern.boottime"])).stdout.trim();
+  return (await run("powershell", ["-NoProfile", "-NonInteractive", "-Command", "(Get-CimInstance Win32_OperatingSystem).LastBootUpTime.ToUniversalTime().ToString('o')"])).stdout.trim();
+}
+
+async function cli(args) {
+  const result = await run(node, [bin, ...args], { env: cleanEnv, maxBuffer: 4 * 1024 * 1024 });
+  return result.stdout.trim();
+}
+
+async function archiveCanary(name) {
+  const path = join(root, `${name}.jsonl`);
+  const marker = `native-reboot-${name}-${randomBytes(12).toString("hex")}`;
+  await writeFile(path, JSON.stringify({ type: "user", message: { content: marker } }) + "\n", { mode: 0o600 });
+  const output = JSON.parse(await cli(["archive", path, "--agent", "claude", "--data-dir", dataDir, "--json"]));
+  if (!output.id) throw new Error(`${name}: archive returned no id`);
+  return { id: output.id };
+}
+
+if (action === "prepare") {
+  await rm(root, { recursive: true, force: true });
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  const setup = JSON.parse(await cli(["setup", "--data-dir", dataDir, "--json"]));
+  if (!expectedBackends.includes(setup.remembered?.backend)) {
+    await rm(root, { recursive: true, force: true });
+    throw new Error(`Native backend required: expected ${expectedBackends.join(" or ")}, got ${setup.remembered?.backend ?? "none"}`);
+  }
+  const backend = setup.remembered.backend;
+  const before = await archiveCanary("before");
+  await writeFile(receiptPath, JSON.stringify({
+    version: 1, platform: platform(), backend, bootId: await bootId(),
+    preparedAt: new Date().toISOString(), dataDir, beforeArchiveId: before.id,
+  }, null, 2) + "\n", { mode: 0o600 });
+  process.stdout.write(`PREPARED ${platform()} ${backend}; reboot this host, then run verify. No secret was written to the receipt.\n`);
+} else if (action === "verify") {
+  const receipt = JSON.parse(await readFile(receiptPath, "utf8"));
+  const currentBoot = await bootId();
+  if (currentBoot === receipt.bootId) throw new Error("The OS boot identity did not change; this was not a real reboot");
+  const after = await archiveCanary("after");
+  await writeFile(receiptPath, JSON.stringify({ ...receipt, verifiedAt: new Date().toISOString(), bootIdAfter: currentBoot, afterArchiveId: after.id, passed: true }, null, 2) + "\n", { mode: 0o600 });
+  if (!expectedBackends.includes(receipt.backend)) throw new Error(`Receipt backend ${receipt.backend} is not native on ${platform()}`);
+  process.stdout.write(`PASS ${platform()} ${receipt.backend}: native secret survived a real reboot and sealed new work without re-entry.\n`);
+} else if (action === "cleanup") {
+  await cli(["recovery", "forget-machine", "--confirm", "--data-dir", dataDir, "--json"]).catch(() => "");
+  await rm(root, { recursive: true, force: true });
+  process.stdout.write(`CLEANED ${root}; encrypted production vaults and integrations were not touched.\n`);
+} else {
+  throw new Error("Usage: native-reboot-rehearsal.mjs prepare|verify|cleanup");
+}