pi-automem-bridge 0.2.2 → 0.2.4

package/README.md

@@ -10,7 +10,7 @@
 pi install npm:pi-automem-bridge
 ```
 
-[![npm version](https://badge.fury.io/js/pi-automem-bridge.svg)](https://badge.fury.io/js/pi-automem-bridge)
+[![npm version](https://img.shields.io/npm/v/pi-automem-bridge)](https://www.npmjs.com/package/pi-automem-bridge)
 [![npm downloads](https://img.shields.io/npm/dw/pi-automem-bridge)](https://www.npmjs.com/package/pi-automem-bridge)
 
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/L2J320X82M)
@@ -34,7 +34,7 @@ Plenty of agents can store a memory. Far fewer reach for it when it counts — o
 
 Once installed, the bridge hooks into pi's session lifecycle:
 
-- **At session start** it runs your startup recall queries against AutoMem and injects the results — your preferences, working style, and environment — into the system prompt.
+- **At session start** it eagerly warms the AutoMem MCP connection, runs your startup recall queries, and injects the results — your preferences, working style, and environment — into the system prompt.
 - **Before each turn** it recalls memories relevant to the current task and the detected project, again injected silently.
 - **When the agent writes a memory** the candidate passes through the write pipeline — normalize → secret-scan → policy check → dedupe → confirm or auto-store — so nothing unvetted reaches AutoMem.
 - **Relationship tools** let the agent link memories or record corrections with provenance, building a connected graph over time.
@@ -78,7 +78,8 @@ Add an MCP server entry named `automem` to `~/.pi/agent/mcp.json`, pointing at t
       "url": "https://your-automem-server.example.com/mcp",
       "headers": {
         "Authorization": "Bearer ${AUTOMEM_TOKEN}"
-      }
+      },
+      "lifecycle": "keep-alive"
     }
   }
 }
@@ -86,6 +87,8 @@ Add an MCP server entry named `automem` to `~/.pi/agent/mcp.json`, pointing at t
 
 This is the one step that can't be automated: the package has no way to know your server's address or auth token, and writing credentials on your behalf would be unsafe. Use `${ENV_VAR}` interpolation for the token — never hardcode secrets. The entry must be named `automem` (the name the extension looks for by default), or set a different name via `mcpServerName` in step 4.
 
+`"lifecycle": "keep-alive"` is strongly recommended. pi-mcp-adapter defaults MCP servers to `"lazy"`, which means the AutoMem sidecar may not connect until a tool is called. Memory should be available from the first prompt, so `keep-alive` connects at startup and reconnects automatically if the connection drops. `eager` also connects at startup, but it does not auto-reconnect.
+
 **Don't want to hand-edit JSON?** pi is a coding agent — tell it to do it: *"add an `automem` MCP server to my `mcp.json` at `https://my-server.example.com/mcp`, using `${AUTOMEM_TOKEN}` for auth."* Keep the real token in your environment so it never touches the file or the chat.
 
 ### 3. Reload pi
@@ -135,6 +138,8 @@ You don't type these — pi does, in plain conversation. Tell it *"remember that
 | `automem_link_memories` | Create a typed relationship between two existing memories. |
 | `automem_correct_memory` | Store a correction and link old → new with a provenance relationship (EVOLVED_INTO or CONTRADICTS). |
 
+Policy blocks, missing approval in non-interactive contexts, and invalid update requests surface as pi tool errors. User-cancelled confirmations and duplicate detection are normal control-flow results, so the agent can stop or choose the next write path deliberately.
+
 ---
 
 ## Write policy
@@ -203,6 +208,8 @@ Controls how much of the recalled context shows in chat. Injection into the syst
 
 Recall is best-effort context enrichment, so it runs on a short, bounded timeout instead of the full MCP request timeout — a slow or unreachable AutoMem server degrades gracefully to no injection rather than blocking your prompt. Tune with `turnRecall.timeoutMs` (default `8000`) and `startupRecall.timeoutMs` (default `15000`).
 
+pi-mcp-adapter supports `lazy`, `eager`, and `keep-alive` MCP lifecycles. Use `keep-alive` for AutoMem. The bridge also performs an eager health check at session start to warm the AutoMem connection; if that early check races startup and misses, later turns retry with a short timeout and run the missed startup recall after AutoMem recovers. `/automem-status` is still useful for manual diagnostics, but it is not required as a startup kick.
+
 ---
 
 ## Development

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-automem-bridge",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Automatic long-term memory recall and policy-gated writes for pi agents via AutoMem MCP",
   "keywords": [
     "pi-package",

package/src/commands/status.ts

@@ -3,7 +3,7 @@
  */
 
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { automemHealth, setAutoMemMcpServerName } from "../mcp-client";
+import { automemHealth, getAutoMemMcpLifecycle, setAutoMemMcpServerName } from "../mcp-client";
 import { loadConfig } from "../config";
 
 export function registerStatusCommand(pi: {
@@ -19,6 +19,15 @@ export function registerStatusCommand(pi: {
       setAutoMemMcpServerName(config.mcpServerName);
 
       ctx.ui.notify("Checking AutoMem...", "info");
+      try {
+        const lifecycle = getAutoMemMcpLifecycle();
+        ctx.ui.notify("MCP lifecycle: " + lifecycle, lifecycle === "lazy" ? "warning" : "info");
+        if (lifecycle === "lazy") {
+          ctx.ui.notify('Set lifecycle to "keep-alive" in ~/.pi/agent/mcp.json so AutoMem connects at startup and reconnects automatically.', "warning");
+        }
+      } catch (err) {
+        ctx.ui.notify("Could not inspect MCP lifecycle: " + err, "warning");
+      }
 
       const health = await automemHealth();
 

package/src/index.ts

@@ -9,7 +9,7 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadConfig } from "./config";
-import { automemHealth, discoverTools, setAutoMemMcpServerName } from "./mcp-client";
+import { automemHealth, discoverTools, getAutoMemMcpLifecycle, setAutoMemMcpServerName } from "./mcp-client";
 import { startupRecall, turnRecall, type RecallResult } from "./recall";
 import { detectProject } from "./project-detect";
 import { buildContextMessage } from "./context-injector";
@@ -24,6 +24,7 @@ export default function (pi: ExtensionAPI) {
   let autoMemHealthy = false;
   let autoMemCount: number | undefined;
   let startupInjected = false;
+  let startupRecallAttempted = false;
   let startupResult: RecallResult = { text: "", count: 0, truncated: false };
 
   // Register commands and write tools
@@ -37,32 +38,11 @@ export default function (pi: ExtensionAPI) {
     config = loadConfig();
     setAutoMemMcpServerName(config.mcpServerName);
 
-    try {
-      await discoverTools();
-      const health = await automemHealth();
-      autoMemHealthy = health.healthy;
-      autoMemCount = health.memoryCount;
-
-      if (health.healthy) {
-        const count = health.memoryCount != null ? " (" + health.memoryCount + ")" : "";
-        ctx.ui.notify("AutoMem: healthy" + count, "info");
-      } else {
-        ctx.ui.notify("AutoMem: unhealthy - " + (health.error || "unreachable"), "warning");
-      }
-    } catch (err) {
-      autoMemHealthy = false;
-      ctx.ui.notify("AutoMem health check failed: " + err, "warning");
-    }
+    notifyIfLazyMcpLifecycle(ctx);
+    await refreshAutoMemHealth(ctx, false);
 
     if (config.startupRecall.enabled && autoMemHealthy) {
-      try {
-        startupResult = await startupRecall(config);
-        if (startupResult.count > 0 && config.startupRecall.showStatus) {
-          ctx.ui.notify("AutoMem: recalled " + startupResult.count + " memories at startup", "info");
-        }
-      } catch (err) {
-        ctx.ui.notify("AutoMem startup recall failed: " + err, "warning");
-      }
+      await runStartupRecall(ctx);
     }
 
     updateStatusWidget(ctx);
@@ -70,7 +50,17 @@ export default function (pi: ExtensionAPI) {
 
   // before_agent_start - Turn-level recall + context injection
   pi.on("before_agent_start", async function(event: any, ctx: any) {
-    if (!autoMemHealthy) return;
+    if (!autoMemHealthy) {
+      const recovered = await refreshAutoMemHealth(ctx, true);
+      if (!recovered) {
+        updateStatusWidget(ctx);
+        return;
+      }
+    }
+
+    if (config.startupRecall.enabled && !startupRecallAttempted) {
+      await runStartupRecall(ctx);
+    }
 
     const prompt = event.prompt || "";
     if (!prompt.trim()) return;
@@ -135,9 +125,70 @@ export default function (pi: ExtensionAPI) {
     autoMemHealthy = false;
     autoMemCount = undefined;
     startupInjected = false;
+    startupRecallAttempted = false;
     startupResult = { text: "", count: 0, truncated: false };
   });
 
+  async function refreshAutoMemHealth(ctx: any, recoveringFromOffline: boolean): Promise<boolean> {
+    try {
+      if (!recoveringFromOffline) {
+        await discoverTools();
+      }
+
+      const healthTimeout = recoveringFromOffline
+        ? Math.max(1000, Math.min(3000, Number(config.turnRecall.timeoutMs || 3000)))
+        : 30000;
+      const health = await automemHealth(healthTimeout);
+      autoMemHealthy = health.healthy;
+      autoMemCount = health.memoryCount;
+
+      if (health.healthy) {
+        const count = health.memoryCount != null ? " (" + health.memoryCount + ")" : "";
+        ctx.ui.notify(recoveringFromOffline ? "AutoMem: recovered" + count : "AutoMem: healthy" + count, "info");
+      } else if (!recoveringFromOffline) {
+        ctx.ui.notify("AutoMem: unhealthy - " + (health.error || "unreachable"), "warning");
+      }
+
+      return health.healthy;
+    } catch (err) {
+      autoMemHealthy = false;
+      if (!recoveringFromOffline) {
+        ctx.ui.notify("AutoMem health check failed: " + err, "warning");
+      } else {
+        console.warn("[automem] AutoMem still unavailable during turn health retry: " + err);
+      }
+      return false;
+    }
+  }
+
+  async function runStartupRecall(ctx: any): Promise<void> {
+    startupRecallAttempted = true;
+    try {
+      startupResult = await startupRecall(config);
+      startupRecallAttempted = startupResult.failed !== true;
+      if (startupResult.count > 0 && config.startupRecall.showStatus) {
+        ctx.ui.notify("AutoMem: recalled " + startupResult.count + " memories at startup", "info");
+      }
+    } catch (err) {
+      startupRecallAttempted = false;
+      ctx.ui.notify("AutoMem startup recall failed: " + err, "warning");
+    }
+  }
+
+  function notifyIfLazyMcpLifecycle(ctx: any): void {
+    try {
+      const lifecycle = getAutoMemMcpLifecycle();
+      if (lifecycle === "lazy") {
+        ctx.ui.notify(
+          'AutoMem MCP lifecycle is "lazy". For automatic memory on every session, set the automem server in ~/.pi/agent/mcp.json to "lifecycle": "keep-alive".',
+          "warning",
+        );
+      }
+    } catch (err) {
+      console.warn("[automem] could not inspect MCP lifecycle: " + err);
+    }
+  }
+
   function updateStatusWidget(ctx: any) {
     const theme = ctx.ui.theme;
     if (autoMemHealthy) {

package/src/mcp-client.ts

@@ -19,11 +19,13 @@ export interface McpCallResult {
   isError?: boolean;
 }
 
-export interface McpHealth {
-  healthy: boolean;
-  memoryCount?: number;
-  error?: string;
-}
+export interface McpHealth {
+  healthy: boolean;
+  memoryCount?: number;
+  error?: string;
+}
+
+export type McpLifecycle = "lazy" | "eager" | "keep-alive" | string;
 
 // ---------------------------------------------------------------------------
 // MCP config reader
@@ -34,7 +36,7 @@ export interface McpHealth {
 // cheap stat signature (mtime + size — the same quick-check make/rsync use), so
 // an in-place mcp.json edit is still picked up even within a single mtime tick.
 // An empty signature (stat failed) never matches, forcing a fresh read.
-interface CachedServerConfig { url: string; auth: string; signature: string }
+interface CachedServerConfig { url: string; auth: string; lifecycle: McpLifecycle; signature: string }
 let mcpConfigCache: Map<string, CachedServerConfig> = new Map();
 
 function loadMcpServerConfig(serverName: string): CachedServerConfig {
@@ -57,9 +59,9 @@ function loadMcpServerConfig(serverName: string): CachedServerConfig {
   // different tools, so drop the discovery cache too.
   if (cached) discoveredTools = null;
 
-  const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf8")) as {
-    mcpServers?: Record<string, { url: string; headers?: Record<string, string> }>;
-  };
+  const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf8")) as {
+    mcpServers?: Record<string, { url: string; headers?: Record<string, string>; lifecycle?: string }>;
+  };
 
   const server = mcpJson.mcpServers ? mcpJson.mcpServers[serverName] : undefined;
   if (!server) {
@@ -68,13 +70,14 @@ function loadMcpServerConfig(serverName: string): CachedServerConfig {
   }
 
   const entry: CachedServerConfig = {
-    url: server.url,
-    auth: resolveEnvVars(server.headers?.Authorization || ""),
-    signature,
-  };
-  mcpConfigCache.set(serverName, entry);
-  return entry;
-}
+    url: server.url,
+    auth: resolveEnvVars(server.headers?.Authorization || ""),
+    lifecycle: server.lifecycle || "lazy",
+    signature,
+  };
+  mcpConfigCache.set(serverName, entry);
+  return entry;
+}
 
 // ---------------------------------------------------------------------------
 // Response parsing — handles both JSON and text/event-stream (SSE)
@@ -114,9 +117,14 @@ export function setAutoMemMcpServerName(serverName: string | undefined): void {
   }
 }
 
-function getAutoMemMcpServerName(): string {
-  return process.env.AUTOMEM_MCP_SERVER || configuredServerName || "automem";
-}
+function getAutoMemMcpServerName(): string {
+  return process.env.AUTOMEM_MCP_SERVER || configuredServerName || "automem";
+}
+
+export function getAutoMemMcpLifecycle(): McpLifecycle {
+  const serverName = getAutoMemMcpServerName();
+  return loadMcpServerConfig(serverName).lifecycle;
+}
 
 async function mcpCall(
   tool: string,
@@ -310,9 +318,9 @@ export async function automemRecall(
   return mcpCall(resolveToolName("recall_memory"), args, timeoutMs);
 }
 
-export async function automemHealth(): Promise<McpHealth> {
-  try {
-    const result = await mcpCall(resolveToolName("check_database_health"), {});
+export async function automemHealth(timeoutMs: number = 30000): Promise<McpHealth> {
+  try {
+    const result = await mcpCall(resolveToolName("check_database_health"), {}, timeoutMs);
     const text = result.content && result.content[0] ? result.content[0].text : undefined;
     if (text) {
       try {

package/src/recall.ts

@@ -179,19 +179,21 @@ function formatMemoriesForContext(
 // Startup recall
 // ---------------------------------------------------------------------------
 
-export interface RecallResult {
-  text: string;
-  count: number;
-  truncated: boolean;
-}
+export interface RecallResult {
+  text: string;
+  count: number;
+  truncated: boolean;
+  failed?: boolean;
+}
 
 export async function startupRecall(config: AutoMemConfig): Promise<RecallResult> {
   if (!config.startupRecall.enabled) {
     return { text: "", count: 0, truncated: false };
   }
 
-  const allMemories: FormattedMemory[] = [];
-  const seenIds = new Set<string>();
+  const allMemories: FormattedMemory[] = [];
+  const seenIds = new Set<string>();
+  let failedQueries = 0;
 
   for (let q = 0; q < config.startupRecall.queries.length; q++) {
     const query = config.startupRecall.queries[q];
@@ -219,16 +221,17 @@ export async function startupRecall(config: AutoMemConfig): Promise<RecallResult
           }
         }
       }
-    } catch (err) {
-      console.warn('[automem] startup recall query failed: "' + query + '" - ' + err);
-    }
-  }
+    } catch (err) {
+      failedQueries++;
+      console.warn('[automem] startup recall query failed: "' + query + '" - ' + err);
+    }
+  }
 
   const maxBytes = config.startupRecall.maxBytes;
   const { text, included, overflowed } = formatMemoriesForContext(allMemories, maxBytes);
   const truncated = included < allMemories.length || overflowed;
 
-  return { text, count: allMemories.length, truncated };
+  return { text, count: allMemories.length, truncated, failed: failedQueries > 0 };
 }
 
 // ---------------------------------------------------------------------------
@@ -276,8 +279,8 @@ export async function turnRecall(
     const truncated = included < memories.length || overflowed;
 
     return { text: formatted, count: memories.length, truncated };
-  } catch (err) {
-    console.warn("[automem] turn recall failed: " + err);
-    return { text: "", count: 0, truncated: false };
-  }
-}
+  } catch (err) {
+    console.warn("[automem] turn recall failed: " + err);
+    return { text: "", count: 0, truncated: false, failed: true };
+  }
+}

package/src/tools/memory-tools.ts

@@ -68,11 +68,10 @@ export function registerMemoryTools(pi: ExtensionAPI) {
         config,
       ).catch(() => ({ text: "Similar recall failed.", matches: [] }));
 
-      return {
-        content: [{ type: "text" as const, text: formatProposal(decision.action, decision.reasons, decision.normalized, similarText, similarMatches) }],
-        details: { action: decision.action, reasons: decision.reasons, findings: decision.findings, candidate: decision.normalized, similarMatches },
-        isError: decision.action === "block",
-      };
+      return {
+        content: [{ type: "text" as const, text: formatProposal(decision.action, decision.reasons, decision.normalized, similarText, similarMatches) }],
+        details: { action: decision.action, reasons: decision.reasons, findings: decision.findings, candidate: decision.normalized, similarMatches },
+      };
     },
   });
 
@@ -87,15 +86,11 @@ export function registerMemoryTools(pi: ExtensionAPI) {
       const config = loadConfig();
       setAutoMemMcpServerName(config.mcpServerName);
       const candidate = toCandidate(params);
-      const decision = evaluateWritePolicy(candidate, config);
-
-      if (decision.action === "block") {
-        return {
-          content: [{ type: "text" as const, text: "Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n") }],
-          details: { action: decision.action, reasons: decision.reasons, findings: decision.findings },
-          isError: true,
-        };
-      }
+      const decision = evaluateWritePolicy(candidate, config);
+
+      if (decision.action === "block") {
+        throw new Error("Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n"));
+      }
 
       const needsConfirmation = decision.action !== "auto";
       if (needsConfirmation && !params.approvedByUser) {
@@ -104,14 +99,10 @@ export function registerMemoryTools(pi: ExtensionAPI) {
           if (!ok) {
             return { content: [{ type: "text" as const, text: "AutoMem memory write cancelled." }], details: { cancelled: true } };
           }
-        } else {
-          return {
-            content: [{ type: "text" as const, text: "Confirmation required before storing this memory. Re-run with approvedByUser=true only after explicit user approval." }],
-            details: { action: decision.action, reasons: decision.reasons, candidate: decision.normalized },
-            isError: true,
-          };
-        }
-      }
+        } else {
+          throw new Error("Confirmation required before storing this memory. Re-run with approvedByUser=true only after explicit user approval.");
+        }
+      }
 
       // ── UPDATE path ──────────────────────────────────────────────────────
       if (params.updateMemoryId) {
@@ -158,11 +149,10 @@ export function registerMemoryTools(pi: ExtensionAPI) {
               "  2. Store anyway (new memory): call automem_commit_memory with dedupeQuery=\"\" to skip dedupe",
               "  3. Cancel: do nothing if this is not worth storing separately",
             ].join("\n"),
-          }],
-          details: { duplicateDetected: true, existingMemoryId: top.id, existingContent: top.content, candidate: decision.normalized, allSimilar: similarMatches },
-          isError: false,
-        };
-      }
+          }],
+          details: { duplicateDetected: true, existingMemoryId: top.id, existingContent: top.content, candidate: decision.normalized, allSimilar: similarMatches },
+        };
+      }
 
       // ── STORE path ───────────────────────────────────────────────────────
       const result = await automemStore(
@@ -193,12 +183,9 @@ export function registerMemoryTools(pi: ExtensionAPI) {
     promptSnippet: "Use after automem_commit_memory returns DUPLICATE_DETECTED, or when correcting a known memory. Requires the existing memory ID.",
     parameters: UpdateParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx: any) {
-      if (!params.memoryId) {
-        return {
-          content: [{ type: "text" as const, text: "memoryId is required for automem_update_memory." }],
-          isError: true,
-        };
-      }
+      if (!params.memoryId) {
+        throw new Error("memoryId is required for automem_update_memory.");
+      }
 
       if (!params.approvedByUser) {
         if (ctx && ctx.ui && typeof ctx.ui.confirm === "function") {
@@ -212,13 +199,10 @@ export function registerMemoryTools(pi: ExtensionAPI) {
           if (!ok) {
             return { content: [{ type: "text" as const, text: "AutoMem memory update cancelled." }], details: { cancelled: true } };
           }
-        } else {
-          return {
-            content: [{ type: "text" as const, text: "Confirmation required before updating this memory. Re-run with approvedByUser=true only after explicit user approval." }],
-            isError: true,
-          };
-        }
-      }
+        } else {
+          throw new Error("Confirmation required before updating this memory. Re-run with approvedByUser=true only after explicit user approval.");
+        }
+      }
 
       const result = await automemUpdate(params.memoryId, {
         content: params.content,

package/src/tools/relationship-tools.ts

@@ -31,14 +31,11 @@ export function registerRelationshipTools(pi: ExtensionAPI) {
     parameters: LinkParams,
     async execute(_toolCallId: string, params: any) {
       const config = loadConfig();
-      setAutoMemMcpServerName(config.mcpServerName);
-
-      if (!params.approvedByUser) {
-        return {
-          content: [{ type: "text" as const, text: "Confirmation required before linking memories. Re-run with approvedByUser=true only after explicit user approval.\n\nWould link:\n  " + params.memoryId1 + " → " + params.relationship + " → " + params.memoryId2 }],
-          isError: true,
-        };
-      }
+      setAutoMemMcpServerName(config.mcpServerName);
+
+      if (!params.approvedByUser) {
+        throw new Error("Confirmation required before linking memories. Re-run with approvedByUser=true only after explicit user approval.\n\nWould link:\n  " + params.memoryId1 + " -> " + params.relationship + " -> " + params.memoryId2);
+      }
 
       const strength = typeof params.strength === "number" ? params.strength : 0.5;
       const result = await automemAssociate(params.memoryId1, params.memoryId2, params.relationship, strength);
@@ -66,21 +63,14 @@ export function registerRelationshipTools(pi: ExtensionAPI) {
         tags: Array.isArray(params.tags) ? params.tags : [],
         importance: params.importance,
       };
-      const decision = evaluateWritePolicy(candidate, config);
-      if (decision.action === "block") {
-        return {
-          content: [{ type: "text" as const, text: "Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n") }],
-          details: { action: decision.action, reasons: decision.reasons, findings: decision.findings },
-          isError: true,
-        };
-      }
-
-      if (!params.approvedByUser) {
-        return {
-          content: [{ type: "text" as const, text: "Confirmation required before correcting memory. Re-run with approvedByUser=true only after explicit user approval.\n\nWould correct memory " + params.memoryId + " with:\n  " + params.correction }],
-          isError: true,
-        };
-      }
+      const decision = evaluateWritePolicy(candidate, config);
+      if (decision.action === "block") {
+        throw new Error("Blocked by AutoMem write policy.\n" + decision.reasons.map((r: string) => "- " + r).join("\n"));
+      }
+
+      if (!params.approvedByUser) {
+        throw new Error("Confirmation required before correcting memory. Re-run with approvedByUser=true only after explicit user approval.\n\nWould correct memory " + params.memoryId + " with:\n  " + params.correction);
+      }
 
       const rel = params.relationship === "CONTRADICTS" ? "CONTRADICTS" : "EVOLVED_INTO";
       // Store the normalized candidate so corrections get the same alwaysTag,