@wrongstack/core 0.313.0 → 0.316.1

package/dist/utils/message-invariants.d.ts

@@ -9,6 +9,9 @@ export interface MessageRepairResult {
     messages: Message[];
     report: MessageRepairReport;
 }
+export interface MessageRepairOptions {
+    preserveTrailingToolUse?: boolean | undefined;
+}
 /**
  * Repair provider-level tool-call adjacency invariants.
  *
@@ -18,7 +21,7 @@ export interface MessageRepairResult {
  * exchange. This function removes only the now-orphaned protocol blocks,
  * preserving surrounding text/images/thinking blocks where possible.
  */
-export declare function repairToolUseAdjacency(messages: Message[]): MessageRepairResult;
+export declare function repairToolUseAdjacency(messages: Message[], opts?: MessageRepairOptions): MessageRepairResult;
 /**
  * True when a message content payload carries meaningful information for
  * the provider: non-whitespace text, a tool call/result, thinking with

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

@@ -8,5 +8,5 @@
  * `tools/tests/regex-guard-parity.test.ts` still pins all three historical
  * entry points to identical verdicts (now trivially true — one code path).
  */
-export { type CompileFail, type CompileResult, capSubject, compileUserRegex, MAX_SUBJECT_LEN, } from '@wrongstack/primitives';
+export { type CompileFail, type CompileResult, type CompileUserRegexResult, capSubject, compileUserRegex, MAX_SUBJECT_LEN, } from '@wrongstack/primitives';
 //# sourceMappingURL=regex-guard.d.ts.map

package/dist/utils/sage-output-block.js

@@ -1,45 +1,8 @@
-// src/utils/sage-output-block.ts
-var SAGE_INJECTOR_HEADINGS = /* @__PURE__ */ new Set([
-  "--- SAGE: task-aware project knowledge (Memory Injector) ---",
-  "--- SAGE: related project knowledge (Memory Injector) ---"
-]);
-var SAGE_MEMORY_LINE = /^- \[[^\]]+\](?:\[[^\]]+\])* <memory id="[^"]+">.*<\/memory>(?: .*)?$/;
-var SAGE_MEMORY_LINE_TRUNCATED = /^- \[[^\]]+\](?:\[[^\]]+\])* <memory id="[^"]+">.*…$/;
-function splitSageOutputBlock(output) {
-  if (!output.includes("--- SAGE: ")) return { body: output, sageLines: [] };
-  const lines = output.split("\n");
-  for (let sageIdx = lines.length - 1; sageIdx >= 0; sageIdx--) {
-    if (!SAGE_INJECTOR_HEADINGS.has(lines[sageIdx] ?? "")) continue;
-    const candidate = lines.slice(sageIdx);
-    if (candidate.length < 2) continue;
-    const memoryLines = candidate.slice(1).filter((line) => line.trim().length > 0);
-    if (memoryLines.length === 0) continue;
-    const bodyOk = memoryLines.every(
-      (line, index) => SAGE_MEMORY_LINE.test(line) || index === memoryLines.length - 1 && SAGE_MEMORY_LINE_TRUNCATED.test(line)
-    );
-    if (!bodyOk) continue;
-    let end = candidate.length;
-    while (end > 1 && candidate[end - 1].trim().length === 0) end--;
-    return {
-      body: lines.slice(0, sageIdx).join("\n").trimEnd(),
-      sageLines: candidate.slice(0, end)
-    };
-  }
-  return { body: output, sageLines: [] };
-}
-function capSageLines(sageLines, maxChars) {
-  if (sageLines.length < 2) return [];
-  const header = sageLines[0];
-  if (header.length >= maxChars) return [];
-  const out = [header];
-  let used = header.length;
-  for (const line of sageLines.slice(1)) {
-    if (used + 1 + line.length > maxChars) break;
-    out.push(line);
-    used += 1 + line.length;
-  }
-  return out.length > 1 ? out : [];
-}
+import {
+  SAGE_INJECTOR_HEADINGS,
+  capSageLines,
+  splitSageOutputBlock
+} from "../chunk-SVT4RNTR.js";
 export {
   SAGE_INJECTOR_HEADINGS,
   capSageLines,

package/dist/utils/socket-path.d.ts

@@ -4,5 +4,5 @@
  * share one implementation with packages that depend on persistence directly
  * (kanban). See `packages/persistence/src/socket-path.ts` for rationale.
  */
-export { assertUnixSocketPathWithinLimit, checkUnixSocketPath, type UnixSocketPathCheck, unixSocketPathLimit, } from '@wrongstack/persistence';
+export { assertUnixSocketPathWithinLimit, checkUnixSocketPath, unixSocketPathLimit } from '@wrongstack/persistence';
 //# sourceMappingURL=socket-path.d.ts.map

package/dist/utils/token-estimate.d.ts

@@ -1,12 +1,16 @@
 import type { Message } from '../types/messages.js';
 /**
  * Estimate tokens for a tool_use block input.
- * Caches the stringified result keyed by the stable string representation
- * to avoid repeated JSON.stringify calls during context window checks.
+ *
+ * Memoized on the input object, so the repeated context-window checks and
+ * breakdown re-runs that walk the same history serialize each payload once.
  */
 export declare function estimateToolInputTokens(input: unknown): number;
 /**
  * Estimate tokens for a tool_result content.
+ *
+ * Same memo as {@link estimateToolInputTokens}; non-object contents (null,
+ * numbers) are cheap enough to stringify outright and cannot key a WeakMap.
  */
 export declare function estimateToolResultTokens(content: string | unknown): number;
 /**

package/dist/utils/wstack-paths.d.ts

@@ -41,6 +41,8 @@ export interface WstackPaths {
     profileModeConfig: (name: string) => string;
     /** Resolve ~/.wrongstack/profiles/<name>/provider-status.json */
     profileProviderStatus: (name: string) => string;
+    /** Resolve ~/.wrongstack/profiles/<name>/provider-status-audit.jsonl */
+    profileProviderAudit: (name: string) => string;
     /** Resolve ~/.wrongstack/profiles/<name>/update-cache.json */
     profileUpdateCache: (name: string) => string;
     /** ~/.wrongstack/.key — 32 random bytes, mode 0600, AES-GCM key for the secret vault. */

package/dist/wiring/proxy-rewrite.d.ts

@@ -54,6 +54,34 @@ export interface ProxyConfig {
     /** Last-known reachability state from the periodic probe. */
     active: boolean;
 }
+/**
+ * Minimal structural logger for probe transitions. Deliberately not core's
+ * full `Logger` so any host (CLI logger, subcommand, test stub) can pass a
+ * plain object.
+ */
+export interface ProxyTransitionLogger {
+    info(message: string): void;
+    warn(message: string): void;
+}
+/**
+ * Install (or replace) the probe's transition logger. Affects the running
+ * probe immediately (the flip path reads this variable at log time).
+ * Passing undefined silences transition logging again.
+ */
+export declare function setProxyTransitionLogger(logger: ProxyTransitionLogger | undefined): void;
+/**
+ * Redact a URL for logging: keep scheme://host[:port]/path, drop query and
+ * fragment. Provider/proxy URLs may embed credentials there (`?key=...`);
+ * a log line must never persist them.
+ */
+export declare function sanitizeUrlForLog(raw: string | undefined): string;
+/**
+ * Emit one probe-transition line. Called ONLY when `active` actually flips
+ * (never on verdict-identical probes) — every flip is a routing change for
+ * every subsequent provider build. Fully isolated: a throwing logger must
+ * never alter probe control flow.
+ */
+export declare function logProxyTransition(next: boolean, reason: string): void;
 /** Read the current proxy configuration. Safe to call from any layer. */
 export declare function getProxyConfig(): ProxyConfig;
 /**
@@ -83,12 +111,30 @@ export declare function applyProxyConfig(next: Partial<ProxyConfig>): ProxyConfi
  * excluded" rule so future call sites can't accidentally skip a check.
  */
 export declare function shouldRewriteFor(providerId: string): boolean;
+/**
+ * Automatically deactivate the proxy if a connection failure occurs while
+ * the proxy was marked active. Triggers instant-apply provider rebuilds to
+ * fallback immediately to direct provider communication without failing the turn.
+ */
+export declare function deactivateProxyOnConnectionFailure(err: unknown): boolean;
 /**
  * Reset to defaults. Intended for tests; do NOT call from production code
  * (the singleton lives for the lifetime of the process). Also drops all
  * change listeners so tests never observe each other's notifications.
  */
 export declare function __resetProxyConfigForTests(): void;
+/** Upper bound for {@link waitForProxyRoutingSettle}. Local provider builds
+ *  settle in single-digit milliseconds; anything slower means the host is
+ *  doing network work inside rebuildProvider, and a retrying turn must not
+ *  hang on it. Resolves on timeout — the barrier delays, never fails. */
+export declare const PROXY_ROUTING_SETTLE_CAP_MS = 2000;
+/**
+ * Wait until every registered instant-apply rebuild triggered by the current
+ * proxy-config change has settled, the cap elapses, or `signal` aborts.
+ * Resolves in all three cases — a settle timeout must not fail the turn,
+ * only stop delaying it.
+ */
+export declare function waitForProxyRoutingSettle(timeoutMs?: number, signal?: AbortSignal | undefined): Promise<void>;
 /** Minimal structural logger — keeps this module dependency-free. */
 export interface ProxyInstantApplyLogger {
     info: (message: string) => void;

package/dist/wiring/proxy-rewrite.js

@@ -1,132 +1,35 @@
-// src/wiring/proxy-rewrite.ts
-var PROXY_PATH_PREFIX = "/proxy/";
-var PROXY_EXCLUDED_PROVIDERS = /* @__PURE__ */ new Set(["openai-codex"]);
-function isProxyEligible(providerId) {
-  if (!providerId) return false;
-  if (PROXY_EXCLUDED_PROVIDERS.has(providerId)) return false;
-  return true;
-}
-function rewriteBaseUrl(originalBaseUrl, proxyUrl) {
-  if (!originalBaseUrl) return void 0;
-  if (!proxyUrl) return originalBaseUrl;
-  if (!isProxyEligibleForRewrite(originalBaseUrl, proxyUrl)) return originalBaseUrl;
-  return composeRewrittenUrl(originalBaseUrl, proxyUrl);
-}
-function isProxyEligibleForRewrite(originalBaseUrl, proxyUrl) {
-  if (!originalBaseUrl.includes("://")) return false;
-  if (!proxyUrl.includes("://")) return false;
-  const normalizedProxy = proxyUrl.replace(/\/+$/, "");
-  if (originalBaseUrl.startsWith(`${normalizedProxy}${PROXY_PATH_PREFIX}`)) {
-    return false;
-  }
-  try {
-    const parsed = new URL(originalBaseUrl);
-    const isLoopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || // WHATWG URL serializes IPv6 hosts with brackets — `[::1]`, not `::1`.
-    parsed.hostname === "[::1]";
-    if (isLoopback && parsed.port !== "") return false;
-  } catch {
-  }
-  return true;
-}
-function composeRewrittenUrl(originalBaseUrl, proxyUrl) {
-  const parsedOriginal = new URL(originalBaseUrl);
-  const hostAndPath = `${parsedOriginal.host}${parsedOriginal.pathname}`;
-  const trailingQuery = parsedOriginal.search || "";
-  const trailingHash = parsedOriginal.hash || "";
-  const proxyRoot = proxyUrl.replace(/\/+$/, "");
-  return `${proxyRoot}${PROXY_PATH_PREFIX}${hostAndPath}${trailingQuery}${trailingHash}`;
-}
-var DEFAULT_PROXY_CONFIG = { enabled: false, url: "", active: false };
-var currentConfig = { ...DEFAULT_PROXY_CONFIG };
-function getProxyConfig() {
-  return currentConfig;
-}
-var listeners = /* @__PURE__ */ new Set();
-function subscribeToProxyConfig(listener) {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-function applyProxyConfig(next) {
-  const previous = currentConfig;
-  currentConfig = {
-    enabled: next.enabled ?? previous.enabled,
-    url: next.url ?? previous.url,
-    active: next.active ?? previous.active
-  };
-  const materialChange = currentConfig.enabled !== previous.enabled || currentConfig.url !== previous.url || currentConfig.active !== previous.active;
-  if (materialChange) {
-    for (const listener of listeners) {
-      try {
-        listener(currentConfig, previous);
-      } catch {
-      }
-    }
-  }
-  return previous;
-}
-function shouldRewriteFor(providerId) {
-  const cfg = currentConfig;
-  if (!cfg.enabled || !cfg.active || !cfg.url) return false;
-  return isProxyEligible(providerId);
-}
-function __resetProxyConfigForTests() {
-  currentConfig = { ...DEFAULT_PROXY_CONFIG };
-  listeners.clear();
-}
-function effectiveBaseUrlFor(cfg, providerId, rawBaseUrl) {
-  if (!rawBaseUrl) return void 0;
-  const active = cfg.enabled && cfg.active && !!cfg.url && isProxyEligible(providerId);
-  return active ? rewriteBaseUrl(rawBaseUrl, cfg.url) : rawBaseUrl;
-}
-function effectiveBaseUrl(providerId, rawBaseUrl) {
-  return effectiveBaseUrlFor(currentConfig, providerId, rawBaseUrl);
-}
-function createProxyInstantApply(deps) {
-  const { getActiveProviderId, getRawBaseUrl, rebuildProvider, logger } = deps;
-  let lastProviderId = getActiveProviderId();
-  let lastEffectiveUrl = effectiveBaseUrl(lastProviderId, getRawBaseUrl(lastProviderId));
-  let disposed = false;
-  let rebuildChain = Promise.resolve();
-  const unsubscribe = subscribeToProxyConfig((next, previous) => {
-    if (disposed) return;
-    const providerId = getActiveProviderId();
-    const raw = getRawBaseUrl(providerId);
-    const nextUrl = effectiveBaseUrlFor(next, providerId, raw);
-    const baselineUrl = providerId === lastProviderId ? lastEffectiveUrl : effectiveBaseUrlFor(previous, providerId, raw);
-    lastProviderId = providerId;
-    lastEffectiveUrl = nextUrl;
-    if (nextUrl === baselineUrl) return;
-    rebuildChain = rebuildChain.then(() => rebuildProvider(providerId)).then(() => {
-      if (!disposed) {
-        logger.info(`WrongProxy routing changed \u2014 live provider rebuilt (${providerId})`);
-      }
-    }).catch((err) => {
-      if (!disposed) {
-        logger.warn(
-          `WrongProxy instant-apply: provider rebuild failed for ${providerId}: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    });
-  });
-  return {
-    dispose() {
-      if (disposed) return;
-      disposed = true;
-      unsubscribe();
-    }
-  };
-}
+import {
+  PROXY_EXCLUDED_PROVIDERS,
+  PROXY_ROUTING_SETTLE_CAP_MS,
+  __resetProxyConfigForTests,
+  applyProxyConfig,
+  createProxyInstantApply,
+  deactivateProxyOnConnectionFailure,
+  getProxyConfig,
+  isProxyEligible,
+  logProxyTransition,
+  rewriteBaseUrl,
+  sanitizeUrlForLog,
+  setProxyTransitionLogger,
+  shouldRewriteFor,
+  subscribeToProxyConfig,
+  waitForProxyRoutingSettle
+} from "../chunk-4SJNS7OB.js";
 export {
   PROXY_EXCLUDED_PROVIDERS,
+  PROXY_ROUTING_SETTLE_CAP_MS,
   __resetProxyConfigForTests,
   applyProxyConfig,
   createProxyInstantApply,
+  deactivateProxyOnConnectionFailure,
   getProxyConfig,
   isProxyEligible,
+  logProxyTransition,
   rewriteBaseUrl,
+  sanitizeUrlForLog,
+  setProxyTransitionLogger,
   shouldRewriteFor,
-  subscribeToProxyConfig
+  subscribeToProxyConfig,
+  waitForProxyRoutingSettle
 };
 //# sourceMappingURL=proxy-rewrite.js.map