digital-brain 1.1.26 → 1.1.30

package/README.md

@@ -102,8 +102,12 @@ digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1
 OPENAI_API_KEY="sk-..." digital-brain auto-whatsapp --allow-all --provider openai --model gpt-4.1-mini --yes
 digital-brain auto-whatsapp --allow-all --provider codex --yes
 digital-brain auto-whatsapp --allow-all --provider codex-app --yes
+digital-brain pause-whatsapp
+digital-brain resume-whatsapp --chat "Name"
 ```
 
+While `auto-whatsapp` is running in a focused terminal, press `Space` to pause/resume globally.
+
 `init` remembers your vault globally, so `run` works from anywhere. `run` syncs the live local sources you selected, extracts relationships, and writes interpreted memory in one command.
 
 Slack and LinkedIn are import-based. Digital Brain reads official export archives; it does not scrape LinkedIn or automate private app UIs. See [docs/INTEGRATIONS.md](docs/INTEGRATIONS.md).

package/bin/digital-brain.js

@@ -31,6 +31,9 @@ async function main() {
   else if (command === "interpret") runPython("digital_brain_relationship_interpreter.py", argv);
   else if (command === "send-whatsapp") runNode("whatsapp-web/send.mjs", argv);
   else if (command === "auto-whatsapp") runNode("whatsapp-web/auto-reply.mjs", argv);
+  else if (command === "pause-whatsapp") pauseWhatsApp(argv, args);
+  else if (command === "resume-whatsapp") resumeWhatsApp(argv, args);
+  else if (command === "whatsapp-status") whatsappStatus(argv);
   else help();
 }
 
@@ -265,6 +268,62 @@ function runNode(script, argv) {
   process.exit(result.status ?? 1);
 }
 
+function pauseWhatsApp(argv, args) {
+  const vault = getVaultFromArgs(argv);
+  const file = pauseFile(vault);
+  ensureDir(path.dirname(file));
+  const state = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : { schemaVersion: 1, paused: false, pausedChats: {} };
+  state.schemaVersion = 1;
+  state.pausedChats ||= {};
+  const chat = args.chat || args.name || "";
+  if (chat) {
+    state.pausedChats[`name:${chat.toLowerCase()}`] = {
+      chatName: chat,
+      reason: args.reason || "",
+      updatedAt: new Date().toISOString(),
+    };
+    console.log(`Paused WhatsApp auto-replies for: ${chat}`);
+  } else {
+    state.paused = true;
+    state.reason = args.reason || "";
+    state.updatedAt = new Date().toISOString();
+    console.log("Paused WhatsApp auto-replies globally.");
+  }
+  writeFileAtomic(file, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function resumeWhatsApp(argv, args) {
+  const vault = getVaultFromArgs(argv);
+  const file = pauseFile(vault);
+  const state = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : { schemaVersion: 1, paused: false, pausedChats: {} };
+  state.schemaVersion = 1;
+  state.pausedChats ||= {};
+  const chat = args.chat || args.name || "";
+  if (chat) {
+    delete state.pausedChats[`name:${chat.toLowerCase()}`];
+    console.log(`Resumed WhatsApp auto-replies for: ${chat}`);
+  } else {
+    state.paused = false;
+    state.reason = "";
+    state.updatedAt = new Date().toISOString();
+    console.log("Resumed WhatsApp auto-replies globally.");
+  }
+  writeFileAtomic(file, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function whatsappStatus(argv) {
+  const vault = getVaultFromArgs(argv);
+  const file = pauseFile(vault);
+  const state = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : { paused: false, pausedChats: {} };
+  console.log(`WhatsApp auto-reply: ${state.paused ? "paused" : "running/not globally paused"}`);
+  const pausedChats = Object.values(state.pausedChats || {});
+  if (pausedChats.length) console.log(`Paused chats: ${pausedChats.map((chat) => chat.chatName).join(", ")}`);
+}
+
+function pauseFile(vault) {
+  return path.join(vault, "08 Sources", "WhatsApp", "Outbound", "auto-reply-pause.json");
+}
+
 function withVault(argv) {
   if (argv.includes("--vault") || argv.some((arg) => arg.startsWith("--vault="))) return argv;
   return ["--vault", getVaultFromArgs(argv), ...argv];
@@ -688,5 +747,8 @@ Usage:
   digital-brain interpret --days 30
   digital-brain send-whatsapp --to "Name" --message "Text" [--yes]
   digital-brain auto-whatsapp --allow "Name" --contact "+15551234567" --provider ollama|openai|codex|codex-app --model llama3.1 [--yes] [--no-process-unread]
+  digital-brain pause-whatsapp [--chat "Name"]
+  digital-brain resume-whatsapp [--chat "Name"]
+  digital-brain whatsapp-status
 `);
 }

package/docs/AUTOMATIONS.md

@@ -142,6 +142,18 @@ digital-brain auto-whatsapp --allow "Mom" --provider codex --codex-command "code
 
 `--provider openai` sends the same Digital Brain prompt and relevant vault context to the OpenAI API. Set `OPENAI_API_KEY`, pass `--openai-api-key`, or choose OpenAI during `digital-brain init` and paste the key into the local vault config.
 
+Pause/resume while `auto-whatsapp` is running:
+
+```bash
+digital-brain pause-whatsapp
+digital-brain resume-whatsapp
+digital-brain pause-whatsapp --chat "Mom"
+digital-brain resume-whatsapp --chat "Mom"
+digital-brain whatsapp-status
+```
+
+The running bot checks the pause file before each reply, so these commands do not require restarting the bot. When the `auto-whatsapp` terminal is focused, press `Space` to pause/resume globally and `Ctrl+C` to exit.
+
 `--provider codex` runs a local Codex command. If `--codex-command` contains `{promptFile}`, Digital Brain writes the prompt to a temp file and substitutes the path; otherwise it pipes the prompt to stdin.
 
 `--provider codex-app` does not use the Codex CLI. It writes request JSON files to `08 Sources/WhatsApp/Outbound/Codex App Bridge/requests` and waits for response JSON files in `responses`. A Codex desktop automation or live Codex thread must process those request files and write `{"reply":"..."}` to the provided `responsePath`.
@@ -164,6 +176,8 @@ Guardrails:
 - requires `--allow "Name"` or `--contact "+15551234567"` unless `--allow-all` is explicitly passed
 - single-threads reply generation so multiple incoming chats do not trigger overlapping sends
 - debounces live messages per chat, default 12000ms, so message bursts get one combined reply; override with `--reply-debounce-ms <ms>`
+- supports global and per-chat pause with `pause-whatsapp` / `resume-whatsapp`
+- supports a focused-terminal hotkey: `Space` toggles global pause/resume
 - skips likely business, notification, OTP, and service chats unless `--include-businesses` is passed or the chat is explicitly allowlisted by name or contact number
 - processes unread chats on startup unless `--no-process-unread` is passed
 - skips groups unless `--include-groups` is passed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "digital-brain",
-  "version": "1.1.26",
+  "version": "1.1.30",
   "description": "Your private digital imprint for AI assistants.",
   "type": "module",
   "bin": {

package/whatsapp-web/auto-reply.mjs

@@ -20,6 +20,7 @@ const outboundDir = path.join(whatsAppDir, "Outbound");
 const sessionDir = path.join(whatsAppDir, ".session");
 const statePath = path.join(outboundDir, "auto-reply-state.json");
 const whitelistPath = path.join(outboundDir, "auto-reply-whitelist.json");
+const pausePath = path.join(outboundDir, "auto-reply-pause.json");
 const codexAppBridgeDir = path.join(outboundDir, "Codex App Bridge");
 const config = readConfig(vault);
 const provider = args.provider || config.autoReplyProvider || "ollama";
@@ -51,6 +52,7 @@ const interactiveTerminal = Boolean(input.isTTY && output.isTTY);
 let queueTail = Promise.resolve();
 const pendingLiveReplies = new Map();
 const rl = interactiveTerminal ? readline.createInterface({ input, output }) : null;
+let keyboardControlsStarted = false;
 
 fs.mkdirSync(outboundDir, { recursive: true });
 
@@ -92,6 +94,7 @@ client.on("ready", async () => {
   if (!includeBusinesses) console.log("Likely business, notification, OTP, and service chats are skipped by default.");
   console.log(maxRepliesPerChat > 0 ? `Reply cap: ${maxRepliesPerChat} per chat per run.` : "Reply cap: unlimited.");
   console.log(`Live reply debounce: ${replyDebounceMs}ms.`);
+  startKeyboardControls();
   try {
     if (processUnreadOnStart) {
       await processUnreadChats();
@@ -121,7 +124,7 @@ async function processUnreadChats() {
   console.log(`Startup unread scan: ${unreadChats.length} unread chat(s).`);
   for (const chat of unreadChats) {
     const name = chatName(chat);
-    if (chat.isGroup && !includeGroups) {
+    if (chat.isGroup && !includeGroups && !isChatWhitelisted(chat)) {
       console.log(`Skipping unread group chat: ${name}`);
       continue;
     }
@@ -247,7 +250,12 @@ async function handleMessage(message, knownChat = null) {
   const chat = knownChat || await message.getChat();
   const name = chatName(chat);
   console.log(`Received from ${name}: ${summarize(message.body || "[non-text message]")}`);
-  if (chat.isGroup && !includeGroups) {
+  if (isAutoReplyPaused(chat)) {
+    console.log(`Skipping paused chat: ${name}`);
+    markProcessed(message, name, { sent: false });
+    return;
+  }
+  if (chat.isGroup && !includeGroups && !isChatWhitelisted(chat)) {
     console.log(`Skipping group chat: ${name}`);
     return;
   }
@@ -288,7 +296,7 @@ async function handleMessage(message, knownChat = null) {
   });
   console.log(`Generating reply for ${name} with ${provider}${provider === "ollama" ? `:${model}` : ""}...`);
   const startedAt = Date.now();
-  const reply = await generateReply(prompt);
+  const reply = matchPunctuationStyle(await generateReply(prompt), recentMessages);
   console.log(`Generated reply for ${name} in ${Date.now() - startedAt}ms: ${summarize(reply || "[empty reply]")}`);
   const finalReply = disclosure.required && !containsDisclosure(reply)
     ? `btw ai is helping me reply rn. ${reply}`
@@ -331,6 +339,7 @@ function buildPrompt({ chatName, incomingBody, recentMessages, disclosureRequire
     "Primary style source: the user's recent messages in this exact chat. Match their length, casing, bluntness, and punctuation from those examples.",
     "Secondary style source: My Communication Style. Use it only to break ties, not to add extra slang.",
     "Do not perform a persona. Do not intensify the tone beyond the user's examples.",
+    "Avoid polished punctuation. Do not add commas, apostrophes, semicolons, or final periods unless the user's recent examples use them.",
     "Do not force bro, lol, haha, lmao, wild, rn, emojis, or question marks. Use them only if the user's recent examples in this chat use them naturally.",
     "Avoid assistant-like niceness and filler such as sounds perfect, happy to, sure thing, smooth, quick, no worries, no demon stuff, digital prep chef, digital neil, spitting facts, living in the future, or let’s unless that exact energy is already in the chat.",
     "If the recipient asks about AI, answer directly in the user's casual tone and do not overexplain.",
@@ -566,6 +575,58 @@ function cleanReply(value) {
     .slice(0, 1200);
 }
 
+function matchPunctuationStyle(reply, recentMessages) {
+  const exampleMessages = recentMessages
+    .filter((item) => item.fromMe && compact(item.body || ""))
+    .map((item) => item.body || "");
+  const local = punctuationProfile(exampleMessages);
+  const global = readSelfPunctuationStyle();
+  let output = reply;
+  if (!prefersPunctuation(local, global, "apostrophe")) output = output.replace(/['’]/g, "");
+  if (!prefersPunctuation(local, global, "semicolon")) output = output.replace(/;/g, "");
+  if (!prefersPunctuation(local, global, "period")) output = output.replace(/\.+$/g, "");
+  if (!prefersPunctuation(local, global, "comma")) output = output.replace(/,/g, "");
+  return output.replace(/\s+/g, " ").trim();
+}
+
+function punctuationProfile(messages) {
+  const text = messages.join(" ");
+  const chars = text.length;
+  const count = (pattern) => (text.match(pattern) || []).length;
+  return {
+    hasLocalEvidence: messages.length >= 3 || chars >= 80,
+    apostropheRate: chars ? count(/['’]/g) / chars : 0,
+    commaRate: chars ? count(/,/g) / chars : 0,
+    semicolonRate: chars ? count(/;/g) / chars : 0,
+    periodRate: chars ? count(/\./g) / chars : 0,
+  };
+}
+
+function prefersPunctuation(local, global, kind) {
+  const field = `${kind}Rate`;
+  if (local.hasLocalEvidence) return local[field] > 0.001;
+  if (kind === "period" && global.noTerminalPunctuationShare >= 0.7) return false;
+  return global[field] > 0.001;
+}
+
+function readSelfPunctuationStyle() {
+  const profilePath = path.join(vault, "08 Sources", "Analysis", "self_profile.json");
+  if (!fs.existsSync(profilePath)) return {};
+  const profile = parseJsonLine(fs.readFileSync(profilePath, "utf8")) || {};
+  const habits = profile.lexicalProfile?.punctuationHabits || [];
+  const noTerminal = habits
+    .map((habit) => String(habit).match(/no terminal punctuation \(([\d.]+)\)/))
+    .find(Boolean);
+  const contractions = profile.lexicalProfile?.contractions || [];
+  return {
+    apostropheRate: contractions.length ? 0.01 : 0,
+    commaRate: 0,
+    semicolonRate: 0,
+    periodRate: noTerminal && Number(noTerminal[1]) >= 0.7 ? 0 : 0.01,
+    noTerminalPunctuationShare: noTerminal ? Number(noTerminal[1]) : 0,
+  };
+}
+
 function isAllowed(chatOrName) {
   if (isChatDenied(chatOrName)) return false;
   if (isChatWhitelisted(chatOrName)) return true;
@@ -650,11 +711,65 @@ function allowlistSummary() {
 }
 
 function isChatWhitelisted(chatOrName) {
-  return Boolean(whitelist.allowedChats?.[chatKey(chatOrName)]);
+  return chatKeys(chatOrName).some((key) => Boolean(whitelist.allowedChats?.[key]));
 }
 
 function isChatDenied(chatOrName) {
-  return Boolean(whitelist.deniedChats?.[chatKey(chatOrName)]);
+  return chatKeys(chatOrName).some((key) => Boolean(whitelist.deniedChats?.[key]));
+}
+
+function isAutoReplyPaused(chatOrName) {
+  const pause = readPauseState();
+  if (pause.paused) return true;
+  return chatKeys(chatOrName).some((key) => Boolean(pause.pausedChats?.[key]));
+}
+
+function readPauseState() {
+  if (!fs.existsSync(pausePath)) return { schemaVersion: 1, paused: false, pausedChats: {} };
+  try {
+    const pause = JSON.parse(fs.readFileSync(pausePath, "utf8"));
+    return {
+      schemaVersion: 1,
+      paused: Boolean(pause.paused),
+      pausedChats: pause.pausedChats || {},
+    };
+  } catch {
+    return { schemaVersion: 1, paused: false, pausedChats: {} };
+  }
+}
+
+function writePauseState(pause) {
+  writeJsonAtomic(pausePath, {
+    schemaVersion: 1,
+    paused: Boolean(pause.paused),
+    reason: pause.reason || "",
+    updatedAt: new Date().toISOString(),
+    pausedChats: pause.pausedChats || {},
+  });
+}
+
+function toggleGlobalPause() {
+  const pause = readPauseState();
+  pause.paused = !pause.paused;
+  pause.reason = pause.paused ? "keyboard-space" : "";
+  writePauseState(pause);
+  return pause.paused;
+}
+
+function startKeyboardControls() {
+  if (keyboardControlsStarted || !interactiveTerminal || typeof input.setRawMode !== "function") return;
+  keyboardControlsStarted = true;
+  input.setRawMode(true);
+  input.resume();
+  input.on("data", async (chunk) => {
+    const value = chunk.toString("utf8");
+    if (value === "\u0003") await shutdown(0);
+    if (value === " ") {
+      const paused = toggleGlobalPause();
+      console.log(paused ? "Paused WhatsApp auto-replies. Press Space to resume." : "Resumed WhatsApp auto-replies. Press Space to pause.");
+    }
+  });
+  console.log("Keyboard controls: Space toggles pause/resume. Ctrl+C exits.");
 }
 
 function setWhitelistDecision(chat, decision, source) {
@@ -676,8 +791,15 @@ function setWhitelistDecision(chat, decision, source) {
 }
 
 function chatKey(chatOrName) {
-  if (typeof chatOrName === "string") return `name:${chatOrName.toLowerCase()}`;
-  return chatOrName.id?._serialized || `name:${chatName(chatOrName).toLowerCase()}`;
+  return chatKeys(chatOrName)[0];
+}
+
+function chatKeys(chatOrName) {
+  if (typeof chatOrName === "string") return [`name:${chatOrName.toLowerCase()}`];
+  return [
+    chatOrName.id?._serialized,
+    `name:${chatName(chatOrName).toLowerCase()}`,
+  ].filter(Boolean);
 }
 
 function loadWhitelist() {
@@ -837,6 +959,7 @@ function shellQuote(value) {
 
 async function shutdown(code) {
   if (rl) rl.close();
+  if (typeof input.setRawMode === "function") input.setRawMode(false);
   await client.destroy().catch(() => undefined);
   process.exit(code);
 }