@astrosheep/pi-context 0.20.0 → 0.22.0

package/dist/test/dream.test.js

@@ -1,43 +1,427 @@
 import test from "node:test";
-import nodeAssert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, readdirSync, statSync, utimesSync, writeFileSync, existsSync } from "node:fs";
+import assert from "node:assert/strict";
+import { execFile, execFileSync } from "node:child_process";
+import { existsSync, linkSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { spawnSync } from "node:child_process";
-import { defaultDreamerSessionFactory, runDreamer, READ_ONLY_TOOLS } from "../src/dream/runner.js";
-const cli = join(process.cwd(), "dist/src/dream/cli.js");
-const assert = nodeAssert;
-assert.match = (value, expected) => nodeAssert.ok(typeof expected === "string" ? value.includes(expected) : expected.test(value));
-function fixture() { const home = mkdtempSync(join(tmpdir(), "dream-")); mkdirSync(join(home, "pi/session"), { recursive: true }); return home; }
-function note(home, session, name, body, window) { const dir = join(home, "pi/session", session); mkdirSync(dir, { recursive: true }); writeFileSync(join(dir, name), `---\nscope: session\norigin: self\nstatus: active\nsource_window: ${window}\ncreated_at: 2020-01-01T00:00:00.000Z\nupdated_at: 2020-01-01T00:00:00.000Z\nlast_accessed: 2020-01-01T00:00:00.000Z\naccess_count: 0\n---\n\n${body}`); }
-function dreamer(home, manifest, sentinel) { const file = join(home, "dreamer.mjs"); writeFileSync(file, `import {writeFileSync} from 'node:fs'; ${sentinel ? `writeFileSync(${JSON.stringify(sentinel)}, 'spawned');` : ""} process.stdin.resume(); process.stdin.on('end',()=>process.stdout.write(${JSON.stringify(JSON.stringify(manifest))}));`); return `node ${file}`; }
-function run(home, extra = []) { return spawnSync(process.execPath, [cli, "--notes-home", home, ...extra], { encoding: "utf8" }); }
+import { acquireLock, failLock, lastRunPath, releaseLock } from "../src/dream/lock.js";
+import { materialGate, timeGate } from "../src/dream/gates.js";
+import { defaultDreamerSessionFactory, dreamerWriteToolDefinitions, runDreamer, DREAMER_TOOLS } from "../src/dream/runner.js";
+import { gitCommit } from "../src/dream/git.js";
+import { main } from "../src/dream/cli.js";
+import { deriveDreamer, mergePiContextSettings, readDreamerSettings } from "../src/thresholds.js";
+import { PI_CONTEXT_DREAMER_KEY, PI_CONTEXT_SETTINGS_KEY } from "../src/protocol.js";
+import { contentText } from "../src/history.js";
+function fixture() { return mkdtempSync(join(tmpdir(), "dream-")); }
 function old(path) { const d = new Date(Date.now() - 48 * 3600_000); utimesSync(path, d, d); }
-test("dream time gate skips first, names reason, and does not spawn", () => { const h = fixture(); const sentinel = join(h, "sentinel"); const lock = join(h, ".dream.lock"); writeFileSync(lock, "999999"); const fresh = new Date(); utimesSync(lock, fresh, fresh); const r = run(h, ["--dreamer", dreamer(h, { report: "x" }, sentinel)]); assert.equal(r.status, 0); assert.match(r.stdout, "time gate"); assert.equal(existsSync(sentinel), false); });
-test("material gate skips when too few session directories changed", () => { const h = fixture(); const lock = join(h, ".dream.lock"); writeFileSync(lock, "999999"); old(lock); note(h, "only", "a.md", "a", "w"); const r = run(h, ["--min-sessions", "3", "--dreamer", dreamer(h, { report: "x" })]); assert.equal(r.status, 0); assert.match(r.stdout, "material gate"); });
-test("force bypasses time and material gates and external dreamer runs", () => { const h = fixture(); const r = run(h, ["--force", "--dreamer", dreamer(h, { report: "forced" })]); assert.equal(r.status, 0); assert.match(readFileSync(readdirSync(join(h, "dreams")).map(x => join(h, "dreams", x))[0], "utf8"), "forced"); });
-test("live PID lock excludes and dead PID is reclaimed", () => { const h = fixture(); const lock = join(h, ".dream.lock"); writeFileSync(lock, String(process.pid)); const r = run(h, ["--force", "--dreamer", dreamer(h, { report: "no" })]); assert.equal(r.status, 0); assert.match(r.stdout, "lock gate"); writeFileSync(lock, "999999"); old(lock); const ok = run(h, ["--force", "--dreamer", dreamer(h, { report: "reclaimed" })]); assert.equal(ok.status, 0); });
-test("external dreamer manifest merges recurrence, proposes global promotion, trashes, and reports", () => { const h = fixture(); note(h, "dream", "a.md", "one", "window-a"); note(h, "dream", "b.md", "two", "window-b"); note(h, "dream", "trash.md", "gone", "window-c"); const m = { merge: [{ into: "a.md", from: ["b.md"] }], promote: [{ path: "a.md", to: "global", reason: "shared" }], trash: [{ path: "trash.md", reason: "obsolete" }], report: "I dreamed on 2026-09-19." }; const r = run(h, ["--force", "--dreamer", dreamer(h, m)]); assert.equal(r.status, 0, r.stderr); const merged = readFileSync(join(h, "pi/session/dream/a.md"), "utf8"); assert.match(merged, "one"); assert.match(merged, "two"); assert.match(merged, "recurrence_count: 1"); assert.match(readFileSync(join(h, "pi/session/dream/b.md"), "utf8"), "status: superseded"); assert.equal(existsSync(join(h, "pi/session/dream/trash.md")), false); const trash = readdirSync(join(h, "trash"))[0]; assert.equal(readFileSync(join(h, "trash", trash, "session", "trash.md"), "utf8").includes("gone"), true); const reports = readdirSync(join(h, "dreams")); const report = readFileSync(join(h, "dreams", reports[0]), "utf8"); assert.match(report, "I dreamed"); assert.match(report, "proposal: promote"); assert.match(report, "trashed"); });
-test("invalid manifest path makes zero writes and exits nonzero", () => { const h = fixture(); note(h, "s1", "a.md", "one", "w"); const before = readFileSync(join(h, "pi/session/s1/a.md"), "utf8"); const r = run(h, ["--force", "--dreamer", dreamer(h, { merge: [{ into: "missing.md", from: ["a.md"] }], report: "bad" })]); assert.notEqual(r.status, 0); assert.match(r.stderr, "missing.md"); assert.equal(readFileSync(join(h, "pi/session/s1/a.md"), "utf8"), before); assert.equal(existsSync(join(h, "dreams")), false); });
-test("failed run restores prior lock mtime", () => { const h = fixture(); const lock = join(h, ".dream.lock"); writeFileSync(lock, "999999"); const prior = Date.now() - 48 * 3600_000; utimesSync(lock, new Date(prior), new Date(prior)); const r = run(h, ["--force", "--dreamer", dreamer(h, { merge: [{ into: "missing", from: [] }], report: "x" })]); assert.notEqual(r.status, 0); assert.ok(Math.abs(statSync(lock).mtimeMs - prior) < 2000); });
-test("SDK dreamer captures assistant event and receives read-only allowlist", async () => {
+/** A session whose prompt runs a scripted interaction with the recorded event handler. */
+function scriptedSession(run) {
+    return async ({ cwd }) => {
+        let handler = () => { };
+        const session = {
+            subscribe(next) { handler = next; return () => { }; },
+            async prompt() { run(handler, cwd); },
+            dispose() { },
+        };
+        return session;
+    };
+}
+function successSession() {
+    return scriptedSession((handler) => handler({ type: "message_end", message: { role: "assistant", content: [{ type: "text", text: "done" }] } }));
+}
+/** Capture console.error lines without letting CLI chatter pollute the test output. */
+async function captureErrors(run) {
+    const errors = [];
+    const original = console.error;
+    console.error = (...parts) => { errors.push(parts.map(String).join(" ")); };
+    try {
+        return { code: await run(), errors };
+    }
+    finally {
+        console.error = original;
+    }
+}
+test("time and material gates preserve skip decisions and reasons", () => {
+    const home = fixture();
+    const lock = join(home, ".dream.lock");
+    const stamp = lastRunPath(lock);
+    assert.deepEqual(timeGate(stamp, 24).ok, true, "no prior dream passes");
+    writeFileSync(stamp, new Date().toISOString());
+    const fresh = timeGate(stamp, 24);
+    assert.equal(fresh.ok, false);
+    assert.equal(fresh.reason, "time gate: last dream is too recent");
+    old(stamp);
+    assert.equal(timeGate(stamp, 24).ok, true);
+    mkdirSync(join(home, "pi/session/one"), { recursive: true });
+    writeFileSync(join(home, "pi/session/one/a.md"), "a");
+    const material = materialGate(home, statSync(stamp).mtimeMs, 1);
+    assert.equal(material.ok, true);
+    assert.match(material.reason, /material gate: 1 changed sessions/);
+    assert.equal(materialGate(home, Date.now(), 2).ok, false);
+    // The lock file's own mtime no longer carries the scheduler timestamp.
+    writeFileSync(lock, "1");
+    old(lock);
+    assert.equal(timeGate(stamp, 24).ok, true, "the sidecar survives an old lock file");
+});
+test("failure restores the last-run timestamp and cleanup is idempotent", () => {
+    const home = fixture();
+    const lock = join(home, ".dream.lock");
+    const stamp = lastRunPath(lock);
+    writeFileSync(stamp, new Date(Date.now() - 48 * 3600_000).toISOString());
+    old(stamp);
+    const prior = statSync(stamp).mtimeMs;
+    const held = acquireLock(lock);
+    assert.equal(held.held, true);
+    assert.equal(readFileSync(lock, "utf8").trim(), `${process.pid} ${held.token}`, "the lock records its owner and token");
+    assert.ok(statSync(stamp).mtimeMs > prior + 1000, "a held lock advances the last-run sidecar, not itself");
+    failLock(held);
+    assert.equal(held.held, false, "failure marks the state released");
+    assert.ok(Math.abs(statSync(stamp).mtimeMs - prior) < 2000, "a failed run restores the last-run timestamp");
+    assert.equal(existsSync(lock), false, "a failed run releases its lock");
+    // Repeated cleanup on an already-released state is harmless.
+    const settled = statSync(stamp).mtimeMs;
+    failLock(held);
+    releaseLock(held);
+    assert.ok(Math.abs(statSync(stamp).mtimeMs - settled) < 1000, "repeated failure cleanup changes nothing");
+    const released = acquireLock(lock);
+    assert.equal(released.held, true);
+    releaseLock(released);
+    releaseLock(released);
+    assert.equal(released.held, false, "release marks the state released");
+    assert.equal(existsSync(lock), false, "release removes the PID marker");
+    assert.equal(existsSync(stamp), true, "the timestamp sidecar survives release");
+});
+test("any existing lock refuses acquisition and is left byte-identical", () => {
+    const home = fixture();
+    const lock = join(home, ".dream.lock");
+    const stamp = lastRunPath(lock);
+    const markers = [
+        `${process.pid} live-owner`, // a live owner's marker
+        "999999", // a dead PID
+        "999999 dead-token", // a dead PID with a token
+        "", // empty
+        "not-a-pid", // malformed
+    ];
+    for (const marker of markers) {
+        writeFileSync(lock, marker);
+        old(lock);
+        const result = acquireLock(lock);
+        assert.equal(result.held, false, `refuses an existing marker ${JSON.stringify(marker)}`);
+        assert.equal(result.reason, "lock gate: lock already exists");
+        assert.equal(readFileSync(lock, "utf8"), marker, "the existing marker is byte-identical");
+    }
+    assert.equal(existsSync(stamp), false, "a refused acquisition writes no timestamp");
+});
+test("an acquired lock blocks every later contender until released", () => {
+    const home = fixture();
+    const lock = join(home, ".dream.lock");
+    const first = acquireLock(lock);
+    assert.equal(first.held, true);
+    const second = acquireLock(lock);
+    assert.equal(second.held, false);
+    assert.equal(second.reason, "lock gate: lock already exists");
+    assert.equal(readFileSync(lock, "utf8").trim(), `${process.pid} ${first.token}`, "the holder's marker is untouched");
+});
+test("cleanup never removes a successor's lock, even repeated", () => {
+    const home = fixture();
+    const lock = join(home, ".dream.lock");
+    const stamp = lastRunPath(lock);
+    const mine = acquireLock(lock);
+    assert.equal(mine.held, true);
+    // A successor acquires after ours is externally gone (human/supported protocol).
+    unlinkSync(lock);
+    const successor = acquireLock(lock);
+    assert.equal(successor.held, true);
+    const successorStamp = Date.now() - 5000;
+    utimesSync(stamp, new Date(), new Date(successorStamp));
+    failLock(mine);
+    releaseLock(mine);
+    assert.equal(mine.held, false, "the old state is marked released by the first cleanup");
+    assert.equal(readFileSync(lock, "utf8").trim(), `${process.pid} ${successor.token}`, "the successor's lock survives");
+    assert.ok(Math.abs(statSync(stamp).mtimeMs - successorStamp) < 1000, "the successor's timestamp survives");
+});
+/** Each child makes one actual acquisition attempt; a holder stays alive so later attempts see it. */
+async function acquireRaceOutcomes(lock, contenders) {
+    const moduleUrl = new URL("../src/dream/lock.js", import.meta.url).href;
+    const script = [
+        `import { acquireLock, releaseLock } from ${JSON.stringify(moduleUrl)};`,
+        `const result = acquireLock(${JSON.stringify(lock)});`,
+        `if (result.held) await new Promise((resolve) => setTimeout(resolve, 1200));`,
+        `process.stdout.write(result.held ? "held" : "lost");`,
+        `if (result.held) releaseLock(result);`,
+    ].join("\n");
+    const contender = () => new Promise((resolve, reject) => {
+        execFile(process.execPath, ["--input-type=module", "-e", script], (error, stdout) => error ? reject(error) : resolve(stdout.trim()));
+    });
+    return Promise.all(Array.from({ length: contenders }, contender));
+}
+test("concurrent acquisitions of an absent lock yield exactly one held:true", async () => {
+    const home = fixture();
+    const lock = join(home, ".dream.lock");
+    assert.equal(existsSync(lock), false, "the lock starts absent");
+    const outcomes = await acquireRaceOutcomes(lock, 8);
+    assert.equal(outcomes.filter((outcome) => outcome === "held").length, 1, "exactly one actual held:true return");
+});
+test("dreamer write jail accepts home files and refuses escapes", async () => {
+    const home = fixture();
+    const tools = new Map(dreamerWriteToolDefinitions(home).map((tool) => [tool.name, tool]));
+    const ctx = { cwd: home };
+    await tools.get("write").execute("write", { path: "global/x.md", content: "one" }, undefined, undefined, ctx);
+    assert.equal(readFileSync(join(home, "global/x.md"), "utf8"), "one");
+    const rejectsOutsideHome = async (tool, path) => {
+        const params = tool === "write" ? { path, content: "outside" } : { path, edits: [{ oldText: "one", newText: "outside" }] };
+        await assert.rejects(() => tools.get(tool).execute("escape", params, undefined, undefined, ctx), (error) => error.message.includes(home));
+    };
+    for (const tool of ["write", "edit"]) {
+        await rejectsOutsideHome(tool, "/tmp/dream-jail-outside.md");
+        await rejectsOutsideHome(tool, "../dream-jail-outside.md");
+    }
+    const outside = fixture();
+    symlinkSync(outside, join(home, "escape"));
+    await rejectsOutsideHome("write", "escape/outside.md");
+    await rejectsOutsideHome("edit", "escape/outside.md");
+    assert.equal(existsSync(join(outside, "outside.md")), false, "the jail does not write through an in-home symlink");
+    const outsideFile = join(outside, "outside.md");
+    writeFileSync(outsideFile, "outside");
+    symlinkSync(outsideFile, join(home, "global/outside-link.md"));
+    await rejectsOutsideHome("write", "global/outside-link.md");
+    assert.equal(readFileSync(outsideFile, "utf8"), "outside", "the jail does not write through a symlinked file outside home");
+    linkSync(outsideFile, join(home, "global/hardlink.md"));
+    await rejectsOutsideHome("write", "global/hardlink.md");
+    assert.equal(readFileSync(outsideFile, "utf8"), "outside", "the jail does not write through a hardlinked file outside home");
+    const insideFile = join(home, "global/inside.md");
+    writeFileSync(insideFile, "inside");
+    symlinkSync(insideFile, join(home, "global/inside-link.md"));
+    await tools.get("write").execute("write", { path: "global/inside-link.md", content: "updated" }, undefined, undefined, ctx);
+    assert.equal(readFileSync(insideFile, "utf8"), "updated", "the jail permits a symlinked file that resolves inside home");
+    // The jail has no `.git` special case: an in-home `.git` path is written like any other.
+    await tools.get("write").execute("write", { path: ".git/config", content: "not protected" }, undefined, undefined, ctx);
+    assert.equal(readFileSync(join(home, ".git/config"), "utf8"), "not protected", "the dream write jail does not protect .git");
+});
+test("dreamer allowlist contains only the file tools and reports their writes", async () => {
     let configured = [];
-    const session = { subscribe(handler) { this.handler = handler; return () => { }; }, handler: (_event) => { }, async prompt(_text) { this.handler({ type: "message_end", message: { role: "assistant", content: [{ type: "text", text: '{"report":"stub"}' }] } }); }, dispose() { } };
-    const manifest = await runDreamer("playbook", "/tmp/notes", { sessionFactory: async (options) => { configured = options.tools; return session; } });
-    assert.deepEqual(manifest, { report: "stub" });
-    assert.deepEqual(configured, READ_ONLY_TOOLS);
-    assert.equal(configured.includes("notes_write"), false);
-    assert.equal(configured.includes("notes_edit"), false);
-});
-test("SDK dreamer surfaces provider stopReason error instead of manifest-parse lie", async () => {
-    const session = { subscribe(handler) { this.handler = handler; return () => { }; }, handler: (_event) => { }, async prompt(_text) { this.handler({ type: "message_end", message: { role: "assistant", content: [], stopReason: "error", errorMessage: "402: {\"error\":{\"message\":\"Insufficient Balance\"}}" } }); }, dispose() { } };
-    await assert.rejects(() => runDreamer("playbook", "/tmp/notes", { sessionFactory: async () => session }), /Insufficient Balance/);
-    await assert.rejects(() => runDreamer("playbook", "/tmp/notes", { sessionFactory: async () => session }), /402/);
-});
-test("SDK dreamer parse failure keeps existing manifest message without provider error", async () => {
-    const session = { subscribe(handler) { this.handler = handler; return () => { }; }, handler: (_event) => { }, async prompt(_text) { this.handler({ type: "message_end", message: { role: "assistant", content: [{ type: "text", text: "sorry, I could not do that" }] } }); }, dispose() { } };
-    await assert.rejects(() => runDreamer("playbook", "/tmp/notes", { sessionFactory: async () => session }), /did not return a valid JSON manifest/);
+    const session = {
+        subscribe(handler) { this.handler = handler; return () => { }; },
+        handler: (_event) => { },
+        async prompt(_text) { this.handler({ type: "tool_execution_start", toolName: "write", args: { path: "global/a.md", content: "a" } }); this.handler({ type: "tool_execution_start", toolName: "edit", args: { path: "project/p.md", edits: [] } }); this.handler({ type: "message_end", message: { role: "assistant", content: [{ type: "text", text: "done" }, { type: "text", text: "again" }] } }); },
+        dispose() { },
+    };
+    const result = await runDreamer("playbook", "/tmp/notes", { sessionFactory: async (options) => { configured = options.tools; return session; } });
+    assert.deepEqual(configured, DREAMER_TOOLS);
+    assert.deepEqual(configured, ["read", "grep", "find", "ls", "write", "edit"]);
+    assert.equal(configured.some((tool) => tool.startsWith("notes_")), false);
+    assert.deepEqual(result.writes, [{ tool: "write", path: "global/a.md" }, { tool: "edit", path: "project/p.md" }]);
+    assert.equal(result.report, "done\nagain");
+    assert.equal(result.report, contentText([{ type: "text", text: "done" }, { type: "text", text: "again" }]), "dream and history share the text projection");
+    assert.equal(result.error, undefined);
+});
+test("dreamer session has exactly the jailed file-tool allowlist", async () => {
+    const session = await defaultDreamerSessionFactory({ cwd: fixture(), tools: DREAMER_TOOLS });
+    try {
+        assert.deepEqual(session.agent.state.tools.map((tool) => tool.name).sort(), [...DREAMER_TOOLS].sort());
+    }
+    finally {
+        session.dispose();
+    }
+});
+test("playbook describes plain files and the retained frontmatter", () => {
+    const playbook = readFileSync(join(process.cwd(), "playbook.md"), "utf8");
+    assert.equal(playbook.includes("notes_"), false);
+    for (const field of ["origin", "status", "stale", "created_at", "updated_at", "last_accessed", "access_count"])
+        assert.match(playbook, new RegExp(`^${field}:`, "m"));
+    assert.equal(/^scope:/m.test(playbook), false, "scope is derived from the address rather than persisted");
+    assert.match(playbook, /Nothing is physically deleted/);
+});
+test("provider errors are reported with partial writes instead of parsing a response", async () => {
+    const factory = scriptedSession((handler) => {
+        handler({ type: "tool_execution_start", toolName: "write", args: { path: "global/partial.md", content: "half" } });
+        handler({ type: "message_end", message: { role: "assistant", stopReason: "error", errorMessage: "Insufficient Balance" } });
+    });
+    const result = await runDreamer("playbook", "/tmp/notes", { sessionFactory: factory });
+    assert.match(result.error ?? "", /Insufficient Balance/);
+    assert.deepEqual(result.writes, [{ tool: "write", path: "global/partial.md" }]);
 });
 test("default dreamer rejects an unresolvable model pattern", async () => {
-    await assert.rejects(() => defaultDreamerSessionFactory({ cwd: "/tmp/notes", modelPattern: "definitely-not-a-real-model", tools: READ_ONLY_TOOLS }), /definitely-not-a-real-model/);
+    await assert.rejects(() => defaultDreamerSessionFactory({ cwd: "/tmp/notes", modelPattern: "definitely-not-a-real-model", tools: DREAMER_TOOLS }), /definitely-not-a-real-model/);
+});
+test("git audit layer commits baseline and dream, stays silent when clean, keeps file content", () => {
+    const home = fixture();
+    writeFileSync(join(home, "a.md"), "one");
+    const baseline = gitCommit(home, "baseline t");
+    assert.equal(baseline.ok, true);
+    const clean = gitCommit(home, "dream t"); // clean tree — no empty commit
+    assert.equal(clean.ok, true);
+    assert.equal(clean.empty, true);
+    const log1 = execFileSync("git", ["log", "--format=%s"], { cwd: home, encoding: "utf8" }).trim();
+    assert.equal(log1, "baseline t");
+    writeFileSync(join(home, "a.md"), "two");
+    const second = gitCommit(home, "dream t2");
+    assert.equal(second.ok, true);
+    assert.equal(second.empty, false);
+    const log2 = execFileSync("git", ["log", "--format=%s"], { cwd: home, encoding: "utf8" }).trim();
+    assert.equal(log2, "dream t2\nbaseline t");
+    assert.equal(readFileSync(join(home, "a.md"), "utf8"), "two"); // notes themselves untouched by the layer
+    const before = execFileSync("git", ["show", "HEAD~1:a.md"], { cwd: home, encoding: "utf8" }).trim();
+    assert.equal(before, "one"); // rollback information actually recorded
+});
+test("git audit layer gives a newly initialized empty repository a real baseline snapshot", () => {
+    const home = fixture();
+    const baseline = gitCommit(home, "baseline empty");
+    assert.equal(baseline.ok, true);
+    if (baseline.ok) {
+        assert.notEqual(baseline.commit, "", "the baseline carries a real commit, not an empty marker");
+        assert.equal(baseline.empty, true, "no files changed");
+    }
+    assert.equal(execFileSync("git", ["log", "--format=%s"], { cwd: home, encoding: "utf8" }).trim(), "baseline empty");
+});
+test("git audit layer reports its failure instead of swallowing it", () => {
+    const missing = gitCommit(join(fixture(), "missing", "home"), "x");
+    assert.equal(missing.ok, false);
+    const broken = fixture();
+    writeFileSync(join(broken, ".git"), "not a git directory");
+    const result = gitCommit(broken, "x");
+    assert.equal(result.ok, false);
+    if (!result.ok)
+        assert.ok(result.error.length > 0, "the audit failure names its cause");
+});
+test("CLI: a failed final audit is recorded in the report and in the exit status", async () => {
+    const home = fixture();
+    const sessionFactory = scriptedSession((_handler, cwd) => {
+        mkdirSync(join(cwd, "global"), { recursive: true });
+        writeFileSync(join(cwd, "global/ok.md"), "ok");
+        // Break the repository after the baseline so only the final audit fails.
+        rmSync(join(cwd, ".git"), { recursive: true, force: true });
+        writeFileSync(join(cwd, ".git"), "broken");
+    });
+    const { code, errors } = await captureErrors(() => main(["--notes-home", home, "--force"], { sessionFactory, dreamerSettings: () => ({ warnings: [] }) }));
+    assert.notEqual(code, 0, "a dream with no final snapshot is not a success");
+    assert.ok(errors.some((line) => /final audit failed/.test(line)), "the audit failure is named");
+    const reports = readdirSync(join(home, "dreams"));
+    assert.equal(reports.length, 1);
+    assert.match(readFileSync(join(home, "dreams", reports[0]), "utf8"), /Final audit failed/, "the success report records the audit failure");
+});
+test("CLI: a report-write failure does not prevent the final failure audit", async () => {
+    const home = fixture();
+    writeFileSync(join(home, "dreams"), "not a directory");
+    const sessionFactory = scriptedSession((handler, cwd) => {
+        mkdirSync(join(cwd, "global"), { recursive: true });
+        writeFileSync(join(cwd, "global/partial.md"), "half");
+        handler({ type: "tool_execution_start", toolName: "write", args: { path: "global/partial.md", content: "half" } });
+        handler({ type: "message_end", message: { role: "assistant", stopReason: "error", errorMessage: "Insufficient Balance" } });
+    });
+    const { code, errors } = await captureErrors(() => main(["--notes-home", home, "--force"], { sessionFactory, dreamerSettings: () => ({ warnings: [] }) }));
+    assert.notEqual(code, 0);
+    assert.ok(errors.some((line) => /could not write report/.test(line)), "the report failure is surfaced");
+    assert.match(execFileSync("git", ["log", "--format=%s"], { cwd: home, encoding: "utf8" }).trim(), /\(failed\)/, "the final failure audit still ran");
+    assert.equal(execFileSync("git", ["show", "HEAD:global/partial.md"], { cwd: home, encoding: "utf8" }), "half", "the partial write is still committed");
+});
+test("CLI: an unwritable report is a failure even when the dreamer succeeds", async () => {
+    const home = fixture();
+    writeFileSync(join(home, "dreams"), "not a directory");
+    const { code, errors } = await captureErrors(() => main(["--notes-home", home, "--force"], { sessionFactory: successSession(), dreamerSettings: () => ({ warnings: [] }) }));
+    assert.notEqual(code, 0, "a missing report is not a success");
+    assert.ok(errors.some((line) => /could not write report/.test(line)), "the report failure is surfaced");
+    assert.notEqual(execFileSync("git", ["log", "--format=%s"], { cwd: home, encoding: "utf8" }).trim(), "", "the final audit still ran");
+});
+test("CLI: a failed baseline audit aborts before the dreamer and preserves the notes bytes", async () => {
+    const home = fixture();
+    writeFileSync(join(home, "keep.md"), "keep me");
+    writeFileSync(join(home, ".git"), "not a git directory"); // every git command fails
+    let started = false;
+    const { code } = await captureErrors(() => main(["--notes-home", home, "--force"], {
+        sessionFactory: async () => { started = true; return {}; },
+        dreamerSettings: () => ({ warnings: [] }),
+    }));
+    assert.notEqual(code, 0, "a missing baseline is a failed run");
+    assert.equal(started, false, "the dreamer never starts without a baseline");
+    assert.equal(readFileSync(join(home, "keep.md"), "utf8"), "keep me", "the notes bytes survive");
+    assert.equal(existsSync(join(home, "dreams")), false, "no dream report is written");
+});
+test("CLI: a dreamer failure records the failure and the partial write in a final commit", async () => {
+    const home = fixture();
+    const sessionFactory = scriptedSession((handler, cwd) => {
+        mkdirSync(join(cwd, "global"), { recursive: true });
+        writeFileSync(join(cwd, "global/partial.md"), "half");
+        handler({ type: "tool_execution_start", toolName: "write", args: { path: "global/partial.md", content: "half" } });
+        handler({ type: "message_end", message: { role: "assistant", stopReason: "error", errorMessage: "Insufficient Balance" } });
+    });
+    const { code } = await captureErrors(() => main(["--notes-home", home, "--force"], { sessionFactory, dreamerSettings: () => ({ warnings: [] }) }));
+    assert.notEqual(code, 0);
+    const reports = readdirSync(join(home, "dreams"));
+    assert.equal(reports.length, 1, "one failure report");
+    const report = readFileSync(join(home, "dreams", reports[0]), "utf8");
+    assert.match(report, /Insufficient Balance/, "the report contains the failure");
+    assert.match(report, /global\/partial\.md/, "the report names the partial write");
+    const log = execFileSync("git", ["log", "--format=%s"], { cwd: home, encoding: "utf8" }).trim();
+    assert.match(log, /\(failed\)/, "the partial state is committed as a failure");
+    assert.equal(execFileSync("git", ["show", "HEAD:global/partial.md"], { cwd: home, encoding: "utf8" }), "half");
+});
+test("CLI: a successful run commits its report and leaves the audited tree clean", async () => {
+    const home = fixture();
+    writeFileSync(join(home, "seed.md"), "seed");
+    const { code } = await captureErrors(() => main(["--notes-home", home, "--force"], { sessionFactory: successSession(), dreamerSettings: () => ({ warnings: [] }) }));
+    assert.equal(code, 0);
+    assert.equal(execFileSync("git", ["status", "--porcelain"], { cwd: home, encoding: "utf8" }).trim(), "", "the audited tree is clean after the lock is released");
+    const tracked = execFileSync("git", ["ls-files"], { cwd: home, encoding: "utf8" }).trim().split("\n");
+    assert.equal(tracked.some((file) => file.startsWith(".dream.lock")), false, "lock artifacts stay out of the snapshot");
+    assert.equal(tracked.includes("seed.md"), true);
+});
+test("CLI: --force does not bypass an existing lock", async () => {
+    const home = fixture();
+    writeFileSync(join(home, ".dream.lock"), "999999 dead-owner");
+    let started = false;
+    const { code } = await captureErrors(() => main(["--notes-home", home, "--force"], {
+        sessionFactory: async () => { started = true; return {}; },
+        dreamerSettings: () => ({ warnings: [] }),
+    }));
+    assert.equal(code, 0, "an existing lock skips the run rather than failing");
+    assert.equal(started, false, "--force never reaches the dreamer while the lock exists");
+    assert.equal(readFileSync(join(home, ".dream.lock"), "utf8"), "999999 dead-owner", "the existing lock is byte-identical");
+    assert.equal(existsSync(join(home, "dreams")), false, "no dream report is written");
+});
+test("dreamer setting is a non-empty string; project overrides global; invalid values warn and fall back", () => {
+    assert.deepEqual(deriveDreamer({}), { warnings: [] }, "absent setting falls back silently");
+    assert.deepEqual(deriveDreamer({ dreamer: "openai/gpt-x" }), { pattern: "openai/gpt-x", warnings: [] });
+    const merged = mergePiContextSettings({ [PI_CONTEXT_SETTINGS_KEY]: { [PI_CONTEXT_DREAMER_KEY]: "global/model" } }, { [PI_CONTEXT_SETTINGS_KEY]: { [PI_CONTEXT_DREAMER_KEY]: "project/model" } });
+    assert.equal(deriveDreamer(merged).pattern, "project/model", "project wins per key");
+    for (const invalid of ["", "   ", 42, null]) {
+        const result = deriveDreamer({ dreamer: invalid });
+        assert.equal(result.pattern, undefined, `invalid ${JSON.stringify(invalid)} is ignored`);
+        assert.equal(result.warnings.length, 1, "one warning per invalid value");
+        assert.match(result.warnings[0], /dreamer/);
+    }
+});
+test("readDreamerSettings reads the project setting over the global one through SettingsManager", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "dream-cwd-"));
+    const agentDir = mkdtempSync(join(tmpdir(), "dream-agent-"));
+    const prior = process.env.PI_CODING_AGENT_DIR;
+    process.env.PI_CODING_AGENT_DIR = agentDir;
+    try {
+        writeFileSync(join(agentDir, "settings.json"), JSON.stringify({ [PI_CONTEXT_SETTINGS_KEY]: { [PI_CONTEXT_DREAMER_KEY]: "global/model" } }));
+        mkdirSync(join(cwd, ".pi"), { recursive: true });
+        writeFileSync(join(cwd, ".pi", "settings.json"), JSON.stringify({ [PI_CONTEXT_SETTINGS_KEY]: { [PI_CONTEXT_DREAMER_KEY]: "project/model" } }));
+        assert.equal(readDreamerSettings(cwd).pattern, "project/model");
+        writeFileSync(join(cwd, ".pi", "settings.json"), JSON.stringify({}));
+        assert.equal(readDreamerSettings(cwd).pattern, "global/model", "global applies when the project does not set the key");
+    }
+    finally {
+        if (prior === undefined)
+            delete process.env.PI_CODING_AGENT_DIR;
+        else
+            process.env.PI_CODING_AGENT_DIR = prior;
+    }
+});
+test("CLI: --dreamer wins over settings, settings win over the automatic fallback", async () => {
+    const home = fixture();
+    const seen = [];
+    const success = successSession();
+    const run = (argv, settings) => main(["--notes-home", home, "--force", ...argv], {
+        sessionFactory: async (options) => { seen.push(options.modelPattern); return success({ cwd: home, tools: DREAMER_TOOLS }); },
+        dreamerSettings: () => settings,
+    });
+    await captureErrors(() => run([], { pattern: "settings/model", warnings: [] }));
+    await captureErrors(() => run(["--dreamer", "cli/model"], { pattern: "settings/model", warnings: [] }));
+    await captureErrors(() => run([], { warnings: [] }));
+    assert.deepEqual(seen, ["settings/model", "cli/model", undefined]);
 });

package/dist/test/history.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { resetV2WindowId, visibleItem } from "../src/history.js";
+import { contentText, resetV2WindowId, rootWindowId, visibleItem } from "../src/history.js";
 test("visibleItem reports a plain fitting prefix and names the full length", () => {
     const item = visibleItem({ windowId: "w", itemId: "i", role: "user", content: "abcdef", createdAt: undefined }, 4);
     assert.equal(Array.from(item.truncated_content).length, 4);
@@ -19,3 +19,8 @@ test("persisted reset IDs are opaque within the supported protocol version", ()
     assert.equal(resetV2WindowId({ piContext: "reset-v2", windowId: 123 }), undefined);
     assert.equal(resetV2WindowId(null), undefined);
 });
+test("text content projection and root window IDs have stable shared forms", () => {
+    const content = [{ type: "text", text: "first" }, { type: "toolCall", name: "ignored" }, { type: "text", text: "second" }];
+    assert.equal(contentText(content), "first\nsecond");
+    assert.equal(rootWindowId("12345678-abcd"), "pcw:12345678:root");
+});