@astrosheep/pi-context 0.24.0 → 0.25.0

package/dist/test/boot.integration.test.js

@@ -0,0 +1,167 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { historyFromSession, internal } from "../src/index.js";
+import { listNotes } from "../src/notes/store.js";
+import { CONTINUATION_TYPE } from "../src/protocol.js";
+import { appendText, call, commitTurnEndBoundary, context, installExtensionTestEnvironment, makeExtension, manager, noticesOf, resultJson, resultRead, runContextHook, runContextWithSystemHook, runHandlers, runManualCompact, runCommand, sentOf, } from "./helpers/extension.js";
+const testEnvironment = installExtensionTestEnvironment("pi-context-integration");
+test.beforeEach(() => testEnvironment.beforeEach());
+test.afterEach(() => testEnvironment.afterEach());
+test.after(() => testEnvironment.dispose());
+test("custom reset marker removes old provider context while history remains searchable", async () => {
+    const sessionManager = manager();
+    const captured = makeExtension(sessionManager);
+    const ctx = context(sessionManager);
+    const oldUserId = appendText(sessionManager, "user", "OLD-UNIQUE-TRANSCRIPT needle");
+    appendText(sessionManager, "assistant", "I will use a tool");
+    const toolResultId = appendText(sessionManager, "toolResult", "tool result safely recorded");
+    await call(captured, "wipe_memory", {}, ctx);
+    const boundary = await commitTurnEndBoundary(captured, sessionManager, ctx);
+    assert.equal(boundary.continue, true);
+    const branch = sessionManager.getBranch();
+    const marker = branch.find((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE);
+    assert.ok(marker && marker.type === "custom");
+    assert.equal(marker.parentId, toolResultId, "marker follows the completed tool result");
+    assert.deepEqual(Object.keys(marker.data), ["windowId"]);
+    const projected = await runContextWithSystemHook(captured, ctx, sessionManager.buildSessionContext().messages);
+    const providerText = JSON.stringify(projected?.messages ?? []);
+    assert.equal(providerText.includes("OLD-UNIQUE-TRANSCRIPT"), false);
+    assert.equal(providerText.includes(internal.CONTEXT_WINDOW_OPEN_TAG), true);
+    assert.equal(providerText.includes(internal.RESET_MARKER_TYPE), false, "plain reset state never reaches the provider");
+    const windows = historyFromSession(ctx);
+    assert.equal(windows.length, 2);
+    const oldWindow = windows[0]?.windowId;
+    assert.ok(oldWindow);
+    const read = resultRead(await call(captured, "history_read", { window_id: oldWindow, item_id: oldUserId }, ctx));
+    assert.match(read.content, /OLD-UNIQUE-TRANSCRIPT/);
+    const found = resultJson(await call(captured, "history_search", { query: "needle" }, ctx));
+    assert.equal(found.items.length, 1);
+    assert.equal(found.items[0]?.item_id, oldUserId);
+});
+test("the root boot and reset boot carry durable window identity", async () => {
+    const sessionManager = manager();
+    const captured = makeExtension(sessionManager);
+    const ctx = context(sessionManager);
+    appendText(sessionManager, "user", "task before reset");
+    appendText(sessionManager, "assistant", "working");
+    await call(captured, "notes_write", { path: "decisions.md", content: "use terra" }, ctx);
+    // Root window: session_start persists the boot block without triggering a turn.
+    runHandlers(captured, "session_start", { reason: "startup" }, ctx);
+    assert.equal(captured.sent.length, 1);
+    const rootBoot = captured.sent[0];
+    assert.equal(rootBoot?.message.customType, internal.BOOT_TYPE);
+    assert.equal(rootBoot?.message.display, false, "boot block stays out of the TUI");
+    assert.equal(rootBoot?.options?.triggerTurn, false);
+    assert.equal(noticesOf(ctx).length, 0, "initial boot is silent");
+    runHandlers(captured, "session_start", { reason: "reload" }, ctx);
+    assert.equal(noticesOf(ctx).length, 0, "reload is silent");
+    assert.deepEqual(rootBoot?.message.details, { windowId: `pcw:${sessionManager.getSessionId().slice(0, 8)}:root` });
+    const rootText = typeof rootBoot?.message.content === "string" ? rootBoot.message.content : "";
+    assert.ok(rootText.startsWith(internal.CONTEXT_WINDOW_OPEN_TAG), "root block omits the reset line");
+    assert.equal(rootText.includes("Previous context window id:"), false, "root block omits the previous-id line");
+    assert.match(rootText, new RegExp(`First context window id: pcw:${sessionManager.getSessionId().slice(0, 8)}:root`));
+    assert.match(rootText, new RegExp(`Current context window id: pcw:${sessionManager.getSessionId().slice(0, 8)}:root`));
+    assert.ok(rootText.includes("decisions.md"));
+    const decisionsMeta = listNotes(ctx, { scope: "session" }).find((row) => row.path === "decisions.md")?.meta;
+    assert.ok(decisionsMeta);
+    assert.match(rootText, /updated \d+s ago\)/, "boot note metadata carries a relative update time");
+    assert.ok(rootText.includes(internal.CONTEXT_WINDOW_PROTOCOL_OPEN_TAG));
+    // Reset: the marker and boot are committed together at the turn boundary.
+    await call(captured, "wipe_memory", {}, ctx);
+    assert.equal(noticesOf(ctx).length, 0, "requesting a reset does not announce success");
+    const boundary = await commitTurnEndBoundary(captured, sessionManager, ctx);
+    assert.equal(boundary.continue, true);
+    runHandlers(captured, "turn_start", {}, ctx);
+    runHandlers(captured, "agent_settled", {}, ctx);
+    assert.equal(noticesOf(ctx).filter((notice) => notice.message.includes("memory cleared")).length, 1, "the committed reset is announced once");
+    const entries = sessionManager.getBranch();
+    const marker = entries.find((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE);
+    assert.ok(marker && marker.type === "custom");
+    const resetWindowId = marker.data.windowId;
+    const resetBoot = entries.find((entry) => entry.type === "custom_message" && entry.customType === internal.BOOT_TYPE && entry.details && typeof entry.details === "object" && entry.details.windowId === resetWindowId);
+    assert.ok(resetBoot && resetBoot.type === "custom_message");
+    assert.equal(resetBoot.details.windowId, marker.data.windowId);
+    const continuation = entries.find((entry) => entry.type === "custom_message" && entry.customType === CONTINUATION_TYPE);
+    assert.ok(continuation && continuation.type === "custom_message" && continuation.display === false, "the resumed run is represented by one hidden continuation");
+});
+test("a marker tail with only metadata repairs its missing boot without moving the boundary", () => {
+    const sessionManager = manager(true);
+    const windowId = "pcw:metadata-tail";
+    const markerId = sessionManager.appendCustomEntry(internal.RESET_MARKER_TYPE, { windowId });
+    const modelChangeId = sessionManager.appendModelChange("openai", "scripted-model");
+    sessionManager.appendThinkingLevelChange("low");
+    const captured = makeExtension(sessionManager);
+    const ctx = context(sessionManager);
+    runHandlers(captured, "session_start", { reason: "startup" }, ctx);
+    const branch = sessionManager.getBranch();
+    const markerIndex = branch.findIndex((entry) => entry.id === markerId);
+    const bootEntries = branch.filter((entry) => entry.type === "custom_message" && entry.customType === internal.BOOT_TYPE && entry.details && typeof entry.details === "object" && entry.details.windowId === windowId);
+    assert.equal(bootEntries.length, 1, "an incomplete marker tail gets one repaired boot");
+    assert.ok(branch.findIndex((entry) => entry.id === modelChangeId) > markerIndex, "metadata remains after the marker");
+    assert.ok(branch.findIndex((entry) => entry.id === bootEntries[0]?.id) > markerIndex, "the repaired boot remains in the marked window");
+    assert.equal(captured.sent.length, 1, "repair emits one hidden boot without a model turn");
+    assert.equal(noticesOf(ctx).length, 0, "repairing a boot is not a new reset");
+});
+test("off preserves an existing marker window and still cancels native compaction", async () => {
+    const sessionManager = manager();
+    const captured = makeExtension(sessionManager);
+    const ctx = context(sessionManager);
+    appendText(sessionManager, "user", "old context must stay hidden");
+    const windowId = "pcw:test:existing";
+    sessionManager.appendCustomEntry(internal.RESET_MARKER_TYPE, { windowId });
+    sessionManager.appendCustomMessageEntry(internal.BOOT_TYPE, "fresh boot", false, { windowId });
+    await runCommand(captured, "pi-context", "off", ctx);
+    const before = await runManualCompact(captured, ctx);
+    assert.deepEqual(before, { cancel: true });
+    const projected = await runContextWithSystemHook(captured, ctx, sessionManager.buildSessionContext().messages);
+    assert.equal(JSON.stringify(projected?.messages ?? []).includes("old context must stay hidden"), false);
+    const windows = resultJson(await call(captured, "history_windows", {}, ctx));
+    assert.equal(windows.windows[0]?.window_id, windowId);
+});
+test("wipe_memory uses one turn boundary and never calls ctx.compact", async () => {
+    const sessionManager = manager();
+    const captured = makeExtension(sessionManager);
+    const ctx = context(sessionManager, () => assert.fail("ctx.compact must not be used"));
+    appendText(sessionManager, "user", "enough history for the boundary test");
+    const result = resultJson(await call(captured, "wipe_memory", {}, ctx));
+    assert.ok(result.status);
+    const boundary = await commitTurnEndBoundary(captured, sessionManager, ctx);
+    assert.equal(boundary.continue, true);
+    assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE).length, 1);
+    assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === internal.BOOT_TYPE && entry.details && typeof entry.details === "object" && "windowId" in entry.details).length, 1);
+});
+test("pi-context command toggles future work, /wipe-memory is the manual path, and active markers cancel /compact", async () => {
+    const sessionManager = manager();
+    appendText(sessionManager, "user", "hello");
+    const captured = makeExtension(sessionManager);
+    const low = context(sessionManager, undefined, { tokens: 170_000, contextWindow: 200_000, percent: 85 });
+    // On by default: session_start persists the root boot block.
+    runHandlers(captured, "session_start", { reason: "startup" }, low);
+    assert.equal(captured.sent.length, 1);
+    assert.equal(captured.sent[0]?.message.customType, internal.BOOT_TYPE);
+    let notices = await runCommand(captured, "pi-context", "off", low);
+    assert.match(notices[0]?.message ?? "", /off/);
+    assert.equal(await runContextHook(captured, low), undefined, "no guidance while off");
+    assert.equal(sentOf(captured, internal.GUIDANCE_TYPE).length, 0, "no guidance persisted while off");
+    runHandlers(captured, "session_start", { reason: "startup" }, low);
+    assert.equal(captured.sent.length, 1, "no new boot block is persisted while off");
+    const offResult = resultJson(await call(captured, "wipe_memory", {}, low));
+    assert.match(offResult.error ?? "", /off/, "wipe_memory refuses while off");
+    notices = await runCommand(captured, "pi-context", "on", low);
+    assert.match(notices[0]?.message ?? "", /on/);
+    notices = await runCommand(captured, "wipe-memory", "", low);
+    assert.equal(notices.length, 1, "manual clear emits exactly one notification");
+    assert.match(notices[0]?.message ?? "", /memory cleared/);
+    assert.equal(captured.sent.length, 2, "/wipe-memory writes one hidden boot without triggering a model turn");
+    assert.equal(captured.sent[1]?.options?.triggerTurn, false);
+    assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom" && entry.customType === internal.RESET_MARKER_TYPE).length, 1);
+    const markerContext = await runManualCompact(captured, low);
+    assert.deepEqual(markerContext, { cancel: true }, "/compact is canceled while a marker is active");
+    const projected = await runContextWithSystemHook(captured, low, sessionManager.buildSessionContext().messages);
+    assert.equal(JSON.stringify(projected?.messages ?? []).includes("hello"), false, "off keeps the existing wipe in force");
+    notices = await runCommand(captured, "pi-context", "maybe", low);
+    assert.equal(notices[0]?.type, "error", "unknown argument rejected");
+    // Bare command reports current state without changing it.
+    notices = await runCommand(captured, "pi-context", "", low);
+    assert.match(notices[0]?.message ?? "", /on/);
+});

package/dist/test/budget-settings.integration.test.js

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { internal } from "../src/index.js";
+import { appendText, call, commitTurnEndBoundary, context, installExtensionTestEnvironment, makeExtension, manager, noticesOf, resultJson, runContextHook, runHandlers, sentOf, settingsFixture, } from "./helpers/extension.js";
+const testEnvironment = installExtensionTestEnvironment("pi-context-integration");
+test.beforeEach(() => testEnvironment.beforeEach());
+test.afterEach(() => testEnvironment.afterEach());
+test.after(() => testEnvironment.dispose());
+test("low-budget guidance and warning persist at turn_end, once per active window", async () => {
+    const sessionManager = manager();
+    const captured = makeExtension(sessionManager);
+    const low = context(sessionManager, undefined, { tokens: 170_000, percent: 85, contextWindow: 200_000 });
+    assert.equal(await runContextHook(captured, low), undefined, "guidance is staged, not injected into this request");
+    assert.equal(captured.sent.length, 0, "guidance does not trigger a detached turn");
+    const guidanceBoundary = await commitTurnEndBoundary(captured, sessionManager, low);
+    assert.equal(guidanceBoundary.entries.filter((entry) => entry.type === "custom_message" && entry.customType === internal.GUIDANCE_TYPE).length, 1);
+    assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === internal.GUIDANCE_TYPE).length, 1);
+    assert.equal(await runContextHook(captured, low), undefined, "the same window does not repeat guidance");
+    const warningContext = context(sessionManager, undefined, { tokens: 199_000, percent: 99.5, contextWindow: 200_000 });
+    const warning = await runContextHook(captured, warningContext);
+    assert.equal(warning?.messages.length, 1, "the warning is visible in the current provider request");
+    assert.equal((warning?.messages[0]).customType, internal.WARNING_TYPE);
+    const warningBoundary = await commitTurnEndBoundary(captured, sessionManager, warningContext);
+    assert.equal(warningBoundary.entries.filter((entry) => entry.type === "custom_message" && entry.customType === internal.WARNING_TYPE).length, 1);
+    assert.equal(sessionManager.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === internal.WARNING_TYPE).length, 1);
+});
+test("the visible countdown ends at the warning line, clamps at zero, and preserves unknown usage", async () => {
+    const fixture = settingsFixture({
+        reserveTokens: 16_384,
+        project: { compaction: { reserveTokens: 32_768 } },
+    });
+    const sm = manager();
+    const captured = makeExtension(sm);
+    runHandlers(captured, "session_tree", {}, context(sm, undefined, undefined, true, fixture.cwd, true));
+    const readBudget = async (tokens, trusted = true) => {
+        const ctx = context(sm, undefined, { tokens, contextWindow: 200_000, percent: tokens === null ? null : tokens / 2000 }, true, fixture.cwd, trusted);
+        return resultJson(await call(captured, "get_context_remaining", {}, ctx)).remaining_tokens;
+    };
+    assert.equal(await readBudget(72_563), 82_381, "the reported 127437 physical tokens exclude reserve plus runway (45056)");
+    assert.equal(await readBudget(167_232), 0, "inside the runway the countdown reads zero");
+    assert.equal(await readBudget(190_000), 0, "below the reserve, still zero");
+    assert.equal(await readBudget(210_000), 0, "over the physical window");
+    assert.equal(await readBudget(null), null, "unknown usage remains unknown");
+    const absent = context(sm, undefined, undefined, true, fixture.cwd);
+    assert.equal(resultJson(await call(captured, "get_context_remaining", {}, absent)).remaining_tokens, null);
+    const untrusted = context(sm, undefined, { tokens: 72_563, contextWindow: 200_000, percent: 36.2815 }, true, fixture.cwd, false);
+    runHandlers(captured, "session_start", {}, untrusted);
+    assert.equal(await readBudget(72_563, false), 98_765, "session start reloads the global reserve when the project is untrusted");
+});
+test("absent pi-context key or margins reproduce the default reminder threshold at Pi's default reserve", async () => {
+    assert.equal(internal.DEFAULT_RESERVE_TOKENS, 16_384);
+    assert.equal(internal.DEFAULT_RESERVE_TOKENS + internal.DEFAULT_REMINDER_MARGIN_TOKENS, 40_960);
+    for (const [label, options] of [
+        ["absent key", { global: {} }],
+        ["absent margins", { global: { [internal.PI_CONTEXT_SETTINGS_KEY]: {} } }],
+    ]) {
+        const fixture = settingsFixture(options);
+        const sm = manager();
+        const captured = makeExtension(sm);
+        // Thresholds are resolved once per session and cached; branch navigation clears the
+        // cache without emitting a boot block, so the next read uses this fixture.
+        runHandlers(captured, "session_tree", {}, context(sm, undefined, undefined, true, fixture.cwd));
+        const window = 200_000;
+        const at = (remaining) => context(sm, undefined, { tokens: window - remaining, percent: 0, contextWindow: window }, true, fixture.cwd);
+        const first = at(40_961);
+        assert.equal(await runContextHook(captured, first), undefined, `${label}: nothing injected above the default reminder`);
+        assert.equal(sentOf(captured, internal.GUIDANCE_TYPE).length, 0, `${label}: no guidance above the default reminder`);
+        const crossing = at(40_960);
+        assert.equal(await runContextHook(captured, crossing), undefined, `${label}: default reminder crossing persists only`);
+        await commitTurnEndBoundary(captured, sm, crossing);
+        assert.equal(sm.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === internal.GUIDANCE_TYPE).length, 1, `${label}: default reminder fires`);
+        assert.equal(noticesOf(first).length, 0, `${label}: valid defaults warn nobody`);
+    }
+});
+test("project pi-context reminder margin and reserve override global per key", async () => {
+    const fixture = settingsFixture({
+        reserveTokens: 20_000,
+        global: { [internal.PI_CONTEXT_SETTINGS_KEY]: { reminderMarginTokens: 30_000 } },
+        project: { compaction: { reserveTokens: 50_000 }, [internal.PI_CONTEXT_SETTINGS_KEY]: { reminderMarginTokens: 40_000 } },
+    });
+    // Project reserve wins: reminder = 50000 + 40000 (project margin).
+    const sm = manager();
+    const captured = makeExtension(sm);
+    runHandlers(captured, "session_tree", {}, context(sm, undefined, undefined, true, fixture.cwd));
+    const window = 300_000;
+    const at = (remaining) => context(sm, undefined, { tokens: window - remaining, percent: 0, contextWindow: window }, true, fixture.cwd);
+    assert.equal(await runContextHook(captured, at(90_001)), undefined, "nothing injected above the project-derived reminder");
+    assert.equal(sentOf(captured, internal.GUIDANCE_TYPE).length, 0);
+    const crossing = at(90_000);
+    assert.equal(await runContextHook(captured, crossing), undefined, "project-derived reminder crossing persists only");
+    await commitTurnEndBoundary(captured, sm, crossing);
+    assert.equal(sm.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === internal.GUIDANCE_TYPE).length, 1, "project reminder margin wins");
+});
+test("an invalid reminder margin degrades to its default with one warning and never throws", async () => {
+    const fixture = settingsFixture({ global: { [internal.PI_CONTEXT_SETTINGS_KEY]: { reminderMarginTokens: 0 } } });
+    const sm = manager();
+    const captured = makeExtension(sm);
+    const ctx = context(sm, undefined, undefined, true, fixture.cwd);
+    assert.doesNotThrow(() => runHandlers(captured, "session_start", { reason: "startup" }, ctx));
+    const notices = noticesOf(ctx).filter((notice) => notice.type === "warning");
+    assert.equal(notices.length, 1, "one warning for the offending key");
+    assert.equal(notices[0]?.type, "warning");
+    assert.match(notices[0]?.message ?? "", /reminderMarginTokens/);
+    assert.match(notices[0]?.message ?? "", /24576/);
+    const window = 200_000;
+    const at = (remaining) => context(sm, undefined, { tokens: window - remaining, percent: 0, contextWindow: window }, true, fixture.cwd);
+    // The degraded reminder is Pi's default reserve + default margin = 40960.
+    assert.equal(await runContextHook(captured, at(40_961)), undefined, "nothing injected above the degraded reminder");
+    const crossing = at(40_960);
+    assert.equal(await runContextHook(captured, crossing), undefined, "degraded reminder uses its default");
+    await commitTurnEndBoundary(captured, sm, crossing);
+    assert.equal(sm.getBranch().filter((entry) => entry.type === "custom_message" && entry.customType === internal.GUIDANCE_TYPE).length, 1, "the degraded reminder is persisted once");
+    assert.equal(noticesOf(ctx).filter((notice) => notice.type === "warning").length, 1, "warning stays one-time across handler calls");
+});
+test("the warning supersedes the early reminder when usage jumps across both thresholds", async () => {
+    const sm = manager();
+    appendText(sm, "user", "ongoing work");
+    const captured = makeExtension(sm);
+    const ctx = context(sm, undefined, { tokens: 199_000, percent: 99.5, contextWindow: 200_000 }, false);
+    const warningResult = await runContextHook(captured, ctx);
+    assert.deepEqual(warningResult?.messages.map((message) => message.customType), [internal.WARNING_TYPE]);
+    await commitTurnEndBoundary(captured, sm, ctx);
+    const reloaded = makeExtension(sm);
+    runHandlers(reloaded, "context", {}, ctx);
+    assert.equal(reloaded.sent.length, 0, "persisted warning also suppresses a late reminder after reload");
+});

package/dist/test/doctor.test.js

@@ -1,44 +1,22 @@
-import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, symlinkSync, readdirSync } from "node:fs";
+import { main } from "../src/dream/cli.js";
+import { doctor } from "../src/dream/doctor.js";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import test from "node:test";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { doctor } from "../src/dream/doctor.js";
-import { main } from "../src/dream/cli.js";
-const note = (body = "") => `---\norigin: self\nstatus: active\nstale: false\ncreated_at: 2026-01-01T00:00:00Z\nupdated_at: 2026-01-01T00:00:00Z\nlast_accessed: 2026-01-01T00:00:00Z\naccess_count: 0\n---\n\n${body}`;
-const home = () => mkdtempSync(join(tmpdir(), "dream-doctor-"));
-test("doctor validates note homes and references without changing files", async () => {
-    const root = home();
-    mkdirSync(join(root, "personal"));
-    writeFileSync(join(root, "personal/a.md"), note());
-    writeFileSync(join(root, "personal/MAP.md"), note("- `a.md`\n- `@personal/a.md`"));
-    const before = readFileSync(join(root, "personal/a.md"));
+const note = "---\norigin: self\nstatus: active\nstale: false\ncreated_at: 2026-01-01T00:00:00Z\nupdated_at: 2026-01-01T00:00:00Z\nlast_accessed: 2026-01-01T00:00:00Z\naccess_count: 0\n---\n\n";
+test("doctor validates without repairing files or running the dreamer", async () => {
+    const root = mkdtempSync(join(tmpdir(), "dream-doctor-test-"));
+    mkdirSync(join(root, "human"));
+    writeFileSync(join(root, "human/a.md"), note);
+    writeFileSync(join(root, "human/MAP.md"), `${note}- \`a.md\``);
+    const before = readFileSync(join(root, "human/a.md"));
     assert.deepEqual(doctor(root), []);
     assert.equal(await main(["doctor", "--notes-home", root], { runDreamer: async () => { throw new Error("must not run"); } }), 0);
-    assert.deepEqual(readFileSync(join(root, "personal/a.md")), before);
-    assert.deepEqual(readdirSync(root), ["personal"]);
-});
-test("doctor reports layout, metadata, links and locks; never repairs", () => {
-    const root = home();
-    mkdirSync(join(root, "global"));
-    mkdirSync(join(root, "project/bad"), { recursive: true });
-    writeFileSync(join(root, "project/bad/MAP.md"), note("`missing.md` `@global/old.md`"));
-    writeFileSync(join(root, "project/bad/broken.md"), "---\norigin: nope\n---\n");
-    writeFileSync(join(root, ".dream.lock"), "garbage");
-    symlinkSync(join(root, "project"), join(root, "project/bad/link"));
-    const output = doctor(root).join("\n");
-    for (const expected of ["legacy home", "invalid project key", "target missing", "invalid address", "invalid origin", "invalid created_at", "malformed lock", "symlink"])
-        assert.ok(output.includes(expected), expected);
-    assert.equal(readFileSync(join(root, ".dream.lock"), "utf8"), "garbage");
-    assert.ok(existsSync(join(root, "global")));
-});
-test("doctor reports missing homes without creating them, including CLI", async () => {
-    const missing = join(home(), "absent");
+    assert.deepEqual(readFileSync(join(root, "human/a.md")), before);
+    assert.deepEqual(readdirSync(root), ["human"]);
+    const missing = join(root, "absent");
     assert.equal(await main(["doctor", "--notes-home", missing]), 1);
     assert.equal(existsSync(missing), false);
 });
-test("doctor reports valid lock presence without claiming it is stale", () => {
-    const root = home();
-    writeFileSync(join(root, ".dream.lock"), "123 12345678-1234-1234-1234-123456789abc");
-    assert.match(doctor(root).join("\n"), /lock present.*liveness not inferred/);
-});