@wrongstack/core 0.307.0 → 0.307.1

package/dist/core/index.js

@@ -6222,6 +6222,225 @@ function maybeAppendPendingNextSteps(ctx, res) {
   return { ...res, content };
 }
 
+// src/prompts/prompt-journal.ts
+import * as fs5 from "node:fs/promises";
+import * as path11 from "node:path";
+async function ensureGitignore(projectRoot) {
+  const gitignorePath = path11.join(projectRoot, ".gitignore");
+  try {
+    let content = "";
+    try {
+      content = await fs5.readFile(gitignorePath, "utf8");
+    } catch {
+      content = "";
+    }
+    if (!content.includes(".wrongstack") && !content.includes(".wrongstack/")) {
+      const addition = content.endsWith("\n") || content.length === 0 ? ".wrongstack/\n" : "\n.wrongstack/\n";
+      await fs5.writeFile(gitignorePath, content + addition, "utf8");
+    }
+  } catch {
+  }
+}
+function sessionFileId(sessionId) {
+  const leaf = sessionId.split(/[\\/]/u).pop();
+  return leaf && leaf.trim().length > 0 ? leaf : "general";
+}
+async function recordPromptJournalEntry(opts) {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString();
+  const dateStr = timestamp.slice(0, 10);
+  const monthStr = dateStr.slice(0, 7);
+  const sessionId = opts.sessionId && opts.sessionId.trim() ? opts.sessionId.trim() : "general";
+  const id = `pmt_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  const content = opts.content ?? "";
+  const lines = content.split("\n");
+  const characterCount = content.length;
+  const lineCount = lines.length;
+  const tokenEstimate = Math.ceil(characterCount / 4);
+  const entry = {
+    id,
+    timestamp,
+    sessionId,
+    projectRoot: opts.projectRoot,
+    role: opts.role ?? (opts.category === "system_prompt" ? "system" : "user"),
+    category: opts.category,
+    content,
+    rawContent: opts.rawContent,
+    metadata: {
+      model: opts.model,
+      provider: opts.provider,
+      iterationIndex: opts.iterationIndex,
+      tokenEstimate,
+      characterCount,
+      lineCount,
+      activeTools: opts.activeTools,
+      contextFiles: opts.contextFiles,
+      durationMs: opts.durationMs,
+      decisionReason: opts.decisionReason,
+      tags: opts.tags
+    }
+  };
+  const basePromptsDir = path11.join(opts.projectRoot, ".wrongstack", "prompts");
+  const dayDir = path11.join(basePromptsDir, monthStr, dateStr);
+  try {
+    await fs5.mkdir(dayDir, { recursive: true });
+    await ensureGitignore(opts.projectRoot);
+    const sessionJsonlFile = path11.join(dayDir, `session-${sessionFileId(sessionId)}.jsonl`);
+    await fs5.appendFile(sessionJsonlFile, JSON.stringify(entry) + "\n", "utf8");
+    const sessionMdFile = path11.join(dayDir, `session-${sessionFileId(sessionId)}.md`);
+    const mdSection = formatEntryMarkdown(entry);
+    await fs5.appendFile(sessionMdFile, mdSection, "utf8");
+    const dailySummaryFile = path11.join(dayDir, "daily-summary.md");
+    await updateDailySummary(dailySummaryFile, dateStr, entry);
+    await updateRootCatalog(basePromptsDir, monthStr, dateStr, sessionId, entry);
+  } catch (err) {
+    console.error?.(`Failed to write hierarchical prompt journal: ${err}`);
+  }
+  return entry;
+}
+function formatEntryMarkdown(entry) {
+  const tagList = [
+    `**Category:** \`${entry.category}\``,
+    `**Role:** \`${entry.role}\``,
+    entry.metadata.model ? `**Model:** \`${entry.metadata.model}\`` : null,
+    `**Tokens (est):** ~${entry.metadata.tokenEstimate}`,
+    entry.metadata.iterationIndex !== void 0 ? `**Iteration:** #${entry.metadata.iterationIndex}` : null,
+    `**Session:** \`${entry.sessionId}\``
+  ].filter(Boolean).join(" | ");
+  let md = `
+### \u{1F4DD} [${entry.timestamp}] \`${entry.id}\`
+${tagList}
+
+`;
+  if (entry.metadata.decisionReason) {
+    md += `> **Rationale:** ${entry.metadata.decisionReason}
+
+`;
+  }
+  if (entry.metadata.activeTools && entry.metadata.activeTools.length > 0) {
+    md += `*Active Tools:* \`${entry.metadata.activeTools.join("`, `")}\`
+
+`;
+  }
+  if (entry.rawContent && entry.rawContent !== entry.content) {
+    md += `**Raw Input:**
+\`\`\`text
+${entry.rawContent.trim()}
+\`\`\`
+
+`;
+    md += `**Refined / Injected Prompt:**
+\`\`\`text
+${entry.content.trim()}
+\`\`\`
+
+`;
+  } else {
+    md += `**Prompt Content:**
+\`\`\`text
+${entry.content.trim()}
+\`\`\`
+
+`;
+  }
+  md += `---
+`;
+  return md;
+}
+async function updateDailySummary(summaryFile, dateStr, entry) {
+  try {
+    let content = "";
+    try {
+      content = await fs5.readFile(summaryFile, "utf8");
+    } catch {
+      content = `# \u{1F4C5} Daily Prompt Summary \u2014 ${dateStr}
+
+| Time | ID | Session | Category | Model | Tokens | Rationale |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+`;
+    }
+    const time = entry.timestamp.slice(11, 19);
+    const model = entry.metadata.model ?? "-";
+    const reason = entry.metadata.decisionReason ? entry.metadata.decisionReason.slice(0, 40) : "-";
+    const row = `| ${time} | [\`${entry.id}\`](session-${sessionFileId(entry.sessionId)}.md) | \`${entry.sessionId}\` | \`${entry.category}\` | ${model} | ~${entry.metadata.tokenEstimate} | ${reason} |
+`;
+    await fs5.writeFile(summaryFile, content + row, "utf8");
+  } catch {
+  }
+}
+async function updateRootCatalog(baseDir, monthStr, dateStr, sessionId, entry) {
+  const indexJsonFile = path11.join(baseDir, "index.json");
+  const indexMdFile = path11.join(baseDir, "index.md");
+  let catalog;
+  try {
+    const raw = await fs5.readFile(indexJsonFile, "utf8");
+    catalog = JSON.parse(raw);
+  } catch {
+    catalog = {
+      updatedAt: entry.timestamp,
+      totalPrompts: 0,
+      totalTokensEstimated: 0,
+      months: {}
+    };
+  }
+  catalog.updatedAt = entry.timestamp;
+  catalog.totalPrompts += 1;
+  catalog.totalTokensEstimated += entry.metadata.tokenEstimate;
+  if (!catalog.months[monthStr]) {
+    catalog.months[monthStr] = { days: {} };
+  }
+  const monthData = catalog.months[monthStr];
+  if (!monthData.days[dateStr]) {
+    monthData.days[dateStr] = { sessions: {} };
+  }
+  const dayData = monthData.days[dateStr];
+  if (!dayData.sessions[sessionId]) {
+    dayData.sessions[sessionId] = {
+      promptCount: 0,
+      tokenEstimate: 0,
+      lastTimestamp: entry.timestamp,
+      categories: {}
+    };
+  }
+  const sessionData = dayData.sessions[sessionId];
+  sessionData.promptCount += 1;
+  sessionData.tokenEstimate += entry.metadata.tokenEstimate;
+  sessionData.lastTimestamp = entry.timestamp;
+  sessionData.categories[entry.category] = (sessionData.categories[entry.category] ?? 0) + 1;
+  try {
+    await fs5.writeFile(indexJsonFile, JSON.stringify(catalog, null, 2), "utf8");
+    let md = `# \u{1F5C2}\uFE0F Prompt Journal Navigation Index
+
+`;
+    md += `* **Total Prompts Logged:** ${catalog.totalPrompts}
+`;
+    md += `* **Total Tokens (est):** ~${catalog.totalTokensEstimated.toLocaleString()}
+`;
+    md += `* **Last Recorded Activity:** ${catalog.updatedAt}
+
+`;
+    md += `## \u{1F4C5} Recorded Dates & Sessions
+
+`;
+    md += `| Date | Session | Prompts | Tokens (est) | Daily Log | Session Log |
+`;
+    md += `| :--- | :--- | :--- | :--- | :--- | :--- |
+`;
+    for (const [m, mObj] of Object.entries(catalog.months).sort().reverse()) {
+      for (const [d, dObj] of Object.entries(mObj.days).sort().reverse()) {
+        for (const [sId, sData] of Object.entries(dObj.sessions)) {
+          const dailyLink = `[daily-summary.md](./${m}/${d}/daily-summary.md)`;
+          const sessionLink = `[session-${sessionFileId(sId)}.md](./${m}/${d}/session-${sessionFileId(sId)}.md)`;
+          md += `| **${d}** | \`${sId}\` | ${sData.promptCount} | ~${sData.tokenEstimate.toLocaleString()} | ${dailyLink} | ${sessionLink} |
+`;
+        }
+      }
+    }
+    await fs5.writeFile(indexMdFile, md, "utf8");
+  } catch {
+  }
+}
+
 // src/core/streaming-response-builder.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 
@@ -7037,6 +7256,36 @@ function providerBoundToRequest(request) {
 function toError(err) {
   return err instanceof Error ? err : new Error(String(err));
 }
+function recordSelfHealingRetry(a, err, reason) {
+  const projectRoot = a.ctx.projectRoot;
+  if (!projectRoot) return;
+  void recordPromptJournalEntry({
+    projectRoot,
+    sessionId: resolveEventSessionId(a.ctx),
+    category: "self_healing_retry",
+    content: toErrorMessage(err),
+    decisionReason: reason,
+    model: a.ctx.model,
+    provider: a.ctx.provider?.id,
+    activeTools: a.ctx.tools?.map((tool) => tool.name) ?? []
+  }).catch(() => {
+  });
+}
+function recordAutonomousContinue(a, text) {
+  const projectRoot = a.ctx.projectRoot;
+  if (!projectRoot) return;
+  void recordPromptJournalEntry({
+    projectRoot,
+    sessionId: resolveEventSessionId(a.ctx),
+    category: "autonomous_next_step",
+    content: text,
+    decisionReason: "text-marker autonomous continue",
+    model: a.ctx.model,
+    provider: a.ctx.provider?.id,
+    activeTools: a.ctx.tools?.map((tool) => tool.name) ?? []
+  }).catch(() => {
+  });
+}
 function signalAbortReason(signal) {
   const r = signal.reason;
   if (r instanceof Error) return r.message || r.name;
@@ -7327,6 +7576,7 @@ ${text}` : text;
               }
               if (extDecision.model) a.ctx.model = extDecision.model;
               a.logger.info("Extension requested retry; retrying turn");
+              recordSelfHealingRetry(a, err, "extension-requested provider retry");
               continue;
             }
           }
@@ -7356,6 +7606,7 @@ ${text}` : text;
             }
             if (recovered.model) a.ctx.model = recovered.model;
             a.logger.info(`Recovered provider error via ${recovered.reason}; retrying turn`);
+            recordSelfHealingRetry(a, err, recovered.reason);
             continue;
           }
           recoveryRetries = 0;
@@ -7415,6 +7666,7 @@ ${text}` : text;
             continue;
           }
           if (autonomousContinue && responseResult.directive === "continue") {
+            recordAutonomousContinue(a, finalText);
             await a.extensions.runAfterIteration(a.ctx, i);
             continue;
           }
@@ -7651,6 +7903,7 @@ var RUNTIME_CAPABILITY_MANIFEST = [
       "codebase-skeleton",
       "codebase-repo-map",
       "codebase-impact-analysis",
+      "codebase-invariant-check",
       "dead-code-scan",
       "diff",
       "json",
@@ -10535,8 +10788,8 @@ var InputBuilder = class {
   async registerFile(input) {
     const ref = await this.store.add({ ...input, kind: "file" });
     this.refs.push(ref);
-    const path15 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
-    return `[file:${path15}]`;
+    const path16 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
+    return `[file:${path16}]`;
   }
   /**
    * Whether `appendPaste(text)` would collapse the text to a placeholder
@@ -10583,8 +10836,8 @@ function paragraphLabel(text) {
 
 // src/core/instruction-bundle.ts
 import { statSync as statSync2 } from "node:fs";
-import * as fs5 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path12 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function loadInstructionBundle(paths) {
   let bundle = {};
@@ -10640,17 +10893,17 @@ function resolveSystemInstructionFile(paths) {
 }
 function sanitizeSystemInstructionFile(file) {
   const trimmed = file.trim();
-  if (trimmed.length === 0 || trimmed !== path11.basename(trimmed) || path11.extname(trimmed).toLowerCase() !== ".md") {
+  if (trimmed.length === 0 || trimmed !== path12.basename(trimmed) || path12.extname(trimmed).toLowerCase() !== ".md") {
     throw new Error(`Invalid system instruction file: ${file}`);
   }
   return trimmed;
 }
 async function readInstructionDir(dir, options) {
   const [json, identity, leaderAfterTask, sections] = await Promise.all([
-    readInstructionJson(path11.join(dir, "instructions.json")),
-    readOptionalText(path11.join(dir, options.systemFile)),
-    readOptionalText(path11.join(dir, "leader-after-task.md")),
-    readSections(path11.join(dir, "sections"))
+    readInstructionJson(path12.join(dir, "instructions.json")),
+    readOptionalText(path12.join(dir, options.systemFile)),
+    readOptionalText(path12.join(dir, "leader-after-task.md")),
+    readSections(path12.join(dir, "sections"))
   ]);
   const fromMarkdown = {
     system: {
@@ -10669,13 +10922,13 @@ async function readSections(root) {
 async function readSectionsInto(root, dir, out) {
   let entries;
   try {
-    entries = await fs5.readdir(dir, { withFileTypes: true });
+    entries = await fs6.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   await Promise.all(
     entries.map(async (entry) => {
-      const file = path11.join(dir, entry.name);
+      const file = path12.join(dir, entry.name);
       if (entry.isDirectory()) {
         await readSectionsInto(root, file, out);
         return;
@@ -10683,7 +10936,7 @@ async function readSectionsInto(root, dir, out) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) return;
       const text = await readOptionalText(file);
       if (text === void 0) return;
-      const rel = path11.relative(root, file).replace(/\\/g, "/").replace(/\.md$/i, "");
+      const rel = path12.relative(root, file).replace(/\\/g, "/").replace(/\.md$/i, "");
       const key = rel.split("/").join(".").replace(/-/g, ".");
       out[key] = text;
     })
@@ -10692,7 +10945,7 @@ async function readSectionsInto(root, dir, out) {
 async function readInstructionJson(file) {
   let raw;
   try {
-    raw = await fs5.readFile(file, "utf8");
+    raw = await fs6.readFile(file, "utf8");
   } catch {
     return {};
   }
@@ -10724,18 +10977,18 @@ function normalizeInstructionBundle(value) {
 }
 async function readOptionalText(file) {
   try {
-    const text = await fs5.readFile(file, "utf8");
+    const text = await fs6.readFile(file, "utf8");
     return text.trimEnd();
   } catch {
     return void 0;
   }
 }
 function defaultBundledInstructionDir() {
-  const here = path11.dirname(fileURLToPath2(import.meta.url));
+  const here = path12.dirname(fileURLToPath2(import.meta.url));
   return firstExistingDirSync([
-    path11.resolve(here, "../../instructions"),
-    path11.resolve(here, "../instructions"),
-    path11.resolve(here, "instructions")
+    path12.resolve(here, "../../instructions"),
+    path12.resolve(here, "../instructions"),
+    path12.resolve(here, "instructions")
   ]);
 }
 function definedPick(obj, keys) {
@@ -10789,13 +11042,13 @@ function flattenSystemPromptRegions(regions) {
 
 // src/core/modes/default.ts
 import { readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var PROMPT = readBundledInstructionFile("system.md");
 var LEADER_AFTER_TASK_PROMPT = readBundledInstructionFile("leader-after-task.md");
 function readBundledInstructionFile(name) {
   for (const dir of bundledInstructionDirCandidates()) {
-    const file = path12.join(dir, name);
+    const file = path13.join(dir, name);
     try {
       return readFileSync6(file, "utf8").trimEnd();
     } catch {
@@ -10804,12 +11057,12 @@ function readBundledInstructionFile(name) {
   return "";
 }
 function bundledInstructionDirCandidates() {
-  const here = path12.dirname(fileURLToPath3(import.meta.url));
+  const here = path13.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
-    path12.resolve(here, "../../../instructions"),
-    path12.resolve(here, "../../instructions"),
-    path12.resolve(here, "../instructions"),
-    path12.resolve(here, "instructions")
+    path13.resolve(here, "../../../instructions"),
+    path13.resolve(here, "../../instructions"),
+    path13.resolve(here, "../instructions"),
+    path13.resolve(here, "instructions")
   ];
   return candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
 }
@@ -10823,12 +11076,12 @@ function isDirectory(candidate) {
 
 // src/core/system-prompt-environment.ts
 import * as os3 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 
 // src/core/system-prompt-environment-probes.ts
 import { spawn as spawn2 } from "node:child_process";
-import * as fs6 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as fs7 from "node:fs/promises";
+import * as path14 from "node:path";
 
 // src/utils/child-env.ts
 var ALLOWED_KEYS = /* @__PURE__ */ new Set([
@@ -10969,7 +11222,7 @@ function buildChildEnv(optsOrSessionId) {
 // src/core/system-prompt-environment-probes.ts
 async function dirExists(p) {
   try {
-    const stat3 = await fs6.stat(p);
+    const stat3 = await fs7.stat(p);
     return stat3.isDirectory();
   } catch {
     return false;
@@ -11056,7 +11309,7 @@ async function detectLanguages(root) {
   const hits = await Promise.all(
     checks.map(async ([marker, lang]) => {
       try {
-        await fs6.access(path13.join(root, marker));
+        await fs7.access(path14.join(root, marker));
         return lang;
       } catch {
         return null;
@@ -11142,7 +11395,7 @@ async function buildEnvironment(ctx, env) {
   const effShell = effectiveShell(os3.platform(), process.env["WRONGSTACK_SHELL"]);
   const shell = effShell === "posix" ? process.env.SHELL ?? process.env.ComSpec ?? "unknown" : SHELL_DISPLAY[effShell];
   const node = process.version;
-  const isGit = await dirExists(path14.join(ctx.projectRoot, ".git"));
+  const isGit = await dirExists(path15.join(ctx.projectRoot, ".git"));
   const [git, langs] = await Promise.all([
     isGit ? gitStatus(ctx.projectRoot) : Promise.resolve("not a git repo"),
     detectLanguages(ctx.projectRoot)
@@ -11618,16 +11871,16 @@ ${skillBodyCache}`);
 }
 
 // src/core/system-prompt-plan.ts
-import * as fs7 from "node:fs/promises";
+import * as fs8 from "node:fs/promises";
 async function readActivePlanBlock(args) {
   const { planPath, cache } = args;
   if (!planPath) return { text: "", cache };
   try {
-    const stat3 = await fs7.stat(planPath);
+    const stat3 = await fs8.stat(planPath);
     if (cache && cache.path === planPath && cache.mtimeMs === stat3.mtimeMs) {
       return { text: cache.text, cache };
     }
-    const raw = await fs7.readFile(planPath, "utf8");
+    const raw = await fs8.readFile(planPath, "utf8");
     const text = formatActivePlan(raw);
     return { text, cache: { path: planPath, mtimeMs: stat3.mtimeMs, text } };
   } catch {

package/dist/defaults/index.js

@@ -1793,6 +1793,7 @@ var RUNTIME_CAPABILITY_MANIFEST = [
       "codebase-skeleton",
       "codebase-repo-map",
       "codebase-impact-analysis",
+      "codebase-invariant-check",
       "dead-code-scan",
       "diff",
       "json",
@@ -2718,13 +2719,50 @@ var HEAVY_BUDGET = {
   maxIterations: 8e3,
   maxToolCalls: 2e4
 };
+var INDEX_READ = [
+  "codebase-stats",
+  "codebase-search",
+  "codebase-skeleton",
+  "codebase-repo-map",
+  "codebase-incoming-calls",
+  "codebase-outgoing-calls"
+];
 var TOOLS = {
+  /** Index-backed code discovery. Spread onto code-facing presets, not browser. */
+  index: INDEX_READ,
   /** Pure read/inspect — safe for analysis and review agents. */
   read: ["read", "grep", "glob", "search", "tree", "mailbox"],
   /** Read + structured inspection (logs, diffs, json, dependency audit). */
-  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit", "mailbox"],
+  inspect: [
+    "read",
+    "grep",
+    "glob",
+    "search",
+    "tree",
+    ...INDEX_READ,
+    "json",
+    "diff",
+    "logs",
+    "audit",
+    "mailbox"
+  ],
   /** Read + edit (no shell). For agents that write code/docs but don't run it. */
-  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "mailbox"],
+  write: [
+    "read",
+    "grep",
+    "glob",
+    "search",
+    "tree",
+    ...INDEX_READ,
+    "codebase-impact-analysis",
+    "codebase-ast-replace",
+    "codebase-invariant-check",
+    "write",
+    "edit",
+    "replace",
+    "patch",
+    "mailbox"
+  ],
   /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
   build: [
     "read",
@@ -2732,6 +2770,11 @@ var TOOLS = {
     "glob",
     "search",
     "tree",
+    ...INDEX_READ,
+    "codebase-impact-analysis",
+    "codebase-ast-replace",
+    "codebase-invariant-check",
+    "codebase-targeted-test",
     "diff",
     "write",
     "edit",
@@ -2758,7 +2801,18 @@ var TOOLS = {
   /** Dependency management + CVE audit. */
   deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
   /** Documentation authoring. */
-  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document", "mailbox"],
+  docs: [
+    "read",
+    "grep",
+    "glob",
+    "search",
+    "tree",
+    ...INDEX_READ,
+    "write",
+    "edit",
+    "document",
+    "mailbox"
+  ],
   /** Web research. */
   research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
 };
@@ -2775,7 +2829,7 @@ var DISCOVERY_AGENTS = [
       id: "explore",
       name: "Explore",
       role: "explore",
-      tools: [...TOOLS.read],
+      tools: [...TOOLS.read, ...TOOLS.index],
       prompt: agentPrompt("explore")
     },
     budget: MEDIUM_BUDGET,
@@ -2803,7 +2857,7 @@ var DISCOVERY_AGENTS = [
       id: "search",
       name: "Search",
       role: "search",
-      tools: [...TOOLS.read, "codebase-search"],
+      tools: [...TOOLS.read, ...TOOLS.index],
       prompt: agentPrompt("search")
     },
     budget: MEDIUM_BUDGET,
@@ -2854,7 +2908,7 @@ var DISCOVERY_AGENTS = [
 ];
 
 // src/coordination/agents/phase2-planning.ts
-var PLAN_TOOLS = [...TOOLS.read, "plan", "todo"];
+var PLAN_TOOLS = [...TOOLS.read, ...TOOLS.index, "plan", "todo"];
 var PLANNING_AGENTS = [
   {
     config: {