@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-KSJ5UTP7.js

@@ -0,0 +1,154 @@
+// src/types/session-markers.ts
+var SESSION_MARKER_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "mode_changed",
+  "compaction",
+  "checkpoint",
+  "skill_activated",
+  "skill_deactivated",
+  "agent_spawned",
+  "agent_stopped",
+  "agent_error",
+  "error",
+  "provider_retry",
+  "provider_error",
+  "message_truncated"
+]);
+var CHAT_MARKER_SOURCES = new Set(
+  [...SESSION_MARKER_EVENT_TYPES].filter((type) => type !== "checkpoint")
+);
+function sessionEventToMarker(ev) {
+  switch (ev.type) {
+    case "compaction": {
+      const before = (ev.before / 1e3).toFixed(0);
+      const after = (ev.after / 1e3).toFixed(0);
+      const level = ev.level ? ` (${ev.level})` : "";
+      const reductions = ev.reductions && ev.reductions.length > 0 ? ` [${ev.reductions.map((r) => `${r.phase}: \u2212${r.saved}`).join(", ")}]` : "";
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `\u27F2 context compacted${level}: ${before}K \u2192 ${after}K tokens${reductions}`
+      };
+    }
+    case "error":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "error",
+        text: ev.phase ? `[${ev.phase}] ${ev.message}` : ev.message
+      };
+    case "provider_retry": {
+      const secs = (ev.delayMs / 1e3).toFixed(ev.delayMs >= 1e3 ? 1 : 2);
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "warn",
+        text: ev.status ? `\u27F3 retry ${ev.attempt} (HTTP ${ev.status}) after ${secs}s \u2014 ${ev.description}` : `\u27F3 retry ${ev.attempt} after ${secs}s \u2014 ${ev.description}`
+      };
+    }
+    case "provider_error":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "error",
+        text: ev.status ? `provider error (HTTP ${ev.status}, ${ev.retryable ? "retryable" : "fatal"}): ${ev.description}` : `provider error (${ev.retryable ? "retryable" : "fatal"}): ${ev.description}`
+      };
+    case "checkpoint":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `\u2713 checkpoint #${ev.promptIndex}: "${ev.promptPreview.slice(0, 60)}"`
+      };
+    case "agent_spawned":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `spawned as ${ev.role}`,
+        agentId: ev.agentId
+      };
+    case "agent_stopped":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: "stopped",
+        agentId: ev.agentId
+      };
+    case "agent_error":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "error",
+        text: `error: ${ev.error.slice(0, 80)}`,
+        agentId: ev.agentId
+      };
+    case "mode_changed":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `mode: ${ev.from} \u2192 ${ev.to}`
+      };
+    case "skill_activated":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `skill activated: ${ev.skillName}`
+      };
+    case "skill_deactivated":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "info",
+        text: `skill deactivated: ${ev.skillName}`
+      };
+    case "message_truncated":
+      return {
+        ts: ev.ts,
+        source: ev.type,
+        level: "warn",
+        text: ev.after < ev.before ? `message truncated: ${ev.before} \u2192 ${ev.after} tokens` : `message truncated at ${ev.after} tokens`
+      };
+    default:
+      return null;
+  }
+}
+function projectSessionMarkers(events, sources = SESSION_MARKER_EVENT_TYPES) {
+  const markers = [];
+  for (const ev of events) {
+    if (!sources.has(ev.type)) continue;
+    const marker = sessionEventToMarker(ev);
+    if (marker) markers.push(marker);
+  }
+  return markers;
+}
+var SYSTEM_INJECTION_PREFIXES = [
+  "[MAILBOX]",
+  "[MAILBOX BTW]",
+  "[BY THE WAY \u2014",
+  "[QUEUED MESSAGES \u2014",
+  "[FLEET PULSE]",
+  "[loop-detector]",
+  "[SESSION RESUME FILE VALIDATION]",
+  "[SESSION RESUME INTERRUPTED WORK]"
+];
+function isSystemInjectedMessage(text) {
+  const trimmed = text.trimStart();
+  for (const prefix of SYSTEM_INJECTION_PREFIXES) {
+    if (trimmed.startsWith(prefix)) return true;
+  }
+  return false;
+}
+
+export {
+  SESSION_MARKER_EVENT_TYPES,
+  CHAT_MARKER_SOURCES,
+  sessionEventToMarker,
+  projectSessionMarkers,
+  SYSTEM_INJECTION_PREFIXES,
+  isSystemInjectedMessage
+};
+//# sourceMappingURL=chunk-KSJ5UTP7.js.map

package/dist/chunk-LHOA5DWA.js

@@ -0,0 +1,28 @@
+// src/utils/win32-cmd.ts
+var WIN32_CMD_META = /[&|<>"%\r\n\0]/;
+function buildWin32CmdShimInvocation(command, args = []) {
+  assertSafeWin32CmdArgs([command, ...args]);
+  const line = ["call", quoteWin32CmdArg(command), ...args.map(quoteWin32CmdArg)].join(" ");
+  return {
+    command: process.env["COMSPEC"] ?? "cmd.exe",
+    args: ["/d", "/c", line],
+    windowsVerbatimArguments: true
+  };
+}
+function assertSafeWin32CmdArgs(args) {
+  for (const arg of args) {
+    if (typeof arg === "string" && WIN32_CMD_META.test(arg)) {
+      throw new Error(
+        'win32 cmd shim spawn: argument contains a shell metacharacter (one of & | < > ", or a newline) that could enable command injection through the .cmd/.bat wrapper - refusing to run. Offending argument: ' + JSON.stringify(arg)
+      );
+    }
+  }
+}
+function quoteWin32CmdArg(arg) {
+  return `"${arg}"`;
+}
+
+export {
+  buildWin32CmdShimInvocation
+};
+//# sourceMappingURL=chunk-LHOA5DWA.js.map

package/dist/chunk-LX5QWLBL.js

@@ -0,0 +1,27 @@
+// src/utils/sqlite-warning.ts
+var SQLITE_EXPERIMENTAL_WARNING_RE = /sqlite is an experimental feature/i;
+function isSqliteExperimentalWarning(warning, rest) {
+  const message = typeof warning === "string" ? warning : warning instanceof Error ? warning.message : "";
+  const typeOrOptions = rest[0];
+  const warningType = typeof warning === "string" ? typeof typeOrOptions === "string" ? typeOrOptions : typeof typeOrOptions === "object" && typeOrOptions !== null && "type" in typeOrOptions && typeof typeOrOptions.type === "string" ? typeOrOptions.type : "" : warning instanceof Error ? warning.name : "";
+  const warningCode = typeof warning === "string" ? typeof typeOrOptions === "object" && typeOrOptions !== null && "code" in typeOrOptions && typeof typeOrOptions.code === "string" ? typeOrOptions.code : typeof rest[1] === "string" ? rest[1] : "" : warning instanceof Error && "code" in warning && typeof warning.code === "string" ? warning.code : "";
+  return SQLITE_EXPERIMENTAL_WARNING_RE.test(message) && (warningType === "ExperimentalWarning" || warningCode === "ExperimentalWarning");
+}
+function withSqliteExperimentalWarningSuppressed(run) {
+  const originalEmitWarning = process.emitWarning;
+  const forwardWarning = originalEmitWarning.bind(process);
+  process.emitWarning = ((warning, ...rest) => {
+    if (isSqliteExperimentalWarning(warning, rest)) return;
+    forwardWarning(warning, ...rest);
+  });
+  try {
+    return run();
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+
+export {
+  withSqliteExperimentalWarningSuppressed
+};
+//# sourceMappingURL=chunk-LX5QWLBL.js.map

package/dist/chunk-LZDDLNCZ.js

@@ -0,0 +1,279 @@
+import {
+  color
+} from "./chunk-4VWO3ZXL.js";
+import {
+  atomicWrite
+} from "./chunk-7ZHZE5EO.js";
+import {
+  resolveWstackPaths
+} from "./chunk-YNCVSFGF.js";
+import {
+  ERROR_CODES,
+  FsError
+} from "./chunk-WOEZV3Q4.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/storage/goal-store.ts
+import * as fsp from "node:fs/promises";
+var MAX_JOURNAL_ENTRIES = 500;
+function goalFilePath(projectRoot) {
+  return resolveWstackPaths({ projectRoot }).projectGoal;
+}
+async function loadGoal(filePath, events, warn) {
+  const t0 = Date.now();
+  let raw;
+  try {
+    raw = await fsp.readFile(filePath, "utf8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      events?.emit("storage.read", {
+        sessionId: "~boot~",
+        store: "goal",
+        filePath,
+        operation: "load",
+        outcome: "success",
+        durationMs: Date.now() - t0
+      });
+      return null;
+    }
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "load",
+      error: toErrorMessage(err),
+      recoverable: false
+    });
+    throw err;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || typeof parsed.goal !== "string" || !Array.isArray(parsed.journal)) {
+      (warn ?? ((msg) => console.warn(JSON.stringify({ level: "warn", event: "goal_store.invalid_schema", path: filePath, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(
+        "invalid schema \u2014 consider deleting and re-creating"
+      );
+      events?.emit("storage.read", {
+        sessionId: "~boot~",
+        store: "goal",
+        filePath,
+        operation: "load",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: "invalid_schema"
+      });
+      return null;
+    }
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "load",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
+    return parsed;
+  } catch {
+    (warn ?? ((msg) => console.warn(JSON.stringify({ level: "warn", event: "goal_store.parse_failed", path: filePath, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(
+      "JSON parse failed \u2014 consider deleting and re-creating"
+    );
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "load",
+      outcome: "failure",
+      durationMs: Date.now() - t0,
+      error: "parse_failed"
+    });
+    return null;
+  }
+}
+async function saveGoal(filePath, goal, events) {
+  const t0 = Date.now();
+  try {
+    await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+    events?.emit("storage.write", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "save",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
+  } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "save",
+      error: toErrorMessage(err),
+      recoverable: false
+    });
+    throw new FsError({
+      message: toErrorMessage(err),
+      code: ERROR_CODES.FS_ATOMIC_WRITE_FAILED,
+      path: filePath,
+      cause: err
+    });
+  }
+}
+function emptyGoal(goal) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 1,
+    goal,
+    setAt: now,
+    lastActivityAt: now,
+    iterations: 0,
+    engineState: "idle",
+    goalState: "active",
+    todoAttempts: {},
+    journal: []
+  };
+}
+function setProgress(goal, progress, note) {
+  const clamped = Math.min(100, Math.max(0, progress));
+  return {
+    ...goal,
+    progress: clamped,
+    progressNote: note ?? clamped + "% complete"
+  };
+}
+function appendJournal(goal, entry) {
+  const iteration = goal.iterations + 1;
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const full = { ...entry, iteration, at };
+  const journal = [...goal.journal, full];
+  const trimmed = journal.length > MAX_JOURNAL_ENTRIES ? journal.slice(journal.length - MAX_JOURNAL_ENTRIES) : journal;
+  return {
+    ...goal,
+    iterations: iteration,
+    lastActivityAt: at,
+    journal: trimmed
+  };
+}
+function summarizeUsage(goal) {
+  let totalCostUsd = 0;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let iterationsWithUsage = 0;
+  for (const e of goal.journal) {
+    if (typeof e.costUsd === "number") totalCostUsd += e.costUsd;
+    if (e.tokens) {
+      totalInputTokens += e.tokens.input;
+      totalOutputTokens += e.tokens.output;
+    }
+    if (typeof e.costUsd === "number" || e.tokens) iterationsWithUsage++;
+  }
+  return { totalCostUsd, totalInputTokens, totalOutputTokens, iterationsWithUsage };
+}
+var DOLLAR = "$";
+function formatGoal(goal, journalLimit = 10) {
+  const lines = [];
+  const displayGoal = goal.refinedGoal || goal.goal;
+  lines.push(color.bold("Goal") + ": " + displayGoal);
+  if (goal.refinedGoal && goal.refinedGoal !== goal.goal) {
+    const snippet = goal.goal.length > 60 ? goal.goal.slice(0, 60) + "\u2026" : goal.goal;
+    lines.push(color.dim('  (original: "' + snippet + '")'));
+  }
+  if (typeof goal.progress === "number") {
+    const pct = Math.min(100, Math.max(0, Math.round(goal.progress)));
+    const filled = Math.round(pct / 5);
+    const empty = 20 - filled;
+    const bar = color.green("\u2588".repeat(filled)) + color.dim("\u2591".repeat(empty));
+    lines.push("Progress: " + bar + " " + color.bold(pct + "%"));
+    if (goal.progressNote) {
+      lines.push("  " + color.dim(goal.progressNote));
+    }
+    if (goal.progressTrend) {
+      const trendIcon = goal.progressTrend === "accelerating" ? "\u{1F680}" : goal.progressTrend === "stalling" ? "\u26A0\uFE0F" : "\u27A1\uFE0F";
+      lines.push("  Trend: " + trendIcon + " " + goal.progressTrend);
+    }
+  }
+  if (goal.deliverables && goal.deliverables.length > 0) {
+    lines.push("");
+    lines.push(color.bold("Deliverables:"));
+    for (const d of goal.deliverables) {
+      const done = /^\[[x✓]\]|✅|\(done\)/i.test(d);
+      const marker = done ? color.green("\u2713") : color.dim("\u25CB");
+      lines.push("  " + marker + " " + d);
+    }
+  }
+  lines.push("");
+  lines.push("Set: " + goal.setAt);
+  lines.push("Last activity: " + goal.lastActivityAt);
+  lines.push("Iterations: " + goal.iterations);
+  const stateLabel = goal.goalState ?? "active";
+  lines.push("State: " + stateLabel + (goal.iterations > 0 ? " (iteration #" + goal.iterations + ")" : ""));
+  lines.push("Engine: " + goal.engineState);
+  const usage = summarizeUsage(goal);
+  if (usage.iterationsWithUsage > 0) {
+    const spent = "Spent: " + DOLLAR + usage.totalCostUsd.toFixed(4) + "  (in " + usage.totalInputTokens + " / out " + usage.totalOutputTokens + " tokens across " + usage.iterationsWithUsage + " iterations)";
+    lines.push(spent);
+  }
+  if (goal.journal.length > 0) {
+    lines.push("");
+    lines.push("Recent journal (last " + Math.min(journalLimit, goal.journal.length) + "):");
+    const tail = goal.journal.slice(-journalLimit);
+    for (const e of tail) {
+      const mark = e.status === "success" ? "\u2713" : e.status === "failure" ? "\u2717" : e.status === "aborted" ? "\u2298" : "\xB7";
+      const note = e.note ? " \u2014 " + e.note : "";
+      const cost = typeof e.costUsd === "number" ? " (" + DOLLAR + e.costUsd.toFixed(4) + ")" : "";
+      lines.push("  #" + e.iteration + " " + mark + " [" + e.source + "] " + e.task + cost + note);
+    }
+  }
+  return lines.join("\n");
+}
+function parseProgressFromText(text) {
+  const re = /\[progress:\s*(\d{1,3})%\]\s*(?:[—-]\s*(.+))?/i;
+  const m = text.match(re);
+  if (!m) return null;
+  const progress = Math.min(100, Math.max(0, Number.parseInt(m[1] ?? "0", 10)));
+  const note = m[2]?.trim() || void 0;
+  return note === void 0 ? { progress } : { progress, note };
+}
+function recordProgress(goal, progress, note) {
+  const clamped = Math.min(100, Math.max(0, progress));
+  const history = [...goal.progressHistory ?? [], { at: (/* @__PURE__ */ new Date()).toISOString(), progress: clamped, note }];
+  const trimmed = history.length > 200 ? history.slice(-200) : history;
+  return {
+    ...goal,
+    progress: clamped,
+    progressNote: note ?? `${clamped}% complete`,
+    progressHistory: trimmed,
+    progressTrend: computeTrend(trimmed)
+  };
+}
+var MAX_PROGRESS_HISTORY = 200;
+function computeTrend(history) {
+  if (history.length < 3) return void 0;
+  const recent = history.slice(-5);
+  const deltas = [];
+  for (let i = 1; i < recent.length; i++) {
+    deltas.push((recent[i]?.progress ?? 0) - (recent[i - 1]?.progress ?? 0));
+  }
+  if (deltas.length < 2) return void 0;
+  const avgDelta = deltas.reduce((a, b) => a + b, 0) / deltas.length;
+  if (avgDelta > 2) return "accelerating";
+  if (avgDelta < -1) return "stalling";
+  return "steady";
+}
+
+export {
+  MAX_JOURNAL_ENTRIES,
+  goalFilePath,
+  loadGoal,
+  saveGoal,
+  emptyGoal,
+  setProgress,
+  appendJournal,
+  summarizeUsage,
+  formatGoal,
+  parseProgressFromText,
+  recordProgress,
+  MAX_PROGRESS_HISTORY
+};
+//# sourceMappingURL=chunk-LZDDLNCZ.js.map

package/dist/chunk-M2WF6AXG.js

@@ -0,0 +1,115 @@
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+
+// src/utils/message-invariants.ts
+function repairToolUseAdjacency(messages) {
+  const removedToolUses = [];
+  const removedToolResults = [];
+  let removedMessages = 0;
+  let changed = false;
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const original = expectDefined(messages[i]);
+    let msg = original;
+    if (hasToolUse(msg)) {
+      const nextIds = toolResultIds(messages[i + 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_use" && !nextIds.has(block.id)) {
+            removedToolUses.push(block.id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (hasToolResult(msg)) {
+      const allowed = toolUseIds(out[out.length - 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
+            removedToolResults.push(block.tool_use_id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (isEmptyMessage(msg)) {
+      removedMessages++;
+      changed = true;
+      continue;
+    }
+    out.push(msg);
+  }
+  return {
+    messages: changed ? out : messages,
+    report: { changed, removedToolUses, removedToolResults, removedMessages }
+  };
+}
+function hasToolUse(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_use");
+}
+function hasToolResult(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_result");
+}
+function toolUseIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (msg?.role !== "assistant") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_use") ids.add(block.id);
+  }
+  return ids;
+}
+function toolResultIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (msg?.role !== "user") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_result") ids.add(block.tool_use_id);
+  }
+  return ids;
+}
+function contentBlocks(msg) {
+  return msg && Array.isArray(msg.content) ? msg.content : [];
+}
+function mapContent(msg, fn) {
+  if (!Array.isArray(msg.content)) return msg;
+  const next = fn(msg.content);
+  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
+    return msg;
+  }
+  return { ...msg, content: next };
+}
+function hasMeaningfulContent(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  for (const block of content) {
+    if (block.type === "text") {
+      if (block.text.trim().length > 0) return true;
+      continue;
+    }
+    if (block.type === "thinking") {
+      if (block.thinking.trim().length > 0 || block.signature) return true;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+function isEmptyMessage(msg) {
+  return !hasMeaningfulContent(msg.content);
+}
+
+export {
+  repairToolUseAdjacency,
+  hasMeaningfulContent
+};
+//# sourceMappingURL=chunk-M2WF6AXG.js.map

package/dist/chunk-M7BS2K6U.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-M7BS2K6U.js.map