digital-brain 1.1.1 → 1.1.11

package/README.md

@@ -78,11 +78,12 @@ node ./bin/digital-brain.js init ./Digital Brain\ Vault
 - Merge confirmed-looking same-person profiles across sources into a person context index.
 - Infer provisional roles like parent, family group, work collaborator, close personal contact, or unlabeled contact.
 - Extract relationship-specific typing style: casing, message length, punctuation, emoji, and slang.
+- Extract your own outbound communication style so drafts can match your casing, slang, punctuation, lexical patterns, and common phrase shapes.
 - Generate "how to continue this relationship" notes.
 - Generate reply-ready person context that keeps WhatsApp, iMessage, Slack, and LinkedIn evidence separate under the same person.
 - Create AI-readable memory files for future prompts.
-- Draft WhatsApp sends by default, and only send with explicit `--yes`.
-- Run an explicit WhatsApp auto-responder that uses local Ollama plus vault memory while the command is running.
+- Draft WhatsApp sends by default, send with explicit `--yes`, or configure auto-send mode during init.
+- Run an explicit WhatsApp auto-responder that uses Ollama or a Codex command plus vault memory while the command is running.
 - Enforce an AI-disclosure guard after repeated AI-assisted sends.
 
 ## Core Commands
@@ -96,6 +97,8 @@ digital-brain import-slack --input ./slack-export.zip
 digital-brain import-linkedin --input ./linkedin-archive.zip
 digital-brain send-whatsapp --to "Name" --message "text"
 digital-brain auto-whatsapp --allow "Name" --model llama3.1
+digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1
+digital-brain auto-whatsapp --allow-all --provider codex --yes
 ```
 
 `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.
@@ -115,14 +118,29 @@ digital-brain interpret
 
 The sender drafts by default. Add `--yes` to actually send.
 
-The auto-responder is opt-in and runs only while the command is active. It requires an allowlist unless you explicitly pass `--allow-all`. Without `--yes`, it only logs drafts:
+The auto-responder is opt-in and runs only while the command is active. On startup it scans unread WhatsApp Web chats, then listens for new messages. It requires an allowlist unless you explicitly pass `--allow-all`. Without `--yes`, it only logs drafts unless you selected `Auto-send while running` during init:
 
 ```bash
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1 --yes
+digital-brain auto-whatsapp --allow "Mom" --model llama3.1 --yes --no-process-unread
+digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1 --yes
+digital-brain auto-whatsapp --allow-all --provider codex --yes
 ```
 
-If Digital Brain has already sent two AI-assisted messages to the same chat in the last 24 hours, the next send must disclose that AI is helping unless you explicitly bypass the check.
+If you start without `--allow`, `--contact`, or `--allow-all` in an interactive terminal, Digital Brain asks whether to cover all contacts or select contacts from your WhatsApp chat list. With `--allow-all`, it still asks once before the first AI reply to each new chat and stores the decision in `08 Sources/WhatsApp/Outbound/auto-reply-whitelist.json`. Use `--auto-approve-new-chats` only if you intentionally want unattended first sends.
+
+Even with `--allow-all`, likely business, notification, OTP, delivery, bank, and support chats are skipped by default. Use explicit `--allow "Name"` or `--contact "+15551234567"` for trusted personal chats. Pass `--include-businesses` only if you intentionally want those chats included.
+
+The default provider is local Ollama. To use Codex instead:
+
+```bash
+digital-brain auto-whatsapp --allow-all --provider codex --yes
+```
+
+If your Codex CLI needs a custom command, pass `--codex-command "..."` or set `DIGITAL_BRAIN_CODEX_COMMAND`. If the command contains `{promptFile}`, Digital Brain writes the reply prompt to a temp file and substitutes that path; otherwise it pipes the prompt to stdin.
+
+If Digital Brain has already sent two AI-assisted messages to the same chat in the last 24 hours, the next send must disclose that AI is helping. Once that chat has received an AI disclosure, Digital Brain will not keep repeating it.
 
 ## Automation
 

package/bin/digital-brain.js

@@ -52,7 +52,7 @@ async function init(argv, args) {
   let privacyMode = args["privacy-mode"] || "standard";
   let sourceMarkdownMode = args["source-markdown-mode"] || "none";
   let selectedSources = parseList(args.sources || "whatsapp");
-  let responsibilityAccepted = fullAuto || schedule === "always-on";
+  let responsibilityAccepted = toBoolean(args["responsibility-accepted"]) || fullAuto || schedule === "always-on";
 
   if (!args.yes) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -103,10 +103,11 @@ async function init(argv, args) {
       ["disabled", "Disabled", "Never prepares WhatsApp sends.", "🔒"],
       ["draft", "Draft only", "Prepares text and requires you to send it.", "✍️"],
       ["send-with-confirmation", "Send with confirmation", "Can send only after explicit command confirmation.", "✅"],
+      ["auto-send", "Auto-send while running", "Lets auto-whatsapp send from allowlisted chats while it is running.", "🚦"],
     ], outboundMode);
     connectAi = await confirm(rl, "🔗 Add global AI pointers for Codex/Claude/Gemini?", true);
     responsibilityAccepted = await responsibilityGate(rl, { schedule, outboundMode });
-    if (!responsibilityAccepted && (schedule === "always-on" || outboundMode === "send-with-confirmation")) {
+    if (!responsibilityAccepted && needsResponsibilityGate({ schedule, outboundMode })) {
       console.log("Full-auto/outbound confirmation was not accepted. Using manual refresh and draft-only outbound.");
       schedule = "manual";
       outboundMode = "draft";
@@ -115,6 +116,10 @@ async function init(argv, args) {
     rl.close();
   }
 
+  if (args.yes && needsResponsibilityGate({ schedule, outboundMode }) && !responsibilityAccepted) {
+    throw new Error("This mode requires explicit responsibility acceptance. Re-run with --responsibility-accepted=true or use draft mode.");
+  }
+
   ensureDir(vault);
   copyDir(path.join(root, "templates", "vault"), vault);
   const config = {
@@ -503,7 +508,7 @@ async function confirm(rl, label, fallback) {
 }
 
 async function responsibilityGate(rl, { schedule, outboundMode }) {
-  const needsGate = schedule === "always-on" || outboundMode === "send-with-confirmation";
+  const needsGate = needsResponsibilityGate({ schedule, outboundMode });
   if (!needsGate) return true;
   console.log("");
   console.log("⚠️  Responsibility check:");
@@ -513,6 +518,10 @@ async function responsibilityGate(rl, { schedule, outboundMode }) {
   return confirm(rl, "I understand and want this mode enabled", false);
 }
 
+function needsResponsibilityGate({ schedule, outboundMode }) {
+  return schedule === "always-on" || ["send-with-confirmation", "auto-send"].includes(outboundMode);
+}
+
 function letterFor(index) {
   return String.fromCharCode(65 + index);
 }
@@ -584,6 +593,6 @@ Usage:
   digital-brain extract --days 30
   digital-brain interpret --days 30
   digital-brain send-whatsapp --to "Name" --message "Text" [--yes]
-  digital-brain auto-whatsapp --allow "Name" --model llama3.1 [--yes]
+  digital-brain auto-whatsapp --allow "Name" --contact "+15551234567" --provider ollama|codex --model llama3.1 [--yes] [--no-process-unread]
 `);
 }

package/docs/AUTOMATIONS.md

@@ -45,6 +45,7 @@ Important defaults:
 - skipped always-on interval uses 5 minutes, with a hard minimum of 1 minute
 - skipped active window uses `08:00-12:00`
 - skipped outbound mode uses draft-only
+- auto-send mode can be selected during init, but only after the responsibility check
 - skipped AI pointers are added during the guided quiz
 
 The answers are saved in:
@@ -63,7 +64,7 @@ digital-brain init --full-auto
 
 Auto mode configures local always-on refreshes with a 5 minute default interval. It still uses the local watch script, so it only runs while the machine and runner are awake.
 
-During the guided quiz, always-on and send-with-confirmation require an explicit responsibility check. Pressing Enter does not approve that check. If it is skipped, Digital Brain falls back to manual refresh and draft-only outbound.
+During the guided quiz, always-on, send-with-confirmation, and auto-send require an explicit responsibility check. Pressing Enter does not approve that check. If it is skipped, Digital Brain falls back to manual refresh and draft-only outbound.
 
 ## Codex App
 
@@ -95,30 +96,64 @@ The generated script loops forever and sleeps for `refreshIntervalMinutes`. The
 
 ## WhatsApp Auto-Reply
 
-`digital-brain auto-whatsapp` is separate from refresh automation. It uses WhatsApp Web for live incoming messages and Ollama for local reply generation.
+`digital-brain auto-whatsapp` is separate from refresh automation. It uses WhatsApp Web for live incoming messages and either Ollama or a Codex command for reply generation. On startup it scans unread WhatsApp Web chats, then continues listening for new messages.
 
 Draft-only:
 
 ```bash
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1
+digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1
+digital-brain auto-whatsapp --allow-all --provider codex
 ```
 
 Auto-send while the command is running:
 
 ```bash
 digital-brain auto-whatsapp --allow "Mom" --model llama3.1 --yes
+digital-brain auto-whatsapp --contact "+15551234567" --model llama3.1 --yes
+digital-brain auto-whatsapp --allow-all --provider codex --yes
+```
+
+Broad auto-send for personal chats:
+
+```bash
+digital-brain auto-whatsapp --allow-all --model llama3.1 --yes
+```
+
+`--allow-all` still skips likely business, notification, OTP, bank, delivery, and support chats by default. Use `--include-businesses` only when you intentionally want those chats included. Prefer explicit `--allow "Name"` or `--contact "+15551234567"` for friends and family.
+
+When `--allow-all` is used, Digital Brain asks once before the first AI reply to each new chat and stores allow/deny decisions in `08 Sources/WhatsApp/Outbound/auto-reply-whitelist.json`. Use `--auto-approve-new-chats` only for fully unattended first sends.
+
+Provider options:
+
+```bash
+digital-brain auto-whatsapp --allow "Mom" --provider ollama --model llama3.1 --yes
+digital-brain auto-whatsapp --allow "Mom" --provider codex --yes
+digital-brain auto-whatsapp --allow "Mom" --provider codex --codex-command "codex exec --skip-git-repo-check" --yes
+```
+
+`--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.
+
+If you selected `Auto-send while running` during init, `auto-whatsapp` can send without `--yes` while it is running:
+
+```bash
+digital-brain auto-whatsapp --allow "Mom" --model llama3.1
 ```
 
 Guardrails:
 
-- requires Ollama running locally
-- requires the selected model, for example `ollama pull llama3.1`
-- requires `--allow "Name"` unless `--allow-all` is explicitly passed
+- with `--provider ollama`, requires Ollama running locally
+- with `--provider ollama`, requires the selected model, for example `ollama pull llama3.1`
+- with `--provider codex`, requires a working local Codex command
+- 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
+- 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
 - uses a per-chat cooldown, default 20 minutes
 - caps replies per chat per run, default 5
 - logs metadata by default, not full sent text
-- still enforces the AI disclosure rule after repeated AI-assisted sends
+- enforces the AI disclosure rule after repeated AI-assisted sends, but does not repeat it after that chat has already received a disclosure
 
 ## Local Cron
 

package/docs/PRIVACY.md

@@ -7,7 +7,7 @@ Digital Brain is designed for local use.
 - No cloud API is called by default.
 - Ollama interpretation is local when enabled.
 - WhatsApp sending uses a local WhatsApp Web session.
-- WhatsApp auto-reply uses local Ollama by default, runs only while the command is active, and requires an allowlist unless explicitly overridden.
+- WhatsApp auto-reply uses local Ollama by default or a configured local Codex command, runs only while the command is active, and requires an allowlist unless explicitly overridden. If init is configured for auto-send mode, it can send without `--yes`.
 - Raw source data stays under `08 Sources/`; normal AI context should use `06 AI Memory/` and human notes under `04 People/`.
 - Same-person matching across sources is provisional and file-based; keep source evidence visible when using merged person context.
 

package/package.json

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

package/scripts/digital_brain_relationship_extractor.py

@@ -13,6 +13,14 @@ NEGATIVE = {"angry", "annoyed", "upset", "sad", "bad", "hate", "sorry", "fight",
 LOGISTICS = {"when", "where", "time", "today", "tomorrow", "meeting", "call", "send", "sent", "come", "coming", "reach", "book", "plan", "schedule"}
 WORK = {"pr", "repo", "client", "customer", "meeting", "deck", "code", "ship", "product", "founder", "startup", "work", "office", "investor", "sales", "demo", "launch"}
 SLANG = {"lol", "lmao", "haha", "hahaha", "bro", "bruh", "wtf", "omg", "ngl", "idk", "rn", "btw", "bc", "pls", "plz", "ya", "yeah", "yep", "nah", "fuck", "shit"}
+DISCOURSE_MARKERS = {"actually", "basically", "bro", "cool", "like", "literally", "no", "okay", "so", "wait", "yeah"}
+STOPWORDS = {
+    "a", "about", "all", "am", "an", "and", "are", "as", "at", "be", "been", "but", "by", "can", "could", "did", "do", "does",
+    "for", "from", "get", "got", "had", "has", "have", "he", "her", "here", "him", "his", "how", "i", "if", "in", "is", "it",
+    "its", "just", "me", "my", "not", "of", "on", "or", "our", "she", "so", "that", "the", "their", "them", "then", "there",
+    "they", "this", "to", "too", "up", "was", "we", "were", "what", "when", "where", "who", "why", "will", "with", "would",
+    "you", "your",
+}
 
 
 def main():
@@ -24,9 +32,12 @@ def main():
     messages = load_messages(sources, args.days)
     profiles = build_profiles(messages, args.min_messages)
     people = build_people(profiles)
+    self_profile = build_self_profile(messages)
     write_json_atomic(output_dir / "relationship_profiles.json", profiles)
     write_json_atomic(output_dir / "person_identity_map.json", people)
+    write_json_atomic(output_dir / "self_profile.json", self_profile)
     write_markdown(output_dir / "Relationship Map.md", profiles, args.days)
+    write_self_memory(vault / "06 AI Memory" / "My Communication Style.md", self_profile, args.days)
     write_people_memory(vault / "06 AI Memory" / "Person Context Index.md", people, args.days)
     write_legacy_whatsapp_outputs(vault, output_dir)
     print(f"Analyzed {len(messages)} messages.")
@@ -246,6 +257,33 @@ def build_people(profiles):
     return people
 
 
+def build_self_profile(messages):
+    outbound = [m for m in messages if m.get("fromMe") and (m.get("body") or "").strip()]
+    by_source = defaultdict(list)
+    for message in outbound:
+        by_source[message.get("sourceSystem") or source_system(message)].append(message)
+    dates = [m["_dt"] for m in outbound]
+    style = typing_style(outbound)
+    lexical = lexical_profile(outbound)
+    return {
+        "profileType": "self_communication_style",
+        "messageCount": len(outbound),
+        "firstSeen": min(dates).date().isoformat() if dates else None,
+        "lastSeen": max(dates).date().isoformat() if dates else None,
+        "sources": sorted(by_source.keys()),
+        "sourceBreakdown": {
+            source: {
+                "messageCount": len(items),
+                "typingStyle": typing_style(items),
+            }
+            for source, items in sorted(by_source.items())
+        },
+        "typingStyle": style,
+        "lexicalProfile": lexical,
+        "replyGuidance": self_reply_guidance(style, lexical),
+    }
+
+
 def write_markdown(path, profiles, days):
     lines = ["# Relationship Map", "", f"Window: last {days} days", "", "Generated signals. Treat as editable working notes.", ""]
     for profile in profiles:
@@ -265,6 +303,52 @@ def write_markdown(path, profiles, days):
     write_text_atomic(path, "\n".join(lines))
 
 
+def write_self_memory(path, profile, days):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    style = profile.get("typingStyle", {})
+    lexical = profile.get("lexicalProfile", {})
+    lines = [
+        "# My Communication Style",
+        "",
+        f"Window: last {days} days",
+        "",
+        "Generated from the user's own outbound messages. Treat this as the default voice for drafts and auto-replies.",
+        "",
+        f"- Outbound sample: {profile.get('messageCount', 0)} messages",
+        f"- Sources: {', '.join(profile.get('sources', [])) or 'none'}",
+        f"- Dates: {profile.get('firstSeen') or 'n/a'} to {profile.get('lastSeen') or 'n/a'}",
+        f"- Signature: {style.get('signature', 'unknown')}",
+        f"- Average length: {style.get('avgWords', 0)} words / {style.get('avgChars', 0)} chars",
+        f"- Lowercase share: {style.get('lowercaseShare', 0)}",
+        f"- Questions: {style.get('questionShare', 0)}",
+        f"- Exclamations: {style.get('exclamationShare', 0)}",
+        f"- Emoji share: {style.get('emojiShare', 0)}",
+        f"- Slang: {', '.join(style.get('slang', [])) or 'none'}",
+        "",
+        "## Lexical Profile",
+        "",
+        f"- Vocabulary density: {lexical.get('uniqueTokenShare', 0)} unique-token share",
+        f"- Common style words: {', '.join(lexical.get('commonStyleWords', [])) or 'none'}",
+        f"- Common content words: {', '.join(lexical.get('topContentWords', [])) or 'none'}",
+        f"- Common phrases: {', '.join(lexical.get('commonPhrases', [])) or 'none'}",
+        f"- Common openers: {', '.join(lexical.get('messageOpeners', [])) or 'none'}",
+        f"- Common endings: {', '.join(lexical.get('messageEndings', [])) or 'none'}",
+        f"- Contractions: {', '.join(lexical.get('contractions', [])) or 'none'}",
+        f"- Abbreviations: {', '.join(lexical.get('abbreviations', [])) or 'none'}",
+        f"- Punctuation habits: {', '.join(lexical.get('punctuationHabits', [])) or 'none'}",
+        f"- Lowercase `i` share: {lexical.get('lowercaseIShare', 0)}",
+        "",
+        "## Reply Guidance",
+        "",
+    ]
+    for item in profile.get("replyGuidance", []):
+        lines.append(f"- {item}")
+    lines.extend(["", "## Source Breakdown", ""])
+    for source, data in profile.get("sourceBreakdown", {}).items():
+        lines.append(f"- {source}: {data.get('messageCount', 0)} outbound messages; {typing_style_summary(data.get('typingStyle', {}))}")
+    write_text_atomic(path, "\n".join(lines) + "\n")
+
+
 def write_people_memory(path, people, days):
     path.parent.mkdir(parents=True, exist_ok=True)
     lines = ["# Person Context Index", "", f"Window: last {days} days", "", "Canonical people matched across sources. Treat matches as provisional unless manually confirmed.", ""]
@@ -289,7 +373,7 @@ def write_people_memory(path, people, days):
 def write_legacy_whatsapp_outputs(vault, output_dir):
     legacy_dir = vault / "08 Sources" / "WhatsApp" / "Analysis"
     legacy_dir.mkdir(parents=True, exist_ok=True)
-    for name in ("relationship_profiles.json", "person_identity_map.json", "Relationship Map.md"):
+    for name in ("relationship_profiles.json", "person_identity_map.json", "self_profile.json", "Relationship Map.md"):
         source = output_dir / name
         target = legacy_dir / name
         if source.exists():
@@ -368,6 +452,115 @@ def typing_style(messages):
     }
 
 
+def lexical_profile(messages):
+    bodies = [(m.get("body") or "").strip() for m in messages if (m.get("body") or "").strip()]
+    tokens_by_body = [tokenize_words(body) for body in bodies]
+    tokens = [token for body_tokens in tokens_by_body for token in body_tokens]
+    if not bodies or not tokens:
+        return empty_lexical_profile()
+
+    content_counts = Counter(token for token in tokens if token not in STOPWORDS and not token.isdigit() and len(token) > 1)
+    style_counts = Counter(token for token in tokens if token in SLANG or token in DISCOURSE_MARKERS)
+    bigrams = Counter(ngram for body_tokens in tokens_by_body for ngram in ngrams(body_tokens, 2))
+    trigrams = Counter(ngram for body_tokens in tokens_by_body for ngram in ngrams(body_tokens, 3))
+    openers = Counter(message_opener(body_tokens) for body_tokens in tokens_by_body if body_tokens)
+    endings = Counter(message_ending(body) for body in bodies if message_ending(body))
+    contractions = Counter(token for token in tokens if "'" in token)
+    abbreviations = Counter(token for token in tokens if token in SLANG or (token.isupper() and len(token) <= 5))
+    lowercase_i = sum(1 for body in bodies if re.search(r"(^|[^A-Za-z])i([^A-Za-z]|$)", body))
+    uppercase_i = sum(1 for body in bodies if re.search(r"(^|[^A-Za-z])I([^A-Za-z]|$)", body))
+
+    return {
+        "sampleSize": len(bodies),
+        "tokenCount": len(tokens),
+        "uniqueTokenShare": round(len(set(tokens)) / max(len(tokens), 1), 2),
+        "commonStyleWords": top_keys(style_counts, 12),
+        "topContentWords": top_keys(content_counts, 12),
+        "commonPhrases": top_phrases(bigrams, trigrams),
+        "messageOpeners": top_keys(openers, 8),
+        "messageEndings": top_keys(endings, 8),
+        "contractions": top_keys(contractions, 8),
+        "abbreviations": top_keys(abbreviations, 8),
+        "punctuationHabits": punctuation_habits(bodies),
+        "lowercaseIShare": round(lowercase_i / max(lowercase_i + uppercase_i, 1), 2),
+    }
+
+
+def empty_lexical_profile():
+    return {
+        "sampleSize": 0,
+        "tokenCount": 0,
+        "uniqueTokenShare": 0,
+        "commonStyleWords": [],
+        "topContentWords": [],
+        "commonPhrases": [],
+        "messageOpeners": [],
+        "messageEndings": [],
+        "contractions": [],
+        "abbreviations": [],
+        "punctuationHabits": [],
+        "lowercaseIShare": 0,
+    }
+
+
+def tokenize_words(text):
+    return re.findall(r"[A-Za-z][A-Za-z']*|\d+", text.lower())
+
+
+def ngrams(tokens, size):
+    return [" ".join(tokens[index:index + size]) for index in range(0, max(len(tokens) - size + 1, 0))]
+
+
+def message_opener(tokens):
+    return " ".join(tokens[:min(3, len(tokens))])
+
+
+def message_ending(text):
+    stripped = text.strip()
+    if not stripped:
+        return ""
+    match = re.search(r"([!?.,]+)$", stripped)
+    if match:
+        return match.group(1)
+    words = tokenize_words(stripped)
+    return words[-1] if words else ""
+
+
+def top_keys(counter, limit):
+    return [key for key, _ in counter.most_common(limit)]
+
+
+def top_phrases(bigrams, trigrams):
+    phrases = []
+    for counter in (trigrams, bigrams):
+        for phrase, count in counter.most_common(10):
+            tokens = phrase.split()
+            if count < 2 and len(phrases) >= 3:
+                continue
+            if all(token in STOPWORDS for token in tokens):
+                continue
+            phrases.append(phrase)
+            if len(phrases) >= 8:
+                return phrases
+    return phrases
+
+
+def punctuation_habits(bodies):
+    habits = []
+    checks = [
+        ("no terminal punctuation", lambda body: bool(body) and body[-1].isalnum()),
+        ("question marks", lambda body: "?" in body),
+        ("exclamation marks", lambda body: "!" in body),
+        ("ellipsis", lambda body: "..." in body),
+        ("repeated punctuation", lambda body: bool(re.search(r"[!?.,]{2,}", body))),
+    ]
+    for label, predicate in checks:
+        share = sum(1 for body in bodies if predicate(body)) / max(len(bodies), 1)
+        if share >= 0.2:
+            habits.append(f"{label} ({round(share, 2)})")
+    return habits
+
+
 def typing_style_summary(style):
     slang = ", ".join(style.get("slang", [])) or "none"
     return (
@@ -376,6 +569,41 @@ def typing_style_summary(style):
     )
 
 
+def self_reply_guidance(style, lexical=None):
+    lexical = lexical or empty_lexical_profile()
+    guidance = []
+    signature = style.get("signature") or ""
+    if style.get("sampleSize", 0) == 0:
+        return ["No outbound sample yet; keep replies concise and natural."]
+    if style.get("lowercaseShare", 0) >= 0.45 or "lowercase-heavy" in signature:
+        guidance.append("Prefer undercapitalized/lowercase casual texting unless the context is formal.")
+    if style.get("avgWords", 0) <= 8:
+        guidance.append("Keep most replies short. Avoid polished essay-like phrasing.")
+    else:
+        guidance.append("Longer replies are normal when the topic needs context, but avoid sounding corporate.")
+    if style.get("questionShare", 0) >= 0.2:
+        guidance.append("It is natural to ask direct follow-up questions.")
+    if style.get("exclamationShare", 0) < 0.1:
+        guidance.append("Use exclamation marks sparingly.")
+    if style.get("emojiShare", 0) < 0.1:
+        guidance.append("Do not add emoji unless the recent chat already uses them.")
+    slang = style.get("slang", [])
+    if slang:
+        guidance.append(f"Known casual words/slang from the user's style: {', '.join(slang)}.")
+    style_words = lexical.get("commonStyleWords", [])
+    phrases = lexical.get("commonPhrases", [])
+    openers = lexical.get("messageOpeners", [])
+    if style_words:
+        guidance.append(f"Prefer the user's recurring style words when natural: {', '.join(style_words[:8])}.")
+    if phrases:
+        guidance.append(f"Reuse short recurring phrase shapes only when they fit: {', '.join(phrases[:5])}.")
+    if openers:
+        guidance.append(f"Common message starts include: {', '.join(openers[:5])}.")
+    if lexical.get("lowercaseIShare", 0) >= 0.45:
+        guidance.append("The user often types lowercase `i`; preserve that in casual replies.")
+    return guidance
+
+
 def infer_typing_signature(avg_words, lowercase, questions, exclaims, emojis, slang):
     parts = []
     if avg_words <= 4:

package/templates/vault/00 Home/How AI Should Use This Vault.md

@@ -7,5 +7,6 @@ Rules:
 - Prefer local evidence over assumptions.
 - Be clear when a claim is inferred.
 - Treat generated relationship notes as provisional.
+- When writing as the user, check `06 AI Memory/My Communication Style.md` for voice, casing, slang, and punctuation.
 - When replying to a person, check `06 AI Memory/Person Reply Context.md` first.
 - Do not send messages without explicit permission.

package/templates/vault/06 AI Memory/My Communication Style.md

@@ -0,0 +1,5 @@
+# My Communication Style
+
+Generated from the user's outbound messages after `digital-brain run`.
+
+Use this as the default voice for drafts and auto-replies. It includes typing averages plus lexical patterns like recurring words, openers, phrase shapes, punctuation, and casing. Keep relationship-specific context from `Person Reply Context.md` separate.

package/templates/vault/08 Sources/WhatsApp/Outbound/README.md

@@ -17,4 +17,4 @@ digital-brain send-whatsapp --to "Name" --message "Text" --yes
 Disclosure rule:
 
 - If Digital Brain sends multiple AI-assisted messages in the same chat, it must disclose that AI is helping after roughly 2 messages.
-- The sender enforces this on the third AI-assisted send within 24 hours unless the message already includes a disclosure.
+- The sender enforces this on the third AI-assisted send within 24 hours unless the message already includes a disclosure. Once a chat has received that disclosure, Digital Brain will not keep repeating it.

package/templates/vault/AGENTS.md

@@ -8,6 +8,7 @@ Before answering personal-context questions, read:
 - `00 Home/How AI Should Use This Vault.md`
 - `01 Identity/Working Profile.md`
 - `06 AI Memory/What AI Should Remember.md`
+- `06 AI Memory/My Communication Style.md`
 - `06 AI Memory/Person Context Index.md`
 - `06 AI Memory/Person Reply Context.md`
 - `06 AI Memory/Interpreted Relationship Memory.md`
@@ -18,6 +19,7 @@ Rules:
 - Separate facts from interpretation.
 - Treat relationship labels as editable working notes.
 - Do not expose private summaries unless asked.
+- For writing as the user, prefer the user's own style profile before generic assistant tone.
 - For reply help, prefer person-level context over source-specific notes when available.
 - Do not read `08 Sources/` raw files unless the user explicitly asks you to inspect source data.
 - Prefer `06 AI Memory/` summaries and `04 People/` human notes for normal context.

package/templates/vault/CLAUDE.md

@@ -4,6 +4,6 @@ This is a Digital Brain vault. Use it as local personal context when relevant.
 
 Start with `00 Home/Start Here.md`.
 
-For reply help, prefer `06 AI Memory/Person Reply Context.md` when available.
+For reply help, prefer `06 AI Memory/My Communication Style.md` for the user's voice and `06 AI Memory/Person Reply Context.md` for the relationship.
 
 Do not read `08 Sources/` raw files unless the user explicitly asks for source-level evidence.

package/templates/vault/GEMINI.md

@@ -4,6 +4,6 @@ This is a Digital Brain vault. Use it as local personal context when relevant.
 
 Start with `00 Home/Start Here.md`.
 
-For reply help, prefer `06 AI Memory/Person Reply Context.md` when available.
+For reply help, prefer `06 AI Memory/My Communication Style.md` for the user's voice and `06 AI Memory/Person Reply Context.md` for the relationship.
 
 Do not read `08 Sources/` raw files unless the user explicitly asks for source-level evidence.

package/whatsapp-web/auto-reply.mjs

@@ -1,10 +1,15 @@
 import fs from "node:fs";
 import crypto from "node:crypto";
 import path from "node:path";
+import readline from "node:readline/promises";
+import { spawn } from "node:child_process";
+import { stdin as input, stdout as output } from "node:process";
 import qrcode from "qrcode-terminal";
 import pkg from "whatsapp-web.js";
 
 const { Client, LocalAuth } = pkg;
+const BUSINESS_NAME_RE = /\b(amazon|flipkart|myntra|nykaa|swiggy|zomato|blinkit|zepto|uber|ola|rapido|delivery|courier|dunzo|paytm|phonepe|gpay|google pay|hdfc|icici|sbi|axis|kotak|amex|bank|airtel|jio|vodafone|vi|support|helpdesk|customer care|official|verified|business|meta ai|whatsapp|no[\s-]?reply|noreply|otp|login|security|alerts?|notifications?|offers?|promo|marketing)\b/i;
+const BUSINESS_BODY_RE = /\b(otp|one time password|verification code|login code|security code|do not share|order|delivered|delivery|shipment|tracking|invoice|payment|transaction|debited|credited|refund|ticket|support|unsubscribe|offer|coupon|sale|valid till|automated message)\b/i;
 const args = parseArgs(process.argv.slice(2));
 
 if (!args.vault) usage();
@@ -14,18 +19,34 @@ const whatsAppDir = path.join(vault, "08 Sources", "WhatsApp");
 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 config = readConfig(vault);
+const provider = args.provider || config.autoReplyProvider || "ollama";
 const model = args.model || config.autoReplyModel || "llama3.1";
+const codexCommand = args["codex-command"] || process.env.DIGITAL_BRAIN_CODEX_COMMAND || config.codexCommand || "codex exec --skip-git-repo-check";
 const allow = parseList(args.allow || "");
 const deny = parseList(args.deny || "");
+const contactNumbers = parseList([args.contact, args.phone, args["contact-number"]].filter(Boolean).join(","))
+  .map(normalizePhone)
+  .filter(Boolean);
 const allowAll = Boolean(args["allow-all"]);
+let runtimeAllowAll = allowAll;
+const autoApproveNewChats = Boolean(args["auto-approve-new-chats"]);
 const includeGroups = Boolean(args["include-groups"]);
-const sendEnabled = Boolean(args.yes);
+const includeBusinesses = Boolean(args["include-businesses"]);
+const sendEnabled = Boolean(args.yes) || config.outboundMode === "auto-send";
+const processUnreadOnStart = !Boolean(args["no-process-unread"]);
 const cooldownMinutes = numberArg("cooldown-minutes", 20);
 const maxRepliesPerChat = numberArg("max-replies-per-chat", 5);
 const maxContextChars = numberArg("max-context-chars", 12000);
 const outboundLogMode = args["log-mode"] || config.outboundLogMode || "metadata";
 const state = loadState();
+const whitelist = loadWhitelist();
+const hasStoredScope = Object.keys(whitelist.allowedChats || {}).length > 0;
+const hasInitialScope = allowAll || allow.length > 0 || contactNumbers.length > 0 || hasStoredScope;
+const interactiveTerminal = Boolean(input.isTTY && output.isTTY);
+let queueTail = Promise.resolve();
+const rl = interactiveTerminal ? readline.createInterface({ input, output }) : null;
 
 fs.mkdirSync(outboundDir, { recursive: true });
 
@@ -34,12 +55,16 @@ if (config.outboundMode === "disabled") {
   process.exit(1);
 }
 
-if (!allowAll && allow.length === 0) {
-  console.error('Refusing to auto-reply without an allowlist. Add --allow "Name" or pass --allow-all explicitly.');
+if (!hasInitialScope && !interactiveTerminal) {
+  console.error('Refusing to auto-reply without an allowlist. Add --allow "Name", --contact "+15551234567", or pass --allow-all explicitly.');
   process.exit(1);
 }
 
-await assertOllamaModel(model);
+if (provider === "ollama") {
+  await assertOllamaModel(model);
+} else if (!["codex"].includes(provider)) {
+  throw new Error(`Unsupported auto-reply provider "${provider}". Use "ollama" or "codex".`);
+}
 
 const client = new Client({
   authStrategy: new LocalAuth({ clientId: "digital-brain", dataPath: sessionDir }),
@@ -51,15 +76,29 @@ client.on("qr", (qr) => {
   qrcode.generate(qr, { small: true });
 });
 
-client.on("ready", () => {
-  console.log(`Digital Brain WhatsApp auto-reply running with Ollama model: ${model}`);
-  console.log(sendEnabled ? "Auto-send is enabled." : "Draft mode. Replies will be logged but not sent. Add --yes to send.");
-  console.log(allowAll ? "Allowlist: all chats." : `Allowlist: ${allow.join(", ")}`);
+client.on("ready", async () => {
+  console.log(`Digital Brain WhatsApp auto-reply running with provider: ${provider}${provider === "ollama" ? ` (${model})` : ""}`);
+  console.log(sendEnabled ? "Auto-send is enabled." : "Draft mode. Replies will be logged but not sent. Add --yes or set outboundMode=auto-send to send.");
+  if (!hasInitialScope) await configureInteractiveScope();
+  console.log(runtimeAllowAll ? "Allowlist: all chats, with first-send approval per new chat." : allowlistSummary());
+  if (provider === "codex") console.log(`Codex command: ${codexCommand}`);
+  if (!includeBusinesses) console.log("Likely business, notification, OTP, and service chats are skipped by default.");
+  try {
+    if (processUnreadOnStart) {
+      await processUnreadChats();
+    } else {
+      console.log("Startup unread scan disabled.");
+    }
+  } catch (error) {
+    console.error(`Startup unread scan failed: ${error.message}`);
+  }
+  console.log("Listening for new WhatsApp messages...");
 });
 
 client.on("message", async (message) => {
   try {
-    await handleMessage(message);
+    console.log(`Received WhatsApp message event: ${summarize(message.body || "[non-text message]")}`);
+    enqueueMessage(message);
   } catch (error) {
     console.error(`Auto-reply error: ${error.message}`);
   }
@@ -67,19 +106,156 @@ client.on("message", async (message) => {
 
 client.initialize();
 
-async function handleMessage(message) {
+async function processUnreadChats() {
+  const chats = await client.getChats();
+  const unreadChats = chats.filter((chat) => Number(chat.unreadCount || 0) > 0);
+  console.log(`Startup unread scan: ${unreadChats.length} unread chat(s).`);
+  for (const chat of unreadChats) {
+    const name = chatName(chat);
+    if (chat.isGroup && !includeGroups) {
+      console.log(`Skipping unread group chat: ${name}`);
+      continue;
+    }
+    if (!isAllowed(chat) || isDenied(name)) {
+      console.log(`Skipping unread chat outside allowlist: ${name}`);
+      continue;
+    }
+    if (isCoolingDown(name)) {
+      console.log(`Skipping unread chat during cooldown: ${name}`);
+      continue;
+    }
+    if (replyCount(name) >= maxRepliesPerChat) {
+      console.log(`Skipping unread chat at reply cap: ${name}`);
+      continue;
+    }
+    const recentMessages = await chat.fetchMessages({ limit: Math.max(12, Number(chat.unreadCount || 0) + 3) });
+    const latestInbound = recentMessages.filter((message) => !message.fromMe && !message.isStatus).at(-1);
+    if (!latestInbound) {
+      console.log(`No inbound unread candidate found for: ${name}`);
+      continue;
+    }
+    console.log(`Processing unread chat: ${name}`);
+    await enqueueMessage(latestInbound, chat);
+  }
+}
+
+async function configureInteractiveScope() {
+  console.log("");
+  console.log("Auto-reply scope:");
+  console.log("  A) all contacts, but ask once before the first AI reply to each new chat");
+  console.log("  S) select contacts from your WhatsApp chat list");
+  console.log("  Q) quit");
+  const answer = (await rl.question("Choose A/S/Q [S]: ")).trim().toLowerCase() || "s";
+  if (answer.startsWith("q")) {
+    await shutdown(0);
+    return;
+  }
+  if (answer.startsWith("a")) {
+    runtimeAllowAll = true;
+    console.log("Scope set to all contacts with first-send approval.");
+    return;
+  }
+  const chats = (await client.getChats())
+    .filter((chat) => includeGroups || !chat.isGroup)
+    .sort((a, b) => Number(b.timestamp || 0) - Number(a.timestamp || 0))
+    .slice(0, numberArg("select-limit", 60));
+  if (chats.length === 0) {
+    console.log("No WhatsApp chats found to select.");
+    return;
+  }
+  console.log("");
+  console.log("Select contacts:");
+  chats.forEach((chat, index) => {
+    console.log(`  ${index + 1}) ${chatName(chat)}`);
+  });
+  const selection = await rl.question("Numbers to whitelist, comma-separated: ");
+  const selected = parseIndexSelection(selection, chats.length).map((index) => chats[index]);
+  for (const chat of selected) {
+    setWhitelistDecision(chat, "allow", "startup-select");
+  }
+  console.log(`Whitelisted ${selected.length} chat(s).`);
+}
+
+function enqueueMessage(message, knownChat = null) {
+  queueTail = queueTail
+    .catch(() => undefined)
+    .then(() => handleMessage(message, knownChat))
+    .catch((error) => console.error(`Auto-reply error: ${error.message}`));
+  return queueTail;
+}
+
+async function ensureChatApproved(chat, recentMessages) {
+  const name = chatName(chat);
+  if (isExplicitlyAllowed(chat) || isChatWhitelisted(chat)) return true;
+  if (isChatDenied(chat)) {
+    console.log(`Skipping stored denied chat: ${name}`);
+    return false;
+  }
+  if (!runtimeAllowAll) return false;
+  if (autoApproveNewChats) {
+    setWhitelistDecision(chat, "allow", "auto-approve-new-chats");
+    return true;
+  }
+  if (!interactiveTerminal) {
+    console.log(`Skipping ${name}: first-send approval required but no interactive terminal is available.`);
+    return false;
+  }
+  console.log("");
+  console.log(`New chat needs AI approval: ${name}`);
+  const inbound = recentMessages.filter((item) => !item.fromMe && !item.isStatus).slice(-3);
+  for (const item of inbound) {
+    console.log(`  ${name}: ${summarize(item.body || "[non-text message]")}`);
+  }
+  const answer = (await rl.question("Whitelist this chat for AI auto-replies? [y/N]: ")).trim().toLowerCase();
+  if (answer === "y" || answer === "yes") {
+    setWhitelistDecision(chat, "allow", "first-send-prompt");
+    console.log(`Whitelisted ${name}.`);
+    return true;
+  }
+  setWhitelistDecision(chat, "deny", "first-send-prompt");
+  console.log(`Denied ${name}.`);
+  return false;
+}
+
+async function handleMessage(message, knownChat = null) {
   if (message.fromMe || message.isStatus) return;
   if (state.processedMessageIds.includes(message.id?._serialized)) return;
 
-  const chat = await message.getChat();
+  const chat = knownChat || await message.getChat();
   const name = chatName(chat);
-  if (chat.isGroup && !includeGroups) return;
-  if (!isAllowed(name)) return;
-  if (isDenied(name)) return;
-  if (isCoolingDown(name)) return;
-  if (replyCount(name) >= maxRepliesPerChat) return;
+  console.log(`Received from ${name}: ${summarize(message.body || "[non-text message]")}`);
+  if (chat.isGroup && !includeGroups) {
+    console.log(`Skipping group chat: ${name}`);
+    return;
+  }
+  if (!isAllowed(chat)) {
+    console.log(`Skipping chat outside allowlist: ${name}`);
+    return;
+  }
+  if (isDenied(name)) {
+    console.log(`Skipping denied chat: ${name}`);
+    return;
+  }
+  if (isCoolingDown(name)) {
+    console.log(`Skipping chat during cooldown: ${name}`);
+    return;
+  }
+  if (replyCount(name) >= maxRepliesPerChat) {
+    console.log(`Skipping chat at reply cap: ${name}`);
+    return;
+  }
 
+  console.log(`Fetching context for ${name}...`);
   const recentMessages = await chat.fetchMessages({ limit: 12 });
+  if (shouldSkipNonPersonalChat(chat, recentMessages)) {
+    console.log(`Skipping likely business/notification chat: ${name}`);
+    markProcessed(message, name, { sent: false });
+    return;
+  }
+  if (!(await ensureChatApproved(chat, recentMessages))) {
+    markProcessed(message, name, { sent: false });
+    return;
+  }
   const disclosure = disclosureStatus(name);
   const prompt = buildPrompt({
     chatName: name,
@@ -87,7 +263,10 @@ async function handleMessage(message) {
     recentMessages,
     disclosureRequired: disclosure.required,
   });
+  console.log(`Generating reply for ${name} with ${provider}${provider === "ollama" ? `:${model}` : ""}...`);
+  const startedAt = Date.now();
   const reply = await generateReply(prompt);
+  console.log(`Generated reply for ${name} in ${Date.now() - startedAt}ms: ${summarize(reply || "[empty reply]")}`);
   const finalReply = disclosure.required && !containsDisclosure(reply)
     ? `Just flagging this is my AI assistant helping draft/send this. ${reply}`
     : reply;
@@ -115,6 +294,12 @@ function buildPrompt({ chatName, incomingBody, recentMessages, disclosureRequire
     "You are helping the user reply on WhatsApp.",
     "Write exactly one message to send as the user.",
     "Be natural, concise, and relationship-appropriate.",
+    "First infer the immediate intent of the current conversation from the recent chat. Continue that thread only.",
+    "Do not start with hey/hi unless the recent chat itself uses that greeting pattern.",
+    "Mirror the vocabulary, register, and pacing already present in this chat.",
+    "Match the user's own communication style from My Communication Style. If it says lowercase-heavy or undercapitalized, prefer lowercase casual texting.",
+    "Use lexical signals from My Communication Style: recurring style words, openers, short phrase shapes, punctuation habits, and lowercase-i behavior.",
+    "Do not sound like customer support, corporate email, or a generic AI assistant.",
     "Use the user's local memory context, but do not reveal private notes or say you read a vault.",
     "Do not invent facts, commitments, times, or promises.",
     disclosureRequired ? "This send requires AI disclosure. Include a short clear disclosure in the message." : "Do not mention AI unless disclosure is required.",
@@ -135,6 +320,7 @@ function buildPrompt({ chatName, incomingBody, recentMessages, disclosureRequire
 
 function readMemoryContext(chatName) {
   const files = [
+    path.join(vault, "06 AI Memory", "My Communication Style.md"),
     path.join(vault, "06 AI Memory", "Person Reply Context.md"),
     path.join(vault, "06 AI Memory", "Person Context Index.md"),
     path.join(vault, "06 AI Memory", "Interpreted Relationship Memory.md"),
@@ -157,6 +343,11 @@ function readMemoryContext(chatName) {
 }
 
 async function generateReply(prompt) {
+  if (provider === "codex") return generateCodexReply(prompt);
+  return generateOllamaReply(prompt);
+}
+
+async function generateOllamaReply(prompt) {
   const response = await fetch("http://127.0.0.1:11434/api/generate", {
     method: "POST",
     headers: { "content-type": "application/json" },
@@ -172,6 +363,44 @@ async function generateReply(prompt) {
   return cleanReply(body.response || "");
 }
 
+async function generateCodexReply(prompt) {
+  return runReplyCommand(codexCommand, prompt, "codex");
+}
+
+async function runReplyCommand(command, prompt, label) {
+  const timeoutMs = numberArg("provider-timeout-ms", 120000);
+  const usesPromptFile = command.includes("{promptFile}");
+  const promptFile = usesPromptFile ? path.join(outboundDir, `reply-prompt-${Date.now()}-${Math.random().toString(16).slice(2)}.txt`) : "";
+  if (promptFile) fs.writeFileSync(promptFile, prompt, "utf8");
+  const renderedCommand = promptFile ? command.replaceAll("{promptFile}", shellQuote(promptFile)) : command;
+  return await new Promise((resolve, reject) => {
+    const child = spawn(renderedCommand, { shell: true, cwd: vault, env: process.env });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`${label} reply command timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+    child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      cleanupPromptFile(promptFile);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      cleanupPromptFile(promptFile);
+      if (code !== 0) {
+        reject(new Error(`${label} reply command failed with ${code}: ${summarize(stderr || stdout)}`));
+        return;
+      }
+      resolve(cleanReply(stdout));
+    });
+    if (!usesPromptFile) child.stdin.end(prompt);
+  });
+}
+
 async function assertOllamaModel(modelName) {
   let response;
   try {
@@ -199,8 +428,18 @@ function cleanReply(value) {
     .slice(0, 1200);
 }
 
-function isAllowed(name) {
-  if (allowAll) return true;
+function isAllowed(chatOrName) {
+  if (isChatDenied(chatOrName)) return false;
+  if (isChatWhitelisted(chatOrName)) return true;
+  if (runtimeAllowAll) return true;
+  const name = typeof chatOrName === "string" ? chatOrName : chatName(chatOrName);
+  if (contactNumbers.some((number) => chatMatchesContact(chatOrName, number))) return true;
+  return allow.some((item) => name.toLowerCase().includes(item.toLowerCase()));
+}
+
+function isExplicitlyAllowed(chatOrName) {
+  const name = typeof chatOrName === "string" ? chatOrName : chatName(chatOrName);
+  if (contactNumbers.some((number) => chatMatchesContact(chatOrName, number))) return true;
   return allow.some((item) => name.toLowerCase().includes(item.toLowerCase()));
 }
 
@@ -208,6 +447,130 @@ function isDenied(name) {
   return deny.some((item) => name.toLowerCase().includes(item.toLowerCase()));
 }
 
+function shouldSkipNonPersonalChat(chatOrName, recentMessages) {
+  if (includeBusinesses || isExplicitlyAllowed(chatOrName) || isChatWhitelisted(chatOrName)) return false;
+  const name = typeof chatOrName === "string" ? chatOrName : chatName(chatOrName);
+  return isLikelyBusinessOrAutomation(name, recentMessages);
+}
+
+function isLikelyBusinessOrAutomation(name, recentMessages = []) {
+  const nameText = normalizeBusinessText(name);
+  const recentText = recentMessages
+    .slice(-8)
+    .map((message) => normalizeBusinessText(message.body || ""))
+    .join(" ");
+  if (isShortCodeOrServiceNumber(nameText)) return true;
+  if (BUSINESS_NAME_RE.test(nameText)) return true;
+  if (BUSINESS_BODY_RE.test(recentText)) return true;
+  return false;
+}
+
+function isShortCodeOrServiceNumber(text) {
+  const compacted = text.replace(/\D/g, "");
+  return compacted.length >= 4 && compacted.length <= 8 && compacted.length / Math.max(text.length, 1) > 0.7;
+}
+
+function normalizeBusinessText(value) {
+  return String(value || "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+function chatMatchesContact(chatOrName, normalizedPhone) {
+  if (!normalizedPhone) return false;
+  if (typeof chatOrName === "string") {
+    return phoneCandidateMatches(normalizePhone(chatOrName), normalizedPhone);
+  }
+  const candidates = [
+    chatOrName.id?.user,
+    chatOrName.id?._serialized,
+    chatOrName.name,
+    chatOrName.formattedTitle,
+  ].map(normalizePhone).filter(Boolean);
+  return candidates.some((candidate) => phoneCandidateMatches(candidate, normalizedPhone));
+}
+
+function phoneCandidateMatches(candidate, expected) {
+  if (!candidate || !expected) return false;
+  return candidate.endsWith(expected) || expected.endsWith(candidate);
+}
+
+function normalizePhone(input) {
+  const digits = String(input || "").replace(/[^\d]/g, "");
+  return digits.length >= 8 ? digits : "";
+}
+
+function maskPhone(value) {
+  return value.length <= 4 ? "****" : `****${value.slice(-4)}`;
+}
+
+function allowlistSummary() {
+  const parts = [];
+  if (allow.length) parts.push(`names: ${allow.join(", ")}`);
+  if (contactNumbers.length) parts.push(`contacts: ${contactNumbers.map(maskPhone).join(", ")}`);
+  const storedCount = Object.keys(whitelist.allowedChats || {}).length;
+  if (storedCount) parts.push(`stored: ${storedCount} chat(s)`);
+  return `Allowlist: ${parts.join("; ")}`;
+}
+
+function isChatWhitelisted(chatOrName) {
+  return Boolean(whitelist.allowedChats?.[chatKey(chatOrName)]);
+}
+
+function isChatDenied(chatOrName) {
+  return Boolean(whitelist.deniedChats?.[chatKey(chatOrName)]);
+}
+
+function setWhitelistDecision(chat, decision, source) {
+  const key = chatKey(chat);
+  const record = {
+    chatName: chatName(chat),
+    chatId: typeof chat === "string" ? null : chat.id?._serialized || null,
+    source,
+    updatedAt: new Date().toISOString(),
+  };
+  if (decision === "allow") {
+    whitelist.allowedChats[key] = record;
+    delete whitelist.deniedChats[key];
+  } else {
+    whitelist.deniedChats[key] = record;
+    delete whitelist.allowedChats[key];
+  }
+  writeJsonAtomic(whitelistPath, whitelist);
+}
+
+function chatKey(chatOrName) {
+  if (typeof chatOrName === "string") return `name:${chatOrName.toLowerCase()}`;
+  return chatOrName.id?._serialized || `name:${chatName(chatOrName).toLowerCase()}`;
+}
+
+function loadWhitelist() {
+  if (!fs.existsSync(whitelistPath)) return emptyWhitelist();
+  try {
+    return normalizeWhitelist(JSON.parse(fs.readFileSync(whitelistPath, "utf8")));
+  } catch {
+    return emptyWhitelist();
+  }
+}
+
+function normalizeWhitelist(value) {
+  return {
+    schemaVersion: 1,
+    allowedChats: value?.allowedChats || {},
+    deniedChats: value?.deniedChats || {},
+  };
+}
+
+function emptyWhitelist() {
+  return { schemaVersion: 1, allowedChats: {}, deniedChats: {} };
+}
+
+function parseIndexSelection(value, max) {
+  return [...new Set(String(value || "")
+    .split(/[,\s]+/)
+    .map((item) => Number(item.trim()))
+    .filter((item) => Number.isInteger(item) && item >= 1 && item <= max)
+    .map((item) => item - 1))];
+}
+
 function isCoolingDown(name) {
   const last = state.lastSentAtByChat[name];
   if (!last) return false;
@@ -218,11 +581,13 @@ function replyCount(name) {
   return state.sentCountByChat[name] || 0;
 }
 
-function markProcessed(message, name) {
+function markProcessed(message, name, options = { sent: true }) {
   state.processedMessageIds.push(message.id?._serialized);
   state.processedMessageIds = state.processedMessageIds.filter(Boolean).slice(-1000);
-  state.lastSentAtByChat[name] = new Date().toISOString();
-  state.sentCountByChat[name] = replyCount(name) + 1;
+  if (options.sent !== false) {
+    state.lastSentAtByChat[name] = new Date().toISOString();
+    state.sentCountByChat[name] = replyCount(name) + 1;
+  }
   writeJsonAtomic(statePath, state);
 }
 
@@ -267,23 +632,28 @@ function disclosureStatus(chatNameValue) {
   const logPath = path.join(outboundDir, "sent.jsonl");
   if (!fs.existsSync(logPath)) return { required: false, count: 0 };
   const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-  const count = fs
+  const records = fs
     .readFileSync(logPath, "utf8")
     .split("\n")
     .filter(Boolean)
-    .map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    })
+    .map(parseJsonLine)
     .filter((record) => record)
     .filter((record) => record.resolvedChatName === chatNameValue)
-    .filter((record) => record.aiAssisted !== false)
+    .filter((record) => record.aiAssisted !== false);
+  const alreadyDisclosed = records.some((record) => record.disclosureIncluded);
+  if (alreadyDisclosed) return { required: false, count: 0, alreadyDisclosed: true };
+  const count = records
     .filter((record) => new Date(record.timestamp).getTime() >= cutoff)
     .filter((record) => !record.disclosureIncluded).length;
-  return { required: count >= 2, count };
+  return { required: count >= 2, count, alreadyDisclosed: false };
+}
+
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
 }
 
 function containsDisclosure(message) {
@@ -305,6 +675,26 @@ function writeJsonAtomic(file, value) {
   fs.renameSync(temp, file);
 }
 
+function cleanupPromptFile(file) {
+  if (file) {
+    try {
+      fs.unlinkSync(file);
+    } catch {
+      // ignore cleanup errors
+    }
+  }
+}
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+async function shutdown(code) {
+  if (rl) rl.close();
+  await client.destroy().catch(() => undefined);
+  process.exit(code);
+}
+
 function visibleMessage(record, reply) {
   return outboundLogMode === "full" ? reply : `[metadata only, ${record.messageCharCount} chars, ${record.messageHash.slice(0, 12)}]`;
 }
@@ -351,6 +741,8 @@ function parseArgs(argv) {
     if (arg === "--yes") out.yes = true;
     else if (arg === "--allow-all") out["allow-all"] = true;
     else if (arg === "--include-groups") out["include-groups"] = true;
+    else if (arg === "--include-businesses") out["include-businesses"] = true;
+    else if (arg === "--no-process-unread") out["no-process-unread"] = true;
     else if (arg.startsWith("--")) {
       const key = arg.slice(2);
       out[key] = argv[++i] || "";
@@ -360,6 +752,6 @@ function parseArgs(argv) {
 }
 
 function usage() {
-  console.error('Usage: digital-brain auto-whatsapp --allow "Name" --model llama3.1 [--yes] [--allow-all] [--include-groups]');
+  console.error('Usage: digital-brain auto-whatsapp --allow "Name" --contact "+15551234567" --model llama3.1 [--yes] [--allow-all] [--include-groups] [--include-businesses]');
   process.exit(1);
 }

package/whatsapp-web/send.mjs

@@ -127,24 +127,29 @@ function disclosureStatus(chat) {
 
   const cutoff = Date.now() - 24 * 60 * 60 * 1000;
   const name = chatName(chat);
-  const count = fs
+  const records = fs
     .readFileSync(logPath, "utf8")
     .split("\n")
     .filter(Boolean)
-    .map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    })
+    .map(parseJsonLine)
     .filter((record) => record)
     .filter((record) => record.resolvedChatName === name)
-    .filter((record) => record.aiAssisted !== false)
+    .filter((record) => record.aiAssisted !== false);
+  const alreadyDisclosed = records.some((record) => record.disclosureIncluded);
+  if (alreadyDisclosed) return { required: false, count: 0, alreadyDisclosed: true };
+  const count = records
     .filter((record) => new Date(record.timestamp).getTime() >= cutoff)
     .filter((record) => !record.disclosureIncluded).length;
 
-  return { required: count >= 2, count };
+  return { required: count >= 2, count, alreadyDisclosed: false };
+}
+
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
 }
 
 function containsDisclosure(message) {