@wrongstack/core 0.298.1 → 0.298.3

package/dist/core/index.js

@@ -124,6 +124,22 @@ function toWrongStackError(err, code = ERROR_CODES.AGENT_RUN_FAILED) {
     cause: err
   });
 }
+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/extension/registry.ts
 var ExtensionRegistry = class {
@@ -1134,6 +1150,36 @@ var MAILBOX_TYPE_PROPERTIES = {
 };
 
 // src/coordination/mailbox-types.ts
+function isAffectedBySessionAffinity(message) {
+  return message.sessionAffinity !== void 0;
+}
+async function acceptMailboxMessageForSession(message, currentSessionId, ctx) {
+  if (!isAffectedBySessionAffinity(message)) return true;
+  const affinity = message.sessionAffinity;
+  if (affinity === null || typeof affinity !== "object" || Array.isArray(affinity)) {
+    return false;
+  }
+  if (affinity.sessionId !== void 0 && typeof affinity.sessionId !== "string" || affinity.reportId !== void 0 && typeof affinity.reportId !== "string") {
+    return false;
+  }
+  if (!currentSessionId) {
+    return ctx?.allowUnscoped === true;
+  }
+  if (typeof affinity.sessionId === "string" && affinity.sessionId.length > 0) {
+    if (affinity.sessionId !== currentSessionId) return false;
+    return true;
+  }
+  if (affinity.reportId && ctx?.resolveChimeraReportSessionId) {
+    try {
+      const resolved = await ctx.resolveChimeraReportSessionId(affinity.reportId);
+      if (resolved === currentSessionId) return true;
+      if (resolved !== void 0) return false;
+    } catch {
+    }
+  }
+  if (ctx?.allowUnscoped === true) return true;
+  return false;
+}
 var SESSION_RECIPIENT_PREFIX = "@session:";
 
 // src/coordination/sqlite-mailbox.ts
@@ -1522,6 +1568,23 @@ import { basename as basename4 } from "node:path";
 import * as fs3 from "node:fs";
 import * as path6 from "node:path";
 
+// src/utils/atomic-write.ts
+import {
+  createPersistencePrimitives
+} from "@wrongstack/persistence";
+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/ulid.ts
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var ENCODING_LEN = ENCODING.length;
@@ -1580,6 +1643,11 @@ function isMissingFileError(error) {
 // src/hq/auth-store.ts
 import * as syncFs from "node:fs";
 import * as path7 from "node:path";
+
+// src/security/file-permissions.ts
+var SECRET_FILE_MODE = 384;
+
+// src/hq/auth-store.ts
 function defaultHqDataDir() {
   return path7.join(wstackGlobalRoot(), "hq");
 }
@@ -2909,6 +2977,307 @@ function resolveMailboxIdentity(ctx, fallbackBase = "leader") {
   return { baseId, callerId, name, role, sessionId };
 }
 
+// src/plugins/review-report-store.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path8 from "node:path";
+
+// src/plugins/review-report-types.ts
+var InvalidReportTransitionError = class extends Error {
+  from;
+  to;
+  constructor(from, to, reason) {
+    const msg = reason ?? `Invalid report transition from "${from}" to "${to}"`;
+    super(msg);
+    this.name = "InvalidReportTransitionError";
+    this.from = from;
+    this.to = to;
+  }
+};
+var REPORT_TRANSITION_MATRIX = {
+  open: /* @__PURE__ */ new Set(["actioned", "completed", "skipped"]),
+  actioned: /* @__PURE__ */ new Set(["completed", "skipped"]),
+  completed: /* @__PURE__ */ new Set(["open"]),
+  skipped: /* @__PURE__ */ new Set(["open"])
+};
+function validateReportTransition(from, to) {
+  if (from === to) return;
+  const allowed = REPORT_TRANSITION_MATRIX[from];
+  if (!allowed?.has(to)) {
+    throw new InvalidReportTransitionError(from, to);
+  }
+}
+function reportEventTypeFor(to) {
+  switch (to) {
+    case "actioned":
+      return "actioned";
+    case "completed":
+      return "completed";
+    case "skipped":
+      return "skipped";
+    default:
+      return "reopened";
+  }
+}
+
+// src/plugins/review-report-store.ts
+var REPORT_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
+var REPORT_DEFAULT_PAGE_SIZE = 25;
+var NL = "\n";
+var REPORT_STORE_FILE = "review-reports.jsonl";
+function resolveReportStorePath(projectDir) {
+  return path8.join(projectDir, REPORT_STORE_FILE);
+}
+var JsonlReportStore = class {
+  filePath;
+  constructor(projectDir) {
+    this.filePath = resolveReportStorePath(projectDir);
+  }
+  get storePath() {
+    return this.filePath;
+  }
+  // ── Persist (create or reopen) ───────────────────────────────────
+  async persist(input) {
+    return withFileLock(this.filePath, async () => {
+      const existing = await this._findRecord(input.id);
+      if (existing) {
+        const updated = {
+          ...existing,
+          counts: input.counts,
+          totalFindings: input.totalFindings,
+          unparseableCount: input.unparseableCount,
+          durationSeconds: input.durationSeconds ?? existing.durationSeconds,
+          rawText: input.rawText || existing.rawText,
+          files: input.files.length > 0 ? input.files : existing.files
+        };
+        await fsp.appendFile(this.filePath, JSON.stringify({ __report: 1, data: updated }) + NL, {
+          encoding: "utf8",
+          mode: SECRET_FILE_MODE
+        });
+        return updated;
+      }
+      const report = {
+        id: input.id,
+        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: input.sessionId,
+        agentId: input.agentId,
+        reviewerModel: input.reviewerModel,
+        source: input.source,
+        reviewStatus: input.reviewStatus,
+        lifecycle: "open",
+        files: input.files,
+        counts: input.counts,
+        totalFindings: input.totalFindings,
+        unparseableCount: input.unparseableCount,
+        durationSeconds: input.durationSeconds,
+        rawText: input.rawText,
+        ...input.cascadeDepth !== void 0 ? { cascadeDepth: input.cascadeDepth } : {}
+      };
+      const createdEvent = {
+        id: randomUUID3(),
+        reportId: report.id,
+        eventType: "created",
+        fromLifecycle: null,
+        toLifecycle: "open",
+        actorId: "system",
+        actorKind: "system",
+        timestamp: report.reviewedAt
+      };
+      const lines = JSON.stringify({ __report: 1, data: report }) + NL + JSON.stringify({ __reportEvent: 1, data: createdEvent }) + NL;
+      await fsp.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
+      return report;
+    });
+  }
+  // ── Lifecycle transitions ────────────────────────────────────────
+  async transition(reportId, to, actor, opts) {
+    return withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const entry = all.find((e) => e.report.id === reportId);
+      if (!entry) throw new Error(`Review report not found: ${reportId}`);
+      const from = this._materialize(entry).lifecycle;
+      validateReportTransition(from, to);
+      const event = {
+        id: randomUUID3(),
+        reportId,
+        eventType: reportEventTypeFor(to),
+        fromLifecycle: from,
+        toLifecycle: to,
+        actorId: actor.id,
+        actorKind: actor.kind,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: opts?.reason
+      };
+      entry.report.lifecycle = to;
+      await fsp.appendFile(this.filePath, JSON.stringify({ __reportEvent: 1, data: event }) + NL, {
+        encoding: "utf8",
+        mode: SECRET_FILE_MODE
+      });
+      return { ...entry.report };
+    });
+  }
+  async addNote(reportId, actor, note) {
+    return withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const entry = all.find((e) => e.report.id === reportId);
+      if (!entry) throw new Error(`Review report not found: ${reportId}`);
+      const materialized = this._materialize(entry);
+      const event = {
+        id: randomUUID3(),
+        reportId,
+        eventType: "note_added",
+        fromLifecycle: materialized.lifecycle,
+        toLifecycle: materialized.lifecycle,
+        actorId: actor.id,
+        actorKind: actor.kind,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: note
+      };
+      await fsp.appendFile(this.filePath, JSON.stringify({ __reportEvent: 1, data: event }) + NL, {
+        encoding: "utf8",
+        mode: SECRET_FILE_MODE
+      });
+      return materialized;
+    });
+  }
+  // ── Query ────────────────────────────────────────────────────────
+  async list(opts) {
+    const all = await this._readAll();
+    let reports = all.map((e) => this._materialize(e));
+    if (opts?.statuses && opts.statuses.length > 0) {
+      const set = new Set(opts.statuses);
+      reports = reports.filter((r) => set.has(r.lifecycle));
+    }
+    if (opts?.sources && opts.sources.length > 0) {
+      const set = new Set(opts.sources);
+      reports = reports.filter((r) => set.has(r.source));
+    }
+    reports.sort((a, b) => b.reviewedAt.localeCompare(a.reviewedAt));
+    const limit = opts?.limit ?? REPORT_DEFAULT_PAGE_SIZE;
+    return reports.slice(0, limit);
+  }
+  async get(id) {
+    const all = await this._readAll();
+    const entry = all.find((e) => e.report.id === id);
+    return entry ? this._materialize(entry) : null;
+  }
+  async getEvents(reportId) {
+    const all = await this._readAllLines();
+    const events = [];
+    for (const line of all) {
+      try {
+        const parsed = JSON.parse(line);
+        if (this._isEventRecord(parsed) && parsed.data.reportId === reportId) {
+          events.push(parsed.data);
+        }
+      } catch {
+      }
+    }
+    return events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  }
+  // ── Compaction ───────────────────────────────────────────────────
+  async compact(opts) {
+    return withFileLock(this.filePath, async () => {
+      const maxAge = opts?.maxAgeMs ?? REPORT_RETENTION_MS;
+      const now = Date.now();
+      const all = await this._readAll();
+      const kept = [];
+      let removed = 0;
+      let eventsFolded = 0;
+      for (const entry of all) {
+        const age = now - new Date(entry.report.reviewedAt).getTime();
+        const materialized = this._materialize(entry);
+        const isTerminal = materialized.lifecycle === "completed" || materialized.lifecycle === "skipped";
+        if (isTerminal && age > maxAge) {
+          removed++;
+          eventsFolded += entry.events.length;
+          continue;
+        }
+        const oldEvents = entry.events.filter(
+          (ev) => now - new Date(ev.timestamp).getTime() > maxAge
+        );
+        if (oldEvents.length > 1) {
+          eventsFolded += oldEvents.length - 1;
+          const newestOld = oldEvents.sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
+          entry.events = [
+            newestOld,
+            ...entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() <= maxAge)
+          ];
+        }
+        kept.push({ record: { __report: 1, data: entry.report }, events: entry.events });
+      }
+      const lines = [];
+      for (const { record, events } of kept) {
+        if (record) lines.push(JSON.stringify(record));
+        for (const ev of events) {
+          lines.push(JSON.stringify({ __reportEvent: 1, data: ev }));
+        }
+      }
+      lines.push(
+        JSON.stringify({
+          __reportCompact: 1,
+          compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          removedReports: removed,
+          foldedEvents: eventsFolded
+        })
+      );
+      await atomicWrite(this.filePath, lines.join(NL) + NL, { mode: 384 });
+      return { removed, eventsFolded };
+    });
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  async _readAllLines() {
+    try {
+      const raw = await fsp.readFile(this.filePath, "utf8");
+      return raw.split(NL).filter((l) => l.trim().length > 0);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  _isReportRecord(v) {
+    return typeof v === "object" && v !== null && v["__report"] === 1;
+  }
+  _isEventRecord(v) {
+    return typeof v === "object" && v !== null && v["__reportEvent"] === 1;
+  }
+  async _readAll() {
+    const lines = await this._readAllLines();
+    const reports = /* @__PURE__ */ new Map();
+    const eventsMap = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (this._isReportRecord(parsed)) {
+          reports.set(parsed.data.id, parsed.data);
+          if (!eventsMap.has(parsed.data.id)) eventsMap.set(parsed.data.id, []);
+        } else if (this._isEventRecord(parsed)) {
+          const list = eventsMap.get(parsed.data.reportId);
+          if (list) list.push(parsed.data);
+        }
+      } catch {
+      }
+    }
+    return Array.from(reports.entries()).map(([id, report]) => ({
+      report,
+      events: eventsMap.get(id) ?? []
+    }));
+  }
+  async _findRecord(id) {
+    const all = await this._readAll();
+    const entry = all.find((e) => e.report.id === id);
+    return entry ? this._materialize(entry) : null;
+  }
+  _materialize(entry) {
+    if (entry.events.length === 0) return { ...entry.report };
+    const sorted = [...entry.events].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    const latest = sorted[sorted.length - 1];
+    if (latest.eventType !== "note_added") {
+      return { ...entry.report, lifecycle: latest.toLifecycle };
+    }
+    return { ...entry.report };
+  }
+};
+
 // src/core/mailbox-loop.ts
 function createMailboxChecker(opts) {
   const getMailbox = typeof opts.mailbox === "function" ? opts.mailbox : () => opts.mailbox;
@@ -3289,9 +3658,43 @@ function attachMailboxCheckerInner(a, source) {
     agentId: () => ensureRegistered(),
     role: () => resolveMailboxIdentity(a.ctx).role,
     aliases: [baseIdOf()],
-    sessionId: () => a.ctx.session.id
+    sessionId: () => a.ctx.session.id,
+    // ACK is deferred to the session-affinity wrapper so messages dropped
+    // by the filter are NOT marked as read by this agent.
+    ack: false
   };
   const checkMailbox = createMailboxChecker(mailboxCheckerOptions);
+  const reportStore = new JsonlReportStore(
+    resolveProjectDir(a.ctx.projectRoot, wstackGlobalRoot())
+  );
+  const sessionAffinityCtx = {
+    resolveChimeraReportSessionId: async (reportId) => (await reportStore.get(reportId))?.sessionId
+  };
+  const applySessionAffinityFilter = (checker, ack) => {
+    return async () => {
+      const currentSessionId = a.ctx.session.id;
+      const agentId = ack ? ensureRegistered() : null;
+      const messages = await checker();
+      const filtered = [];
+      for (const m of messages) {
+        if (await acceptMailboxMessageForSession(m, currentSessionId, sessionAffinityCtx)) {
+          filtered.push(m);
+        }
+      }
+      if (ack && filtered.length > 0 && agentId) {
+        void getMailbox().ackMany({
+          acks: filtered.map((m) => ({
+            messageId: m.id,
+            readerId: agentId,
+            read: true
+          }))
+        }).catch(() => {
+        });
+      }
+      return filtered;
+    };
+  };
+  const sessionScopedCheckMailbox = applySessionAffinityFilter(checkMailbox, true);
   const checkMailboxAwareness = createMailboxChecker({
     ...mailboxCheckerOptions,
     // Exclude out-of-band types (control) from awareness polling.
@@ -3301,6 +3704,7 @@ function attachMailboxCheckerInner(a, source) {
     include: (m) => !MAILBOX_TYPE_PROPERTIES[m.type]?.outOfBand,
     ack: false
   });
+  const sessionScopedCheckMailboxAwareness = applySessionAffinityFilter(checkMailboxAwareness, false);
   const AWARENESS_FALLBACK_INTERVAL_MS = MAILBOX_AWARENESS_INTERVAL_MS;
   const AWARENESS_PUSH_DEBOUNCE_MS = 500;
   let pollInFlight = false;
@@ -3310,7 +3714,7 @@ function attachMailboxCheckerInner(a, source) {
     if (awarenessDisposed || pollInFlight) return;
     pollInFlight = true;
     try {
-      const messages = await checkMailboxAwareness();
+      const messages = await sessionScopedCheckMailboxAwareness();
       if (!awarenessDisposed && messages.length > 0 && a.ctx.meta["coordinationContextMode"] !== "background") {
         setBtwNote(a.ctx, buildMailboxBtwAwarenessBlock(messages).text);
       }
@@ -3343,7 +3747,7 @@ function attachMailboxCheckerInner(a, source) {
     if (pushDebounceTimer !== null) clearTimeout(pushDebounceTimer);
     pushUnsub?.();
   });
-  return checkMailbox;
+  return sessionScopedCheckMailbox;
 }
 function attachFleetPulse(a, cfg) {
   if (!a.ctx.projectRoot || cfg?.enabled === false) {
@@ -3547,7 +3951,7 @@ function kindToCode(kind) {
 }
 
 // src/utils/context-evidence.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 var MAX_TOOL_CALLS = 80;
 var MAX_FACTS = 40;
 var MAX_ERRORS = 20;
@@ -3710,10 +4114,10 @@ function addPath(ctx, out, raw) {
   if (!clean || clean.length > 260) return;
   let normalized = clean.replace(/\\/g, "/");
   try {
-    const abs = path8.isAbsolute(clean) ? path8.resolve(clean) : null;
+    const abs = path9.isAbsolute(clean) ? path9.resolve(clean) : null;
     if (abs) {
-      const rel = path8.relative(ctx.projectRoot, abs);
-      if (!rel.startsWith("..") && !path8.isAbsolute(rel)) {
+      const rel = path9.relative(ctx.projectRoot, abs);
+      if (!rel.startsWith("..") && !path9.isAbsolute(rel)) {
         normalized = rel.replace(/\\/g, "/");
       }
     }
@@ -3831,7 +4235,7 @@ function implicitFactFor(metadata) {
 function metadataReferencedByText(metadata, haystack) {
   for (const file of metadata.files) {
     const f = file.toLowerCase();
-    const base = path8.basename(file).toLowerCase();
+    const base = path9.basename(file).toLowerCase();
     if (f && haystack.includes(f)) return true;
     if (base && haystack.includes(base)) return true;
   }
@@ -4119,7 +4523,7 @@ function getCalibrationState(calibrationKey = CALIBRATION_GLOBAL_KEY) {
 }
 
 // src/core/context.ts
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 
 // src/core/conversation-state.ts
 var ConversationState = class {
@@ -4931,11 +5335,11 @@ var Context = class _Context {
    * Returns the resolved absolute path.
    */
   setWorkingDir(dir) {
-    const resolved = path9.isAbsolute(dir) ? path9.resolve(dir) : path9.resolve(this.projectRoot, dir);
+    const resolved = path10.isAbsolute(dir) ? path10.resolve(dir) : path10.resolve(this.projectRoot, dir);
     if (!this.allowOutsideProjectRoot) {
-      const root = path9.resolve(this.projectRoot);
-      const rel = path9.relative(root, resolved);
-      if (rel.startsWith("..") || path9.isAbsolute(rel)) {
+      const root = path10.resolve(this.projectRoot);
+      const rel = path10.relative(root, resolved);
+      if (rel.startsWith("..") || path10.isAbsolute(rel)) {
         throw new Error(`Working directory "${resolved}" is outside project root "${root}"`);
       }
     }
@@ -5043,7 +5447,7 @@ function requestLimitExtension(opts) {
 }
 
 // src/core/streaming-response-builder.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/utils/json-repair.ts
 function completePartialObject(s) {
@@ -5197,7 +5601,7 @@ function handleContentBlockStart(state, ev) {
     state.textBuffers.push("");
     state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
   } else if (kind === "tool_use") {
-    const id = ev.id ?? randomUUID3();
+    const id = ev.id ?? randomUUID4();
     state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
     state.blockOrder.push({ kind: "tool", id });
     state.currentTextIndex = -1;
@@ -5568,7 +5972,7 @@ function runWithNetworkTelemetry(context, run) {
 }
 
 // src/core/provider-runner.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 function providerLogCtx(p, r) {
   return {
     providerId: p.id,
@@ -5580,11 +5984,11 @@ function providerLogCtx(p, r) {
 }
 async function runProviderWithRetry(opts) {
   const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
-  const logicalRequestId = randomUUID4();
+  const logicalRequestId = randomUUID5();
   const promptManifest = createChroniclePromptManifest(request);
   let attempt = 0;
   for (; ; ) {
-    const attemptId = randomUUID4();
+    const attemptId = randomUUID5();
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startedNs = process.hrtime.bigint();
     const correlation = {
@@ -7660,8 +8064,8 @@ var InputBuilder = class {
   async registerFile(input) {
     const ref = await this.store.add({ ...input, kind: "file" });
     this.refs.push(ref);
-    const path14 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
-    return `[file:${path14}]`;
+    const path15 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
+    return `[file:${path15}]`;
   }
   /**
    * Whether `appendPaste(text)` would collapse the text to a placeholder
@@ -8626,7 +9030,7 @@ function flattenSystemPromptRegions(regions) {
 // src/core/instruction-bundle.ts
 import { statSync as statSync2 } from "node:fs";
 import * as fs5 from "node:fs/promises";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function loadInstructionBundle(paths) {
   let bundle = {};
@@ -8682,17 +9086,17 @@ function resolveSystemInstructionFile(paths) {
 }
 function sanitizeSystemInstructionFile(file) {
   const trimmed = file.trim();
-  if (trimmed.length === 0 || trimmed !== path10.basename(trimmed) || path10.extname(trimmed).toLowerCase() !== ".md") {
+  if (trimmed.length === 0 || trimmed !== path11.basename(trimmed) || path11.extname(trimmed).toLowerCase() !== ".md") {
     throw new Error(`Invalid system instruction file: ${file}`);
   }
   return trimmed;
 }
 async function readInstructionDir(dir, options) {
   const [json, identity, leaderAfterTask, sections] = await Promise.all([
-    readInstructionJson(path10.join(dir, "instructions.json")),
-    readOptionalText(path10.join(dir, options.systemFile)),
-    readOptionalText(path10.join(dir, "leader-after-task.md")),
-    readSections(path10.join(dir, "sections"))
+    readInstructionJson(path11.join(dir, "instructions.json")),
+    readOptionalText(path11.join(dir, options.systemFile)),
+    readOptionalText(path11.join(dir, "leader-after-task.md")),
+    readSections(path11.join(dir, "sections"))
   ]);
   const fromMarkdown = {
     system: {
@@ -8717,7 +9121,7 @@ async function readSectionsInto(root, dir, out) {
   }
   await Promise.all(
     entries.map(async (entry) => {
-      const file = path10.join(dir, entry.name);
+      const file = path11.join(dir, entry.name);
       if (entry.isDirectory()) {
         await readSectionsInto(root, file, out);
         return;
@@ -8725,7 +9129,7 @@ async function readSectionsInto(root, dir, out) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) return;
       const text = await readOptionalText(file);
       if (text === void 0) return;
-      const rel = path10.relative(root, file).replace(/\\/g, "/").replace(/\.md$/i, "");
+      const rel = path11.relative(root, file).replace(/\\/g, "/").replace(/\.md$/i, "");
       const key = rel.split("/").join(".").replace(/-/g, ".");
       out[key] = text;
     })
@@ -8773,11 +9177,11 @@ async function readOptionalText(file) {
   }
 }
 function defaultBundledInstructionDir() {
-  const here = path10.dirname(fileURLToPath2(import.meta.url));
+  const here = path11.dirname(fileURLToPath2(import.meta.url));
   return firstExistingDirSync([
-    path10.resolve(here, "../../instructions"),
-    path10.resolve(here, "../instructions"),
-    path10.resolve(here, "instructions")
+    path11.resolve(here, "../../instructions"),
+    path11.resolve(here, "../instructions"),
+    path11.resolve(here, "instructions")
   ]);
 }
 function definedPick(obj, keys) {
@@ -8800,13 +9204,13 @@ function firstExistingDirSync(candidates) {
 
 // src/core/modes/default.ts
 import { readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var PROMPT = readBundledInstructionFile("system.md");
 var LEADER_AFTER_TASK_PROMPT = readBundledInstructionFile("leader-after-task.md");
 function readBundledInstructionFile(name) {
   for (const dir of bundledInstructionDirCandidates()) {
-    const file = path11.join(dir, name);
+    const file = path12.join(dir, name);
     try {
       return readFileSync6(file, "utf8").trimEnd();
     } catch {
@@ -8815,12 +9219,12 @@ function readBundledInstructionFile(name) {
   return "";
 }
 function bundledInstructionDirCandidates() {
-  const here = path11.dirname(fileURLToPath3(import.meta.url));
+  const here = path12.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
-    path11.resolve(here, "../../../instructions"),
-    path11.resolve(here, "../../instructions"),
-    path11.resolve(here, "../instructions"),
-    path11.resolve(here, "instructions")
+    path12.resolve(here, "../../../instructions"),
+    path12.resolve(here, "../../instructions"),
+    path12.resolve(here, "../instructions"),
+    path12.resolve(here, "instructions")
   ];
   return candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
 }
@@ -8886,12 +9290,12 @@ function agentsFingerprint(agents) {
 
 // src/core/system-prompt-environment.ts
 import * as os3 from "node:os";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 
 // src/core/system-prompt-environment-probes.ts
 import { spawn as spawn2 } from "node:child_process";
 import * as fs6 from "node:fs/promises";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 
 // src/utils/child-env.ts
 var ALLOWED_KEYS = /* @__PURE__ */ new Set([
@@ -9119,7 +9523,7 @@ async function detectLanguages(root) {
   const hits = await Promise.all(
     checks.map(async ([marker, lang]) => {
       try {
-        await fs6.access(path12.join(root, marker));
+        await fs6.access(path13.join(root, marker));
         return lang;
       } catch {
         return null;
@@ -9202,7 +9606,7 @@ async function buildEnvironment(ctx, env) {
   const effShell = effectiveShell(os3.platform(), process.env["WRONGSTACK_SHELL"]);
   const shell = effShell === "posix" ? process.env.SHELL ?? process.env.ComSpec ?? "unknown" : SHELL_DISPLAY[effShell];
   const node = process.version;
-  const isGit = await dirExists(path13.join(ctx.projectRoot, ".git"));
+  const isGit = await dirExists(path14.join(ctx.projectRoot, ".git"));
   const [git, langs] = await Promise.all([
     isGit ? gitStatus(ctx.projectRoot) : Promise.resolve("not a git repo"),
     detectLanguages(ctx.projectRoot)