@agentprojectcontext/apx 1.66.0 → 1.68.0

package/src/core/config/secret-values.js

@@ -0,0 +1,132 @@
+// Value-based secret masking (OpenHands-inspired). redact.js masks secrets by
+// KEY (a config view knows "engines.openai.api_key" is secret); this module
+// masks by VALUE: known secret strings are registered once (daemon boot +
+// config hot-reload) and then scrubbed from ANY log text they leak into —
+// free-text error messages, provider echoes, tool output captured in traces.
+//
+// Both layers stay on: key-based redaction catches secrets in structured meta
+// even before registration; value-based masking catches them everywhere else.
+
+import { SECRET_PATHS } from "./redact.js";
+
+// Never register strings shorter than this — masking "abc" would shred every
+// log line containing those three letters.
+const MIN_SECRET_LENGTH = 6;
+
+// Same key heuristic as SECRET_KEY_RE in core/logging.js — used to decide
+// which MCP env/header entries hold secrets (env also carries harmless values
+// like NODE_ENV whose masking would mangle unrelated log text).
+const SECRET_ENTRY_KEY_RE = /(token|secret|password|api[_-]?key|authorization|credential)/i;
+
+// Module-level registry. Additive on purpose: a hot-reload that removes a key
+// keeps the old value masked — stale masking is harmless, a leak is not.
+const registry = new Set();
+
+function isRegistrable(value) {
+  return typeof value === "string" && value.trim().length >= MIN_SECRET_LENGTH;
+}
+
+function getDotted(obj, dotted) {
+  let cur = obj;
+  for (const part of dotted.split(".")) {
+    if (!cur || typeof cur !== "object") return undefined;
+    cur = cur[part];
+  }
+  return cur;
+}
+
+/**
+ * Walk a config object and return every secret VALUE it holds: all
+ * SECRET_PATHS entries, every telegram channel bot_token, and the legacy
+ * root telegram.bot_token (pre-migration configs). Deduped; empty and
+ * too-short strings dropped.
+ */
+export function collectSecretValues(cfg) {
+  const out = new Set();
+  try {
+    if (!cfg || typeof cfg !== "object") return [];
+    for (const dotted of SECRET_PATHS) {
+      if (dotted.includes("*")) continue; // array paths handled below
+      const val = getDotted(cfg, dotted);
+      if (isRegistrable(val)) out.add(val);
+    }
+    const channels = cfg?.telegram?.channels;
+    if (Array.isArray(channels)) {
+      for (const ch of channels) {
+        if (isRegistrable(ch?.bot_token)) out.add(ch.bot_token);
+      }
+    }
+    if (isRegistrable(cfg?.telegram?.bot_token)) out.add(cfg.telegram.bot_token);
+  } catch {
+    // collection must never break the caller — return what we got so far
+  }
+  return Array.from(out);
+}
+
+/**
+ * Extract secret values from an mcps.json shape ({ mcpServers: {name: {env,
+ * headers}} }) — runtime/global MCP stores carry tokens in env vars and HTTP
+ * headers. Only entries whose KEY looks secret are taken (see regex above).
+ */
+export function collectMcpSecretValues(mcpsJson) {
+  const out = new Set();
+  try {
+    const servers = mcpsJson?.mcpServers;
+    if (!servers || typeof servers !== "object") return [];
+    for (const server of Object.values(servers)) {
+      for (const bag of [server?.env, server?.headers]) {
+        if (!bag || typeof bag !== "object") continue;
+        for (const [key, val] of Object.entries(bag)) {
+          if (SECRET_ENTRY_KEY_RE.test(key) && isRegistrable(val)) out.add(val);
+        }
+      }
+    }
+  } catch {
+    // same never-throw contract as collectSecretValues
+  }
+  return Array.from(out);
+}
+
+/** Add values to the module-level registry. Invalid/short entries ignored. */
+export function registerSecretValues(values) {
+  if (!Array.isArray(values)) return;
+  for (const v of values) {
+    if (isRegistrable(v)) registry.add(v);
+  }
+}
+
+export function getRegisteredSecretValues() {
+  return Array.from(registry);
+}
+
+/** Test hook — empties the registry so cases don't bleed into each other. */
+export function clearRegisteredSecretValues() {
+  registry.clear();
+}
+
+// Visible marker in the same spirit as secretMarker() in redact.js (keep a
+// short suffix so the user can tell WHICH secret leaked), but compact enough
+// to live inline in a log line.
+function maskedMarker(value) {
+  return `***…${value.slice(-4)}`;
+}
+
+/**
+ * Replace every registered secret value found in `text` with its marker.
+ * Longest-first so a secret that contains another is masked whole instead of
+ * being shredded by the shorter one. Non-string input is returned unchanged;
+ * this function NEVER throws.
+ */
+export function maskSecretValues(text) {
+  try {
+    if (typeof text !== "string" || !text || registry.size === 0) return text;
+    const values = Array.from(registry).sort((a, b) => b.length - a.length);
+    let out = text;
+    for (const value of values) {
+      if (out.includes(value)) out = out.split(value).join(maskedMarker(value));
+    }
+    return out;
+  } catch {
+    return text;
+  }
+}

package/src/core/engines/mock.js

@@ -31,11 +31,14 @@ export default {
         raw: { model, mock: true },
       };
     }
+    // `[mock:risk:HIGH]` → the emitted tool call carries a security_risk grade,
+    // so the inline security analyzer / confirmation gate can be exercised.
+    const riskGrade = userText.match(/\[mock:risk:(LOW|MEDIUM|HIGH|UNKNOWN)\]/)?.[1];
     const mkToolCall = (name, id) => {
       const toolCall = {
         id,
         type: "function",
-        function: { name, arguments: "{}" },
+        function: { name, arguments: riskGrade ? JSON.stringify({ security_risk: riskGrade }) : "{}" },
       };
       return {
         text: "",
@@ -66,6 +69,17 @@ export default {
     if (loopTool && toolsAvailable) {
       return mkToolCall(loopTool, "mock-loop-1");
     }
+    // `[mock:loopany:<tool>]` → like loop, but sticky: matched against ANY
+    // user turn, so the model keeps looping even after the agent loop injects
+    // in-band user notes (exercises stuck-detection escalation, which needs a
+    // model that ignores the nudge).
+    const loopAnyTool = messages
+      .filter((m) => m.role === "user")
+      .map((m) => String(m.content || "").match(/\[mock:loopany:([a-z_]+)\]/)?.[1])
+      .find(Boolean);
+    if (loopAnyTool && toolsAvailable) {
+      return mkToolCall(loopAnyTool, "mock-loopany-1");
+    }
     if (requestedTool && !hasToolResult && toolsAvailable) {
       return mkToolCall(requestedTool, "mock-call-1");
     }

package/src/core/logging.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { APX_HOME } from "./config/index.js";
+import { maskSecretValues } from "./config/secret-values.js";
 
 export const LOG_DIR = path.join(APX_HOME, "logs");
 export const ERROR_TRACE_PATH = path.join(LOG_DIR, "errors.jsonl");
@@ -32,7 +33,10 @@ export function appendErrorTrace(record) {
     ts: new Date().toISOString(),
     ...redact(record),
   };
-  fs.appendFileSync(ERROR_TRACE_PATH, JSON.stringify(entry) + "\n", "utf8");
+  // Second layer: registered secret VALUES are scrubbed from the serialized
+  // record too — error strings often echo a key the key-based redact above
+  // can't see (it only inspects object keys, not free text).
+  fs.appendFileSync(ERROR_TRACE_PATH, maskSecretValues(JSON.stringify(entry)) + "\n", "utf8");
 }
 
 export function previewText(text, max = 500) {
@@ -68,10 +72,13 @@ export function formatLogLine(level, module, message, meta) {
     ? String(level).toUpperCase()
     : "INFO";
   const mod = String(module || "apx").slice(0, 24);
-  const msg = String(message ?? "").replace(/\n/g, " ");
+  // Key-based redact (meta) + value-based mask (message AND meta): a secret
+  // value embedded in a free-text message or under an innocuous meta key
+  // ("detail", "stderr") only the value registry can catch.
+  const msg = maskSecretValues(String(message ?? "").replace(/\n/g, " "));
   let suffix = "";
   if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
-    try { suffix = " " + JSON.stringify(redact(meta)); }
+    try { suffix = " " + maskSecretValues(JSON.stringify(redact(meta))); }
     catch { suffix = " {meta:unserializable}"; }
   }
   return `[${fmtTs()}] [${lvl.padEnd(5)}] [${mod}] ${msg}${suffix}`;

package/src/core/memory/compactor.js

@@ -1,11 +1,18 @@
-// Progressive history compaction (Pieza 3).
+// Progressive history compaction (Pieza 3) — condenser v2.
 //
 // When a channel chat accumulates more than `maxTurns` (60) conversational
 // turns in the rolling window, the oldest turns beyond `keepRecent` (40) are
-// collapsed into a dense summary by a light LLM (ollama:gemma2 → haiku
-// fallback) and persisted as a `type:"compact"` record in the channel JSONL.
+// collapsed by a light LLM into a STRUCTURED STATE summary (OpenHands
+// LLMSummarizingCondenser mechanics) and persisted as a `type:"compact"`
+// record in the channel JSONL. Two condenser behaviors on top of the original
+// narrative recap:
+//   - previous-summary threading: the latest compact record (if any) is fed
+//     into the prompt as the FIRST event so the new summary subsumes it —
+//     state tracked across compactions never silently drops;
+//   - keep_first: the conversation's opening turns (original goal) get special
+//     treatment — see the keep_first comment in compactChannelIfNeeded.
 //
-// The reader (getRecentChannelTurnsFromFs) then prepends that summary as a
+// The reader (getRecentChannelTurnsFromFs) then prepends the summary as a
 // [RESUMEN COMPACTADO] system turn and drops the raw turns it covers, keeping
 // the model context bounded while preserving decisions / tasks / tool results.
 //
@@ -17,37 +24,18 @@ import fs from "node:fs";
 import path from "node:path";
 import { GLOBAL_MESSAGES_DIR } from "../config/index.js";
 import { parseDayJsonl, appendGlobalMessage } from "../stores/messages.js";
-import { callEngine } from "../engines/index.js";
+import {
+  resolveCompactModels,
+  buildCondenserPrompt,
+  summarizeStructured,
+} from "./summarizer.js";
+
+// Re-export so existing importers (tests, callers) keep working.
+export { resolveCompactModels };
 
 const DEFAULT_MAX_TURNS = 60;
 const DEFAULT_KEEP_RECENT = 40;
-const COMPACT_MAX_TOKENS = 1000; // ~800-token target + headroom
-
-const COMPACT_SYSTEM =
-  "Compactás conversaciones para continuidad de contexto de un agente. " +
-  "Otro modelo va a leer esto para seguir el trabajo: sé denso y factual.";
-
-function compactPrompt(transcript) {
-  return (
-    "Compactá estos turnos en un resumen estructurado de máximo 800 tokens, " +
-    "preservando: decisiones tomadas, tareas asignadas, resultados de tools, y " +
-    "datos acordados. Sin saludos ni meta-comentarios. Sólo los hechos.\n\n" +
-    "---\n\n" +
-    transcript
-  );
-}
-
-export function resolveCompactModels(config = {}) {
-  const mem = config.memory || {};
-  // Primary: a light, local-endpoint model (Ollama, incl. *-cloud models served
-  // via localhost). Fallback: whatever the user configured, else the APX
-  // default super-agent model — never silently a paid service the user didn't
-  // pick. A blank fallback resolves to super_agent.model at call time.
-  return {
-    primary: mem.compact_model || "ollama:gemma4:31b-cloud",
-    fallback: mem.compact_fallback_model || config.super_agent?.model || "",
-  };
-}
+const DEFAULT_KEEP_FIRST = 2;
 
 // Read every record for a chat in the rolling window, oldest first.
 function readChatRecords({ channel, chat_id, max_age_hours, messagesDir }) {
@@ -84,30 +72,18 @@ function renderTurn(m) {
   return `[${who}]\n${String(m.body || "")}`;
 }
 
-async function summarize({ transcript, models, config }) {
-  for (const modelId of [models.primary, models.fallback]) {
-    if (!modelId) continue;
-    try {
-      const r = await callEngine({
-        modelId,
-        system: COMPACT_SYSTEM,
-        messages: [{ role: "user", content: compactPrompt(transcript) }],
-        config,
-        maxTokens: COMPACT_MAX_TOKENS,
-        temperature: 0.2,
-      });
-      const text = String(r.text || "").trim();
-      if (text) return { text, model: modelId };
-    } catch {
-      /* try next model */
-    }
+function renderEvent(m, id) {
+  if (m.type === "tool") {
+    const name = m.meta?.tool_name || m.meta?.tool || "tool";
+    return `<EVENT id=${id} role=tool name=${name}>\n${String(m.body || "").slice(0, 600)}\n</EVENT>`;
   }
-  return null;
+  const role = m.type === "user" ? "user" : "assistant";
+  return `<EVENT id=${id} role=${role}>\n${String(m.body || "")}\n</EVENT>`;
 }
 
 // Compact one channel chat if it's over threshold. Returns a small status obj.
-// opts: { channel, chat_id, config, log, maxTurns, keepRecent, max_age_hours,
-//         messagesDir }  (messagesDir overridable for tests)
+// opts: { channel, chat_id, config, log, maxTurns, keepRecent, keepFirst,
+//         max_age_hours, messagesDir }  (messagesDir overridable for tests)
 export async function compactChannelIfNeeded(opts = {}) {
   const channel = opts.channel || "telegram";
   const chat_id = opts.chat_id;
@@ -115,6 +91,7 @@ export async function compactChannelIfNeeded(opts = {}) {
   const log = typeof opts.log === "function" ? opts.log : () => {};
   const maxTurns = opts.maxTurns ?? config.memory?.compact_threshold ?? DEFAULT_MAX_TURNS;
   const keepRecent = opts.keepRecent ?? config.memory?.keep_recent ?? DEFAULT_KEEP_RECENT;
+  const keepFirst = opts.keepFirst ?? config.memory?.keep_first ?? DEFAULT_KEEP_FIRST;
   const max_age_hours = opts.max_age_hours ?? 24;
   const messagesDir = opts.messagesDir || GLOBAL_MESSAGES_DIR;
   if (!chat_id) return { skipped: "no chat_id" };
@@ -147,14 +124,44 @@ export async function compactChannelIfNeeded(opts = {}) {
   const compactedReal = toCompact.filter((m) => m.type === "user" || m.type === "agent").length;
   if (compactedReal === 0) return { skipped: "nothing to compact" };
 
-  let transcript = toCompact.map(renderTurn).join("\n\n");
+  // keep_first (OpenHands): the first K events of a conversation are never
+  // condensed because they hold the original goal. Our JSONL model has a
+  // single covers_until_ts boundary and the reader drops EVERYTHING at or
+  // before it, so leaving those turns verbatim on disk reads would need a
+  // second boundary plus an intrusive reader change. We take the documented
+  // simplification instead: on the FIRST condensation (no previous compact —
+  // i.e. these really are the conversation's opening turns) the first
+  // `keepFirst` real turns are pulled out of the <EVENT> stream and quoted
+  // verbatim in the prompt with an instruction to preserve the original goal
+  // in USER_CONTEXT. On later condensations the goal already lives in the
+  // threaded previous summary, so keep_first no longer applies.
+  let openingTurns = [];
+  let eventRecords = toCompact;
+  if (!prevCompact && keepFirst > 0) {
+    openingTurns = toCompact
+      .filter((m) => m.type === "user" || m.type === "agent")
+      .slice(0, keepFirst);
+    const openingSet = new Set(openingTurns);
+    eventRecords = toCompact.filter((m) => !openingSet.has(m));
+  }
+
+  // Previous-summary threading: the last summary rides along as the first
+  // event so the new summary subsumes it (continuity across compactions).
+  const events = [];
   if (prevCompact && String(prevCompact.body || "").trim()) {
-    transcript =
-      `[RESUMEN PREVIO]\n${String(prevCompact.body).trim()}\n\n---\n\n` + transcript;
+    events.push(
+      `<EVENT id=0 role=summary>\n[PREVIOUS STATE SUMMARY]\n${String(prevCompact.body).trim()}\n</EVENT>`
+    );
   }
+  for (const m of eventRecords) events.push(renderEvent(m, events.length));
+
+  const prompt = buildCondenserPrompt({
+    eventsBlock: events.join("\n\n"),
+    openingBlock: openingTurns.map(renderTurn).join("\n\n"),
+  });
 
   const models = resolveCompactModels(config);
-  const summary = await summarize({ transcript, models, config });
+  const summary = await summarizeStructured({ prompt, models, config });
   if (!summary) {
     log(`memory: compaction for ${channel}/${chat_id} skipped — no model available`);
     return { skipped: "no model" };
@@ -177,6 +184,8 @@ export async function compactChannelIfNeeded(opts = {}) {
       covers_until_ts: boundaryTs,
       compacted_turns: compactedReal,
       model: summary.model,
+      condenser: "v2",
+      ...(prevCompact ? { prev_compact_ts: prevCompact.ts } : {}),
     },
   });
   log(

package/src/core/memory/summarizer.js

@@ -0,0 +1,125 @@
+// Structured-state summarizer — the ONE summarization service (condenser v2).
+//
+// Both compaction entry points share this brain so summaries are identical in
+// quality no matter how they were triggered:
+//   - automatic: core/memory/compactor.js over the rolling cross-channel log
+//   - on demand:  core/stores/conversations-compactor.js (apx session compact,
+//                 the web "compact" button, POST …/compact)
+// Different STORES, different triggers, ONE summarizer. Don't add a third.
+//
+// Mechanics ported from OpenHands' LLMSummarizingCondenser: a structured state
+// (not a narrative recap) plus previous-summary threading for continuity.
+
+import { callEngine } from "../engines/index.js";
+
+// Structured state summaries carry several labelled sections, so they need more
+// room than the old ~800-token narrative recap.
+export const COMPACT_MAX_TOKENS = 1200;
+
+export const CONDENSER_SYSTEM =
+  "You are maintaining a context-aware state summary for an interactive agent. " +
+  "Another model will read your summary to continue the work: be dense, factual, and structured.";
+
+// The instructions live in the USER prompt (not the system prompt) so offline
+// tests can capture the full instruction set through the echoing mock engine.
+const CONDENSER_INSTRUCTIONS = `You will be given a list of events from an agent conversation as <EVENT> blocks. If the first event is a PREVIOUS STATE SUMMARY, your new summary must fully subsume it — carry forward all still-relevant state.
+
+Maintain this structured state, one section per line group:
+
+USER_CONTEXT: (essential user requirements, goals, and clarifications, in concise form)
+TASK_TRACKING: (active tasks and their statuses; preserve exact task IDs)
+COMPLETED: (tasks completed so far, with brief results)
+PENDING: (tasks that still need to be done)
+CURRENT_STATE: (current variables, data structures, or other relevant state)
+
+For code-related tasks, also maintain:
+CODE_STATE: (file paths, function signatures, data structures)
+TESTS: (failing cases, error messages, outputs)
+CHANGES: (code edits and their effects)
+DEPS: (dependencies, imports, external calls)
+VERSION_CONTROL_STATUS: (repository state, current branch, PR status, commits)
+
+PRIORITIZE:
+1. Adapt the format to the actual task type — omit sections that do not apply.
+2. Capture key user requirements and goals.
+3. Distinguish completed work from pending work.
+4. Keep every section concise and relevant.
+
+SKIP: greetings, meta-commentary, failed operations without semantic importance, repetitive details.
+
+Output ONLY the summary sections (max ~900 tokens).`;
+
+/**
+ * Resolve the compaction model chain. Primary: a light, local-endpoint model
+ * (Ollama, incl. *-cloud served via localhost). Fallback: whatever the user
+ * configured, else the APX default super-agent model — never silently a paid
+ * service the user didn't pick. A blank fallback resolves at call time.
+ */
+export function resolveCompactModels(config = {}) {
+  const mem = config.memory || {};
+  return {
+    primary: mem.compact_model || "ollama:gemma4:31b-cloud",
+    fallback: mem.compact_fallback_model || config.super_agent?.model || "",
+  };
+}
+
+/**
+ * Render a normalized turn list into `<EVENT>` blocks. Items:
+ *   { role: "user"|"assistant"|"tool", content: string, name?: string }
+ * `prevSummary` (if any) rides along as EVENT id=0 role=summary so the new
+ * summary subsumes it (continuity across compactions).
+ */
+export function renderEvents(items, { prevSummary = "" } = {}) {
+  const events = [];
+  if (prevSummary && String(prevSummary).trim()) {
+    events.push(
+      `<EVENT id=0 role=summary>\n[PREVIOUS STATE SUMMARY]\n${String(prevSummary).trim()}\n</EVENT>`
+    );
+  }
+  for (const it of items) {
+    const id = events.length;
+    if (it.role === "tool") {
+      const name = it.name || "tool";
+      events.push(`<EVENT id=${id} role=tool name=${name}>\n${String(it.content || "").slice(0, 600)}\n</EVENT>`);
+    } else {
+      const role = it.role === "user" ? "user" : "assistant";
+      events.push(`<EVENT id=${id} role=${role}>\n${String(it.content || "")}\n</EVENT>`);
+    }
+  }
+  return events.join("\n\n");
+}
+
+/** Assemble the full user prompt (opening verbatim block + events). */
+export function buildCondenserPrompt({ eventsBlock, openingBlock = "" }) {
+  const opening = openingBlock
+    ? "The following opening turns of the conversation are quoted verbatim. They carry the ORIGINAL GOAL — preserve their intent (near-verbatim) under USER_CONTEXT:\n\n" +
+      `<CONVERSATION_OPENING>\n${openingBlock}\n</CONVERSATION_OPENING>\n\n`
+    : "";
+  return `${CONDENSER_INSTRUCTIONS}\n\n${opening}${eventsBlock}`;
+}
+
+/**
+ * Run the summarizer over a prompt, walking the model chain. Returns
+ * { text, model } or null when no model produced text (caller decides what a
+ * null means — skip compaction, keep raw history, etc.).
+ */
+export async function summarizeStructured({ prompt, models, config, maxTokens = COMPACT_MAX_TOKENS }) {
+  for (const modelId of [models.primary, models.fallback]) {
+    if (!modelId) continue;
+    try {
+      const r = await callEngine({
+        modelId,
+        system: CONDENSER_SYSTEM,
+        messages: [{ role: "user", content: prompt }],
+        config,
+        maxTokens,
+        temperature: 0.2,
+      });
+      const text = String(r.text || "").trim();
+      if (text) return { text, model: modelId };
+    } catch {
+      /* try next model */
+    }
+  }
+  return null;
+}

package/src/core/stores/conversations-compactor.js

@@ -25,30 +25,22 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseConversation } from "./conversations.js";
-import { callEngine } from "#core/engines/index.js";
+import {
+  renderEvents,
+  buildCondenserPrompt,
+  summarizeStructured,
+} from "#core/memory/summarizer.js";
 
 const KEEP_LAST = 6;
 
 const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
-const COMPACT_SYSTEM =
-  "You summarize conversations for AI agent context continuity. " +
-  "Be dense and factual — another AI will read this to continue the work.";
-
-const COMPACT_PROMPT = `Summarize this conversation for future context.
-
-Cover:
-- Main task or goal being worked on
-- Key decisions made and why
-- Files, code, commands modified (exact paths where relevant)
-- Current state: what's done, what's pending or unresolved
-- Errors encountered and how they were resolved
-
-Style: dense and factual. No pleasantries. No meta-commentary. Just the facts.
-
----
-
-`;
+// Map a parsed conversation role to the summarizer's normalized event role.
+function toEventRole(role) {
+  if (role === "user") return "user";
+  if (role === "tool") return "tool";
+  return "assistant"; // assistant / system → assistant side
+}
 
 // Resolve the most-recent conversation file for an agent, or the one explicitly
 // named. Returns the full filepath.
@@ -90,19 +82,21 @@ export async function compactConversation({
   const realTurns = turns.filter((t) => t.role !== "compact");
   if (realTurns.length === 0) throw new Error("nothing to compact — no user/assistant turns");
 
-  // Build a readable transcript for the model.
-  const transcript = realTurns
-    .map((t) => `[${t.role.toUpperCase()}]\n${t.content}`)
-    .join("\n\n---\n\n");
-
-  const result = await callEngine({
-    modelId,
-    system: COMPACT_SYSTEM,
-    messages: [{ role: "user", content: COMPACT_PROMPT + transcript }],
+  // Same summarizer service as the automatic condenser (structured state),
+  // just a different store/entry point. The whole conversation is condensed
+  // (no previous-summary threading here — a fresh compact per call).
+  const eventsBlock = renderEvents(
+    realTurns.map((t) => ({ role: toEventRole(t.role), content: t.content }))
+  );
+  const prompt = buildCondenserPrompt({ eventsBlock });
+  const out = await summarizeStructured({
+    prompt,
+    models: { primary: modelId, fallback: config?.super_agent?.model || "" },
     config,
   });
+  if (!out) throw new Error("compaction failed — no model produced a summary");
 
-  const summary = result.text.trim();
+  const summary = out.text;
   const ts = nowIso();
   const turnCount = realTurns.length;
 
@@ -133,8 +127,7 @@ export async function compactConversation({
     filename: path.basename(filepath),
     compacted_turns: turnCount,
     kept_turns: recentTurns.length,
-    model: modelId,
+    model: out.model,
     summary,
-    usage: result.usage,
   };
 }

package/src/host/daemon/api/admin-config.js

@@ -14,6 +14,7 @@ import {
   isSecretMarker,
   mergeRedactedChannels,
 } from "#core/config/redact.js";
+import { collectSecretValues, registerSecretValues } from "#core/config/secret-values.js";
 
 export function register(app, { config, scheduler, plugins }) {
   app.get("/admin/config", (_req, res) => {
@@ -57,6 +58,10 @@ export function register(app, { config, scheduler, plugins }) {
     const fresh = readConfig();
     for (const key of Object.keys(config)) delete config[key];
     Object.assign(config, fresh);
+    // Keep the log-masking registry current: any secret just added via PATCH
+    // must be masked from this point on (registry is additive — removed
+    // secrets stay masked, which is the safe direction).
+    registerSecretValues(collectSecretValues(fresh));
     if (scheduler) scheduler.globalConfig = config;
     if (plugins) plugins.config = config;
     res.json({ ok: true, config: redact(fresh) });