@wrongstack/core 0.309.1 → 0.310.0

package/dist/types/tool.d.ts

@@ -1,4 +1,4 @@
-import type { Context } from '../core/context.js';
+import type { AgentContext } from './context.js';
 export type Permission = 'auto' | 'confirm' | 'deny';
 /**
  * Risk tier for tools in UI/audit surfaces. YOLO auto-approves non-denied
@@ -150,7 +150,7 @@ export interface Tool<I = unknown, O = unknown> {
      * Each UI maps this id to its own icon library.
      */
     icon?: ToolIconId | undefined;
-    execute(input: I, ctx: Context, opts: {
+    execute(input: I, ctx: AgentContext, opts: {
         signal: AbortSignal;
     }): Promise<O>;
     /**
@@ -176,7 +176,7 @@ export interface Tool<I = unknown, O = unknown> {
      * have intermediate state shouldn't implement this; the default `execute`
      * path is more efficient.
      */
-    executeStream?(input: I, ctx: Context, opts: {
+    executeStream?(input: I, ctx: AgentContext, opts: {
         signal: AbortSignal;
     }): AsyncIterable<ToolStreamEvent<O>>;
     /**
@@ -222,7 +222,7 @@ export interface Tool<I = unknown, O = unknown> {
      * Avoid double-free by gating one on the other's effect, or pick a single
      * teardown channel per resource.
      */
-    cleanup?(input: I, ctx: Context): Promise<void>;
+    cleanup?(input: I, ctx: AgentContext): Promise<void>;
     /**
      * Optional custom output serializer. When present, the executor's output
      * serializer calls this INSTEAD of the central `renderToolObject()` switch
@@ -243,7 +243,7 @@ export interface ToolCallContext {
     tool: Tool;
     input: unknown;
     callId: string;
-    ctx: Context;
+    ctx: AgentContext;
     signal: AbortSignal;
 }
 /**

package/dist/utils/context-breakdown.d.ts

@@ -1,4 +1,4 @@
-import type { Context } from '../core/context.js';
+import type { AgentContext } from '../types/context.js';
 import { type SystemBlockSource } from '../core/system-prompt-builder.js';
 /**
  * Real, per-category token accounting for the live context window — the data
@@ -61,5 +61,5 @@ export interface ContextBreakdown {
  * interactively (e.g. from `/context`): it walks the full message array once, so
  * it is O(messages·blocks), not the O(1) cached path the per-turn bar uses.
  */
-export declare function getContextBreakdown(ctx: Context): ContextBreakdown;
+export declare function getContextBreakdown(ctx: AgentContext): ContextBreakdown;
 //# sourceMappingURL=context-breakdown.d.ts.map

package/dist/utils/context-evidence.d.ts

@@ -1,4 +1,4 @@
-import type { Context } from '../core/context.js';
+import type { AgentContext } from '../types/context.js';
 import { type TextBlock } from '../types/blocks.js';
 import type { CompactReport } from '../types/compactor.js';
 import type { CompletedWorkEvidence, CompletedWorkSource, ContextEvidenceState, ToolOutputMetadata } from '../types/context-evidence.js';
@@ -13,7 +13,7 @@ export interface RecordToolOutputEvidenceInput {
     outputTokens?: number | undefined;
     outputLines?: number | undefined;
 }
-export declare function recordUserIntentEvidence(ctx: Context, text: string): void;
+export declare function recordUserIntentEvidence(ctx: AgentContext, text: string): void;
 /** Runtime steering/status blocks must not displace real conversation turns. */
 export declare function isRuntimeContextInput(text: string): boolean;
 /**
@@ -25,11 +25,11 @@ export declare function isRuntimeContextInput(text: string): boolean;
  * It is volatile provider evidence, so it never grows the durable chat log or
  * invalidates the cached base prompt.
  */
-export declare function buildConversationContinuityBlock(ctx: Pick<Context, 'contextEvidence' | 'messages'>): TextBlock | undefined;
-export declare function recordToolOutputEvidence(ctx: Context, input: RecordToolOutputEvidenceInput): ToolOutputMetadata;
-export declare function markAssistantReferencedEvidence(ctx: Context, text: string): void;
-export declare function buildContextEvidenceDigest(ctx: Context): string;
-export declare function repeatedReadPressure(ctx: Context): number;
+export declare function buildConversationContinuityBlock(ctx: Pick<AgentContext, 'contextEvidence' | 'messages'>): TextBlock | undefined;
+export declare function recordToolOutputEvidence(ctx: AgentContext, input: RecordToolOutputEvidenceInput): ToolOutputMetadata;
+export declare function markAssistantReferencedEvidence(ctx: AgentContext, text: string): void;
+export declare function buildContextEvidenceDigest(ctx: AgentContext): string;
+export declare function repeatedReadPressure(ctx: AgentContext): number;
 /**
  * Deterministic post-compaction sanity check. Cheap and local: records whether
  * the compacted context still carries an intent anchor and a tool/path trail.
@@ -37,7 +37,7 @@ export declare function repeatedReadPressure(ctx: Context): number;
  * only HybridCompactor did). Advisory on its own — pair with
  * `injectEvidenceFloor` to actually repair a flagged loss.
  */
-export declare function checkCompactionQuality(ctx: Context, opts: {
+export declare function checkCompactionQuality(ctx: AgentContext, opts: {
     collapsedDigest?: string | undefined;
     evidenceDigest?: string | undefined;
     reduced: boolean;
@@ -50,7 +50,7 @@ export declare function checkCompactionQuality(ctx: Context, opts: {
  * no-op when quality is fine or there is no evidence to inject. Returns true
  * when it injected a block (so the caller re-estimates tokens).
  */
-export declare function injectEvidenceFloor(ctx: Context, quality: CompactReport['quality'] | undefined): boolean;
+export declare function injectEvidenceFloor(ctx: AgentContext, quality: CompactReport['quality'] | undefined): boolean;
 /** Marker prefixing the ledger's system-prompt block (also used to find/replace it). */
 export declare const COMPLETED_WORK_LEDGER_MARKER = "[completed_work_ledger]";
 export interface RecordCompletedWorkInput {
@@ -68,14 +68,14 @@ export interface RecordCompletedWorkInput {
  * composer renders this state as a volatile tail block; the stable system-prompt
  * prefix is never mutated here.
  */
-export declare function recordCompletedWorkEvidence(ctx: Context, input: RecordCompletedWorkInput): CompletedWorkEvidence;
+export declare function recordCompletedWorkEvidence(ctx: AgentContext, input: RecordCompletedWorkInput): CompletedWorkEvidence;
 /** Render the ledger's system-prompt block text (marker + newest entries). */
 export declare function formatCompletedWorkLedger(items: readonly CompletedWorkEvidence[]): string;
 /** Build the current volatile completed-work block without mutating the prompt. */
-export declare function buildCompletedWorkLedgerBlock(ctx: Context): TextBlock | undefined;
+export declare function buildCompletedWorkLedgerBlock(ctx: AgentContext): TextBlock | undefined;
 /**
  * @deprecated Volatile state must be composed at request time. Kept as a
  * compatibility no-op for embedders importing the old helper.
  */
-export declare function syncCompletedWorkLedgerBlock(_ctx: Context): void;
+export declare function syncCompletedWorkLedgerBlock(_ctx: AgentContext): void;
 //# sourceMappingURL=context-evidence.d.ts.map

package/dist/utils/crash-shield.d.ts

@@ -1,3 +1,12 @@
+/** Register a synchronous salvage hook. Returns an unregister function. */
+export declare function addFatalSalvageHook(hook: () => void): () => void;
+/**
+ * Run every registered salvage hook once. Swallows individual hook failures
+ * so one broken hook cannot skip the remaining ones. Safe to call multiple
+ * times — hooks are expected to be idempotent (a drained buffer stays
+ * drained).
+ */
+export declare function runFatalSalvageSync(): void;
 interface CrashShieldTarget {
     on(event: 'unhandledRejection' | 'uncaughtException', listener: (reason: unknown) => void): unknown;
     off(event: 'unhandledRejection' | 'uncaughtException', listener: (reason: unknown) => void): unknown;

package/dist/utils/heap-watchdog.js

@@ -2,7 +2,10 @@
 import * as fs from "node:fs";
 import * as fsp2 from "node:fs/promises";
 import * as path3 from "node:path";
-import { PerformanceObserver, constants as performanceConstants } from "node:perf_hooks";
+import {
+  PerformanceObserver,
+  constants as performanceConstants
+} from "node:perf_hooks";
 import * as v8 from "node:v8";
 
 // src/utils/memory-flight-recorder.ts
@@ -308,7 +311,8 @@ function createMemoryFlightRecorder(options = {}) {
   const now = options.now ?? Date.now;
   const startedAt = now();
   const root = options.diagnosticsRoot ?? path2.join(wstackGlobalRoot(), "diagnostics", "memory");
-  const enabled = options.enabled ?? (process.env["WRONGSTACK_MEMORY_FLIGHT_RECORDER"] !== "0" && process.env["NODE_ENV"] !== "test");
+  const isBunRuntime = typeof globalThis.Bun !== "undefined";
+  const enabled = options.enabled ?? (!isBunRuntime && process.env["WRONGSTACK_MEMORY_FLIGHT_RECORDER"] !== "0" && process.env["NODE_ENV"] !== "test");
   const writer = options.captureWriter ?? (enabled ? new ContinuousMemoryCaptureWriter(root) : disabledWriter(path2.join(root, `${timestampSlug()}-pid-${process.pid}`)));
   const observations = [];
   const windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
@@ -418,7 +422,11 @@ function defaultHeapLogPath() {
 function takeHeapSample() {
   const m = process.memoryUsage();
   const heap = v8.getHeapStatistics();
-  const spaces = v8.getHeapSpaceStatistics();
+  let spaces = [];
+  try {
+    spaces = v8.getHeapSpaceStatistics();
+  } catch {
+  }
   const spaceUsed = (name) => spaces.find((space) => space.space_name === name)?.space_used_size ?? 0;
   const limit = heap.heap_size_limit || 0;
   let activeResources = 0;

package/dist/utils/index.d.ts

@@ -7,7 +7,7 @@ export * from './config-backup.js';
 export * from './config-json.js';
 export { checkConnectivity, resetConnectivityCache } from './connectivity.js';
 export { type ContextBreakdown, getContextBreakdown } from './context-breakdown.js';
-export { type CrashShieldOptions, installCrashShield } from './crash-shield.js';
+export { addFatalSalvageHook, runFatalSalvageSync, type CrashShieldOptions, installCrashShield, } from './crash-shield.js';
 export { buildCompletedWorkLedgerBlock, buildContextEvidenceDigest, COMPLETED_WORK_LEDGER_MARKER, createContextEvidenceState, formatCompletedWorkLedger, markAssistantReferencedEvidence, type RecordCompletedWorkInput, type RecordToolOutputEvidenceInput, recordCompletedWorkEvidence, recordToolOutputEvidence, recordUserIntentEvidence, repeatedReadPressure, syncCompletedWorkLedgerBlock, } from './context-evidence.js';
 export { type DeepMergeOptions, deepMerge, FORBIDDEN_PROTO_KEYS, isPrimitiveArray, } from './deep-merge.js';
 export * from './diff.js';

package/dist/utils/index.js

@@ -1915,6 +1915,22 @@ function getContextBreakdown(ctx) {
 // src/utils/crash-shield.ts
 var CRASH_STORM_WINDOW_MS = 6e4;
 var CRASH_STORM_LIMIT = 20;
+var fatalSalvageHooks = [];
+function addFatalSalvageHook(hook) {
+  fatalSalvageHooks.push(hook);
+  return () => {
+    const idx = fatalSalvageHooks.indexOf(hook);
+    if (idx >= 0) fatalSalvageHooks.splice(idx, 1);
+  };
+}
+function runFatalSalvageSync() {
+  for (const hook of [...fatalSalvageHooks]) {
+    try {
+      hook();
+    } catch {
+    }
+  }
+}
 function isBrokenOutputConsumer(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) return false;
   return error.code === "EPIPE" || error.code === "ECONNRESET" || error.code === "ECONNABORTED";
@@ -1950,6 +1966,7 @@ function installCrashShield(options = {}) {
           `error storm: >${CRASH_STORM_LIMIT} in ${CRASH_STORM_WINDOW_MS / 1e3}s \u2014 exiting`
         )
       );
+      runFatalSalvageSync();
       exit(1);
     }
   };
@@ -2232,49 +2249,57 @@ async function expandGlob(pattern) {
   async function walk2(dir, pat) {
     let entries;
     try {
-      entries = await fsp.readdir(dir);
+      entries = await fsp.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
-    const firstGlob = pat.search(/[*?[[]/);
-    if (firstGlob < 0) {
-      const re = globToRegex(pat);
+    if (pat.startsWith("**/")) {
+      const rest = pat.slice(3);
+      await walk2(dir, rest);
       for (const e of entries) {
-        if (re.test(e)) {
-          const full = `${dir}${SEP}${e}`;
-          results.add(abs ? resolve2(full) : full);
+        if (e.isDirectory()) {
+          const subDir = `${dir}${SEP}${e.name}`;
+          await walk2(subDir, pat);
         }
       }
       return;
     }
-    const before = pat.slice(0, firstGlob);
-    const rest = pat.slice(firstGlob);
-    if (before.endsWith("**")) {
-      await walk2(dir, rest);
+    if (pat === "**") {
       for (const e of entries) {
-        const full = `${dir}${SEP}${e}`;
-        try {
-          const stat4 = await fsp.stat(full);
-          if (stat4.isDirectory()) await walk2(full, rest);
-        } catch {
+        const full = `${dir}${SEP}${e.name}`;
+        results.add(abs ? resolve2(full) : full);
+        if (e.isDirectory()) {
+          await walk2(full, "**");
         }
       }
-    } else if (before === "") {
-      const re = globToRegex(rest);
+      return;
+    }
+    const firstSlash = pat.indexOf("/");
+    if (firstSlash < 0) {
+      const re = globToRegex(pat);
       for (const e of entries) {
-        if (re.test(e)) {
-          const full = `${dir}${SEP}${e}`;
+        if (re.test(e.name)) {
+          const full = `${dir}${SEP}${e.name}`;
           results.add(abs ? resolve2(full) : full);
         }
       }
+      return;
+    }
+    const currentSeg = pat.slice(0, firstSlash);
+    const remainingPat = pat.slice(firstSlash + 1);
+    if (isGlob(currentSeg)) {
+      const re = globToRegex(currentSeg);
+      for (const e of entries) {
+        if (e.isDirectory() && re.test(e.name)) {
+          const subDir = `${dir}${SEP}${e.name}`;
+          await walk2(subDir, remainingPat);
+        }
+      }
     } else {
-      const seg = before.replace(/[*?[\]]/g, "").replace(/\/$/, "");
-      if (entries.includes(seg)) {
-        const full = `${dir}${SEP}${seg}`;
-        try {
-          const stat4 = await fsp.stat(full);
-          if (stat4.isDirectory()) await walk2(full, rest);
-        } catch {
+      for (const e of entries) {
+        if (e.isDirectory() && e.name === currentSeg) {
+          const subDir = `${dir}${SEP}${e.name}`;
+          await walk2(subDir, remainingPat);
         }
       }
     }
@@ -2379,7 +2404,10 @@ function matchAnyCommand(patterns, input) {
 import * as fs4 from "node:fs";
 import * as fsp3 from "node:fs/promises";
 import * as path5 from "node:path";
-import { PerformanceObserver, constants as performanceConstants } from "node:perf_hooks";
+import {
+  PerformanceObserver,
+  constants as performanceConstants
+} from "node:perf_hooks";
 import * as v8 from "node:v8";
 
 // src/utils/memory-flight-recorder.ts
@@ -2696,8 +2724,8 @@ async function pruneOldSessions(root, currentDir) {
   const sessions = await Promise.all(
     entries.filter((entry) => entry.isDirectory() && entry.name !== path4.basename(currentDir)).map(async (entry) => {
       const fullPath = path4.join(root, entry.name);
-      const stat4 = await fsp2.stat(fullPath);
-      return { fullPath, mtimeMs: stat4.mtimeMs };
+      const stat3 = await fsp2.stat(fullPath);
+      return { fullPath, mtimeMs: stat3.mtimeMs };
     })
   );
   sessions.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -2815,7 +2843,8 @@ function createMemoryFlightRecorder(options = {}) {
   const now = options.now ?? Date.now;
   const startedAt = now();
   const root = options.diagnosticsRoot ?? path4.join(wstackGlobalRoot(), "diagnostics", "memory");
-  const enabled = options.enabled ?? (process.env["WRONGSTACK_MEMORY_FLIGHT_RECORDER"] !== "0" && process.env["NODE_ENV"] !== "test");
+  const isBunRuntime = typeof globalThis.Bun !== "undefined";
+  const enabled = options.enabled ?? (!isBunRuntime && process.env["WRONGSTACK_MEMORY_FLIGHT_RECORDER"] !== "0" && process.env["NODE_ENV"] !== "test");
   const writer = options.captureWriter ?? (enabled ? new ContinuousMemoryCaptureWriter(root) : disabledWriter(path4.join(root, `${timestampSlug()}-pid-${process.pid}`)));
   const observations = [];
   const windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
@@ -2925,7 +2954,11 @@ function defaultHeapLogPath() {
 function takeHeapSample() {
   const m = process.memoryUsage();
   const heap = v8.getHeapStatistics();
-  const spaces = v8.getHeapSpaceStatistics();
+  let spaces = [];
+  try {
+    spaces = v8.getHeapSpaceStatistics();
+  } catch {
+  }
   const spaceUsed = (name) => spaces.find((space) => space.space_name === name)?.space_used_size ?? 0;
   const limit = heap.heap_size_limit || 0;
   let activeResources = 0;
@@ -4270,130 +4303,11 @@ function watchProjectTree(root, listener, opts) {
 }
 
 // src/utils/regex-guard.ts
-var MAX_PATTERN_LEN = 256;
-var DANGEROUS_PATTERNS = [
-  // (a+)+, (.*)+, etc — nested quantifier on a group with internal quantifier
-  /(\([^)]*[+*][^)]*\))[+*]/,
-  /(\(\?:[^)]*[+*][^)]*\))[+*]/,
-  // Adjacent quantifiers: a++ a*+
-  /[+*]{2,}/,
-  // Quantifier on alternation with length 2+
-  /\([^|)]+\|[^)]+\)[+*][+*]/,
-  // Greedy quantifier inside lookahead/lookbehind — (?!.*a+)
-  /[([][^)\]]*[+*][^)\]]*[)\]][^)]*\?\??/
-];
-function hasAmbiguousQuantifiedAlternation(pattern) {
-  for (let i = 0; i < pattern.length; i++) {
-    if (pattern[i] !== "(") continue;
-    if (i > 0 && pattern[i - 1] === "\\") continue;
-    let depth = 0;
-    let inClass = false;
-    let j = i;
-    for (; j < pattern.length; j++) {
-      const ch = pattern[j];
-      if (ch === "\\") {
-        j++;
-        continue;
-      }
-      if (inClass) {
-        if (ch === "]") inClass = false;
-        continue;
-      }
-      if (ch === "[") {
-        inClass = true;
-        continue;
-      }
-      if (ch === "(") depth++;
-      else if (ch === ")") {
-        depth--;
-        if (depth === 0) break;
-      }
-    }
-    if (j >= pattern.length) return false;
-    const next = pattern[j + 1];
-    if (next !== "+" && next !== "*" && next !== "{") continue;
-    let inner = pattern.slice(i + 1, j);
-    inner = inner.replace(/^\?(?::|<?[=!])/u, "");
-    const branches = [];
-    let current = "";
-    let d = 0;
-    let cls = false;
-    for (let k = 0; k < inner.length; k++) {
-      const ch = inner[k];
-      if (ch === "\\") {
-        current += ch + (inner[k + 1] ?? "");
-        k++;
-        continue;
-      }
-      if (cls) {
-        if (ch === "]") cls = false;
-        current += ch;
-        continue;
-      }
-      if (ch === "[") {
-        cls = true;
-        current += ch;
-        continue;
-      }
-      if (ch === "(") d++;
-      if (ch === ")") d--;
-      if (ch === "|" && d === 0) {
-        branches.push(current);
-        current = "";
-        continue;
-      }
-      current += ch;
-    }
-    branches.push(current);
-    if (branches.length < 2) continue;
-    for (let a = 0; a < branches.length; a++) {
-      for (let b = a + 1; b < branches.length; b++) {
-        const x = branches[a];
-        const y = branches[b];
-        if (x === "" || y === "") return true;
-        if (x === y || x.startsWith(y) || y.startsWith(x)) return true;
-      }
-    }
-  }
-  return false;
-}
-function compileUserRegex(pattern, flags) {
-  if (typeof pattern !== "string") {
-    return { ok: false, reason: "pattern must be a string" };
-  }
-  if (pattern.length === 0) {
-    return { ok: false, reason: "pattern is empty" };
-  }
-  if (pattern.length > MAX_PATTERN_LEN) {
-    return { ok: false, reason: `pattern exceeds ${MAX_PATTERN_LEN} characters` };
-  }
-  for (const rx of DANGEROUS_PATTERNS) {
-    if (rx.test(pattern)) {
-      return {
-        ok: false,
-        reason: "pattern looks vulnerable to catastrophic backtracking \u2014 rewrite without nested quantifiers"
-      };
-    }
-  }
-  if (hasAmbiguousQuantifiedAlternation(pattern)) {
-    return {
-      ok: false,
-      reason: "pattern quantifies an alternation with overlapping branches \u2014 rewrite so no two branches can match the same text"
-    };
-  }
-  try {
-    return { ok: true, regex: new RegExp(pattern, flags) };
-  } catch (err) {
-    return {
-      ok: false,
-      reason: err instanceof Error ? err.message : "invalid regex"
-    };
-  }
-}
-var MAX_SUBJECT_LEN = 64 * 1024;
-function capSubject(line) {
-  return line.length > MAX_SUBJECT_LEN ? line.slice(0, MAX_SUBJECT_LEN) : line;
-}
+import {
+  capSubject,
+  compileUserRegex,
+  MAX_SUBJECT_LEN
+} from "@wrongstack/primitives";
 
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
@@ -5799,6 +5713,7 @@ export {
   WIRE_TOOL_NAME_MAX_LENGTH,
   WIRE_TOOL_NAME_PATTERN,
   activateProjectStateGuard,
+  addFatalSalvageHook,
   applyToolDescriptionModeToTool,
   applyToolDescriptionModes,
   applyToolResultRenderModes,
@@ -5933,6 +5848,7 @@ export {
   resolveToolDescriptionMode,
   resolveToolResultRenderMode,
   resolveWstackPaths,
+  runFatalSalvageSync,
   safeEmit,
   safeParse,
   safeProfileName,

package/dist/utils/regex-guard.d.ts

@@ -1,35 +1,12 @@
 /**
  * Compile a user-supplied regex with conservative bounds against ReDoS.
  *
- * Duplicated from @wrongstack/tools/_regex.ts to avoid a circular
- * dependency (tools depends on core, not vice versa). There is a THIRD copy —
- * `@wrongstack/kanban/src/verification/safe-regex.ts` — which sits below both
- * in the workspace DAG for the same reason. This header used to say "keep
- * both copies in sync", unaware of the third, and this copy had drifted the
- * furthest: 2 of the 5 heuristics, a 512-character cap instead of 256, and no
- * subject cap at all. `packages/tools/tests/regex-guard-parity.test.ts` now
- * holds all three to the same verdicts — change one, change all three.
- *
- * V8's regex engine is backtracking-based and cannot interrupt a
- * synchronous match — a pattern like `(a+)+$` against a sufficiently
- * long line will pin a worker for seconds.
- */
-export interface CompileResult {
-    ok: true;
-    regex: RegExp;
-}
-export interface CompileFail {
-    ok: false;
-    reason: string;
-}
-export declare function compileUserRegex(pattern: string, flags: string): CompileResult | CompileFail;
-/**
- * Truncate a subject line to a safe length for synchronous regex eval.
- *
- * The canonical copy has always shipped this; this one did not, so callers
- * here bounded the pattern but never the SUBJECT — and a linear-time pattern
- * over a multi-megabyte line is still a stall.
+ * Canonical home since card #5: `@wrongstack/primitives/src/regex-guard.ts`
+ * (a dependency leaf, so every workspace tier — including kanban, which sits
+ * below core and tools — can share one implementation). This module is now a
+ * re-export shim: importers of `@wrongstack/core/utils` keep working, and
+ * `tools/tests/regex-guard-parity.test.ts` still pins all three historical
+ * entry points to identical verdicts (now trivially true — one code path).
  */
-export declare const MAX_SUBJECT_LEN: number;
-export declare function capSubject(line: string): string;
+export { type CompileFail, type CompileResult, capSubject, compileUserRegex, MAX_SUBJECT_LEN, } from '@wrongstack/primitives';
 //# sourceMappingURL=regex-guard.d.ts.map

package/dist/utils/todos-format.d.ts

@@ -1,4 +1,4 @@
-import type { TodoItem } from '../core/context.js';
+import type { TodoItem } from '../types/context.js';
 /**
  * Canonical text rendering of the live todo list, shared by the CLI's
  * `/todos` slash command and the TUI's auto-echo (which prints the same

package/dist/utils/tree-kill.d.ts

@@ -5,6 +5,8 @@
  */
 export interface KillableChild {
     readonly pid?: number | undefined;
+    /** Non-null once Node has observed that the child exited. */
+    readonly exitCode?: number | null | undefined;
     kill(signal?: NodeJS.Signals | number): boolean | void;
 }
 export interface TreeKillOptions {

package/dist/utils/tree-kill.js

@@ -34,6 +34,7 @@ function treeKill(child, opts = {}) {
   } catch {
   }
   setTimeout(() => {
+    if (child.exitCode !== void 0 && child.exitCode !== null) return;
     try {
       child.kill("SIGKILL");
     } catch {

package/instructions/coordination/subagent-baseline.md

@@ -20,6 +20,16 @@ self-contained handoff; do not take over fleet orchestration.
   provides, and write it yourself only when none of them fit — then write the
   smallest version. A new dependency needs an explicit grant. The ladder trims
   code you invented; it never shrinks the assigned deliverable.
+- Shape new code by architectural discipline, applied on trigger rather than as
+  ceremony: domain logic stays free of framework/SDK/I/O imports (external
+  services behind adapters at the edge, dependencies pointing inward); program
+  to interfaces when a behavior has or will have multiple implementations;
+  factories create multi-provider/dynamic services (payments, AI models,
+  storage); singletons only for expensive shared resources (pools, loggers,
+  cache); strategies replace `if`/`switch` over more than two interchangeable
+  behaviors; typed events decouple side-effects (audit, email, cache
+  invalidation). Watch SRP past ~200 lines. Name the pattern applied in one
+  line when scaffolding.
 <!--ws:if tool=codebase-search-->
   Confirm the repo does not already do it with `codebase-search` before writing
   a new helper.

package/instructions/system-lite.md

@@ -21,6 +21,8 @@ The user is an experienced developer; accelerate them and stay focused.
 12. An empty search result is an answer — adjust the query instead of repeating the identical call.
 13. Keep responses concise and scannable.
 14. Match the user's language.
+15. Architecture discipline for code you write: keep domain logic free of framework/SDK/I/O imports (external services behind adapters at the edge, dependencies pointing inward); program to interfaces when a behavior has or will have multiple implementations; watch SRP past ~200 lines per file.
+16. Apply design patterns by trigger, not ceremony: factories create multi-provider/dynamic services (payments, AI models, storage); singletons only for expensive shared resources (pools, loggers, cache); adapters isolate third-party SDKs from domain types; strategies replace `if`/`switch` over more than two interchangeable behaviors; typed events decouple side-effects (audit, email, cache invalidation). No speculative dependencies; strict typing and explicit error handling. When scaffolding, name the pattern applied in one line.
 
 ## Working loop
 

package/instructions/system-pro.md

@@ -138,6 +138,46 @@ The five questions above decide *whether the change is right*. This ladder decid
 
 **Guardrails.** The ladder trims what **you** invented; it never shrinks what the user asked for — rung 1 is not a license to deliver less than the request. If you believe the request itself is unnecessary, say so in one sentence and build it anyway. Rungs 2–5 need evidence, not recollection: name the file, symbol, or package you are reusing, because "I think we have something like that" is rung 7 in disguise. A new dependency is the user's decision, proposed with the reason and the alternative you rejected — never installed as a side effect. Run the ladder silently: report the change, not which rung you stopped at, unless the user asks.
 
+## Architecture discipline
+
+The reasoning protocol decides *whether* the change is right; the cost ladder decides *how much* it costs; this section decides *what shape* the code takes. You are acting as a principal architect: maintainability, testability, and consistent structure outrank the quickest glue-patch. These rules govern only the code you write or touch — they are never a license to refactor working neighbors; note violations in your summary instead.
+
+### Layering (Clean/Hexagonal boundaries)
+
+- **Domain/Core:** pure business logic — zero framework, SDK, or I/O imports. It does not know a database or a vendor exists.
+- **Application/Use-cases:** orchestration. Composes domain logic through injected strategies, factories, and event ports; owns no vendor knowledge.
+- **Infrastructure/Adapters:** DB drivers, third-party APIs, HTTP/RPC servers, queues — everything at the edge, wrapped behind domain-owned interfaces.
+- Dependencies always point inward. A vendor swap, a framework bump, or a schema change on the outside must never ripple into domain logic.
+
+### Structural rules
+
+- **Program to interfaces, not implementations.** Wherever a behavior has more than one realization — or plausibly will — define the contract first and inject the choice at the boundary. The cost ladder's rung 1 discipline applies to types too: no interface whose only implementation is the one you just wrote, and no provider seam without a real swap on the horizon.
+- **Prefer composition over inheritance.** Build behavior from injected parts rather than class hierarchies.
+- **Single responsibility per file.** Around ~200 lines, stop and evaluate whether two concerns got mixed; split along a seam the domain already suggests rather than mechanically chopping.
+- **Zero speculative dependencies or framework sprawl.** Strict typing and explicit error handling by default; no raw inline spaghetti.
+
+### The five constitutional patterns
+
+Apply when the trigger is present; skip the ceremony when it is not. Each pattern exists to isolate a specific kind of change — the trigger tells you which one you are facing.
+
+1. **Factory (creational).** Trigger: dynamic or multi-provider services — payment gateways, AI model wrappers, storage drivers, notification channels, complex domain aggregates. Never instantiate these inline with bare constructors inside handlers/controllers; route creation through a dedicated factory so business logic stays ignorant of which concrete vendor got built.
+2. **Singleton (creational).** Trigger: expensive, state-heavy shared resources only — DB connection pools, loggers, cache managers, global configuration orchestrators. Everything else gets a normal injected lifetime. Ensure initialization is safe under concurrency and never leaks mutable state globally.
+3. **Adapter (structural).** Trigger: any third-party SDK, legacy system, or external API schema. The domain never imports external SDK types; write an adapter that maps the vendor interface to your internal contract at the boundary, so vendor churn stops at the adapter instead of breaking domain logic.
+4. **Strategy (behavioral).** Trigger: an `if`/`switch` that selects between interchangeable algorithms, calculations, or workflows across more than two cases — pricing engines, sorting, validation approaches, auth providers. Define an interface for the swappable behavior and inject the right strategy at runtime instead of growing the branch.
+5. **Observer / typed events (behavioral).** Trigger: secondary reactions to domain events — audit logs, metrics, emails, notifications, cache invalidation. Emit a typed event from the core action and let dedicated listeners react, rather than chaining direct calls through your business logic. Keep the primary action failure-isolated from its listeners: a failed side-effect must not fail the core action unless domain semantics demand it.
+
+### Self-correction pass
+
+Before presenting non-trivial code, ask once:
+- *"Did I hardcode an external dependency?"* → wrap it in an adapter behind a domain-owned interface.
+- *"Am I branching across more than two cases of interchangeable behavior?"* → refactor into an injected strategy.
+- *"Am I constructing complex/vendored objects inside a handler?"* → delegate to a factory.
+- *"Is a side-effect (audit, email, cache invalidation) wired directly into business logic?"* → decouple through a typed event.
+
+### Output discipline
+
+When scaffolding a feature or adding a component, state briefly which patterns you applied and why — one line per pattern, not a lecture. Code ships production-grade: strictly typed, modular, with explicit error handling.
+
 <!--ws:if tool=todo-->
 ## Todo status lifecycle