@wrongstack/core 0.297.0 → 0.298.1

package/dist/chronicle/project-server.js

@@ -1,11 +1,133 @@
 #!/usr/bin/env node
 
 // src/chronicle/project-server.ts
+import { randomBytes } from "node:crypto";
 import * as fs9 from "node:fs";
 import * as fsp4 from "node:fs/promises";
 import * as net from "node:net";
 import * as path15 from "node:path";
 
+// src/utils/atomic-write.ts
+import {
+  createPersistencePrimitives
+} from "@wrongstack/persistence";
+
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
+  // Tool
+  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
+  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
+  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
+  TOOL_TIMEOUT: "TOOL_TIMEOUT",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  // Config
+  CONFIG_INVALID: "CONFIG_INVALID",
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
+  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
+  // Plugin
+  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
+  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
+  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // Session
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_CORRUPTED: "SESSION_CORRUPTED",
+  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
+  // Container / Registry
+  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
+  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
+  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
+  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  REGISTRY_INVALID: "REGISTRY_INVALID",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_WRITE_FAILED: "FS_WRITE_FAILED",
+  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
+  FS_DELETE_FAILED: "FS_DELETE_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
+  // SDD (Spec-Driven Development)
+  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
+  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
+  SDD_INVALID_STATE: "SDD_INVALID_STATE",
+  SDD_NOT_READY: "SDD_NOT_READY",
+  // General
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  PARSE_FAILED: "PARSE_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var FsError = class extends WrongStackError {
+  path;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "fs",
+      severity: "error",
+      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
+      context: { path: opts.path, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FsError";
+    this.path = opts.path;
+  }
+};
+
+// src/utils/atomic-write.ts
+var primitives = createPersistencePrimitives({
+  createLockTimeoutError: ({ targetPath, timeoutMs }) => new FsError({
+    message: `Timed out waiting for file lock: ${targetPath}`,
+    code: "FS_ATOMIC_WRITE_FAILED",
+    path: targetPath,
+    context: { timeoutMs }
+  })
+});
+var atomicWrite = primitives.atomicWrite;
+var atomicReplaceWithWriter = primitives.atomicReplaceWithWriter;
+var ensureDir = primitives.ensureDir;
+var withFileLock = primitives.withFileLock;
+
 // src/utils/heap-watchdog.ts
 import * as fs from "node:fs";
 import * as fsp2 from "node:fs/promises";
@@ -526,7 +648,7 @@ function startHeapWatchdog(opts = {}) {
       dirReady = true;
     }
     await fsp2.appendFile(targetPath, `${line}
-`, "utf8");
+`, { encoding: "utf8", mode: 384 });
   });
   const drainWrites = async (firstLine) => {
     let line = firstLine;
@@ -1244,126 +1366,8 @@ import * as fs3 from "node:fs/promises";
 import * as path8 from "node:path";
 import { createInterface } from "node:readline";
 
-// src/utils/atomic-write.ts
-import {
-  createPersistencePrimitives
-} from "@wrongstack/persistence";
-
-// src/types/errors.ts
-var ERROR_CODES = {
-  // Provider
-  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
-  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
-  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
-  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
-  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
-  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
-  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
-  // Tool
-  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
-  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
-  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
-  TOOL_TIMEOUT: "TOOL_TIMEOUT",
-  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
-  // Config
-  CONFIG_INVALID: "CONFIG_INVALID",
-  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
-  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
-  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
-  // Plugin
-  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
-  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
-  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
-  // Agent
-  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
-  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
-  AGENT_ABORTED: "AGENT_ABORTED",
-  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
-  // Session
-  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
-  SESSION_CORRUPTED: "SESSION_CORRUPTED",
-  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
-  // Container / Registry
-  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
-  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
-  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
-  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
-  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
-  REGISTRY_INVALID: "REGISTRY_INVALID",
-  // File system
-  FS_READ_FAILED: "FS_READ_FAILED",
-  FS_WRITE_FAILED: "FS_WRITE_FAILED",
-  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
-  FS_DELETE_FAILED: "FS_DELETE_FAILED",
-  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
-  // SDD (Spec-Driven Development)
-  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
-  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
-  SDD_INVALID_STATE: "SDD_INVALID_STATE",
-  SDD_NOT_READY: "SDD_NOT_READY",
-  // General
-  VALIDATION_ERROR: "VALIDATION_ERROR",
-  PARSE_FAILED: "PARSE_FAILED",
-  UNKNOWN: "UNKNOWN"
-};
-var WrongStackError = class extends Error {
-  code;
-  subsystem;
-  severity;
-  recoverable;
-  context;
-  constructor(opts) {
-    super(opts.message, { cause: opts.cause });
-    this.name = "WrongStackError";
-    this.code = opts.code;
-    this.subsystem = opts.subsystem;
-    this.severity = opts.severity ?? "error";
-    this.recoverable = opts.recoverable ?? false;
-    this.context = opts.context;
-  }
-  /**
-   * Render a one-line user-facing description.
-   * Subclasses should override for domain-specific formatting.
-   */
-  describe() {
-    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
-    return `${this.code}: ${this.message}${ctx}`;
-  }
-};
-function formatContext(ctx) {
-  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
-  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
-}
-var FsError = class extends WrongStackError {
-  path;
-  constructor(opts) {
-    super({
-      message: opts.message,
-      code: opts.code,
-      subsystem: "fs",
-      severity: "error",
-      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
-      context: { path: opts.path, ...opts.context },
-      cause: opts.cause
-    });
-    this.name = "FsError";
-    this.path = opts.path;
-  }
-};
-
-// src/utils/atomic-write.ts
-var primitives = createPersistencePrimitives({
-  createLockTimeoutError: ({ targetPath, timeoutMs }) => new FsError({
-    message: `Timed out waiting for file lock: ${targetPath}`,
-    code: "FS_ATOMIC_WRITE_FAILED",
-    path: targetPath,
-    context: { timeoutMs }
-  })
-});
-var atomicWrite = primitives.atomicWrite;
-var atomicReplaceWithWriter = primitives.atomicReplaceWithWriter;
-var ensureDir = primitives.ensureDir;
-var withFileLock = primitives.withFileLock;
+// src/security/file-permissions.ts
+var SECRET_FILE_MODE = 384;
 
 // src/chronicle/event-hash.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -1422,7 +1426,16 @@ var ChronicleJournal = class {
   drainPromise;
   drainScheduled = false;
   drainTimer;
-  counters = { acceptedEvents: 0, persistedEvents: 0, rejectedEvents: 0, failedEvents: 0, batches: 0, maxObservedPending: 0, largestBatch: 0, partitionRolls: 0 };
+  counters = {
+    acceptedEvents: 0,
+    persistedEvents: 0,
+    rejectedEvents: 0,
+    failedEvents: 0,
+    batches: 0,
+    maxObservedPending: 0,
+    largestBatch: 0,
+    partitionRolls: 0
+  };
   lastBatchDurationMs;
   partitionIndex = 0;
   partitionStartedAt;
@@ -1448,18 +1461,27 @@ var ChronicleJournal = class {
     return this.partitionIndex === 0 ? this.basePath : rotatedPath(this.basePath, this.partitionIndex);
   }
   stats() {
-    return { ...this.counters, pendingEvents: this.pending.length, ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {} };
+    return {
+      ...this.counters,
+      pendingEvents: this.pending.length,
+      ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {}
+    };
   }
   append(input) {
     if (this.pending.length >= this.maxPending) {
       this.counters.rejectedEvents++;
-      return Promise.reject(new Error(`Chronicle backpressure limit reached (${this.maxPending} pending events)`));
+      return Promise.reject(
+        new Error(`Chronicle backpressure limit reached (${this.maxPending} pending events)`)
+      );
     }
     const promise = new Promise((resolve12, reject) => {
       this.pending.push({ input, resolve: resolve12, reject });
     });
     this.counters.acceptedEvents++;
-    this.counters.maxObservedPending = Math.max(this.counters.maxObservedPending, this.pending.length);
+    this.counters.maxObservedPending = Math.max(
+      this.counters.maxObservedPending,
+      this.pending.length
+    );
     this.scheduleDrain();
     return promise;
   }
@@ -1485,7 +1507,8 @@ var ChronicleJournal = class {
     await this.flush();
     const files = await collectPartitions(this.basePath);
     const checkpointResult = await readRetentionCheckpoint(this.basePath);
-    if (checkpointResult.error) return { ok: false, entries: 0, brokenAt: 0, reason: checkpointResult.error };
+    if (checkpointResult.error)
+      return { ok: false, entries: 0, brokenAt: 0, reason: checkpointResult.error };
     return verifyPartitionFiles(files, checkpointResult.checkpoint);
   }
   async purge(options) {
@@ -1503,7 +1526,10 @@ var ChronicleJournal = class {
     for (const suppliedPath of new Set(suppliedFiles)) {
       const file = path8.resolve(suppliedPath);
       if (!isJournalPartition(file, path8.dirname(this.basePath), this.basePath)) {
-        errors.push({ file: suppliedPath, reason: "not a Chronicle journal partition in this journal directory" });
+        errors.push({
+          file: suppliedPath,
+          reason: "not a Chronicle journal partition in this journal directory"
+        });
         sc++;
         continue;
       }
@@ -1552,8 +1578,12 @@ var ChronicleJournal = class {
             const checkpointResult = await readRetentionCheckpoint(familyBase);
             if (checkpointResult.error) throw new Error(checkpointResult.error);
             const checkpoint = checkpointResult.checkpoint;
-            const nextCheckpoint = await verifyRetainedPrefix(streamEntriesStrict(file), checkpoint);
-            if (!nextCheckpoint) throw new Error("partition does not extend the trusted Chronicle chain");
+            const nextCheckpoint = await verifyRetainedPrefix(
+              streamEntriesStrict(file),
+              checkpoint
+            );
+            if (!nextCheckpoint)
+              throw new Error("partition does not extend the trusted Chronicle chain");
             if (nextCheckpoint.sequence > (checkpoint?.sequence ?? 0)) {
               await writeRetentionCheckpoint(familyBase, nextCheckpoint);
             }
@@ -1573,7 +1603,13 @@ var ChronicleJournal = class {
         }
       }
     }
-    return { deletedCount: dc, deletedBytes: db, skippedCount: sc, errors, ...options.dryRun ? { candidates } : {} };
+    return {
+      deletedCount: dc,
+      deletedBytes: db,
+      skippedCount: sc,
+      errors,
+      ...options.dryRun ? { candidates } : {}
+    };
   }
   async maybeAutoPurge() {
     if (this.retentionDays <= 0) return;
@@ -1649,7 +1685,8 @@ var ChronicleJournal = class {
       this.rotate();
       return;
     }
-    if (Number.isFinite(this.maxPartitionSizeBytes) && this.partitionSizeBytes >= this.maxPartitionSizeBytes) this.rotate();
+    if (Number.isFinite(this.maxPartitionSizeBytes) && this.partitionSizeBytes >= this.maxPartitionSizeBytes)
+      this.rotate();
   }
   rotate() {
     this.partitionIndex++;
@@ -1670,13 +1707,23 @@ var ChronicleJournal = class {
         let prev = this.lastSequence > 0 ? { sequence: this.lastSequence, hash: this.lastHash } : void 0;
         recorded = batch.map(({ input }) => {
           const instant = this.now().toISOString();
-          const uh = { ...input, occurredAt: input.occurredAt ?? instant, monotonicNs: input.monotonicNs ?? this.monotonicNow().toString(), schemaVersion: CHRONICLE_SCHEMA_VERSION, eventId: this.idFactory(), observedAt: instant, persistedAt: instant, sequence: (prev?.sequence ?? 0) + 1, previousHash: prev?.hash ?? GENESIS_HASH };
+          const uh = {
+            ...input,
+            occurredAt: input.occurredAt ?? instant,
+            monotonicNs: input.monotonicNs ?? this.monotonicNow().toString(),
+            schemaVersion: CHRONICLE_SCHEMA_VERSION,
+            eventId: this.idFactory(),
+            observedAt: instant,
+            persistedAt: instant,
+            sequence: (prev?.sequence ?? 0) + 1,
+            previousHash: prev?.hash ?? GENESIS_HASH
+          };
           const event = { ...uh, hash: hashValue(uh) };
           prev = event;
           return event;
         });
         const serialized = recorded.map((e) => JSON.stringify(e)).join("\n") + "\n";
-        await fs3.appendFile(cp, serialized, "utf8");
+        await fs3.appendFile(cp, serialized, { encoding: "utf8", mode: SECRET_FILE_MODE });
         this.partitionSizeBytes += Buffer.byteLength(serialized);
       });
       const last = recorded[recorded.length - 1];
@@ -1712,7 +1759,8 @@ async function collectPartitions(basePath) {
   const result = [];
   try {
     const entries = await fs3.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) if (entry.isFile() && pattern.test(entry.name)) result.push(path8.join(dir, entry.name));
+    for (const entry of entries)
+      if (entry.isFile() && pattern.test(entry.name)) result.push(path8.join(dir, entry.name));
   } catch {
   }
   const baseFile = path8.join(dir, base + ext);
@@ -1787,23 +1835,42 @@ async function verifyPartitionFiles(files, checkpoint) {
       for await (const entry of streamEntriesStrict(file)) {
         const { hash: recordedHash, ...content } = entry;
         if (entry.sequence <= checkpointSequence) {
-          if (hashValue(content) !== recordedHash) return { ok: false, entries, brokenAt: entries, reason: "entry hash mismatch" };
+          if (hashValue(content) !== recordedHash)
+            return { ok: false, entries, brokenAt: entries, reason: "entry hash mismatch" };
           if (coveredPrevious && entry.sequence !== coveredPrevious.sequence + 1) {
-            return { ok: false, entries, brokenAt: entries, reason: `sequence ${entry.sequence} is not ${coveredPrevious.sequence + 1}` };
+            return {
+              ok: false,
+              entries,
+              brokenAt: entries,
+              reason: `sequence ${entry.sequence} is not ${coveredPrevious.sequence + 1}`
+            };
           }
           if (coveredPrevious && entry.previousHash !== coveredPrevious.hash) {
             return { ok: false, entries, brokenAt: entries, reason: "previous hash mismatch" };
           }
           if (entry.sequence === checkpointSequence && recordedHash !== checkpoint?.hash) {
-            return { ok: false, entries, brokenAt: entries, reason: "retention checkpoint hash mismatch" };
+            return {
+              ok: false,
+              entries,
+              brokenAt: entries,
+              reason: "retention checkpoint hash mismatch"
+            };
           }
           coveredPrevious = entry;
           continue;
         }
         const index = entries++;
-        if (entry.sequence !== lastSequence + 1) return { ok: false, entries, brokenAt: index, reason: `sequence ${entry.sequence} is not ${lastSequence + 1}` };
-        if (entry.previousHash !== previousHash) return { ok: false, entries, brokenAt: index, reason: "previous hash mismatch" };
-        if (hashValue(content) !== recordedHash) return { ok: false, entries, brokenAt: index, reason: "entry hash mismatch" };
+        if (entry.sequence !== lastSequence + 1)
+          return {
+            ok: false,
+            entries,
+            brokenAt: index,
+            reason: `sequence ${entry.sequence} is not ${lastSequence + 1}`
+          };
+        if (entry.previousHash !== previousHash)
+          return { ok: false, entries, brokenAt: index, reason: "previous hash mismatch" };
+        if (hashValue(content) !== recordedHash)
+          return { ok: false, entries, brokenAt: index, reason: "entry hash mismatch" };
         previousHash = recordedHash;
         lastSequence = entry.sequence;
       }
@@ -1836,7 +1903,9 @@ async function readRetentionCheckpoint(basePath) {
 }
 async function writeRetentionCheckpoint(basePath, checkpoint) {
   await atomicWrite(retentionCheckpointPath(basePath), `${JSON.stringify(checkpoint)}
-`, { mode: 384 });
+`, {
+    mode: 384
+  });
 }
 function isHash(value) {
   return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
@@ -1876,7 +1945,11 @@ async function readLastEntryState(filePath) {
         const trimmed = lines[i].trim();
         if (!trimmed) continue;
         try {
-          return { entry: JSON.parse(trimmed), size, birthtimeMs: stat5.birthtimeMs };
+          return {
+            entry: JSON.parse(trimmed),
+            size,
+            birthtimeMs: stat5.birthtimeMs
+          };
         } catch {
         }
       }
@@ -4389,6 +4462,11 @@ var metadataPath = chronicleProjectServerMetadataPath(parsed.projectDir);
 var idleInput = Number(process.env["WRONGSTACK_CHRONICLE_SERVER_IDLE_MS"]);
 var idleMs = Number.isFinite(idleInput) && idleInput >= 100 ? idleInput : DEFAULT_IDLE_MS;
 var startedAt = (/* @__PURE__ */ new Date()).toISOString();
+var authToken = randomBytes(16).toString("hex");
+var markMetadataWritten;
+var metadataWritten = new Promise((resolve12) => {
+  markMetadataWritten = resolve12;
+});
 var serverInfo = {
   protocolVersion: CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION,
   pid: process.pid,
@@ -4670,6 +4748,16 @@ function send(state, message) {
   state.socket.write(encoded);
 }
 async function handleMessage(state, message) {
+  if (message.authToken !== authToken) {
+    send(state, {
+      type: "response",
+      id: message.id,
+      ok: false,
+      error: "Chronicle IPC request rejected: missing or invalid authToken. Reconnect to refresh metadata (server.json#authToken).",
+      errorName: "UnauthorizedChronicleRequest"
+    });
+    return;
+  }
   if (message.type === "shutdown") {
     send(state, { type: "response", id: message.id, ok: true, result: { stopped: true } });
     await stop(message.reason ?? "client request");
@@ -4724,18 +4812,9 @@ function scheduleIdleStop() {
 }
 async function writeMetadata() {
   await fsp4.mkdir(path15.dirname(metadataPath), { recursive: true });
-  const temporary = `${metadataPath}.${process.pid}.tmp`;
-  await fsp4.writeFile(temporary, `${JSON.stringify(serverInfo, null, 2)}
-`, {
-    encoding: "utf8",
-    mode: 384
-  });
-  try {
-    await fsp4.rename(temporary, metadataPath);
-  } catch {
-    await fsp4.rm(metadataPath, { force: true });
-    await fsp4.rename(temporary, metadataPath);
-  }
+  const metadata = { ...serverInfo, authToken };
+  await atomicWrite(metadataPath, `${JSON.stringify(metadata, null, 2)}
+`, { mode: 384 });
 }
 async function removeOwnedMetadata() {
   try {
@@ -4749,6 +4828,7 @@ async function stop(_reason) {
   stopping = true;
   if (idleTimer) clearTimeout(idleTimer);
   idleTimer = void 0;
+  await removeOwnedMetadata();
   await new Promise((resolve12) => server.close(() => resolve12()));
   for (const state of clients) state.socket.destroy();
   clients.clear();
@@ -4759,7 +4839,6 @@ async function stop(_reason) {
   });
   metricsStore?.close();
   metricsStore = void 0;
-  await removeOwnedMetadata();
   if (process.platform !== "win32") await fsp4.rm(endpoint, { force: true }).catch(() => {
   });
   await stopMemoryWatchdog();
@@ -4775,7 +4854,9 @@ var server = net.createServer((socket) => {
   socket.setEncoding("utf8");
   const state = { socket, buffer: "" };
   clients.add(state);
-  send(state, { type: "hello", ...serverInfo });
+  void metadataWritten.then(() => {
+    if (!socket.destroyed) send(state, { type: "hello", ...serverInfo });
+  });
   socket.on("data", (chunk) => onData(state, chunk));
   socket.on("close", () => {
     clients.delete(state);
@@ -4818,7 +4899,7 @@ server.on("listening", () => {
     } catch {
     }
   }
-  void writeMetadata();
+  void writeMetadata().then(() => markMetadataWritten?.());
   void startChronicleFileObserver({
     projectRoot: parsed.projectRoot,
     journal: watcherSink,