digital-brain 0.1.3 → 1.0.3

package/scripts/digital_brain_relationship_interpreter.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import argparse
 import json
+import time
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -19,26 +20,38 @@ ROLE_KEYWORDS = [
 def main():
     args = parse_args()
     vault = args.vault.resolve()
-    whatsapp = vault / "08 Sources" / "WhatsApp"
-    profile_path = whatsapp / "Analysis" / "relationship_profiles.json"
+    sources = vault / "08 Sources"
+    whatsapp = sources / "WhatsApp"
+    analysis = sources / "Analysis"
+    profile_path = analysis / "relationship_profiles.json"
+    if not profile_path.exists():
+        profile_path = whatsapp / "Analysis" / "relationship_profiles.json"
     profiles = json.loads(profile_path.read_text(encoding="utf-8"))
-    overrides = load_json(whatsapp / "relationship_overrides.json", {})
-    out_dir = whatsapp / "Analysis" / "Interpreted"
-    people_dir = vault / "04 People" / "Interpreted Relationships"
+    people_path = analysis / "person_identity_map.json"
+    people = load_json(people_path, [])
+    overrides = load_overrides(sources)
+    out_dir = analysis / "Interpreted"
+    legacy_out_dir = whatsapp / "Analysis" / "Interpreted"
+    drafts_dir = vault / "06 AI Memory" / "Generated Relationship Drafts"
     out_dir.mkdir(parents=True, exist_ok=True)
-    people_dir.mkdir(parents=True, exist_ok=True)
+    legacy_out_dir.mkdir(parents=True, exist_ok=True)
+    drafts_dir.mkdir(parents=True, exist_ok=True)
 
     models = []
     for profile in profiles:
-        model = build_model(profile, overrides.get(profile["chatName"], {}))
+        override = overrides.get(profile_key(profile), overrides.get(profile["chatName"], {}))
+        model = build_model(profile, override)
         note = render_note(model)
-        filename = safe_filename(profile["chatName"]) + ".md"
-        (out_dir / filename).write_text(note, encoding="utf-8")
-        (people_dir / filename).write_text(note, encoding="utf-8")
+        filename = safe_filename(profile.get("displayName") or profile["chatName"]) + ".md"
+        write_text_atomic(out_dir / filename, note)
+        write_text_atomic(legacy_out_dir / filename, note)
+        write_text_atomic(drafts_dir / filename, note)
         models.append(model)
 
-    (whatsapp / "Analysis" / "interpreted_relationship_models.json").write_text(json.dumps(models, indent=2, ensure_ascii=False), encoding="utf-8")
+    write_json_atomic(analysis / "interpreted_relationship_models.json", models)
+    write_json_atomic(whatsapp / "Analysis" / "interpreted_relationship_models.json", models)
     write_index(vault / "06 AI Memory" / "Interpreted Relationship Memory.md", models)
+    write_person_reply_index(vault / "06 AI Memory" / "Person Reply Context.md", people, models)
     print(f"Wrote interpreted notes: {len(models)}")
 
 
@@ -130,16 +143,17 @@ def infer_boundaries(role, difficulty):
 
 
 def render_note(model):
-    return f"""# {model['chatName']}
+    return f"""# {model.get('displayName') or model['chatName']}
 
 Generated: {datetime.now(timezone.utc).isoformat()}
+Source: {model.get('sourceSystem', 'Unknown')}
 Role: {model['role']}
 Role confidence: {model['roleConfidence']}
 Closeness: {model['closeness']}
 Conversation difficulty: {model['conversationDifficulty']}
 Typing style: {model['typingStyle'].get('signature', 'unknown')}
 
-These are private working notes. Edit them where wrong.
+Generated draft, not truth. These are private working notes. Edit them where wrong.
 
 ## Role / Relationship Label
 - {model['role']} ({model['roleConfidence']} confidence).
@@ -173,8 +187,62 @@ def write_index(path, models):
     lines = ["# Interpreted Relationship Memory", "", "Generated working notes. Treat as editable, not truth.", ""]
     for model in models:
         style = model.get("typingStyle", {}).get("signature", "unknown style")
-        lines.append(f"- [[{safe_filename(model['chatName'])}]]: {model['role']} ({model['roleConfidence']}), closeness {model['closeness']}, difficulty {model['conversationDifficulty']}, style {style}")
-    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        display = model.get("displayName") or model["chatName"]
+        lines.append(f"- [[{safe_filename(display)}]]: {model['role']} ({model['roleConfidence']}), closeness {model['closeness']}, difficulty {model['conversationDifficulty']}, style {style}")
+    write_text_atomic(path, "\n".join(lines) + "\n")
+
+
+def write_person_reply_index(path, people, models):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    models_by_key = {}
+    for model in models:
+        key = model.get("canonicalPersonKey")
+        if key:
+            models_by_key.setdefault(key, []).append(model)
+    if not people:
+        people = synthesize_people(models_by_key)
+    lines = [
+        "# Person Reply Context",
+        "",
+        "Use this first when responding to a specific person. It merges confirmed-looking matches across sources while keeping each source visible.",
+        "",
+    ]
+    for person in people:
+        key = person.get("canonicalPersonKey")
+        linked_models = sorted(models_by_key.get(key, []), key=lambda model: (model["messageCount"], model["lastSeen"]), reverse=True)
+        if not linked_models:
+            continue
+        lines.extend([
+            f"## {person.get('displayName') or linked_models[0].get('identityName') or linked_models[0]['chatName']}",
+            "",
+            f"- Canonical key: `{key}`",
+            f"- Aliases: {', '.join(person.get('aliases') or [])}",
+            f"- Sources: {', '.join(sorted({model['sourceSystem'] for model in linked_models}))}",
+            f"- Total messages: {sum(model['messageCount'] for model in linked_models)}",
+            "- Source-specific guidance:",
+        ])
+        for model in linked_models:
+            lines.extend([
+                f"  - {model['sourceSystem']} / {model['chatName']}: {model['role']} ({model['roleConfidence']}), closeness {model['closeness']}, difficulty {model['conversationDifficulty']}.",
+                f"    Style: {model.get('typingStyle', {}).get('signature', 'unknown')}.",
+                f"    Reply: {' '.join(model.get('replyStyle', [])[:2])}",
+            ])
+        lines.append("")
+    write_text_atomic(path, "\n".join(lines) + "\n")
+
+
+def synthesize_people(models_by_key):
+    people = []
+    for key, models in models_by_key.items():
+        if key.startswith("group::"):
+            continue
+        names = [model.get("identityName") or model["chatName"] for model in models]
+        people.append({
+            "canonicalPersonKey": key,
+            "displayName": names[0],
+            "aliases": sorted(set(names)),
+        })
+    return people
 
 
 def bullets(items):
@@ -229,6 +297,27 @@ def load_json(path, fallback):
     return json.loads(path.read_text(encoding="utf-8"))
 
 
+def write_json_atomic(path, data):
+    write_text_atomic(path, json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def write_text_atomic(path, content):
+    temp = path.with_name(f"{path.name}.{time.time_ns()}.tmp")
+    temp.write_text(content, encoding="utf-8")
+    temp.replace(path)
+
+
+def load_overrides(sources):
+    merged = {}
+    for path in sorted(sources.glob("*/relationship_overrides.json")):
+        merged.update(load_json(path, {}))
+    return merged
+
+
+def profile_key(profile):
+    return f"{profile.get('sourceSystem') or 'Unknown'}::{profile.get('chatName') or 'Unknown Chat'}"
+
+
 def parse_args():
     parser = argparse.ArgumentParser()
     parser.add_argument("--vault", type=Path, required=True)

package/scripts/digital_brain_slack_export_import.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import tempfile
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def main():
+    args = parse_args()
+    with unpack(args.input) as source:
+        import_export(args.vault.resolve(), source, args.days)
+
+
+def import_export(vault, source, days):
+    slack = vault / "08 Sources" / "Slack"
+    raw_dir = slack / "Raw"
+    chats_dir = slack / "ChatsByMonth"
+    state_dir = slack / ".sync-state"
+    for directory in (raw_dir, chats_dir, state_dir):
+        directory.mkdir(parents=True, exist_ok=True)
+
+    users = load_users(source / "users.json")
+    conversations = load_conversations(source)
+    seen_path = state_dir / "slack-seen-message-ids.json"
+    seen = load_seen(seen_path)
+    cutoff = datetime.now(timezone.utc).timestamp() - days * 24 * 60 * 60 if days else None
+    added = 0
+
+    for folder in sorted(path for path in source.iterdir() if path.is_dir()):
+        conversation = conversations.get(folder.name, {"name": folder.name, "is_group": True})
+        chat_name = conversation.get("name") or folder.name
+        is_group = conversation.get("is_group", True)
+        for file in sorted(folder.glob("*.json")):
+            for item in load_json(file, []):
+                if "ts" not in item or not item.get("text"):
+                    continue
+                timestamp = float(item["ts"])
+                if cutoff and timestamp < cutoff:
+                    continue
+                record = slack_record(item, users, chat_name, is_group, folder.name)
+                if record["id"] in seen:
+                    continue
+                append_jsonl(raw_dir, record)
+                append_markdown(chats_dir, record)
+                seen.add(record["id"])
+                added += 1
+
+    save_seen(seen_path, seen)
+    print(f"Imported {added} Slack messages.")
+
+
+def slack_record(item, users, chat_name, is_group, conversation_id):
+    user_id = item.get("user") or item.get("bot_id") or "unknown"
+    author = users.get(user_id, user_id)
+    timestamp = datetime.fromtimestamp(float(item["ts"]), tz=timezone.utc).isoformat()
+    return {
+        "id": f"slack-{conversation_id}-{item['ts']}",
+        "source": "Slack export",
+        "sourceSystem": "Slack",
+        "timestamp": timestamp,
+        "chatName": chat_name,
+        "chatId": conversation_id,
+        "isGroup": is_group,
+        "fromMe": False,
+        "author": author,
+        "authorId": user_id,
+        "body": item.get("text") or "",
+    }
+
+
+def load_users(path):
+    users = {}
+    for item in load_json(path, []):
+        user_id = item.get("id")
+        if not user_id:
+            continue
+        profile = item.get("profile") or {}
+        users[user_id] = profile.get("real_name") or profile.get("display_name") or item.get("name") or user_id
+    return users
+
+
+def load_conversations(source):
+    conversations = {}
+    for filename in ("channels.json", "groups.json", "dms.json", "mpims.json"):
+        for item in load_json(source / filename, []):
+            conversation_id = item.get("id") or item.get("name")
+            if not conversation_id:
+                continue
+            conversations[conversation_id] = {
+                "name": item.get("name") or item.get("name_normalized") or conversation_id,
+                "is_group": not filename == "dms.json",
+            }
+    return conversations
+
+
+def append_jsonl(raw_dir, record):
+    with (raw_dir / f"{record['timestamp'][:10]}.jsonl").open("a", encoding="utf-8") as f:
+        f.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+
+def append_markdown(chats_dir, record):
+    directory = chats_dir / record["timestamp"][:7]
+    directory.mkdir(parents=True, exist_ok=True)
+    file_path = directory / f"{safe_filename(record['chatName'])}.md"
+    if not file_path.exists():
+        file_path.write_text(f"# {record['chatName']}\n\nSynced from Slack export.\n\n", encoding="utf-8")
+    body = " ".join((record.get("body") or "").split())
+    with file_path.open("a", encoding="utf-8") as f:
+        f.write(f"- {record['timestamp']} | {record['author']}: {body}\n")
+
+
+def load_json(path, fallback):
+    if not path.exists():
+        return fallback
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def load_seen(path):
+    if not path.exists():
+        return set()
+    try:
+        return set(json.loads(path.read_text(encoding="utf-8")))
+    except Exception:
+        return set()
+
+
+def save_seen(path, seen):
+    path.write_text(json.dumps(sorted(seen), indent=2), encoding="utf-8")
+
+
+def safe_filename(value):
+    cleaned = "".join("-" if char in '/:\\?%*"<>|' else char for char in value)
+    return (" ".join(cleaned.split()).strip() or "Unknown Chat")[:120]
+
+
+def unpack(input_path):
+    input_path = input_path.resolve()
+    if input_path.is_dir():
+        return NullContext(input_path)
+    temp = tempfile.TemporaryDirectory()
+    with zipfile.ZipFile(input_path) as archive:
+        archive.extractall(temp.name)
+    return TempContext(Path(temp.name), temp)
+
+
+class NullContext:
+    def __init__(self, path):
+        self.path = path
+
+    def __enter__(self):
+        return self.path
+
+    def __exit__(self, *_):
+        return False
+
+
+class TempContext:
+    def __init__(self, path, temp):
+        self.path = path
+        self.temp = temp
+
+    def __enter__(self):
+        return self.path
+
+    def __exit__(self, *_):
+        self.temp.cleanup()
+        return False
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--vault", type=Path, required=True)
+    parser.add_argument("--input", type=Path, required=True)
+    parser.add_argument("--days", type=int, default=365)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

package/scripts/digital_brain_whatsapp_mac_sync.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 import argparse
+import hashlib
 import json
 import sqlite3
 import time
@@ -60,7 +61,7 @@ def sync_once(args, seen, raw_dir, chats_dir, whats_app):
 
     added = 0
     for row in rows:
-        record = row_to_record(row, args.self_name)
+        record = row_to_record(row, args.self_name, args.privacy_mode)
         if args.no_groups and record["isGroup"]:
             continue
         if args.chat and args.chat.lower() not in record["chatName"].lower():
@@ -74,13 +75,16 @@ def sync_once(args, seen, raw_dir, chats_dir, whats_app):
     return added
 
 
-def row_to_record(row, self_name):
+def row_to_record(row, self_name, privacy_mode):
     timestamp = datetime.fromtimestamp(float(row["message_date"]) + CORE_DATA_EPOCH_OFFSET, tz=timezone.utc).isoformat()
     chat_name = row["chat_name"] or row["chat_jid"] or "Unknown Chat"
     from_me = bool(row["is_from_me"])
+    body = row["text"] or ""
+    record_id = compound_id(row, timestamp)
     return {
-        "id": str(row["stanza_id"] or f"mac-db-{row['message_pk']}"),
+        "id": record_id,
         "source": "WhatsApp Mac app ChatStorage.sqlite",
+        "sourceSystem": "WhatsApp",
         "timestamp": timestamp,
         "chatPk": row["chat_pk"],
         "chatName": chat_name,
@@ -91,10 +95,23 @@ def row_to_record(row, self_name):
         "fromJid": row["from_jid"],
         "toJid": row["to_jid"],
         "messageType": row["message_type"],
-        "body": row["text"] or "",
+        "body": "" if privacy_mode == "metadata-only" else body,
+        "bodyHash": hashlib.sha256(body.encode("utf-8")).hexdigest() if privacy_mode == "metadata-only" else "",
+        "bodyCharCount": len(body),
     }
 
 
+def compound_id(row, timestamp):
+    parts = [
+        "whatsapp",
+        str(row["chat_pk"] or row["chat_jid"] or "unknown-chat"),
+        str(row["stanza_id"] or "no-stanza"),
+        str(row["message_pk"] or "no-pk"),
+        timestamp,
+    ]
+    return "::".join(parts)
+
+
 def append_jsonl(raw_dir, record):
     with (raw_dir / f"{record['timestamp'][:10]}.jsonl").open("a", encoding="utf-8") as f:
         f.write(json.dumps(record, ensure_ascii=False) + "\n")
@@ -110,9 +127,9 @@ def append_markdown(chats_dir, whats_app, record, mode):
     else:
         file_path = chats_dir / f"{safe_filename(record['chatName'])}.md"
     if not file_path.exists():
-        file_path.write_text(f"# {record['chatName']}\n\nSynced from WhatsApp Mac app.\n\n", encoding="utf-8")
-    speaker = record["author"]
-    body = " ".join(record["body"].split())
+        write_text_atomic(file_path, f"# {escape_markdown(record['chatName'])}\n\nSynced from WhatsApp Mac app.\n\n")
+    speaker = escape_markdown(record["author"])
+    body = escape_markdown(" ".join(record["body"].split()))
     with file_path.open("a", encoding="utf-8") as f:
         f.write(f"- {record['timestamp']} | {speaker}: {body}\n")
 
@@ -127,7 +144,7 @@ def load_seen(path):
 
 
 def save_seen(path, seen):
-    path.write_text(json.dumps(sorted(seen), indent=2), encoding="utf-8")
+    write_text_atomic(path, json.dumps(sorted(seen), indent=2))
 
 
 def safe_filename(value):
@@ -135,6 +152,17 @@ def safe_filename(value):
     return (" ".join(cleaned.split()).strip() or "Unknown Chat")[:120]
 
 
+def escape_markdown(value):
+    text = str(value).replace("\n", " ").replace("\r", " ")
+    return text.replace("\\", "\\\\").replace("[", "\\[").replace("]", "\\]").replace("|", "\\|")
+
+
+def write_text_atomic(path, content):
+    temp = path.with_name(f"{path.name}.{time.time_ns()}.tmp")
+    temp.write_text(content, encoding="utf-8")
+    temp.replace(path)
+
+
 def parse_args():
     parser = argparse.ArgumentParser()
     parser.add_argument("--vault", type=Path, required=True)
@@ -146,6 +174,7 @@ def parse_args():
     parser.add_argument("--db", type=Path, default=DEFAULT_DB)
     parser.add_argument("--self-name", default="Me")
     parser.add_argument("--markdown-mode", choices=["chat", "month", "none"], default="chat")
+    parser.add_argument("--privacy-mode", choices=["standard", "metadata-only"], default="standard")
     return parser.parse_args()
 
 

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

@@ -7,5 +7,5 @@ Rules:
 - Prefer local evidence over assumptions.
 - Be clear when a claim is inferred.
 - Treat generated relationship notes as provisional.
+- When replying to a person, check `06 AI Memory/Person Reply Context.md` first.
 - Do not send messages without explicit permission.
-

package/templates/vault/00 Home/Start Here.md

@@ -7,5 +7,6 @@ Core notes:
 - [[How AI Should Use This Vault]]
 - [[Working Profile]]
 - [[What AI Should Remember]]
+- [[Person Context Index]]
+- [[Person Reply Context]]
 - [[Interpreted Relationship Memory]]
-

package/templates/vault/04 People/Relationship Overrides.md

@@ -1,5 +1,7 @@
 # Relationship Overrides
 
+Keep human-edited relationship notes in this folder. Generated drafts are written to `06 AI Memory/Generated Relationship Drafts/` and may be overwritten.
+
 Use `08 Sources/WhatsApp/relationship_overrides.json` to manually label important people.
 
 Example:
@@ -13,4 +15,3 @@ Example:
   }
 }
 ```
-

package/templates/vault/06 AI Memory/Generated Relationship Drafts/README.md

@@ -0,0 +1,5 @@
+# Generated Relationship Drafts
+
+These files are generated and may be overwritten.
+
+Put human-edited relationship notes in `04 People/`.

package/templates/vault/06 AI Memory/Interpreted Relationship Memory.md

@@ -1,4 +1,3 @@
 # Interpreted Relationship Memory
 
-Run `digital-brain interpret` to populate this file.
-
+Run `digital-brain run` to populate this file.

package/templates/vault/06 AI Memory/Person Context Index.md

@@ -0,0 +1,4 @@
+# Person Context Index
+
+Run `digital-brain run` to populate canonical people matched across sources.
+

package/templates/vault/06 AI Memory/Person Reply Context.md

@@ -0,0 +1,4 @@
+# Person Reply Context
+
+Run `digital-brain run` to populate reply-ready person context across sources.
+

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

@@ -0,0 +1,5 @@
+# Sources
+
+This folder stores raw and derived imported data.
+
+AI assistants should not read this folder by default. Use `06 AI Memory/` for normal context. Only inspect source files when the user explicitly asks for source-level evidence.

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

@@ -5,13 +5,13 @@ Outbound sending is disabled unless you explicitly run the sender with `--yes`.
 Draft:
 
 ```bash
-digital-brain send-whatsapp --vault . --to "Name" --message "Text"
+digital-brain send-whatsapp --to "Name" --message "Text"
 ```
 
 Send:
 
 ```bash
-digital-brain send-whatsapp --vault . --to "Name" --message "Text" --yes
+digital-brain send-whatsapp --to "Name" --message "Text" --yes
 ```
 
 Disclosure rule:

package/templates/vault/AGENTS.md

@@ -8,6 +8,8 @@ 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/Person Context Index.md`
+- `06 AI Memory/Person Reply Context.md`
 - `06 AI Memory/Interpreted Relationship Memory.md`
 
 Rules:
@@ -16,4 +18,6 @@ Rules:
 - Separate facts from interpretation.
 - Treat relationship labels as editable working notes.
 - Do not expose private summaries unless asked.
-
+- 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,3 +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.
+
+Do not read `08 Sources/` raw files unless the user explicitly asks for source-level evidence.

package/templates/vault/GEMINI.md

@@ -3,3 +3,7 @@
 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.
+
+Do not read `08 Sources/` raw files unless the user explicitly asks for source-level evidence.

package/whatsapp-web/send.mjs

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import crypto from "node:crypto";
 import path from "node:path";
 import qrcode from "qrcode-terminal";
 import pkg from "whatsapp-web.js";
@@ -12,6 +13,8 @@ const vault = path.resolve(args.vault);
 const whatsAppDir = path.join(vault, "08 Sources", "WhatsApp");
 const outboundDir = path.join(whatsAppDir, "Outbound");
 const sessionDir = path.join(whatsAppDir, ".session");
+const config = readConfig(vault);
+const outboundLogMode = args["log-mode"] || config.outboundLogMode || "metadata";
 fs.mkdirSync(outboundDir, { recursive: true });
 
 if (!args.yes) {
@@ -36,7 +39,11 @@ client.on("ready", async () => {
   try {
     const chat = await resolveChat(args.to);
     const disclosure = disclosureStatus(chat);
-    if (disclosure.required && !containsDisclosure(args.message) && !args["skip-disclosure-check"]) {
+    const bypassDisclosure = args["skip-disclosure-check"] && process.env.DIGITAL_BRAIN_ALLOW_DISCLOSURE_BYPASS === "1";
+    if (args["skip-disclosure-check"] && !bypassDisclosure) {
+      throw new Error("Disclosure bypass requires DIGITAL_BRAIN_ALLOW_DISCLOSURE_BYPASS=1.");
+    }
+    if (disclosure.required && !containsDisclosure(args.message) && !bypassDisclosure) {
       throw new Error(
         'AI disclosure required before sending. Add a clear disclosure like: "Just flagging this is my AI assistant helping draft/send this."',
       );
@@ -46,13 +53,19 @@ client.on("ready", async () => {
       timestamp: new Date().toISOString(),
       to: args.to,
       resolvedChatName: chatName(chat),
-      message: args.message,
+      message: outboundLogMode === "full" ? args.message : undefined,
+      messageHash: hash(args.message),
+      messageCharCount: args.message.length,
       messageId: sent.id?._serialized || null,
       aiAssisted: !args.human,
       disclosureIncluded: containsDisclosure(args.message),
+      disclosureBypassed: bypassDisclosure,
     };
-    fs.appendFileSync(path.join(outboundDir, "sent.jsonl"), `${JSON.stringify(record)}\n`);
-    fs.appendFileSync(path.join(outboundDir, "Sent.md"), `- ${record.timestamp} | ${record.resolvedChatName}: ${record.message}\n`);
+    if (outboundLogMode !== "off") {
+      fs.appendFileSync(path.join(outboundDir, "sent.jsonl"), `${JSON.stringify(record)}\n`);
+      const visible = outboundLogMode === "full" ? args.message : `[metadata only, ${record.messageCharCount} chars, ${record.messageHash.slice(0, 12)}]`;
+      fs.appendFileSync(path.join(outboundDir, "Sent.md"), `- ${record.timestamp} | ${record.resolvedChatName}: ${visible}\n`);
+    }
     console.log(`Sent to ${record.resolvedChatName}`);
     await client.destroy();
     process.exit(0);
@@ -104,7 +117,7 @@ function parseArgs(argv) {
 }
 
 function usage() {
-  console.error('Usage: digital-brain send-whatsapp --vault <path> --to "Name" --message "Text" [--yes]');
+  console.error('Usage: digital-brain send-whatsapp --vault <path> --to "Name" --message "Text" [--yes] [--log-mode metadata|full|off]');
   process.exit(1);
 }
 
@@ -137,3 +150,17 @@ function disclosureStatus(chat) {
 function containsDisclosure(message) {
   return /\b(ai|assistant|automated|bot)\b/i.test(message);
 }
+
+function readConfig(vaultPath) {
+  const file = path.join(vaultPath, "digital-brain.config.json");
+  if (!fs.existsSync(file)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function hash(value) {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}