@remnic/core 1.1.31 → 9.3.516

package/src/session-integrity.test.ts

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { applySessionRepair, planSessionRepair } from "./session-integrity.js";
+import type { SessionIntegrityReport, SessionRepairPlan } from "./session-integrity.js";
+
+test("session repair rejects forged transcript paths outside memoryDir", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-session-repair-"));
+  const outside = await mkdtemp(path.join(os.tmpdir(), "remnic-session-outside-"));
+  try {
+    await mkdir(path.join(memoryDir, "transcripts"), { recursive: true });
+    const outsideFile = path.join(outside, "forged.jsonl");
+    await writeFile(outsideFile, "not json\n", "utf8");
+    const plan: SessionRepairPlan = {
+      generatedAt: new Date().toISOString(),
+      dryRun: false,
+      memoryDir,
+      allowSessionFileRepair: false,
+      actions: [
+        {
+          kind: "rewrite_transcript",
+          description: "forged",
+          targetPath: outsideFile,
+        },
+      ],
+    };
+
+    const result = await applySessionRepair({ plan });
+    assert.equal(result.actionsApplied, 0);
+    assert.match(result.errors.join("\n"), /escapes configured memoryDir/);
+    assert.equal(await readFile(outsideFile, "utf8"), "not json\n");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+    await rm(outside, { recursive: true, force: true });
+  }
+});
+
+test("session repair rejects symlinked transcript targets", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-session-repair-"));
+  const outside = await mkdtemp(path.join(os.tmpdir(), "remnic-session-outside-"));
+  try {
+    const transcripts = path.join(memoryDir, "transcripts");
+    await mkdir(transcripts, { recursive: true });
+    const outsideFile = path.join(outside, "real.jsonl");
+    const linkFile = path.join(transcripts, "link.jsonl");
+    await writeFile(outsideFile, "not json\n", "utf8");
+    await symlink(outsideFile, linkFile);
+    const plan: SessionRepairPlan = {
+      generatedAt: new Date().toISOString(),
+      dryRun: false,
+      memoryDir,
+      allowSessionFileRepair: false,
+      actions: [
+        {
+          kind: "rewrite_transcript",
+          description: "symlink",
+          targetPath: linkFile,
+        },
+      ],
+    };
+
+    const result = await applySessionRepair({ plan });
+    assert.equal(result.actionsApplied, 0);
+    assert.match(result.errors.join("\n"), /repair target crosses symlink/);
+    assert.equal(await readFile(outsideFile, "utf8"), "not json\n");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+    await rm(outside, { recursive: true, force: true });
+  }
+});
+
+test("planned session repair carries the report memoryDir into apply-time validation", () => {
+  const report: SessionIntegrityReport = {
+    generatedAt: "2026-05-22T00:00:00.000Z",
+    memoryDir: "/tmp/remnic-memory",
+    healthy: false,
+    sessions: [],
+    checkpoint: {
+      present: true,
+      healthy: false,
+      path: "/tmp/remnic-memory/state/checkpoint.json",
+    },
+    issues: [
+      {
+        code: "checkpoint_invalid_json",
+        severity: "error",
+        message: "bad checkpoint",
+        filePath: "/tmp/remnic-memory/state/checkpoint.json",
+      },
+    ],
+  };
+
+  const plan = planSessionRepair({ report, dryRun: false });
+  assert.equal(plan.memoryDir, "/tmp/remnic-memory");
+});

package/src/session-integrity.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { lstat, readFile, readdir, realpath, unlink, writeFile } from "node:fs/promises";
 import type { Checkpoint, TranscriptEntry } from "./types.js";
 
 export type SessionIntegrityIssueCode =
@@ -70,6 +70,7 @@ export interface SessionRepairAction {
 export interface SessionRepairPlan {
   generatedAt: string;
   dryRun: boolean;
+  memoryDir: string;
   allowSessionFileRepair: boolean;
   actions: SessionRepairAction[];
 }
@@ -487,6 +488,7 @@ export function planSessionRepair(options: PlanSessionRepairOptions): SessionRep
   return {
     generatedAt: new Date().toISOString(),
     dryRun: options.dryRun,
+    memoryDir: options.report.memoryDir,
     allowSessionFileRepair: options.allowSessionFileRepair === true,
     actions,
   };
@@ -535,11 +537,13 @@ export async function applySessionRepair(
   for (const action of plan.actions) {
     try {
       if (action.kind === "rewrite_transcript") {
+        await assertRepairTargetAllowed(plan.memoryDir, action);
         await rewriteTranscriptFile(action.targetPath);
         actionsApplied += 1;
         continue;
       }
       if (action.kind === "remove_checkpoint") {
+        await assertRepairTargetAllowed(plan.memoryDir, action);
         try {
           await unlink(action.targetPath);
         } catch (err) {
@@ -567,3 +571,49 @@ export async function applySessionRepair(
     errors,
   };
 }
+
+async function assertRepairTargetAllowed(memoryDir: string, action: SessionRepairAction): Promise<void> {
+  const root = path.resolve(memoryDir);
+  const target = path.resolve(action.targetPath);
+  if (action.kind === "rewrite_transcript") {
+    const transcriptsRoot = path.join(root, "transcripts");
+    if (!target.endsWith(".jsonl")) {
+      throw new Error("transcript repair target must end in .jsonl");
+    }
+    await assertNoSymlinkPath(transcriptsRoot, target);
+    return;
+  }
+  if (action.kind === "remove_checkpoint") {
+    const checkpointPath = path.join(root, "state", "checkpoint.json");
+    if (target !== checkpointPath) {
+      throw new Error("checkpoint repair target must be the configured checkpoint.json");
+    }
+    await assertNoSymlinkPath(root, target);
+  }
+}
+
+async function assertNoSymlinkPath(root: string, target: string): Promise<void> {
+  const rootReal = await realpath(root);
+  const targetDir = path.dirname(target);
+  const targetDirReal = await realpath(targetDir);
+  const relative = path.relative(rootReal, targetDirReal);
+  if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+    const normalizedTarget = path.join(targetDirReal, path.basename(target));
+    let current = rootReal;
+    for (const segment of path.relative(rootReal, normalizedTarget).split(path.sep)) {
+      if (!segment) continue;
+      current = path.join(current, segment);
+      try {
+        const stat = await lstat(current);
+        if (stat.isSymbolicLink()) {
+          throw new Error(`repair target crosses symlink: ${current}`);
+        }
+      } catch (err) {
+        const code = typeof err === "object" && err && "code" in err ? String((err as { code?: unknown }).code ?? "") : "";
+        if (code !== "ENOENT") throw err;
+      }
+    }
+    return;
+  }
+  throw new Error("repair target escapes configured memoryDir");
+}

package/src/session-observer-state.ts

@@ -215,38 +215,53 @@ export class SessionObserverState {
 
   async save(): Promise<void> {
     await this.withSaveLock(async () => {
-      const merged = new Map<string, SessionObserverCursor>();
-      const persisted = await this.readPersistedState();
-      if (persisted) {
-        for (const [key, value] of this.normalizePersistedSessions(persisted.sessions).entries()) {
-          merged.set(key, value);
-        }
-      }
-      for (const [key, current] of this.sessions.entries()) {
-        const existing = merged.get(key);
-        if (!existing) {
-          merged.set(key, current);
-          continue;
-        }
-        merged.set(key, mergeSessionCursor(existing, current));
-      }
+      const merged = await this.readMergedSessions();
       this.sessions = merged;
 
-      const sessions: Record<string, SessionObserverCursor> = {};
-      for (const [key, value] of merged.entries()) {
-        sessions[key] = value;
-      }
-      const payload: SessionObserverPersistedState = { version: 1, sessions };
-      await mkdir(path.dirname(this.statePath), { recursive: true });
-      await writeFile(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
+      await this.writeSessions(merged);
     });
   }
 
-  private enqueueSave(): Promise<void> {
-    this.saveQueue = this.saveQueue
+  private async readMergedSessions(): Promise<Map<string, SessionObserverCursor>> {
+    const merged = new Map<string, SessionObserverCursor>();
+    const persisted = await this.readPersistedState();
+    if (persisted) {
+      for (const [key, value] of this.normalizePersistedSessions(persisted.sessions).entries()) {
+        merged.set(key, value);
+      }
+    }
+    for (const [key, current] of this.sessions.entries()) {
+      const existing = merged.get(key);
+      if (!existing) {
+        merged.set(key, current);
+        continue;
+      }
+      merged.set(key, mergeSessionCursor(existing, current));
+    }
+    return merged;
+  }
+
+  private async writeSessions(sessionsMap: Map<string, SessionObserverCursor>): Promise<void> {
+    const sessions: Record<string, SessionObserverCursor> = {};
+    for (const [key, value] of sessionsMap.entries()) {
+      sessions[key] = value;
+    }
+    const payload: SessionObserverPersistedState = { version: 1, sessions };
+    await mkdir(path.dirname(this.statePath), { recursive: true });
+    await writeFile(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
+  }
+
+  private enqueueObservation(
+    input: SessionObservationInput,
+  ): Promise<SessionObservationDecision> {
+    const operation = this.saveQueue
       .catch(() => undefined)
-      .then(() => this.save());
-    return this.saveQueue;
+      .then(() => this.observeWithSaveLock(input));
+    this.saveQueue = operation.then(
+      () => undefined,
+      () => undefined,
+    );
+    return operation;
   }
 
   private bandForTotalBytes(totalBytes: number): SessionObserverBandConfig {
@@ -258,20 +273,48 @@ export class SessionObserverState {
   }
 
   async observe(input: SessionObservationInput): Promise<SessionObservationDecision> {
+    return this.enqueueObservation(input);
+  }
+
+  private async observeWithSaveLock(
+    input: SessionObservationInput,
+  ): Promise<SessionObservationDecision> {
+    let decision: SessionObservationDecision | undefined;
+    await this.withSaveLock(async () => {
+      const localExisting = this.sessions.get(input.sessionKey);
+      const sessions = await this.readMergedSessions();
+      decision = await this.observeMerged(
+        input,
+        sessions,
+        localExisting ? { ...localExisting } : undefined,
+      );
+    });
+    if (!decision) {
+      throw new Error("session observer decision was not computed");
+    }
+    return decision;
+  }
+
+  private async observeMerged(
+    input: SessionObservationInput,
+    sessions: Map<string, SessionObserverCursor>,
+    localExisting?: SessionObserverCursor,
+  ): Promise<SessionObservationDecision> {
     const nowIso = input.observedAt ?? new Date().toISOString();
     const totalBytes = sanitizeNonNegativeInt(input.totalBytes);
     const totalTokens = sanitizeNonNegativeInt(input.totalTokens);
     const band = this.bandForTotalBytes(totalBytes);
 
-    const existing = this.sessions.get(input.sessionKey);
+    const existing = sessions.get(input.sessionKey);
     if (!existing) {
-      this.sessions.set(input.sessionKey, {
+      sessions.set(input.sessionKey, {
         sessionKey: input.sessionKey,
         cursorBytes: totalBytes,
         cursorTokens: totalTokens,
         lastObservedAt: nowIso,
       });
-      await this.enqueueSave();
+      this.sessions = sessions;
+      await this.writeSessions(sessions);
       return {
         triggered: false,
         deltaBytes: 0,
@@ -282,13 +325,32 @@ export class SessionObserverState {
     }
 
     const session = { ...existing };
+    const observedMs = parseIsoMs(nowIso);
+    const existingObservedMs = parseIsoMs(session.lastObservedAt);
+    const existingResetMs = parseIsoMs(session.lastResetAt);
+    if (existingResetMs > 0 && observedMs < existingResetMs) {
+      this.sessions = sessions;
+      return { triggered: false, deltaBytes: 0, deltaTokens: 0, band, reason: "baseline" };
+    }
+
     if (totalBytes < session.cursorBytes || totalTokens < session.cursorTokens) {
-      session.cursorBytes = totalBytes;
-      session.cursorTokens = totalTokens;
-      session.lastObservedAt = nowIso;
-      session.lastResetAt = nowIso;
-      this.sessions.set(input.sessionKey, session);
-      await this.enqueueSave();
+      const localSawReset =
+        localExisting !== undefined
+        && (totalBytes < sanitizeNonNegativeInt(localExisting.cursorBytes)
+          || totalTokens < sanitizeNonNegativeInt(localExisting.cursorTokens));
+      const canApplyReset = localSawReset && observedMs >= existingObservedMs;
+
+      if (canApplyReset) {
+        session.cursorBytes = totalBytes;
+        session.cursorTokens = totalTokens;
+        session.lastObservedAt = nowIso;
+        session.lastResetAt = nowIso;
+      } else if (observedMs >= existingObservedMs) {
+        session.lastObservedAt = nowIso;
+      }
+      sessions.set(input.sessionKey, session);
+      this.sessions = sessions;
+      await this.writeSessions(sessions);
       return { triggered: false, deltaBytes: 0, deltaTokens: 0, band, reason: "baseline" };
     }
 
@@ -302,8 +364,11 @@ export class SessionObserverState {
     if (!crossedThreshold) {
       const unchanged = deltaBytes === 0 && deltaTokens === 0;
       if (!unchanged) {
-        this.sessions.set(input.sessionKey, session);
-        await this.enqueueSave();
+        sessions.set(input.sessionKey, session);
+        this.sessions = sessions;
+        await this.writeSessions(sessions);
+      } else {
+        this.sessions = sessions;
       }
       return {
         triggered: false,
@@ -319,8 +384,9 @@ export class SessionObserverState {
       Number.isFinite(lastTriggeredMs) && nowMs - lastTriggeredMs < this.debounceMs;
 
     if (withinDebounce) {
-      this.sessions.set(input.sessionKey, session);
-      await this.enqueueSave();
+      sessions.set(input.sessionKey, session);
+      this.sessions = sessions;
+      await this.writeSessions(sessions);
       return {
         triggered: false,
         deltaBytes,
@@ -333,8 +399,9 @@ export class SessionObserverState {
     session.lastTriggeredAt = nowIso;
     session.cursorBytes = totalBytes;
     session.cursorTokens = totalTokens;
-    this.sessions.set(input.sessionKey, session);
-    await this.enqueueSave();
+    sessions.set(input.sessionKey, session);
+    this.sessions = sessions;
+    await this.writeSessions(sessions);
     return {
       triggered: true,
       deltaBytes,

package/src/shared-context/manager.ts

@@ -1,4 +1,5 @@
-import { mkdir, readFile, readdir, appendFile, writeFile, stat } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, appendFile, writeFile, stat, rename, rm } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { log } from "../logger.js";
@@ -86,6 +87,17 @@ function ymd(d: Date): string {
   return d.toISOString().slice(0, 10);
 }
 
+function safeDateSegment(date: string): string {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    throw new Error(`Invalid shared-context date: ${JSON.stringify(date)}; expected YYYY-MM-DD`);
+  }
+  const parsed = new Date(`${date}T00:00:00.000Z`);
+  if (!Number.isFinite(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== date) {
+    throw new Error(`Invalid shared-context date: ${JSON.stringify(date)}; expected a real calendar date`);
+  }
+  return date;
+}
+
 const CROSS_SIGNAL_STOPWORDS = new Set([
   "a",
   "an",
@@ -373,15 +385,38 @@ function compareFeedbackPriority(a: SharedFeedbackEntry, b: SharedFeedbackEntry)
   );
 }
 
+function markdownLineText(value: string): string {
+  return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}
+
+function markdownLineList(values: readonly string[]): string {
+  return values.map(markdownLineText).filter(Boolean).join(", ");
+}
+
 function formatFeedbackLine(entry: SharedFeedbackEntry): string {
-  const extras: string[] = [`feedback: ${entry.date}`];
-  if (entry.severity) extras.push(`severity: ${entry.severity}`);
-  if (entry.refs?.length) extras.push(`refs: ${entry.refs.join(", ")}`);
-  return `- [${entry.agent}] ${entry.decision}: ${entry.reason} [${extras.join("; ")}]`;
+  const extras: string[] = [`feedback: ${markdownLineText(entry.date)}`];
+  if (entry.severity) extras.push(`severity: ${markdownLineText(entry.severity)}`);
+  if (entry.refs?.length) extras.push(`refs: ${markdownLineList(entry.refs)}`);
+  return `- [${markdownLineText(entry.agent)}] ${entry.decision}: ${markdownLineText(entry.reason)} [${extras.join("; ")}]`;
 }
 
 function formatOverlapLine(entry: SharedCrossSignalOverlap): string {
-  return `- \`${entry.token}\` (${entry.agentCount} agents: ${entry.agents.join(", ")}) [sources: ${entry.sourcePaths.join(", ")}]`;
+  return `- \`${entry.token}\` (${entry.agentCount} agents: ${markdownLineList(entry.agents)}) [sources: ${markdownLineList(entry.sourcePaths)}]`;
+}
+
+async function writeFileAtomic(filePath: string, content: string): Promise<void> {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const tempPath = path.join(
+    path.dirname(filePath),
+    `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`,
+  );
+  try {
+    await writeFile(tempPath, content, { encoding: "utf-8", flag: "wx" });
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => undefined);
+    throw error;
+  }
 }
 
 export function resolveSharedContextDir(config: PluginConfig): string {
@@ -399,6 +434,7 @@ export class SharedContextManager {
   private readonly feedbackDir: string;
   private readonly feedbackInboxPath: string;
   private readonly crossSignalsDir: string;
+  private readonly dailySynthesisChains = new Map<string, Promise<void>>();
 
   constructor(private readonly config: PluginConfig) {
     const base = resolveSharedContextDir(config);
@@ -553,17 +589,48 @@ export class SharedContextManager {
     await appendFile(this.prioritiesInboxPath, lines, "utf-8");
   }
 
+  private async withDailySynthesisLock<T>(date: string, fn: () => Promise<T>): Promise<T> {
+    const previous = this.dailySynthesisChains.get(date) ?? Promise.resolve();
+    let releaseCurrent!: () => void;
+    const current = new Promise<void>((resolve) => {
+      releaseCurrent = resolve;
+    });
+    const queued = previous.catch(() => undefined).then(() => current);
+    this.dailySynthesisChains.set(date, queued);
+    await previous.catch(() => undefined);
+    try {
+      return await fn();
+    } finally {
+      releaseCurrent();
+      if (this.dailySynthesisChains.get(date) === queued) {
+        this.dailySynthesisChains.delete(date);
+      }
+    }
+  }
+
   async synthesizeCrossSignals(opts: {
     date?: string;
     maxSummaryItems?: number;
   }): Promise<SharedCrossSignalSynthesisResult> {
-    const date = opts.date ?? ymd(new Date());
+    const date = safeDateSegment(opts.date ?? ymd(new Date()));
+    return this.withDailySynthesisLock(date, () => this.synthesizeCrossSignalsUnlocked({
+      date,
+      maxSummaryItems: opts.maxSummaryItems,
+    }));
+  }
+
+  private async synthesizeCrossSignalsUnlocked(opts: {
+    date: string;
+    maxSummaryItems?: number;
+  }): Promise<SharedCrossSignalSynthesisResult> {
+    const date = opts.date;
     const maxSummaryItems = Math.max(1, opts.maxSummaryItems ?? 8);
 
     // Collect outputs for the day (best-effort).
     const outputs: Array<{ agent: string; path: string; title: string; raw: string }> = [];
     try {
-      const agents = await readdir(this.outputsDir, { withFileTypes: true });
+      const agents = (await readdir(this.outputsDir, { withFileTypes: true }))
+        .sort((a, b) => a.name.localeCompare(b.name));
       for (const a of agents) {
         if (!a.isDirectory()) continue;
         const dayDir = path.join(this.outputsDir, a.name, date);
@@ -583,6 +650,12 @@ export class SharedContextManager {
     } catch {
       // ignore
     }
+    outputs.sort(
+      (a, b) =>
+        a.agent.localeCompare(b.agent)
+        || a.path.localeCompare(b.path)
+        || a.title.localeCompare(b.title),
+    );
 
     // Collect feedback entries for the day.
     const feedback: SharedFeedbackEntry[] = [];
@@ -700,7 +773,7 @@ export class SharedContextManager {
     };
 
     const crossSignalsPath = path.join(this.crossSignalsDir, `${date}.json`);
-    await writeFile(crossSignalsPath, `${JSON.stringify(report, null, 2)}\n`, "utf-8");
+    await writeFileAtomic(crossSignalsPath, `${JSON.stringify(report, null, 2)}\n`);
 
     const recurringThemeLines = mergedOverlaps.length === 0
       ? ["- No multi-agent topic overlap detected."]
@@ -718,7 +791,7 @@ export class SharedContextManager {
     const promotionLines = promotionCandidates.length === 0
       ? ["- No promotion candidates yet."]
       : promotionCandidates.map((entry) =>
-          `- Consider promoting \`${entry.token}\` into priorities or operating rules [sources: ${entry.sourcePaths.join(", ")}]`
+          `- Consider promoting \`${entry.token}\` into priorities or operating rules [sources: ${markdownLineList(entry.sourcePaths)}]`
         );
 
     const crossSignalsMarkdown = [
@@ -742,13 +815,13 @@ export class SharedContextManager {
       "",
       "## Sources",
       ...(sources.length === 0 ? ["- (none)"] : sources.map((source) =>
-        `- [${source.agent}] ${source.title} (${source.path})`
+        `- [${markdownLineText(source.agent)}] ${markdownLineText(source.title)} (${markdownLineText(source.path)})`
       )),
       "",
     ].join("\n");
 
     const crossSignalsMarkdownPath = path.join(this.crossSignalsDir, `${date}.md`);
-    await writeFile(crossSignalsMarkdownPath, crossSignalsMarkdown, "utf-8");
+    await writeFileAtomic(crossSignalsMarkdownPath, crossSignalsMarkdown);
 
     return {
       date,
@@ -760,9 +833,14 @@ export class SharedContextManager {
   }
 
   async curateDaily(opts: { date?: string; maxChars?: number }): Promise<SharedDailyCurationResult> {
-    const date = opts.date ?? ymd(new Date());
+    const date = safeDateSegment(opts.date ?? ymd(new Date()));
+    return this.withDailySynthesisLock(date, () => this.curateDailyUnlocked({ ...opts, date }));
+  }
+
+  private async curateDailyUnlocked(opts: { date: string; maxChars?: number }): Promise<SharedDailyCurationResult> {
+    const date = opts.date;
     const maxChars = Math.max(2_000, opts.maxChars ?? 20_000);
-    const crossSignals = await this.synthesizeCrossSignals({ date });
+    const crossSignals = await this.synthesizeCrossSignalsUnlocked({ date });
     const feedbackLines = crossSignals.report.feedbackEntries.length === 0
       ? ["- (none)"]
       : crossSignals.report.feedbackEntries.map((entry) => formatFeedbackLine(entry));
@@ -796,7 +874,7 @@ export class SharedContextManager {
     const trimmed = out.length > maxChars ? out.slice(0, maxChars) + "\n\n...(trimmed)\n" : out;
 
     const roundtablePath = path.join(this.roundtableDir, `${date}.md`);
-    await writeFile(roundtablePath, trimmed, "utf-8");
+    await writeFileAtomic(roundtablePath, trimmed);
 
     log.info(`shared-context curated daily roundtable: ${roundtablePath}`);
     return {

package/src/signal.test.ts

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { scanSignals } from "./signal.js";
+
+test("scanSignals skips invalid custom patterns without throwing", () => {
+  const result = scanSignals("please always remember the deployment window", [
+    "[",
+    "deployment",
+  ]);
+
+  assert.equal(result.level, "high");
+  assert.ok(result.patterns.some((pattern) => pattern === "custom:deployment"));
+});

package/src/signal.ts

@@ -48,7 +48,14 @@ export function scanSignals(
 ): SignalScanResult {
   const matched: string[] = [];
 
-  const customRegexes = customPatterns.map((p) => new RegExp(p, "i"));
+  const customRegexes: RegExp[] = [];
+  for (const pattern of customPatterns) {
+    try {
+      customRegexes.push(new RegExp(pattern, "i"));
+    } catch {
+      // Invalid custom patterns should not make the scan path fail closed.
+    }
+  }
 
   for (const rx of customRegexes) {
     if (rx.test(text)) {

package/src/source-attribution.test.ts

@@ -16,6 +16,7 @@ import {
   parseAllCitations,
   parseCitation,
   stripCitation,
+  stripCitationForTemplate,
 } from "./source-attribution.js";
 
 test("formatCitation emits the default template with provided fields", () => {
@@ -739,6 +740,13 @@ test("hasCitationForTemplate (Finding 1): bracket-wrapped compact template is ac
   );
 });
 
+test("stripCitationForTemplate removes bracket-wrapped compact citations", () => {
+  assert.equal(
+    stripCitationForTemplate("Fact body. [agent-abc123]", "{agent}-{sessionId}"),
+    "Fact body.",
+  );
+});
+
 // Finding 2: stripCitation must be a no-op on uncited input
 test("stripCitation (Finding 2): returns uncited input byte-for-byte unchanged", () => {
   // Core regression: the old implementation normalised all repeated whitespace

package/src/source-attribution.ts

@@ -620,9 +620,13 @@ export function stripCitationForTemplate(
   let match: RegExpExecArray | null;
 
   while ((match = globalMatcher.exec(text)) !== null) {
-    const before = text.slice(lastIndex, match.index).replace(/[ \t]+$/, "");
+    const matchEnd = match.index + match[0].length;
+    const enclosure = enclosingDelimiterRange(text, match.index, matchEnd);
+    const removalStart = enclosure?.start ?? match.index;
+    const removalEnd = enclosure?.end ?? matchEnd;
+    const before = text.slice(lastIndex, removalStart).replace(/[ \t]+$/, "");
     result += before;
-    lastIndex = match.index + match[0].length;
+    lastIndex = removalEnd;
     // Guard against zero-width matches causing an infinite loop.
     if (match[0].length === 0) {
       globalMatcher.lastIndex++;
@@ -637,3 +641,21 @@ export function stripCitationForTemplate(
 
   return result.trimEnd();
 }
+
+function enclosingDelimiterRange(
+  text: string,
+  start: number,
+  end: number,
+): { start: number; end: number } | undefined {
+  if (start <= 0 || end >= text.length) return undefined;
+  const opener = text[start - 1];
+  const closer = text[end];
+  if (
+    (opener === "[" && closer === "]") ||
+    (opener === "(" && closer === ")") ||
+    (opener === "<" && closer === ">")
+  ) {
+    return { start: start - 1, end: end + 1 };
+  }
+  return undefined;
+}