@reticlehq/server 3.7.0 → 3.8.1

package/dist/memory/journal/journal-recorder.d.ts

@@ -1,4 +1,11 @@
 import { type JournalAction, type JournalWriteLoss, type ReticleEvent } from '@reticlehq/core';
+/**
+ * The arguments as the journal keeps them: every typed value replaced, at any depth (a sequence's
+ * steps too). A fill's arguments kept a typed password in clear in `actions.jsonl`; the page cannot
+ * tell the daemon which field was secret before the call is written, and nothing reads a typed value
+ * back from the journal — the run fold reads the ref, the target and the action — so none is kept.
+ */
+export declare function withoutTypedInput(args: unknown): unknown;
 /** Where a recorder persists. `SessionJournal` satisfies this structurally. */
 export interface JournalSink {
     appendEvents(events: readonly ReticleEvent[]): Promise<void>;

package/dist/memory/journal/journal-recorder.js

@@ -3,6 +3,7 @@ import { isSelfObservation } from './self-observation.js';
 import { currentDrivenBy } from '../../hooks/driven-by.js';
 import { callerClientName } from '../../hooks/coding-agents.js';
 import { log } from '../../log.js';
+import { runLedger } from '../../judgement/runs/run-ledger.js';
 /**
  * Logged the FIRST time a journal write is lost, and never again for that recorder.
  *
@@ -23,11 +24,13 @@ const TYPED_KEYS = ['value', 'text'];
  * tell the daemon which field was secret before the call is written, and nothing reads a typed value
  * back from the journal — the run fold reads the ref, the target and the action — so none is kept.
  */
-function withoutTypedInput(args) {
-    if (Array.isArray(args))
+export function withoutTypedInput(args) {
+    if (Array.isArray(args)) {
         return args.map(withoutTypedInput);
-    if ('object' !== typeof args || null === args)
+    }
+    if ('object' !== typeof args || null === args) {
         return args;
+    }
     const record = args;
     const typing = TYPING_ACTIONS.has(String(record['action']));
     const out = {};
@@ -37,9 +40,11 @@ function withoutTypedInput(args) {
     }
     if (typing && 'object' === typeof record['args'] && null !== record['args']) {
         const inner = { ...record['args'] };
-        for (const key of TYPED_KEYS)
-            if ('string' === typeof inner[key])
+        for (const key of TYPED_KEYS) {
+            if ('string' === typeof inner[key]) {
                 inner[key] = REDACTED_VALUE;
+            }
+        }
         out['args'] = inner;
     }
     return out;
@@ -90,8 +95,9 @@ export class JournalRecorder {
         // session keeps seeing this event. What is declined is the DURABLE copy: see isSelfObservation.
         if (!isSelfObservation(out)) {
             this.#pending.push(out);
-            if (this.#pending.length >= this.#flushAt)
+            if (this.#pending.length >= this.#flushAt) {
                 this.#enqueueFlush();
+            }
         }
         return out;
     }
@@ -109,8 +115,9 @@ export class JournalRecorder {
     /** Close the active window: persist its buffered events, then the action record. No-op if none active. */
     finishAction(effect, settled, settledInMs) {
         const active = this.#active;
-        if (active === undefined)
+        if (active === undefined) {
             return;
+        }
         this.#active = undefined;
         const action = {
             v: JOURNAL_FILE_VERSION,
@@ -128,6 +135,8 @@ export class JournalRecorder {
             ...(active.drivenBy === undefined ? {} : { drivenBy: active.drivenBy }),
             ...(active.agent === undefined ? {} : { agent: active.agent }),
         };
+        // The agent's own verdicts make its run's report; the ledger ignores the Harness's.
+        runLedger.verdict(action);
         this.#enqueueFlush();
         this.#chain = this.#chain
             .then(() => this.#sink.appendAction(action))
@@ -173,6 +182,8 @@ export class JournalRecorder {
                 return agent === undefined ? {} : { agent };
             })(),
         };
+        // The agent's own verdicts make its run's report; the ledger ignores the Harness's.
+        runLedger.verdict(action);
         this.#enqueueFlush();
         this.#chain = this.#chain
             .then(() => this.#sink.appendAction(action))
@@ -184,8 +195,9 @@ export class JournalRecorder {
         await this.#chain;
     }
     #enqueueFlush() {
-        if (0 === this.#pending.length)
+        if (0 === this.#pending.length) {
             return;
+        }
         const batch = this.#pending;
         this.#pending = [];
         this.#chain = this.#chain
@@ -194,8 +206,9 @@ export class JournalRecorder {
     }
     /** Swallow a lost write, but say so once. See JOURNAL_WRITE_LOST. */
     #reportLoss(error) {
-        if (this.#lossReported)
+        if (this.#lossReported) {
             return;
+        }
         this.#lossReported = true;
         log(JOURNAL_WRITE_LOST, { error: error instanceof Error ? error.message : String(error) });
     }

package/dist/memory/journal/on-disk/ambient-file.d.ts

@@ -12,10 +12,4 @@ import { z } from 'zod';
 export declare const AmbientFileSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     regions: z.ZodRecord<z.ZodString, z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    version: 1;
-    regions: Record<string, number>;
-}, {
-    version: 1;
-    regions: Record<string, number>;
-}>;
+}, z.core.$strip>;

package/dist/memory/journal/on-disk/ambient-file.js

@@ -11,5 +11,5 @@ import { z } from 'zod';
  */
 export const AmbientFileSchema = z.object({
     version: z.literal(1),
-    regions: z.record(z.number()),
+    regions: z.record(z.string(), z.number()),
 });

package/dist/memory/journal/on-disk/workspace-gitignore.d.ts

@@ -1,10 +1,31 @@
 import type { FileSystemPort } from '../../project/fs/fs-port.js';
 /**
- * Write `.reticle/.gitignore` if it is not already there.
+ * The `.reticle/` entries that are LOCAL state, and must never be committed by accident.
  *
- * Never overwrites — once the file exists it belongs to whoever edited it last, and silently
+ * Read from the tier table rather than restated here: which half a name belongs to is one decision,
+ * and a second copy of it is the list that silently disagrees. This file asks the table exactly one
+ * of its two questions — `sharing` — and has no opinion at all about what retention may delete.
+ *
+ * The reason this matters beyond tidiness: a session journal carries URLs, request and response
+ * bodies, and DOM text from the app under test. `.reticle/` is created by the daemon rather than by
+ * the user, so it arrives untracked and unexplained, and one `git add -A` puts an app's traffic into
+ * a shared repository. Reticle created the directory; the ignore for it is Reticle's to write.
+ */
+/** The ignore file inside `.reticle/`. */
+export declare const WORKSPACE_GITIGNORE = ".gitignore";
+/**
+ * The ignore file `.reticle/` should hold, given the one it holds now (`undefined`: none). Returns
+ * `undefined` when nothing needs to change. A new file gets every local entry. An existing file
+ * keeps every line it has, and gets only the prompt files it lacks, appended at the end.
+ */
+export declare function workspaceGitignore(existing: string | undefined): string | undefined;
+/**
+ * Write `.reticle/.gitignore`, or add the prompt files to the one that is there.
+ *
+ * Never overwrites. Once the file exists it belongs to whoever edited it last, and silently
  * reverting somebody's change to a file we placed in their repository is worse than not having
- * written it. Best-effort throughout: this runs on the daemon's start path, and a workspace that
+ * written it. The one exception is additive: the prompt files are appended when missing, because
+ * a file written before prompt capture existed would otherwise let them be committed. Best-effort throughout: this runs on the daemon's start path, and a workspace that
  * cannot be written must not stop a daemon coming up. Nothing about verification depends on it.
  */
 export declare function ensureWorkspaceGitignore(fs: FileSystemPort, root: string): Promise<void>;

package/dist/memory/journal/on-disk/workspace-gitignore.js

@@ -13,6 +13,8 @@ import { LOCAL_DIRS, LOCAL_FILES } from './workspace-tiers.js';
  * the user, so it arrives untracked and unexplained, and one `git add -A` puts an app's traffic into
  * a shared repository. Reticle created the directory; the ignore for it is Reticle's to write.
  */
+/** The ignore file inside `.reticle/`. */
+export const WORKSPACE_GITIGNORE = '.gitignore';
 const TRANSIENT = [
     ...LOCAL_DIRS.map((dir) => `${dir}/`),
     ...LOCAL_FILES,
@@ -30,23 +32,52 @@ const HEADER = [
     `# ${ReticleDir.CAPSULES_SUBDIR}/. Those are meant to be committed — a saved flow only earns its keep`,
     '# when a teammate or CI can replay it.',
     '#',
-    '# Edit freely: Reticle writes this once and never rewrites it.',
+    '# Edit freely. Reticle only adds the prompt files below when they are missing: they hold every',
+    '# prompt you typed, and a `git add -A` must never publish them.',
 ];
 /**
- * Write `.reticle/.gitignore` if it is not already there.
+ * The entries Reticle adds to an ignore file that already exists. They are the user's prompts, and
+ * a `.gitignore` written before prompt capture existed has none of them.
+ */
+const PROMPT_FILES = [
+    ReticleDir.REQUEST_FILE,
+    ReticleDir.REQUESTS_LOG_FILE,
+    ReticleDir.REQUESTS_LOG_ROTATED_FILE,
+];
+const MERGED_NOTE = '# Added by Reticle: the prompts you typed, kept on this machine.';
+/**
+ * The ignore file `.reticle/` should hold, given the one it holds now (`undefined`: none). Returns
+ * `undefined` when nothing needs to change. A new file gets every local entry. An existing file
+ * keeps every line it has, and gets only the prompt files it lacks, appended at the end.
+ */
+export function workspaceGitignore(existing) {
+    if (existing === undefined)
+        return `${[...HEADER, '', ...TRANSIENT].join('\n')}\n`;
+    const lines = new Set(existing.split(/\r?\n/).map((line) => line.trim()));
+    const missing = PROMPT_FILES.filter((name) => !lines.has(name) && !lines.has(`/${name}`));
+    if (0 === missing.length)
+        return undefined;
+    const base = existing.endsWith('\n') || '' === existing ? existing : `${existing}\n`;
+    return `${base}${[MERGED_NOTE, ...missing].join('\n')}\n`;
+}
+/**
+ * Write `.reticle/.gitignore`, or add the prompt files to the one that is there.
  *
- * Never overwrites — once the file exists it belongs to whoever edited it last, and silently
+ * Never overwrites. Once the file exists it belongs to whoever edited it last, and silently
  * reverting somebody's change to a file we placed in their repository is worse than not having
- * written it. Best-effort throughout: this runs on the daemon's start path, and a workspace that
+ * written it. The one exception is additive: the prompt files are appended when missing, because
+ * a file written before prompt capture existed would otherwise let them be committed. Best-effort throughout: this runs on the daemon's start path, and a workspace that
  * cannot be written must not stop a daemon coming up. Nothing about verification depends on it.
  */
 export async function ensureWorkspaceGitignore(fs, root) {
-    const path = join(root, '.gitignore');
+    const path = join(root, WORKSPACE_GITIGNORE);
     try {
-        if (await fs.exists(path))
+        const existing = (await fs.exists(path)) ? await fs.readFile(path) : undefined;
+        const next = workspaceGitignore(existing);
+        if (next === undefined)
             return;
         await fs.mkdir(root);
-        await fs.writeFile(path, `${[...HEADER, '', ...TRANSIENT].join('\n')}\n`);
+        await fs.writeFile(path, next);
     }
     catch {
         /* a workspace we cannot write is not a reason to fail a session */

package/dist/memory/journal/on-disk/workspace-tiers.js

@@ -41,7 +41,11 @@ const sharedFile = { durability: Durability.MEMORY, sharing: Sharing.COMMIT, isD
  */
 export const WORKSPACE_TIERS = {
     [ReticleDir.SESSIONS_SUBDIR]: localDir,
+    // Every tool call and its whole result: app data, so local, and evidence, so swept by age.
+    [ReticleDir.EPISODES_SUBDIR]: localDir,
     [ReticleDir.RUNS_SUBDIR]: localDir,
+    // A dev server's output, written here only when the state home cannot be written.
+    [ReticleDir.LOGS_SUBDIR]: localDir,
     [ReticleDir.VISUAL_SUBDIR]: localDir,
     // Write-only: a local copy of what was already sent. The outbox is the record.
     [ReticleDir.FEEDBACK_SUBDIR]: localDir,
@@ -56,6 +60,9 @@ export const WORKSPACE_TIERS = {
     [ReticleDir.TIERS_FILE]: localFile,
     // The user's request in their own words: it leaves only with `shareRequests`, never by git push.
     [ReticleDir.REQUEST_FILE]: localFile,
+    // Every prompt the agent hook captured: the same words, so the same rule.
+    [ReticleDir.REQUESTS_LOG_FILE]: localFile,
+    [ReticleDir.REQUESTS_LOG_ROTATED_FILE]: localFile,
     // How to target this app, learned from corrected failures: a teammate's agent needs it too.
     [ReticleDir.APP_NOTES_FILE]: sharedFile,
     [ReticleDir.PLATFORM_MOMENTS_FILE]: localFile,

package/dist/memory/journal/self-observation.js

@@ -46,6 +46,7 @@ const NET_TYPES = new Set([
     EventType.NET_REQUEST,
     EventType.NET_PENDING,
     EventType.NET_DETAIL,
+    EventType.NET_RESPONSE_BODY,
     EventType.NET_STREAM,
 ]);
 /** A base for parsing relative URLs. Never dereferenced — only the path is read. */
@@ -60,8 +61,9 @@ function pathOf(url) {
 }
 /** True when this event is the page fetching Reticle's own code rather than doing anything. */
 export function isSelfObservation(event) {
-    if (!NET_TYPES.has(event.type))
+    if (!NET_TYPES.has(event.type)) {
         return false;
+    }
     const path = pathOf(urlForMatch(event.data));
     return path.includes(SCOPE_PATH) || path.includes(SCOPE_FLATTENED);
 }

package/dist/memory/journal/session-end.js

@@ -22,6 +22,8 @@ import { RunStore } from '../../judgement/runs/artifact/run-store.js';
  * starts already knowing which regions churn.
  */
 export function makeSessionEnd(deps) {
+    // The `flow_recorded` outcomes this daemon already reported. See saveDrivenFlow.
+    const flowStepsSent = new Set();
     return async (session) => {
         /*
          * Retention is maintenance of a directory, not a part of journalling, so it runs either way.
@@ -94,7 +96,7 @@ export function makeSessionEnd(deps) {
         // Saved only when the tape declared a consequence — see drive-flow.ts for why the alternative is
         // a false-green factory running once per session.
         try {
-            await saveDrivenFlow(deps, session);
+            await saveDrivenFlow(deps, session, flowStepsSent);
         }
         catch (error) {
             // A flow is a by-product of the session; failing to write one never fails the teardown. It is
@@ -171,8 +173,9 @@ export function makeSessionEnd(deps) {
 export async function recordDriveRun(deps, session) {
     // Called through the object, not lifted into a local: a lifted method loses its `this`, and the
     // real Session's reader closes over the journal it was constructed with.
-    if (session.readJournalActions === undefined)
+    if (session.readJournalActions === undefined) {
         return;
+    }
     const actions = await session.readJournalActions();
     const root = session.artifactRoot ?? deps.reticleRoot;
     const inputs = driveRunsFrom(actions, {
@@ -188,8 +191,9 @@ export async function recordDriveRun(deps, session) {
         ...(session.projectId === undefined ? {} : { projectId: session.projectId }),
         projectName: basename(dirname(root)),
     });
-    if (0 === inputs.length)
+    if (0 === inputs.length) {
         return;
+    }
     // The protocol reaching the artifact a person actually reads. Only when the session could say
     // where it was: a subject with no locator is not a weaker subject, it is a guess, and the
     // schema makes the field optional so that absence can be told from invention.
@@ -213,15 +217,16 @@ export async function recordDriveRun(deps, session) {
         // restamping on every rewrite showed the tab's close as the drive's time.
         const held = await store.read(asRunId(input.runId));
         const firstAt = held.ok ? held.run.createdAt : undefined;
-        await store.write(buildVerificationRun({ ...input, ...(subject === undefined ? {} : { subject }) }, firstAt === undefined ? clock : () => firstAt));
+        await store.write(buildVerificationRun({ ...input, ...(subject === undefined ? {} : { subject }) }, firstAt === undefined ? clock : () => firstAt), { sessionId: session.id });
     }
 }
 /** Persist what this session drove as a replayable flow, when it declared anything provable. */
-async function saveDrivenFlow(deps, session) {
+async function saveDrivenFlow(deps, session, stepsSent) {
     const takeTape = deps.takeAmbientTape;
     const flows = deps.flowsAt?.(session.artifactRoot ?? deps.reticleRoot) ?? deps.flows;
-    if (takeTape === undefined || flows === undefined)
+    if (takeTape === undefined || flows === undefined) {
         return;
+    }
     // One flow per journey the session contained, not one flow per session — see drive-flow.ts.
     const { programs, outcome } = driveFlowsFrom(takeTape(session.id));
     const author = deps.author?.();
@@ -235,7 +240,7 @@ async function saveDrivenFlow(deps, session) {
     // which is a real outcome and not our bug. Counting it as a failure would blame the product for a
     // choice the agent made, and counting it as success would claim a regression test that cannot go
     // red. `unprovenSteps` is what separates "drove and proved nothing" from "drove nothing at all".
-    await deps.reportStep?.({
+    const step = {
         phase: OnboardingPhase.FIRST_RUN,
         step: 'flow_recorded',
         status: 0 === programs.length ? OnboardingStepStatus.SKIPPED : OnboardingStepStatus.COMPLETED,
@@ -246,7 +251,15 @@ async function saveDrivenFlow(deps, session) {
         ...(0 < programs.length || outcome.mockedSteps === undefined
             ? {}
             : { reason: DriveFlowSkipReason.DRIVEN_UNDER_NETWORK_MOCKS }),
-    });
+    };
+    // Once per daemon for each status and reason. A browser session ends at every page reload, and
+    // a page that reloads in a loop sent this step without end. A repeat tells the funnel nothing.
+    const key = `${step.status}/${step.reason ?? ''}`;
+    if (stepsSent.has(key)) {
+        return;
+    }
+    stepsSent.add(key);
+    await deps.reportStep?.(step);
 }
 /**
  * Remove this session's journal when it served no tool call.
@@ -258,8 +271,9 @@ async function saveDrivenFlow(deps, session) {
 async function dropUndrivenJournal(fs, root, sessionId) {
     try {
         const actions = await fs.readFile(journalActionsPath(root, sessionId)).catch(() => '');
-        if (actions.trim().length > 0)
+        if (actions.trim().length > 0) {
             return;
+        }
         await fs.rm(sessionDirPath(root, sessionId));
     }
     catch {

package/dist/memory/journal/session-journal.js

@@ -49,8 +49,9 @@ const CACHE_COMPACT_AT = 1024;
  * bound is used in and silently disable it, which is the one failure mode a bound must not have.
  */
 function boundedOption(value, fallback, name) {
-    if (value === undefined)
+    if (value === undefined) {
         return fallback;
+    }
     if (!Number.isSafeInteger(value) || value <= 0) {
         throw new Error(`refusing a journal ${name} that is not a positive whole number: ${String(value)}`);
     }
@@ -184,11 +185,13 @@ export class SessionJournal {
      * already on disk is deleted, and the loss is at the end where it can be declared.
      */
     async appendEvents(events) {
-        if (0 === events.length)
+        if (0 === events.length) {
             return;
+        }
         // Durable, not a field: see #writeLoss. A closed ledger is closed for a one-event batch too.
-        if ((await this.#closureReport()) !== undefined)
+        if ((await this.#closureReport()) !== undefined) {
             return;
+        }
         await this.#ensureDir();
         const path = journalEventsPath(this.#root, this.#sessionId);
         const written = await this.#eventBytesOnDisk(path);
@@ -221,8 +224,9 @@ export class SessionJournal {
      */
     async #eventBytesOnDisk(path) {
         const known = this.#eventBytes;
-        if (known !== undefined)
+        if (known !== undefined) {
             return known;
+        }
         let size;
         try {
             size = (await this.#fs.stat(path)).size;
@@ -235,8 +239,9 @@ export class SessionJournal {
             // by exactly the conditions most likely to accompany a failing disk. Thrown before anything is
             // appended; `JournalRecorder` swallows sink errors, so a live session is never taken down by
             // one.
-            if (!this.#fs.isNotFound(error))
+            if (!this.#fs.isNotFound(error)) {
                 throw error;
+            }
             size = 0;
         }
         this.#eventBytes = size;
@@ -252,16 +257,18 @@ export class SessionJournal {
      * necessarily the ceiling that closed the file.
      */
     async #closureReport() {
-        if (this.#lossLoaded)
+        if (this.#lossLoaded) {
             return this.#writeLoss;
+        }
         let text;
         try {
             text = await this.#fs.readFile(journalClosedPath(this.#root, this.#sessionId));
         }
         catch (error) {
             // Same rule as the size read above, and for the same reason: only ENOENT is "never closed".
-            if (!this.#fs.isNotFound(error))
+            if (!this.#fs.isNotFound(error)) {
                 throw error;
+            }
             this.#lossLoaded = true;
             return undefined;
         }
@@ -371,8 +378,9 @@ export class SessionJournal {
             await this.#fs.appendFile(path, text);
         }
         catch (error) {
-            if (!this.#fs.isNotFound(error))
+            if (!this.#fs.isNotFound(error)) {
                 throw error;
+            }
             this.#dirEnsured = false;
             await this.#ensureDir();
             await this.#fs.appendFile(path, text);
@@ -390,8 +398,9 @@ export class SessionJournal {
                 chunk = await readFrom(path, this.#eventBytesConsumed, this.#maxReadBytes);
             }
             catch (error) {
-                if (this.#fs.isNotFound(error))
+                if (this.#fs.isNotFound(error)) {
                     return this.#liveEvents();
+                }
                 throw error;
             }
             // Shrink guard: if the file is smaller than what we consumed, the offset is meaningless — reset
@@ -408,8 +417,9 @@ export class SessionJournal {
             const from = chunk.from ?? this.#eventBytesConsumed;
             const skipped = Math.max(0, from - this.#eventBytesConsumed);
             this.#ingestTail(chunk.text);
-            if (skipped > 0)
+            if (skipped > 0) {
                 this.#noteCut(skipped);
+            }
             // Resume at the end of the last COMPLETE line, counted forward over the bytes that actually
             // ARRIVED. Not from `chunk.size`: that is the file's end as `fstat` reported it, and a read
             // truncated or cut short returns less — a cursor there would skip every unread byte, silently
@@ -424,8 +434,9 @@ export class SessionJournal {
             text = await this.#fs.readFile(path);
         }
         catch (error) {
-            if (this.#fs.isNotFound(error))
+            if (this.#fs.isNotFound(error)) {
                 return this.#liveEvents();
+            }
             throw error;
         }
         // Fallback (whole-file) path: #eventCharsConsumed is a UTF-16 offset into the whole text. Shrink
@@ -467,11 +478,13 @@ export class SessionJournal {
      */
     #ingestTail(tail) {
         const end = tail.lastIndexOf('\n') + 1;
-        if (0 === end)
-            return; // no complete line yet
+        if (0 === end) {
+            return;
+        } // no complete line yet
         for (const line of tail.slice(0, end).split('\n')) {
-            if (0 === line.length)
+            if (0 === line.length) {
                 continue;
+            }
             let parsed;
             try {
                 parsed = JSON.parse(line);
@@ -515,8 +528,9 @@ export class SessionJournal {
             this.#droppedBytes += cost;
             this.#droppedEvents += 1;
             // Exact, unlike a byte cut: this record was parsed, so the millisecond it was lost at is known.
-            if (victim !== undefined)
+            if (victim !== undefined) {
                 this.#lostThroughT = Math.max(this.#lostThroughT, victim.t);
+            }
             // Release the payload now. Waiting for slot compaction keeps evicted snapshots strongly
             // reachable, so a short returned list alone would not bound retained evidence in memory.
             this.#eventCache[this.#cacheHead] = undefined;
@@ -545,8 +559,9 @@ export class SessionJournal {
      * is what carries this to a verdict.
      */
     readLoss() {
-        if (0 === this.#droppedBytes && 0 === this.#droppedEvents)
+        if (0 === this.#droppedBytes && 0 === this.#droppedEvents) {
             return undefined;
+        }
         const bounded = Number.isFinite(this.#lostThroughT);
         return {
             droppedBytes: this.#droppedBytes,
@@ -568,8 +583,9 @@ export class SessionJournal {
         return this.#readLines(journalActionsPath(this.#root, this.#sessionId), JournalActionSchema);
     }
     async #ensureDir() {
-        if (this.#dirEnsured)
+        if (this.#dirEnsured) {
             return;
+        }
         await this.#fs.mkdir(sessionDirPath(this.#root, this.#sessionId));
         this.#dirEnsured = true;
     }
@@ -579,14 +595,16 @@ export class SessionJournal {
             text = await this.#fs.readFile(path);
         }
         catch (error) {
-            if (this.#fs.isNotFound(error))
+            if (this.#fs.isNotFound(error)) {
                 return [];
+            }
             throw error;
         }
         const out = [];
         for (const line of text.split('\n')) {
-            if (0 === line.length)
+            if (0 === line.length) {
                 continue;
+            }
             let parsed;
             try {
                 parsed = JSON.parse(line);
@@ -596,8 +614,9 @@ export class SessionJournal {
             }
             const result = schema.safeParse(parsed);
             // Validated at this boundary; ZodTypeAny widens `.data` to any, so re-narrow to the schema output.
-            if (result.success)
+            if (result.success) {
                 out.push(result.data);
+            }
         }
         return out;
     }

package/dist/memory/project/artifact-root-resolver.d.ts

@@ -1,6 +1,15 @@
 import { type ProjectCandidate } from '@reticlehq/core/artifacts';
-import { type ProjectId } from '@reticlehq/core';
+import { type Checkout, type ProjectId } from '@reticlehq/core';
 import { type ArtifactRoot } from './artifact-root.js';
+/**
+ * May the daemon write into this `.reticle` root? This is the one answer for every writer.
+ *
+ * The resolver asks it ONCE for the daemon's own root: a directory does not become a project
+ * between two tabs connecting, and this is the IO half `unmatchedRoot` deliberately does not do.
+ * A writer that holds a root for the daemon's life (the impact ledger) asks it on each write, so
+ * that it starts to write into the project when `init` wires it.
+ */
+export declare function mayWriteIntoRoot(reticleRoot: string): boolean;
 /**
  * Every project this machine knows the directory of: discovered `.reticle.json` files first, then
  * the user-level registry, then the dev servers the build plugin announced. Read on each call, since
@@ -34,5 +43,9 @@ export interface ArtifactRootResolverDeps {
      * would silently keep sending every worktree's artifacts to the primary checkout.
      */
     servingDirectory: (origin: string) => string | undefined;
+    /** The git checkout a directory is in. Defaults to reading `.git` on disk. */
+    checkout?: (dir: string) => Checkout | undefined;
+    /** Whether a repository has linked worktrees. Defaults to one directory read. */
+    hasWorktrees?: (commonDir: string) => boolean;
 }
 export declare function artifactRootResolver(daemonRoot: string, deps: ArtifactRootResolverDeps): (projectId: ProjectId | undefined, origin?: string) => ArtifactRoot;