@manny-est/node-red-flowpilot 0.5.0 → 0.5.2

package/lib/provider-anthropic.js

@@ -0,0 +1,385 @@
+const https = require("https");
+const http = require("http");
+
+const ANTHROPIC_API_BASE = "https://api.anthropic.com";
+const ANTHROPIC_VERSION = "2023-06-01";
+const DEFAULT_MAX_TOKENS = 8192;
+
+// ---- HTTP helpers ----
+
+function postJson(urlString, headers, body, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let url;
+    try { url = new URL(urlString); } catch (err) { reject(new Error("Invalid provider URL: " + urlString)); return; }
+
+    const payload = JSON.stringify(body);
+    const transport = url.protocol === "https:" ? https : http;
+    const req = transport.request({
+      method: "POST",
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname + url.search,
+      headers: Object.assign({ "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) }, headers || {})
+    }, (res) => {
+      let data = "";
+      res.setEncoding("utf8");
+      res.on("data", chunk => { data += chunk; });
+      res.on("end", () => {
+        let parsed = null;
+        try { parsed = data ? JSON.parse(data) : null; } catch (err) {
+          reject(new Error("Provider returned non-JSON response (" + res.statusCode + "): " + data.slice(0, 500)));
+          return;
+        }
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          const msg = parsed && parsed.error ? JSON.stringify(parsed.error) : data;
+          reject(new Error("Provider request failed (" + res.statusCode + "): " + msg));
+          return;
+        }
+        resolve(parsed);
+      });
+    });
+    req.on("error", reject);
+    req.setTimeout(timeoutMs || 180000, () => {
+      req.destroy(new Error("Provider request timed out after " + (timeoutMs || 180000) + "ms — increase the request timeout in Settings → Behavior for slower hardware."));
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
+function getJson(urlString, headers, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let url;
+    try { url = new URL(urlString); } catch (err) { reject(new Error("Invalid provider URL: " + urlString)); return; }
+
+    const transport = url.protocol === "https:" ? https : http;
+    const req = transport.request({
+      method: "GET",
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname + url.search,
+      headers: headers || {}
+    }, (res) => {
+      let data = "";
+      res.setEncoding("utf8");
+      res.on("data", chunk => { data += chunk; });
+      res.on("end", () => {
+        let parsed = null;
+        try { parsed = data ? JSON.parse(data) : null; } catch (err) {
+          reject(new Error("Provider returned non-JSON response (" + res.statusCode + "): " + data.slice(0, 500)));
+          return;
+        }
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          const msg = parsed && parsed.error ? JSON.stringify(parsed.error) : data;
+          reject(new Error("Provider request failed (" + res.statusCode + "): " + msg));
+          return;
+        }
+        resolve(parsed);
+      });
+    });
+    req.on("error", reject);
+    req.setTimeout(timeoutMs || 30000, () => {
+      req.destroy(new Error("Timeout"));
+    });
+    req.end();
+  });
+}
+
+function postStream(urlString, headers, body, timeoutMs, onDelta, onReasoningDelta) {
+  return new Promise((resolve, reject) => {
+    let url;
+    try { url = new URL(urlString); } catch (err) { reject(new Error("Invalid provider URL: " + urlString)); return; }
+
+    const payload = JSON.stringify(body);
+    const transport = url.protocol === "https:" ? https : http;
+    const startedAt = Date.now();
+    let firstTokenAt = null;
+    let usage = null;
+    let full = "";
+
+    const req = transport.request({
+      method: "POST",
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname + url.search,
+      headers: Object.assign({ "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) }, headers || {})
+    }, (res) => {
+      res.setEncoding("utf8");
+      if (res.statusCode < 200 || res.statusCode >= 300) {
+        let errData = "";
+        res.on("data", chunk => { errData += chunk; });
+        res.on("end", () => { reject(new Error("Provider request failed (" + res.statusCode + "): " + errData.slice(0, 500))); });
+        return;
+      }
+
+      let sseBuf = "";
+      res.on("data", (chunk) => {
+        sseBuf += chunk;
+        const lines = sseBuf.split("\n");
+        sseBuf = lines.pop();
+        lines.forEach((line) => {
+          line = line.trim();
+          if (!line.startsWith("data:")) { return; }
+          const dataStr = line.slice(5).trim();
+          if (!dataStr) { return; }
+          let evt;
+          try { evt = JSON.parse(dataStr); } catch (e) { return; }
+
+          // Anthropic SSE event types used here:
+          // message_start: carries input_tokens
+          // content_block_delta: text_delta or thinking_delta
+          // message_delta: carries output_tokens
+          if (evt.type === "message_start" && evt.message && evt.message.usage) {
+            usage = { prompt_tokens: evt.message.usage.input_tokens || 0, completion_tokens: 0 };
+          } else if (evt.type === "content_block_delta" && evt.delta) {
+            if (evt.delta.type === "text_delta" && evt.delta.text) {
+              if (firstTokenAt === null) { firstTokenAt = Date.now(); }
+              full += evt.delta.text;
+              onDelta(evt.delta.text);
+            } else if (evt.delta.type === "thinking_delta" && evt.delta.thinking && onReasoningDelta) {
+              onReasoningDelta(evt.delta.thinking);
+            }
+          } else if (evt.type === "message_delta" && evt.usage) {
+            if (usage) { usage.completion_tokens = evt.usage.output_tokens || 0; }
+            else { usage = { prompt_tokens: 0, completion_tokens: evt.usage.output_tokens || 0 }; }
+          }
+        });
+      });
+      res.on("end", () => {
+        resolve({ content: full, ttftMs: firstTokenAt !== null ? firstTokenAt - startedAt : null, totalMs: Date.now() - startedAt, usage: usage });
+      });
+    });
+
+    req.on("error", reject);
+    req.setTimeout(timeoutMs || 180000, () => {
+      req.destroy(new Error("Provider request timed out after " + (timeoutMs || 180000) + "ms — increase the request timeout in Settings → Behavior for slower hardware."));
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
+// ---- Message format conversion ----
+
+// OpenAI {type:"function", function:{name,description,parameters}} →
+// Anthropic {name, description, input_schema}
+function toAnthropicTool(tool) {
+  const fn = tool && tool.function;
+  if (!fn) { return null; }
+  return {
+    name: fn.name,
+    description: fn.description || "",
+    input_schema: fn.parameters || { type: "object", properties: {} }
+  };
+}
+
+// Anthropic {type:"tool_use", id, name, input} →
+// OpenAI {id, type:"function", function:{name, arguments:string}}
+function toOpenAiToolCall(block) {
+  return {
+    id: block.id,
+    type: "function",
+    function: {
+      name: block.name,
+      arguments: JSON.stringify(block.input || {})
+    }
+  };
+}
+
+// Convert an OpenAI-shaped messages array to Anthropic format.
+// Returns { system: string, messages: [...] }
+//
+// - role:"system" messages are extracted and concatenated into top-level system param
+// - role:"assistant" + tool_calls converted to Anthropic tool_use content blocks
+// - role:"tool" results converted and grouped into user messages with tool_result blocks
+// - role:"user" and plain role:"assistant" pass through unchanged
+function convertMessages(messages) {
+  const systemParts = [];
+  const converted = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+
+    if (msg.role === "system") {
+      if (typeof msg.content === "string" && msg.content) {
+        systemParts.push(msg.content);
+      }
+      continue;
+    }
+
+    // Group consecutive tool result messages into one user message
+    if (msg.role === "tool") {
+      const toolResults = [];
+      while (i < messages.length && messages[i].role === "tool") {
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: messages[i].tool_call_id,
+          content: messages[i].content || ""
+        });
+        i++;
+      }
+      i--; // outer loop will increment
+      converted.push({ role: "user", content: toolResults });
+      continue;
+    }
+
+    // Assistant with tool_calls → Anthropic tool_use content blocks
+    if (msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length) {
+      const content = [];
+      if (msg.content) { content.push({ type: "text", text: msg.content }); }
+      msg.tool_calls.forEach(function (tc) {
+        let input = {};
+        try { input = JSON.parse(tc.function.arguments || "{}"); } catch (e) {}
+        content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input: input });
+      });
+      converted.push({ role: "assistant", content: content });
+      continue;
+    }
+
+    converted.push({ role: msg.role, content: msg.content });
+  }
+
+  return { system: systemParts.join("\n\n"), messages: converted };
+}
+
+function anthropicHeaders(settings) {
+  return {
+    "x-api-key": settings.apiKey || "",
+    "anthropic-version": ANTHROPIC_VERSION
+  };
+}
+
+function resolveBaseUrl(settings) {
+  return String(settings.baseUrl || ANTHROPIC_API_BASE).replace(/\/+$/, "") || ANTHROPIC_API_BASE;
+}
+
+// ---- chat ----
+
+async function chat(settings, messages, options) {
+  if (!settings.model) { throw new Error("Model is required."); }
+  const baseUrl = resolveBaseUrl(settings);
+  const { system, messages: anthropicMessages } = convertMessages(messages);
+  const temperature = settings.temperature !== undefined ? Number(settings.temperature) : 0.2;
+
+  const body = {
+    model: settings.model,
+    messages: anthropicMessages,
+    max_tokens: DEFAULT_MAX_TOKENS,
+    temperature: temperature,
+    stream: false
+  };
+  if (system) { body.system = system; }
+  if (options && Array.isArray(options.tools) && options.tools.length) {
+    body.tools = options.tools.map(toAnthropicTool).filter(Boolean);
+    body.tool_choice = { type: "auto" };
+  }
+
+  const startedAt = Date.now();
+  const response = await postJson(baseUrl + "/v1/messages", anthropicHeaders(settings), body, settings.requestTimeoutMs || 180000);
+  const totalMs = Date.now() - startedAt;
+
+  const contentArray = (response && Array.isArray(response.content)) ? response.content : [];
+  const textContent = contentArray.filter(function (b) { return b.type === "text"; }).map(function (b) { return b.text; }).join("");
+  const toolUseBlocks = contentArray.filter(function (b) { return b.type === "tool_use"; });
+  const toolCalls = toolUseBlocks.length ? toolUseBlocks.map(toOpenAiToolCall) : null;
+  const usage = (response && response.usage)
+    ? { prompt_tokens: response.usage.input_tokens, completion_tokens: response.usage.output_tokens }
+    : null;
+
+  return {
+    raw: response,
+    content: textContent || (toolCalls ? "" : "[No assistant message returned by provider]"),
+    toolCalls: toolCalls,
+    timing: { totalMs: totalMs },
+    usage: usage
+  };
+}
+
+// ---- chatStream ----
+
+async function chatStream(settings, messages, onDelta, onReasoningDelta) {
+  if (!settings.model) { throw new Error("Model is required."); }
+  const baseUrl = resolveBaseUrl(settings);
+  const { system, messages: anthropicMessages } = convertMessages(messages);
+  const temperature = settings.temperature !== undefined ? Number(settings.temperature) : 0.2;
+
+  const body = {
+    model: settings.model,
+    messages: anthropicMessages,
+    max_tokens: DEFAULT_MAX_TOKENS,
+    temperature: temperature,
+    stream: true
+  };
+  if (system) { body.system = system; }
+
+  const result = await postStream(baseUrl + "/v1/messages", anthropicHeaders(settings), body, settings.requestTimeoutMs || 180000, onDelta, onReasoningDelta);
+
+  return {
+    content: result.content || "",
+    timing: { ttftMs: result.ttftMs, totalMs: result.totalMs },
+    usage: result.usage
+  };
+}
+
+// ---- listModels ----
+// Tries GET /v1/models; falls back to a hardcoded list if that endpoint
+// is unavailable (non-standard proxy) or returns an error.
+async function listModels(settings) {
+  const baseUrl = resolveBaseUrl(settings);
+  try {
+    const response = await getJson(baseUrl + "/v1/models", anthropicHeaders(settings), settings.requestTimeoutMs || 30000);
+    const data = response && Array.isArray(response.data) ? response.data : [];
+    const models = data.map(function (m) { return m && m.id; }).filter(function (id) { return typeof id === "string" && id; });
+    if (models.length) { return { models: models }; }
+    throw new Error("Empty model list from provider");
+  } catch (err) {
+    return {
+      models: [
+        "claude-opus-4-8",
+        "claude-sonnet-5",
+        "claude-haiku-4-5-20251001"
+      ],
+      error: err.message
+    };
+  }
+}
+
+// ---- probeTools ----
+async function probeTools(settings) {
+  if (!settings.model) { throw new Error("Model is required."); }
+  const baseUrl = resolveBaseUrl(settings);
+
+  try {
+    const response = await postJson(baseUrl + "/v1/messages", anthropicHeaders(settings), {
+      model: settings.model,
+      messages: [{ role: "user", content: "Call the \"ping\" tool now with no arguments." }],
+      system: "You are being tested for tool/function-calling support.",
+      tools: [{
+        name: "ping",
+        description: "Respond to a connectivity probe. Takes no arguments.",
+        input_schema: { type: "object", properties: {}, additionalProperties: false }
+      }],
+      tool_choice: { type: "auto" },
+      max_tokens: 128,
+      temperature: 0,
+      stream: false
+    }, settings.requestTimeoutMs || 30000);
+
+    const contentArray = (response && Array.isArray(response.content)) ? response.content : [];
+    const hasToolUse = contentArray.some(function (b) { return b.type === "tool_use" && b.name === "ping"; });
+    return { supportsTools: hasToolUse };
+  } catch (err) {
+    return { supportsTools: false, error: err.message };
+  }
+}
+
+// ---- detectReasoning ----
+// Extended thinking responses include content blocks with type:"thinking".
+// Standard non-thinking responses never include them.
+function detectReasoning(rawResponse) {
+  const contentArray = (rawResponse && Array.isArray(rawResponse.content)) ? rawResponse.content : [];
+  const isReasoningModel = contentArray.some(function (b) { return b && b.type === "thinking" && b.thinking; });
+  return { isReasoningModel: isReasoningModel };
+}
+
+module.exports = { chat, chatStream, probeTools, listModels, detectReasoning };

package/lib/provider-openai-compatible.js

@@ -169,6 +169,9 @@ async function chat(settings, messages, options) {
     body.tools = options.tools;
     body.tool_choice = options.toolChoice || "auto";
   }
+  if (options && options.responseFormat) {
+    body.response_format = options.responseFormat;
+  }
 
   const startedAt = Date.now();
   const response = await postJson(`${baseUrl}/v1/chat/completions`, headers, body, settings.requestTimeoutMs || 180000);
@@ -194,7 +197,66 @@ async function chat(settings, messages, options) {
 // `data: [DONE]`). Calls onDelta(text) for each content fragment as it
 // arrives and resolves with { content } containing the full concatenated
 // text once the stream ends. Used for chat streaming only.
-function postStream(urlString, headers, body, timeoutMs, onDelta) {
+// Splits a streaming content string on <think>...</think> tags so that
+// reasoning text is routed to onReasoning and the actual response text to
+// onContent. Handles tags that arrive split across multiple chunks via a
+// small lookahead buffer. Handles both:
+//   - SGLang/Nemotron style: delta.reasoning_content (separate field)
+//   - llama.cpp/LocalAI style: <think>...</think> embedded in delta.content
+// The two paths converge at onReasoningDelta in postStream — callers see
+// one uniform reasoning callback regardless of provider format.
+function createThinkTagSplitter(onContent, onReasoning) {
+  let phase = "seek"; // "seek" | "think" | "content"
+  let buf = "";
+  const OPEN = "<think>";
+  const CLOSE = "</think>";
+
+  function push(text) {
+    buf += text;
+    while (buf.length > 0) {
+      if (phase === "seek") {
+        const idx = buf.indexOf(OPEN);
+        if (idx === -1) {
+          // No opening tag visible — emit everything except the last few bytes
+          // that might be a partial tag, buffer the rest.
+          const safe = buf.length > OPEN.length - 1 ? buf.length - (OPEN.length - 1) : 0;
+          if (safe > 0) { onContent(buf.slice(0, safe)); buf = buf.slice(safe); }
+          break;
+        }
+        if (idx > 0) { onContent(buf.slice(0, idx)); }
+        buf = buf.slice(idx + OPEN.length);
+        phase = "think";
+      } else if (phase === "think") {
+        const idx = buf.indexOf(CLOSE);
+        if (idx === -1) {
+          const safe = buf.length > CLOSE.length - 1 ? buf.length - (CLOSE.length - 1) : 0;
+          if (safe > 0) { onReasoning(buf.slice(0, safe)); buf = buf.slice(safe); }
+          break;
+        }
+        if (idx > 0) { onReasoning(buf.slice(0, idx)); }
+        buf = buf.slice(idx + CLOSE.length);
+        // Skip whitespace/newline immediately after </think>
+        const trimmed = buf.replace(/^\s+/, "");
+        buf = trimmed;
+        phase = "content";
+      } else {
+        onContent(buf);
+        buf = "";
+        break;
+      }
+    }
+  }
+
+  function finish() {
+    if (!buf) { return; }
+    if (phase === "think") { onReasoning(buf); } else { onContent(buf); }
+    buf = "";
+  }
+
+  return { push, finish };
+}
+
+function postStream(urlString, headers, body, timeoutMs, onDelta, onReasoningDelta) {
   return new Promise((resolve, reject) => {
     let url;
     try {
@@ -233,12 +295,22 @@ function postStream(urlString, headers, body, timeoutMs, onDelta) {
         return;
       }
 
-      let buf = "";
+      let sseBuf = "";
       let full = "";
+      // When onReasoningDelta is provided, intercept <think>...</think> from
+      // delta.content in addition to the dedicated delta.reasoning_content field
+      // (llama.cpp/LocalAI style vs SGLang/Nemotron style — both converge here).
+      const thinkSplitter = onReasoningDelta
+        ? createThinkTagSplitter(
+            function (c) { if (firstTokenAt === null) { firstTokenAt = Date.now(); } full += c; onDelta(c); },
+            onReasoningDelta
+          )
+        : null;
+
       res.on("data", (chunk) => {
-        buf += chunk;
-        const lines = buf.split("\n");
-        buf = lines.pop(); // keep the last (possibly partial) line for next time
+        sseBuf += chunk;
+        const lines = sseBuf.split("\n");
+        sseBuf = lines.pop(); // keep the last (possibly partial) line for next time
 
         lines.forEach((line) => {
           line = line.trim();
@@ -255,17 +327,29 @@ function postStream(urlString, headers, body, timeoutMs, onDelta) {
 
           if (evt && evt.usage) { usage = evt.usage; }
 
-          const delta = evt && evt.choices && evt.choices[0] && evt.choices[0].delta
-            ? evt.choices[0].delta.content
-            : "";
-          if (delta) {
-            if (firstTokenAt === null) { firstTokenAt = Date.now(); }
-            full += delta;
-            onDelta(delta);
+          const deltaObj = evt && evt.choices && evt.choices[0] && evt.choices[0].delta;
+          if (deltaObj) {
+            if (deltaObj.content) {
+              if (thinkSplitter) {
+                thinkSplitter.push(deltaObj.content);
+              } else {
+                if (firstTokenAt === null) { firstTokenAt = Date.now(); }
+                full += deltaObj.content;
+                onDelta(deltaObj.content);
+              }
+            }
+            // Separate reasoning_content field (SGLang/Nemotron style). Both
+            // paths run in parallel — they are mutually exclusive per provider
+            // (llama.cpp puts reasoning in delta.content via <think> tags;
+            // SGLang puts it in delta.reasoning_content with delta.content "").
+            if (deltaObj.reasoning_content && onReasoningDelta) {
+              onReasoningDelta(deltaObj.reasoning_content);
+            }
           }
         });
       });
       res.on("end", () => {
+        if (thinkSplitter) { thinkSplitter.finish(); }
         const endedAt = Date.now();
         resolve({
           content: full,
@@ -287,7 +371,7 @@ function postStream(urlString, headers, body, timeoutMs, onDelta) {
   });
 }
 
-async function chatStream(settings, messages, onDelta) {
+async function chatStream(settings, messages, onDelta, onReasoningDelta, options) {
   const baseUrl = String(settings.baseUrl || "").replace(/\/+$/, "");
   if (!baseUrl) throw new Error("Provider base URL is required.");
   if (!settings.model) throw new Error("Model is required.");
@@ -303,13 +387,19 @@ async function chatStream(settings, messages, onDelta) {
   // final SSE chunk carrying token usage (no delta) before [DONE]. Providers
   // that don't support it just ignore the option; postStream treats a
   // missing usage field as null either way.
-  const result = await postStream(`${baseUrl}/v1/chat/completions`, headers, {
+  const body = {
     model: settings.model,
     messages,
     temperature,
     stream: true,
     stream_options: { include_usage: true }
-  }, settings.requestTimeoutMs || 180000, onDelta);
+  };
+  if (options && options.responseFormat) {
+    body.response_format = options.responseFormat;
+  }
+
+  const result = await postStream(`${baseUrl}/v1/chat/completions`, headers,
+    body, settings.requestTimeoutMs || 180000, onDelta, onReasoningDelta);
 
   return {
     content: result.content || "",
@@ -377,4 +467,20 @@ async function probeTools(settings) {
   }
 }
 
-module.exports = { chat, chatStream, probeTools, listModels };
+// ---------------------------------------------------------------------
+// Checks whether the provider's response includes reasoning_content —
+// the separate chain-of-thought field emitted by reasoning models
+// (e.g. Nemotron, DeepSeek-R1, o1-style). Reuses the connectivity test
+// response already obtained by the /test route rather than making a
+// second round-trip: caller passes the raw response object.
+// Returns { isReasoningModel: boolean }.
+// ---------------------------------------------------------------------
+function detectReasoning(rawResponse) {
+  const message = rawResponse && rawResponse.choices && rawResponse.choices[0]
+    && rawResponse.choices[0].message;
+  const isReasoningModel = !!(message && message.reasoning_content != null
+    && message.reasoning_content !== "");
+  return { isReasoningModel };
+}
+
+module.exports = { chat, chatStream, probeTools, listModels, detectReasoning };

package/lib/storage.js

@@ -18,10 +18,15 @@ function createStorage(userDir) {
     return {
       id: "default",
       providerName: "LocalAI",
+      // "openai-compatible" (default) or "anthropic"
+      type: "openai-compatible",
       baseUrl: "http://localhost:8080",
       apiKey: "",
       model: "",
-      temperature: 0.2
+      temperature: 0.2,
+      // Configured context window size for this provider in tokens (0 = unknown).
+      // When set, FlowPilot warns when the assembled prompt approaches the limit.
+      numCtx: 0
     };
   }
 
@@ -33,7 +38,11 @@ function createStorage(userDir) {
     maxContextChars: 12000,
     defaultContextMode: "selected",
     allowConfigContext: false,
-    logFullContext: false,
+    // When true, each assembled prompt (post-redaction messages array) plus the
+    // raw provider response and parse outcome is appended to assembled-prompts.log
+    // (0600 perms). Auth headers/keys are never logged — only the content bytes
+    // that the provider actually received. Off by default (diagnostic tool).
+    logAssembledPrompts: false,
     streamingEnabled: true,
     // First-run welcome/warning shows until the user saves settings once.
     firstRunAcknowledged: false,
@@ -62,6 +71,10 @@ function createStorage(userDir) {
     // and shows a checkpoint question ("Continue with AI review, or stop?")
     // instead of auto-advancing. Default false = original auto-advance behavior.
     loopHoldStep: false,
+    // Routes Generate through the Phase 10 step-queue engine (graph read-back
+    // verification after import). The legacy path remains available when a
+    // user explicitly disables this setting.
+    enableStepQueue: true,
     // Lets the user silence the recurring secrets/size reminder bar after
     // typing an explicit acknowledgement in settings.
     suppressContextWarnings: false,
@@ -290,6 +303,32 @@ function createStorage(userDir) {
     return defaultSettings.systemPrompt;
   }
 
+  const assembledPromptsFile = path.join(baseDir, "assembled-prompts.log");
+
+  // W0.4: Append one JSON-lines entry to assembled-prompts.log.
+  // Written 0600 — diagnostic data, never world-readable.
+  // Auth keys are NOT included (only baseUrl + model from the provider
+  // profile, never apiKey). The bytes logged are post-redaction: the same
+  // content the provider actually received.
+  function appendAssembledPromptLog(entry) {
+    init();
+    const line = JSON.stringify({
+      timestamp: new Date().toISOString(),
+      ...entry
+    });
+    try {
+      // Open with O_APPEND | O_CREAT, mode 0600 so secrets never land
+      // in a world-readable file even on first write.
+      const fd = fs.openSync(assembledPromptsFile, "a", 0o600);
+      fs.writeSync(fd, line + "\n");
+      fs.closeSync(fd);
+      // Ensure 0600 regardless of umask on subsequent opens.
+      fs.chmodSync(assembledPromptsFile, 0o600);
+    } catch (err) {
+      console.error("[FlowPilot] assembled-prompts log write failed:", err.message);
+    }
+  }
+
   init();
 
   return {
@@ -298,11 +337,13 @@ function createStorage(userDir) {
     backupsDir,
     settingsFile,
     auditFile,
+    assembledPromptsFile,
     getSettings,
     saveSettings,
     getActiveProvider,
     getDefaultSystemPrompt,
     appendAudit,
+    appendAssembledPromptLog,
     appendTranscript,
     readTranscript,
     deleteTranscript,