nexo-brain 2.6.6 → 2.6.9

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.6",
-  "description": "Local cognitive runtime for Claude Code — persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
+  "version": "2.6.9",
+  "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",
     "email": "info@nexo-brain.com",

package/bin/nexo-brain.js

@@ -32,6 +32,7 @@ const LAUNCH_AGENTS = path.join(
   "LaunchAgents"
 );
 const MACOS_FDA_SETTINGS_URL = "x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles";
+const PUBLIC_CONTRIBUTION_UPSTREAM = "wazionapps/nexo";
 
 function isEphemeralInstall(nexoHome) {
   const homeDir = require("os").homedir();
@@ -433,6 +434,22 @@ function getDefaultSchedule(timezone) {
     full_disk_access_status: "unset",
     full_disk_access_status_version: 1,
     full_disk_access_reasons: [],
+    public_contribution: {
+      enabled: false,
+      mode: "unset",
+      consent_version: 1,
+      github_user: "",
+      upstream_repo: PUBLIC_CONTRIBUTION_UPSTREAM,
+      fork_repo: "",
+      machine_id: crypto.createHash("sha1").update(require("os").hostname()).digest("hex").slice(0, 12),
+      active_pr_url: "",
+      active_pr_number: null,
+      active_branch: "",
+      status: "unset",
+      cooldown_until: "",
+      last_run_at: "",
+      last_result: "",
+    },
     processes: {
       "cognitive-decay": { hour: 3, minute: 0 },
       "postmortem": { hour: 23, minute: 30 },
@@ -445,6 +462,23 @@ function getDefaultSchedule(timezone) {
   };
 }
 
+function normalizePublicContributionConfig(config = {}) {
+  const base = getDefaultSchedule().public_contribution;
+  const merged = { ...base, ...(config || {}) };
+  merged.enabled = Boolean(merged.enabled);
+  merged.mode = String(merged.mode || "unset").toLowerCase();
+  merged.status = String(merged.status || "unset").toLowerCase();
+  merged.github_user = String(merged.github_user || "").trim();
+  merged.fork_repo = String(merged.fork_repo || "").trim();
+  merged.upstream_repo = String(merged.upstream_repo || PUBLIC_CONTRIBUTION_UPSTREAM).trim() || PUBLIC_CONTRIBUTION_UPSTREAM;
+  merged.active_pr_url = String(merged.active_pr_url || "").trim();
+  merged.active_branch = String(merged.active_branch || "").trim();
+  merged.cooldown_until = String(merged.cooldown_until || "").trim();
+  merged.last_run_at = String(merged.last_run_at || "").trim();
+  merged.last_result = String(merged.last_result || "").trim();
+  return merged;
+}
+
 async function maybeConfigurePowerPolicy(schedule, useDefaults) {
   const current = String((schedule && schedule.power_policy) || "unset").toLowerCase();
   if (current && current !== "unset") {
@@ -477,6 +511,84 @@ async function maybeConfigurePowerPolicy(schedule, useDefaults) {
   return schedule;
 }
 
+function ghLogin() {
+  const login = run("gh api user --jq .login 2>/dev/null");
+  return (login || "").trim();
+}
+
+function ensureFork(login) {
+  if (!login) return { ok: false, message: "Missing GitHub login.", forkRepo: "" };
+  const forkRepo = `${login}/nexo`;
+  const existing = run(`gh repo view "${forkRepo}" --json nameWithOwner 2>/dev/null`);
+  if (existing) return { ok: true, message: "", forkRepo };
+  const created = run(`gh repo fork "${PUBLIC_CONTRIBUTION_UPSTREAM}" --clone=false --remote=false 2>/dev/null`);
+  if (created !== null) return { ok: true, message: "", forkRepo };
+  return { ok: false, message: `Could not ensure fork ${forkRepo}.`, forkRepo: "" };
+}
+
+async function maybeConfigurePublicContribution(schedule, useDefaults) {
+  const current = normalizePublicContributionConfig((schedule && schedule.public_contribution) || {});
+  if (current.mode && current.mode !== "unset") {
+    schedule.public_contribution = current;
+    fs.writeFileSync(path.join(NEXO_HOME, "config", "schedule.json"), JSON.stringify(schedule, null, 2));
+    return schedule;
+  }
+
+  if (useDefaults || !process.stdin.isTTY || !process.stdout.isTTY) {
+    schedule.public_contribution = current;
+    fs.writeFileSync(path.join(NEXO_HOME, "config", "schedule.json"), JSON.stringify(schedule, null, 2));
+    return schedule;
+  }
+
+  console.log("");
+  log("Optional public contribution mode:");
+  log("If enabled, this machine may prepare core NEXO improvements from an isolated checkout and open a Draft PR to the public repository.");
+  log("NEXO never auto-merges, and it pauses public evolution on this machine while that Draft PR stays open.");
+  log("Public contribution must never publish personal scripts, runtime data, local prompts, logs, or secrets.");
+  const answer = (await ask("  Enable public contribution via Draft PRs on this machine? [y/N/later]: ")).trim().toLowerCase();
+  if (answer === "y" || answer === "yes") {
+    const login = ghLogin();
+    if (!login) {
+      current.enabled = false;
+      current.mode = "pending_auth";
+      current.status = "pending_auth";
+      current.github_user = "";
+      current.fork_repo = "";
+      log("GitHub CLI authentication is missing. Contributor mode is pending until 'gh auth login' succeeds.");
+    } else {
+      const fork = ensureFork(login);
+      if (!fork.ok) {
+        current.enabled = false;
+        current.mode = "pending_auth";
+        current.status = "pending_auth";
+        current.github_user = login;
+        current.fork_repo = "";
+        log(fork.message || "Could not ensure a GitHub fork.");
+      } else {
+        current.enabled = true;
+        current.mode = "draft_prs";
+        current.status = "active";
+        current.github_user = login;
+        current.fork_repo = fork.forkRepo;
+      }
+    }
+  } else if (answer === "later" || answer === "l" || answer === "") {
+    current.enabled = false;
+    current.mode = "unset";
+    current.status = "unset";
+  } else {
+    current.enabled = false;
+    current.mode = "off";
+    current.status = "off";
+    current.github_user = "";
+    current.fork_repo = "";
+  }
+
+  schedule.public_contribution = current;
+  fs.writeFileSync(path.join(NEXO_HOME, "config", "schedule.json"), JSON.stringify(schedule, null, 2));
+  return schedule;
+}
+
 /**
  * Resolve the venv python path for an existing NEXO_HOME installation.
  */
@@ -980,6 +1092,7 @@ async function main() {
         // Regenerate all core LaunchAgents / systemd timers
         let migSchedule = loadOrCreateSchedule(NEXO_HOME);
         migSchedule = await maybeConfigurePowerPolicy(migSchedule, useDefaults);
+        migSchedule = await maybeConfigurePublicContribution(migSchedule, useDefaults);
         const migPython = findVenvPython(NEXO_HOME) || "python3";
         migSchedule = await maybeConfigureFullDiskAccess(migSchedule, useDefaults, migPython);
         let migOptionals = {};
@@ -1616,6 +1729,7 @@ async function main() {
   );
 
   // Copy source files
+  log("Copying core runtime files...");
   const srcDir = path.join(__dirname, "..", "src");
   const pluginsSrcDir = path.join(srcDir, "plugins");
   const scriptsSrcDir = path.join(srcDir, "scripts");
@@ -1694,6 +1808,7 @@ async function main() {
   fs.writeFileSync(runtimeCliPath, runtimeCli);
   fs.chmodSync(runtimeCliPath, 0o755);
 
+  log("Copying core packages...");
   // Core packages (directories with __init__.py)
   ["db", "cognitive", "doctor"].forEach(pkg => {
     const pkgSrc = path.join(srcDir, pkg);
@@ -1702,6 +1817,7 @@ async function main() {
     }
   });
 
+  log("Copying plugins, scripts, and templates...");
   // Plugins (all .py files in plugins/)
   fs.mkdirSync(path.join(NEXO_HOME, "plugins"), { recursive: true });
   if (fs.existsSync(pluginsSrcDir)) {
@@ -2254,6 +2370,7 @@ ${doScan ? `- Stack: ${Object.keys(profileData.code.languages || {}).slice(0, 5)
   log("Setting up automated processes...");
   let schedule = loadOrCreateSchedule(NEXO_HOME);
   schedule = await maybeConfigurePowerPolicy(schedule, useDefaults);
+  schedule = await maybeConfigurePublicContribution(schedule, useDefaults);
   schedule = await maybeConfigureFullDiskAccess(schedule, useDefaults, python);
   const enabledOptionals = { dashboard: doDashboard };
   if (isEphemeralInstall(NEXO_HOME)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.6",
+  "version": "2.6.9",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — local cognitive runtime for Claude Code. Persistent memory, overnight learning, recovery-aware crons, personal scripts, doctor diagnostics, startup preflight, and optional power helper.",
   "bin": {

package/src/auto_close_sessions.py

@@ -17,7 +17,7 @@ os.environ["NEXO_SKIP_FS_INDEX"] = "1"  # Skip FTS rebuild on import
 
 from db import (
     init_db, get_db, get_diary_draft, delete_diary_draft,
-    get_orphan_sessions, write_session_diary, now_epoch,
+    get_orphan_sessions, read_checkpoint, write_session_diary, now_epoch,
     SESSION_STALE_SECONDS,
 )
 
@@ -67,9 +67,18 @@ def promote_draft_to_diary(sid: str, draft: dict, task: str = ""):
     context_hint = draft.get("last_context_hint", "")
     hb_count = draft.get("heartbeat_count", 0)
 
+    checkpoint = read_checkpoint(sid) or {}
     summary_parts = []
     if draft.get("summary_draft"):
         summary_parts.append(draft["summary_draft"])
+    if task and task not in " ".join(summary_parts):
+        summary_parts.append(f"Final task: {task}")
+    if context_hint:
+        summary_parts.append(f"Latest context: {context_hint[:300]}")
+    if checkpoint.get("current_goal"):
+        summary_parts.append(f"Current goal: {str(checkpoint['current_goal'])[:300]}")
+    if checkpoint.get("next_step"):
+        summary_parts.append(f"Next step was: {str(checkpoint['next_step'])[:240]}")
 
     tool_summary = get_tool_log_summary(sid)
     if tool_summary:
@@ -98,6 +107,10 @@ def promote_draft_to_diary(sid: str, draft: dict, task: str = ""):
         context_next = f"Last topic: {context_hint}"
     if tasks:
         context_next += f" | Tasks: {', '.join(tasks[-5:])}"
+    if checkpoint.get("reasoning_thread"):
+        context_next += f" | Reasoning: {str(checkpoint['reasoning_thread'])[:240]}"
+    if checkpoint.get("active_files"):
+        context_next += f" | Active files: {str(checkpoint['active_files'])[:180]}"
 
     write_session_diary(
         session_id=sid,
@@ -131,12 +144,19 @@ def main():
         if draft:
             promote_draft_to_diary(sid, draft, task=session.get("task", ""))
         else:
+            checkpoint = read_checkpoint(sid) or {}
+            tool_summary = get_tool_log_summary(sid)
+            summary_parts = [f"Auto-closed session. Task: {session.get('task', 'unknown')}"]
+            if checkpoint.get("current_goal"):
+                summary_parts.append(f"Current goal: {str(checkpoint['current_goal'])[:300]}")
+            if tool_summary:
+                summary_parts.append(tool_summary)
             write_session_diary(
                 session_id=sid,
                 decisions="No decisions logged",
-                summary=f"Auto-closed session. Task: {session.get('task', 'unknown')}",
-                context_next="",
-                mental_state="[auto-close] No draft available. Minimal diary.",
+                summary=" | ".join(summary_parts),
+                context_next=str(checkpoint.get("next_step") or ""),
+                mental_state="[auto-close] No draft available. Diary reconstructed from task/checkpoint/tool logs.",
                 self_critique="[auto-close] Session terminated without diary or draft.",
                 source="auto-close",
             )

package/src/auto_update.py

@@ -1236,7 +1236,7 @@ def _restore_runtime_tree(backup_dir: str, dest: Path = NEXO_HOME) -> None:
             shutil.copy2(str(item), str(target))
 
 
-def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_HOME) -> dict:
+def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_HOME, progress_fn=None) -> dict:
     import shutil
 
     packages = ["db", "cognitive", "doctor", "dashboard", "rules", "crons", "hooks"]
@@ -1253,6 +1253,7 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
     copied_packages = 0
     copied_files = 0
 
+    _emit_progress(progress_fn, "Copying core packages...")
     for pkg in packages:
         pkg_src = src_dir / pkg
         pkg_dest = dest / pkg
@@ -1266,12 +1267,14 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
             )
             copied_packages += 1
 
+    _emit_progress(progress_fn, "Copying core modules...")
     for name in flat_files:
         src_file = src_dir / name
         if src_file.is_file():
             shutil.copy2(str(src_file), str(dest / name))
             copied_files += 1
 
+    _emit_progress(progress_fn, "Copying plugin modules...")
     plugins_src = src_dir / "plugins"
     plugins_dest = dest / "plugins"
     if plugins_src.is_dir():
@@ -1280,6 +1283,7 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
             if item.is_file() and item.suffix == ".py":
                 shutil.copy2(str(item), str(plugins_dest / item.name))
 
+    _emit_progress(progress_fn, "Copying scripts...")
     scripts_src = src_dir / "scripts"
     scripts_dest = dest / "scripts"
     if scripts_src.is_dir():
@@ -1297,6 +1301,7 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
                 if item.suffix == ".sh":
                     dst.chmod(0o755)
 
+    _emit_progress(progress_fn, "Copying templates and version metadata...")
     templates_src = repo_dir / "templates"
     templates_dest = dest / "templates"
     if templates_src.is_dir():
@@ -1317,6 +1322,7 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
         except Exception:
             pass
 
+    _emit_progress(progress_fn, "Copying core skills and runtime wrapper...")
     skills_src = src_dir / "skills"
     skills_dest = dest / "skills-core"
     if skills_src.is_dir():
@@ -1365,10 +1371,11 @@ def _reinstall_runtime_pip_deps(runtime_root: Path = NEXO_HOME) -> bool:
         return False
 
 
-def _run_runtime_post_sync(dest: Path = NEXO_HOME) -> tuple[bool, list[str]]:
+def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bool, list[str]]:
     actions: list[str] = []
     env = {**os.environ, "NEXO_HOME": str(dest), "NEXO_CODE": str(dest)}
     try:
+        _emit_progress(progress_fn, "Initializing database and reconciling personal schedules...")
         init_result = subprocess.run(
             [
                 sys.executable,
@@ -1394,6 +1401,7 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME) -> tuple[bool, list[str]]:
     except Exception as e:
         return False, [f"runtime init error: {e}"]
 
+    _emit_progress(progress_fn, "Reconciling Python dependencies...")
     if _reinstall_runtime_pip_deps(dest):
         actions.append("pip-deps")
     else:
@@ -1402,6 +1410,7 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME) -> tuple[bool, list[str]]:
     sync_path = dest / "crons" / "sync.py"
     if sync_path.is_file():
         try:
+            _emit_progress(progress_fn, "Syncing core cron definitions...")
             sync_result = subprocess.run(
                 [sys.executable, str(sync_path)],
                 cwd=str(dest),
@@ -1418,10 +1427,12 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME) -> tuple[bool, list[str]]:
 
     from runtime_power import apply_power_policy
 
+    _emit_progress(progress_fn, "Refreshing runtime power helper...")
     power_result = apply_power_policy()
     if power_result.get("ok"):
         actions.append(f"power:{power_result.get('action')}")
 
+    _emit_progress(progress_fn, "Verifying runtime imports...")
     verify = subprocess.run(
         [sys.executable, "-c", "import server"],
         cwd=str(dest),
@@ -1460,11 +1471,20 @@ def _write_update_summary(summary: dict):
         _log(f"Failed to write update summary: {e}")
 
 
-def manual_sync_update(*, interactive: bool = False, allow_source_pull: bool = True) -> dict:
+def _emit_progress(progress_fn, message: str) -> None:
+    if callable(progress_fn):
+        try:
+            progress_fn(message)
+        except Exception:
+            pass
+
+
+def manual_sync_update(*, interactive: bool = False, allow_source_pull: bool = True, progress_fn=None) -> dict:
     src_dir, repo_dir = _resolve_sync_source()
     if src_dir is None or repo_dir is None:
         return {"ok": False, "mode": "sync", "error": "No source repo recorded for this runtime."}
 
+    _emit_progress(progress_fn, "Checking recorded source repository...")
     source_status = _source_repo_status(repo_dir)
     pulled = False
     old_head = source_status.get("local_head")
@@ -1474,17 +1494,21 @@ def manual_sync_update(*, interactive: bool = False, allow_source_pull: bool = T
         elif source_status.get("diverged"):
             _log("Source repo diverged; syncing local tree without remote pull.")
         elif source_status.get("behind"):
+            _emit_progress(progress_fn, "Pulling latest source changes...")
             rc, _, pull_err = _git_in_repo(repo_dir, "pull", "--ff-only", timeout=60)
             if rc != 0:
                 return {"ok": False, "mode": "sync", "error": pull_err or "git pull failed"}
             pulled = True
 
+    _emit_progress(progress_fn, "Creating runtime backups...")
     db_backup_dir = _backup_dbs()
     tree_backup_dir = _backup_runtime_tree(NEXO_HOME)
     sync_result = {"ok": False, "mode": "sync", "pulled_source": pulled, "backup_dir": db_backup_dir, "tree_backup": tree_backup_dir}
     try:
-        copy_stats = _copy_runtime_from_source(src_dir, repo_dir, NEXO_HOME)
-        ok, actions = _run_runtime_post_sync(NEXO_HOME)
+        _emit_progress(progress_fn, "Syncing runtime files...")
+        copy_stats = _copy_runtime_from_source(src_dir, repo_dir, NEXO_HOME, progress_fn=progress_fn)
+        _emit_progress(progress_fn, "Reconciling runtime state...")
+        ok, actions = _run_runtime_post_sync(NEXO_HOME, progress_fn=progress_fn)
         if not ok:
             raise RuntimeError("; ".join(actions))
         sync_result.update({
@@ -1496,7 +1520,9 @@ def manual_sync_update(*, interactive: bool = False, allow_source_pull: bool = T
             "source": copy_stats["source"],
             "repo": copy_stats["repo"],
         })
+        _emit_progress(progress_fn, "Runtime update completed.")
     except Exception as e:
+        _emit_progress(progress_fn, "Update failed; restoring previous runtime state...")
         _restore_runtime_tree(tree_backup_dir, NEXO_HOME)
         if db_backup_dir:
             _restore_dbs(db_backup_dir)

package/src/cli.py

@@ -22,6 +22,7 @@ Entry points:
   nexo skills approve ID [--execution-level ...] [--approved-by ...] [--json]
   nexo skills featured [--limit N] [--json]
   nexo skills evolution [--json]
+  nexo contributor status|on|off [--json]
   nexo doctor [--tier boot|runtime|deep|all] [--json] [--fix]
 """
 from __future__ import annotations
@@ -458,8 +459,18 @@ def _update(args):
         ensure_full_disk_access_choice,
         format_full_disk_access_label,
     )
+    from public_contribution import (
+        ensure_public_contribution_choice,
+        format_public_contribution_label,
+    )
 
     interactive = sys.stdin.isatty() and sys.stdout.isatty()
+    progress_messages: list[str] = []
+
+    def progress(message: str) -> None:
+        progress_messages.append(message)
+        if not args.json:
+            print(f"[NEXO] {message}", flush=True)
 
     dest = NEXO_HOME
     src_dir, repo_dir = _resolve_sync_source()
@@ -475,20 +486,25 @@ def _update(args):
             )
             return 1
 
-        result = handle_update()
+        result = handle_update(progress_fn=progress)
         choice = ensure_power_policy_choice(interactive=interactive, reason="update")
         power_result = apply_power_policy(choice.get("policy"))
         fda_choice = ensure_full_disk_access_choice(interactive=interactive, reason="update")
+        contrib_choice = ensure_public_contribution_choice(interactive=interactive, reason="update")
         if args.json:
             print(json.dumps({
                 "mode": "packaged",
                 "message": result,
+                "progress": progress_messages,
                 "power_policy": choice.get("policy"),
                 "power_action": power_result.get("action"),
                 "power_details": power_result.get("details"),
                 "full_disk_access_status": fda_choice.get("status"),
                 "full_disk_access_reasons": fda_choice.get("reasons"),
                 "full_disk_access_message": fda_choice.get("message"),
+                "public_contribution_mode": contrib_choice.get("mode"),
+                "public_contribution_status": contrib_choice.get("status"),
+                "public_contribution_message": contrib_choice.get("message"),
             }, indent=2, ensure_ascii=False))
         else:
             print(result)
@@ -500,21 +516,31 @@ def _update(args):
                 print(f"Full Disk Access: {format_full_disk_access_label(fda_choice.get('status'))}")
             if fda_choice.get("message"):
                 print(f"Full Disk Access: {fda_choice.get('message')}")
+            if contrib_choice.get("prompted"):
+                print(f"Contributor mode: {format_public_contribution_label(contrib_choice)}")
+            if contrib_choice.get("message"):
+                print(f"Contributor mode: {contrib_choice.get('message')}")
         return 0 if "UPDATE SUCCESSFUL" in result or "Already up to date" in result else 1
 
     choice = ensure_power_policy_choice(interactive=interactive, reason="update")
     power_result = apply_power_policy(choice.get("policy"))
     fda_choice = ensure_full_disk_access_choice(interactive=interactive, reason="update")
-    result = manual_sync_update(interactive=interactive, allow_source_pull=True)
+    contrib_choice = ensure_public_contribution_choice(interactive=interactive, reason="update")
+    result = manual_sync_update(interactive=interactive, allow_source_pull=True, progress_fn=progress)
     result["power_policy"] = choice.get("policy")
     result["power_action"] = power_result.get("action")
     result["power_details"] = power_result.get("details")
     result["full_disk_access_status"] = fda_choice.get("status")
     result["full_disk_access_reasons"] = fda_choice.get("reasons")
+    result["public_contribution_mode"] = contrib_choice.get("mode")
+    result["public_contribution_status"] = contrib_choice.get("status")
+    result["progress"] = progress_messages
     if power_result.get("message"):
         result["power_message"] = power_result.get("message")
     if fda_choice.get("message"):
         result["full_disk_access_message"] = fda_choice.get("message")
+    if contrib_choice.get("message"):
+        result["public_contribution_message"] = contrib_choice.get("message")
     if args.json:
         print(json.dumps(result, indent=2, ensure_ascii=False))
     else:
@@ -534,11 +560,80 @@ def _update(args):
                 print(f"  Full Disk Access: {format_full_disk_access_label(fda_choice.get('status'))}")
             if fda_choice.get("message"):
                 print(f"  Full Disk Access: {fda_choice.get('message')}")
+            if contrib_choice.get("prompted"):
+                print(f"  Contributor mode: {format_public_contribution_label(contrib_choice)}")
+            if contrib_choice.get("message"):
+                print(f"  Contributor mode: {contrib_choice.get('message')}")
         else:
             print(f"UPDATE FAILED: {result.get('error', 'sync failed')}", file=sys.stderr)
     return 0 if result.get("ok") else 1
 
 
+def _contributor_status(args):
+    from public_contribution import (
+        format_public_contribution_label,
+        load_public_contribution_config,
+        refresh_public_contribution_state,
+    )
+
+    config = refresh_public_contribution_state(load_public_contribution_config())
+    payload = {
+        "enabled": bool(config.get("enabled")),
+        "mode": config.get("mode"),
+        "status": config.get("status"),
+        "label": format_public_contribution_label(config),
+        "github_user": config.get("github_user"),
+        "fork_repo": config.get("fork_repo"),
+        "active_pr_url": config.get("active_pr_url"),
+        "active_branch": config.get("active_branch"),
+        "cooldown_until": config.get("cooldown_until"),
+        "last_result": config.get("last_result"),
+    }
+    if args.json:
+        print(json.dumps(payload, indent=2, ensure_ascii=False))
+    else:
+        print(f"Contributor mode: {payload['label']}")
+        if payload["github_user"]:
+            print(f"  GitHub user: {payload['github_user']}")
+        if payload["fork_repo"]:
+            print(f"  Fork: {payload['fork_repo']}")
+        if payload["active_pr_url"]:
+            print(f"  Active Draft PR: {payload['active_pr_url']}")
+        if payload["cooldown_until"]:
+            print(f"  Cooldown until: {payload['cooldown_until']}")
+        if payload["last_result"]:
+            print(f"  Last result: {payload['last_result']}")
+    return 0
+
+
+def _contributor_on(args):
+    from public_contribution import ensure_public_contribution_choice, format_public_contribution_label
+
+    interactive = sys.stdin.isatty() and sys.stdout.isatty()
+    if not interactive:
+        print("Contributor mode requires an interactive terminal to confirm GitHub Draft PR consent.", file=sys.stderr)
+        return 1
+    config = ensure_public_contribution_choice(interactive=True, reason="contributor", force_prompt=True)
+    if args.json:
+        print(json.dumps(config, indent=2, ensure_ascii=False))
+    else:
+        print(f"Contributor mode: {format_public_contribution_label(config)}")
+        if config.get("message"):
+            print(config.get("message"))
+    return 0 if config.get("mode") == "draft_prs" else 1
+
+
+def _contributor_off(args):
+    from public_contribution import disable_public_contribution, format_public_contribution_label
+
+    config = disable_public_contribution()
+    if args.json:
+        print(json.dumps(config, indent=2, ensure_ascii=False))
+    else:
+        print(f"Contributor mode: {format_public_contribution_label(config)}")
+    return 0
+
+
 def _service_control(service_name: str, action: str) -> int:
     """Control a LaunchAgent/systemd service: on, off, status."""
     import platform as plat
@@ -767,6 +862,7 @@ Commands:
                                                       Personal scripts
   nexo skills list|apply|sync|approve                  Executable skills
   nexo update                                          Update installed runtime
+  nexo contributor status|on|off                       Public Draft PR contribution mode
   nexo dashboard on|off|status                         Web dashboard control
 
 Run 'nexo <command> --help' for details.
@@ -861,6 +957,11 @@ def main():
     doctor_parser.add_argument("--json", action="store_true", help="JSON output")
     doctor_parser.add_argument("--fix", action="store_true", help="Apply deterministic fixes")
 
+    # -- contributor --
+    contributor_parser = sub.add_parser("contributor", help="Public Draft PR contribution mode")
+    contributor_parser.add_argument("action", choices=["status", "on", "off"], help="Manage contributor mode")
+    contributor_parser.add_argument("--json", action="store_true", help="JSON output")
+
     # -- skills --
     skills_parser = sub.add_parser("skills", help="Skills v2 runtime")
     skills_sub = skills_parser.add_subparsers(dest="skills_command")
@@ -946,6 +1047,15 @@ def main():
         return _update(args)
     elif args.command == "doctor":
         return _doctor(args)
+    elif args.command == "contributor":
+        if args.action == "status":
+            return _contributor_status(args)
+        elif args.action == "on":
+            return _contributor_on(args)
+        elif args.action == "off":
+            return _contributor_off(args)
+        contributor_parser.print_help()
+        return 0
     elif args.command == "skills":
         if args.skills_command == "list":
             return _skills_list(args)

package/src/db/_episodic.py

@@ -573,7 +573,7 @@ def read_session_diary(session_id: str = '', last_n: int = 3, last_day: bool = F
     """Read session diary entries.
 
     - session_id: returns entries for that specific session
-    - last_day: returns ALL entries from the most recent day (multi-terminal aware)
+    - last_day: returns the recent continuity window (~36h), including the previous evening
     - last_n: returns last N entries (default)
     - domain: filter by project context (nexo, other)
     - include_automated: if False (default), excludes automated sessions (auto-close,
@@ -605,21 +605,11 @@ def read_session_diary(session_id: str = '', last_n: int = 3, last_day: bool = F
             (session_id,) + domain_params
         ).fetchall()
     elif last_day:
-        # Get all entries from the most recent calendar day (human sessions only)
-        if domain:
-            latest = conn.execute(
-                f"SELECT date(created_at) as day FROM session_diary WHERE domain = ?{source_clause} ORDER BY created_at DESC LIMIT 1",
-                (domain,)
-            ).fetchone()
-        else:
-            latest = conn.execute(
-                f"SELECT date(created_at) as day FROM session_diary WHERE 1=1{source_clause} ORDER BY created_at DESC LIMIT 1"
-            ).fetchone()
-        if not latest:
-            return []
         rows = conn.execute(
-            f"SELECT * FROM session_diary WHERE date(created_at) = ?{domain_clause}{source_clause} ORDER BY created_at DESC",
-            (latest['day'],) + domain_params
+            f"SELECT * FROM session_diary "
+            f"WHERE created_at >= datetime('now', '-36 hours'){domain_clause}{source_clause} "
+            f"ORDER BY created_at DESC",
+            domain_params
         ).fetchall()
     else:
         rows = conn.execute(
@@ -770,4 +760,3 @@ def recall(query: str, days: int = 30) -> list[dict]:
     results.sort(key=lambda r: r.get('created_at', ''), reverse=True)
     return results[:20]
 
-