@wrongstack/core 0.307.0 → 0.307.1

package/dist/prompts/index.d.ts

@@ -1,4 +1,4 @@
 export { type JsonFetcher, PromptInstaller, type PromptInstallerOptions, type PromptPullResult, } from './prompt-installer.js';
 export { PromptManifestStore } from './prompt-manifest-store.js';
-export { ensureGitignore, getPromptJournalEntries, recordPromptJournalEntry, type PromptCategory, type PromptJournalEntry, type PromptJournalFilter, type RecordPromptOptions, } from './prompt-journal.js';
+export { ensureGitignore, getPromptJournalEntries, PROMPT_JOURNAL_RAW_MARKER, recordPromptJournalEntry, type PromptCategory, type PromptJournalEntry, type PromptJournalFilter, type RecordPromptOptions, } from './prompt-journal.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/prompts/index.js

@@ -0,0 +1,601 @@
+// src/types/prompt-registry.ts
+var SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var CHECKSUM_RE = /^[a-f0-9]{64}$/;
+var MAX_STR = 4096;
+function validateRegistryManifest(raw) {
+  const errors = [];
+  if (!raw || typeof raw !== "object") return { ok: false, errors: ["manifest is not an object"] };
+  const m = raw;
+  if (m["registryVersion"] !== 1) errors.push("registryVersion must be 1");
+  if (typeof m["source"] !== "string" || !m["source"])
+    errors.push("source must be a non-empty string");
+  if (typeof m["generatedAt"] !== "string") errors.push("generatedAt must be a string");
+  if (!Array.isArray(m["prompts"])) {
+    errors.push("prompts must be an array");
+    return { ok: false, errors };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const refs = [];
+  m["prompts"].forEach((p, i) => {
+    if (!p || typeof p !== "object") {
+      errors.push(`prompts[${i}] is not an object`);
+      return;
+    }
+    const r = p;
+    const slug = r["slug"];
+    if (typeof slug !== "string" || !SLUG_RE.test(slug)) {
+      errors.push(`prompts[${i}].slug invalid (must be kebab-case)`);
+      return;
+    }
+    if (seen.has(slug)) {
+      errors.push(`prompts[${i}].slug "${slug}" duplicated`);
+      return;
+    }
+    seen.add(slug);
+    if (typeof r["checksum"] !== "string" || !CHECKSUM_RE.test(r["checksum"])) {
+      errors.push(`prompts[${i}].checksum must be a 64-char sha256 hex`);
+      return;
+    }
+    for (const field of ["id", "title", "description", "category"]) {
+      const v = r[field];
+      if (typeof v !== "string" || v.length === 0 || v.length > MAX_STR) {
+        errors.push(`prompts[${i}].${field} must be a non-empty string under ${MAX_STR} chars`);
+        return;
+      }
+    }
+    const tags = Array.isArray(r["tags"]) ? r["tags"].filter((t) => typeof t === "string") : [];
+    refs.push({
+      id: r["id"],
+      slug,
+      title: r["title"],
+      description: r["description"],
+      category: r["category"],
+      tags,
+      checksum: r["checksum"],
+      version: typeof r["version"] === "string" ? r["version"] : void 0,
+      license: typeof r["license"] === "string" ? r["license"] : void 0,
+      url: typeof r["url"] === "string" ? r["url"] : void 0
+    });
+  });
+  if (errors.length > 0) return { ok: false, errors };
+  return {
+    ok: true,
+    manifest: {
+      registryVersion: 1,
+      source: m["source"],
+      generatedAt: m["generatedAt"],
+      prompts: refs
+    }
+  };
+}
+function diffRegistry(local, manifest) {
+  const localBySlug = new Map(local.map((e) => [e.slug, e.checksum]));
+  const diff = { added: [], updated: [], unchanged: [] };
+  for (const ref of manifest.prompts) {
+    if (!localBySlug.has(ref.slug)) diff.added.push(ref);
+    else if (localBySlug.get(ref.slug) !== ref.checksum) diff.updated.push(ref);
+    else diff.unchanged.push(ref);
+  }
+  return diff;
+}
+
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
+  // Tool
+  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
+  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
+  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
+  TOOL_TIMEOUT: "TOOL_TIMEOUT",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  // Config
+  CONFIG_INVALID: "CONFIG_INVALID",
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
+  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
+  // Plugin
+  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
+  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
+  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // Session
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_CORRUPTED: "SESSION_CORRUPTED",
+  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
+  // Container / Registry
+  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
+  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
+  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
+  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  REGISTRY_INVALID: "REGISTRY_INVALID",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_WRITE_FAILED: "FS_WRITE_FAILED",
+  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
+  FS_DELETE_FAILED: "FS_DELETE_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
+  // SDD (Spec-Driven Development)
+  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
+  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
+  SDD_INVALID_STATE: "SDD_INVALID_STATE",
+  SDD_NOT_READY: "SDD_NOT_READY",
+  // General
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  PARSE_FAILED: "PARSE_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var FsError = class extends WrongStackError {
+  path;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "fs",
+      severity: "error",
+      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
+      context: { path: opts.path, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FsError";
+    this.path = opts.path;
+  }
+};
+var FetchError = class extends WrongStackError {
+  status;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general",
+      severity: "error",
+      recoverable: opts.status === 429 || opts.status >= 500,
+      context: { status: opts.status, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FetchError";
+    this.status = opts.status;
+  }
+};
+var ParseError = class extends WrongStackError {
+  source;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.PARSE_FAILED,
+      subsystem: "general",
+      severity: "error",
+      recoverable: false,
+      context: { source: opts.source, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "ParseError";
+    this.source = opts.source;
+  }
+};
+
+// src/prompts/prompt-installer.ts
+var defaultFetcher = async (url) => {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new FetchError({
+      message: `registry fetch failed: ${res.status} ${res.statusText}`,
+      status: res.status,
+      context: { op: "fetchManifest" }
+    });
+  }
+  return res.json();
+};
+var PromptInstaller = class {
+  fetcher;
+  constructor(opts = {}) {
+    this.fetcher = opts.fetcher ?? defaultFetcher;
+  }
+  /**
+   * Fetch + validate a manifest and report what a sync WOULD change. Read-only.
+   * @param manifestUrl URL to the registry's `registry.json`.
+   * @param local       The prompts the caller already has (slug + checksum).
+   */
+  async pull(manifestUrl, local) {
+    const raw = await this.fetcher(manifestUrl);
+    const validated = validateRegistryManifest(raw);
+    if (!validated.ok) {
+      throw new ParseError({
+        message: `Invalid prompt registry manifest:
+  - ${validated.errors.join("\n  - ")}`,
+        source: "prompt-registry-manifest"
+      });
+    }
+    const diff = diffRegistry(local, validated.manifest);
+    return { manifest: validated.manifest, diff, dryRun: true };
+  }
+  /**
+   * EXTENSION POINT (not yet wired): download the prompt bodies for the given
+   * registry refs and write them into the user layer as `source:'synced'`,
+   * recording each in the installed-prompts manifest. Intentionally unimplemented
+   * — pulling real content over the network is gated behind a future change so
+   * the format/diff path can ship and be reviewed first.
+   */
+  async install() {
+    throw new Error(
+      "Prompt sync is not implemented yet. `pull()` reports the diff; installing remote prompt bodies will land in a follow-up."
+    );
+  }
+};
+
+// src/prompts/prompt-manifest-store.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+// src/utils/atomic-write.ts
+import {
+  createPersistencePrimitives
+} from "@wrongstack/persistence";
+var primitives = createPersistencePrimitives({
+  createLockTimeoutError: ({ targetPath, timeoutMs }) => new FsError({
+    message: `Timed out waiting for file lock: ${targetPath}`,
+    code: "FS_ATOMIC_WRITE_FAILED",
+    path: targetPath,
+    context: { timeoutMs }
+  })
+});
+var atomicWrite = primitives.atomicWrite;
+var atomicReplaceWithWriter = primitives.atomicReplaceWithWriter;
+var ensureDir = primitives.ensureDir;
+var withFileLock = primitives.withFileLock;
+
+// src/prompts/prompt-manifest-store.ts
+var PromptManifestStore = class {
+  constructor(manifestPath) {
+    this.manifestPath = manifestPath;
+  }
+  manifestPath;
+  async load() {
+    try {
+      const raw = JSON.parse(await fs.readFile(this.manifestPath, "utf8"));
+      if (raw && typeof raw === "object" && Array.isArray(raw.entries)) {
+        return { version: 1, entries: raw.entries };
+      }
+    } catch {
+    }
+    return { version: 1, entries: [] };
+  }
+  async save(data) {
+    await ensureDir(path.dirname(this.manifestPath));
+    await atomicWrite(this.manifestPath, JSON.stringify(data, null, 2));
+  }
+  /** Upsert one entry keyed by slug. */
+  async record(entry) {
+    const data = await this.load();
+    const idx = data.entries.findIndex((e) => e.slug === entry.slug);
+    if (idx === -1) data.entries.push(entry);
+    else data.entries[idx] = entry;
+    await this.save(data);
+  }
+  async remove(slug) {
+    const data = await this.load();
+    const next = data.entries.filter((e) => e.slug !== slug);
+    if (next.length === data.entries.length) return false;
+    await this.save({ version: 1, entries: next });
+    return true;
+  }
+  async list() {
+    return (await this.load()).entries;
+  }
+};
+
+// src/prompts/prompt-journal.ts
+import * as fs2 from "node:fs/promises";
+import * as path2 from "node:path";
+var PROMPT_JOURNAL_RAW_MARKER = "promptJournal.raw";
+async function ensureGitignore(projectRoot) {
+  const gitignorePath = path2.join(projectRoot, ".gitignore");
+  try {
+    let content = "";
+    try {
+      content = await fs2.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 fs2.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 = path2.join(opts.projectRoot, ".wrongstack", "prompts");
+  const dayDir = path2.join(basePromptsDir, monthStr, dateStr);
+  try {
+    await fs2.mkdir(dayDir, { recursive: true });
+    await ensureGitignore(opts.projectRoot);
+    const sessionJsonlFile = path2.join(dayDir, `session-${sessionFileId(sessionId)}.jsonl`);
+    await fs2.appendFile(sessionJsonlFile, JSON.stringify(entry) + "\n", "utf8");
+    const sessionMdFile = path2.join(dayDir, `session-${sessionFileId(sessionId)}.md`);
+    const mdSection = formatEntryMarkdown(entry);
+    await fs2.appendFile(sessionMdFile, mdSection, "utf8");
+    const dailySummaryFile = path2.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 fs2.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 fs2.writeFile(summaryFile, content + row, "utf8");
+  } catch {
+  }
+}
+async function updateRootCatalog(baseDir, monthStr, dateStr, sessionId, entry) {
+  const indexJsonFile = path2.join(baseDir, "index.json");
+  const indexMdFile = path2.join(baseDir, "index.md");
+  let catalog;
+  try {
+    const raw = await fs2.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 fs2.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 fs2.writeFile(indexMdFile, md, "utf8");
+  } catch {
+  }
+}
+async function getPromptJournalEntries(projectRoot, filter = {}) {
+  const basePromptsDir = path2.join(projectRoot, ".wrongstack", "prompts");
+  const results = [];
+  try {
+    const months = await fs2.readdir(basePromptsDir);
+    for (const month of months) {
+      if (!/^\d{4}-\d{2}$/.test(month)) continue;
+      if (filter.month && filter.month !== month) continue;
+      const monthDir = path2.join(basePromptsDir, month);
+      const days = await fs2.readdir(monthDir);
+      for (const day of days) {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) continue;
+        if (filter.date && filter.date !== day) continue;
+        const dayDir = path2.join(monthDir, day);
+        const files = await fs2.readdir(dayDir);
+        const jsonlFiles = files.filter((f) => f.startsWith("session-") && f.endsWith(".jsonl"));
+        for (const jsonlFile of jsonlFiles) {
+          const sessionMatch = jsonlFile.match(/^session-(.+)\.jsonl$/);
+          const sId = sessionMatch ? sessionMatch[1] : void 0;
+          if (filter.sessionId && sId !== sessionFileId(filter.sessionId)) continue;
+          const filePath = path2.join(dayDir, jsonlFile);
+          const content = await fs2.readFile(filePath, "utf8");
+          const lines = content.split("\n");
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const entry = JSON.parse(line);
+              if (filter.sessionId && sessionFileId(entry.sessionId) !== sessionFileId(filter.sessionId)) {
+                continue;
+              }
+              if (filter.category && entry.category !== filter.category) continue;
+              if (filter.since && entry.timestamp < filter.since) continue;
+              results.push(entry);
+            } catch {
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  results.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  if (filter.limit && results.length > filter.limit) {
+    return results.slice(-filter.limit);
+  }
+  return results;
+}
+export {
+  PROMPT_JOURNAL_RAW_MARKER,
+  PromptInstaller,
+  PromptManifestStore,
+  ensureGitignore,
+  getPromptJournalEntries,
+  recordPromptJournalEntry
+};
+//# sourceMappingURL=index.js.map

package/dist/prompts/prompt-journal.d.ts

@@ -78,6 +78,15 @@ export interface PromptJournalIndex {
         }>;
     }>;
 }
+/**
+ * `ctx.meta` key the TUI's submit path stamps with the raw (pre-refinement)
+ * user prompt text when the refiner rewrote the prompt. The CLI's
+ * prompt-journal recorder consumes the marker to label the turn
+ * `refined_user` (with `rawContent` preserved) instead of `raw_user`.
+ *
+ * Shared here so the two sides (TUI stamp, CLI consumer) cannot drift.
+ */
+export declare const PROMPT_JOURNAL_RAW_MARKER = "promptJournal.raw";
 /**
  * Ensures `<projectRoot>/.gitignore` contains `.wrongstack/` to keep all
  * prompt logs, telemetry, and indexes out of version control.

package/dist/storage/queue-store.d.ts

@@ -11,6 +11,12 @@ export interface PersistedQueueItem {
     blocks: ContentBlock[];
     /** When true, the item will be refined via model.refine before entering the agent context. */
     shouldRefine?: boolean | undefined;
+    /**
+     * Raw (pre-refinement) user text for prompt-journal provenance. Carried on
+     * the item so the TUI drainer can stamp `PROMPT_JOURNAL_RAW_MARKER` per-item
+     * right before that item runs; survives restart rehydration.
+     */
+    journalRaw?: string | undefined;
 }
 /** Hard memory/disk budgets shared by QueueStore and the TUI reducer. */
 export declare const QUEUE_MAX_ITEMS = 100;