0agent 1.0.17 → 1.0.18

package/bin/0agent.js

@@ -98,26 +98,63 @@ switch (cmd) {
     await runWatch();
     break;
 
+  case 'memory':
+    await runMemoryCommand(args.slice(1));
+    break;
+
   default:
     showHelp();
     break;
 }
 
-// ─── Init wizard ─────────────────────────────────────────────────────────
+// ─── Init wizard — arrow key selection, GitHub memory built in ───────────────
+
+// Arrow-key select using enquirer (falls back to number input if not available)
+async function arrowSelect(message, choices, initial = 0) {
+  try {
+    const { Select } = await import('enquirer');
+    const prompt = new Select({ message, choices: choices.map((c, i) => ({ name: c, value: i })), initial });
+    const answer = await prompt.run();
+    return choices.indexOf(answer);
+  } catch {
+    // Fallback: number-based selection (no enquirer)
+    return choose(message, choices, initial);
+  }
+}
+
+async function arrowInput(message, initial = '') {
+  try {
+    const { Input } = await import('enquirer');
+    const prompt = new Input({ message, initial });
+    return await prompt.run();
+  } catch {
+    return ask(`  ${message}: `);
+  }
+}
+
+async function arrowPassword(message) {
+  try {
+    const { Password } = await import('enquirer');
+    const prompt = new Password({ message });
+    return await prompt.run();
+  } catch {
+    return ask(`  ${message}: `);
+  }
+}
 
 async function runInit() {
-  console.log('\n  ┌─────────────────────────────────────────┐');
-  console.log('  │                                         │');
-  console.log('  │   0agent — An agent that learns.        │');
-  console.log('  │                                         │');
-  console.log('  │   v1.0.0 · Apache 2.0                   │');
-  console.log('  └─────────────────────────────────────────┘\n');
-
-  // Check if already initialised
+  console.log('\n  \x1b[1m┌─────────────────────────────────────────┐\x1b[0m');
+  console.log('  \x1b[1m│                                         │\x1b[0m');
+  console.log('  \x1b[1m│   0agent — An agent that learns.        │\x1b[0m');
+  console.log('  \x1b[1m│                                         │\x1b[0m');
+  console.log('  \x1b[1m│   v1.0 · Apache 2.0                     │\x1b[0m');
+  console.log('  \x1b[1m└─────────────────────────────────────────┘\x1b[0m\n');
+
   if (existsSync(CONFIG_PATH)) {
-    const answer = await ask('Config already exists. Reinitialise? [y/N] ');
+    const answer = await ask('  Config already exists. Reinitialise? [y/N] ');
     if (answer.toLowerCase() !== 'y') {
-      console.log('\n  Run `0agent start` to start the daemon.\n');
+      console.log('\n  Running: 0agent start\n');
+      await startDaemon();
       return;
     }
   }
@@ -127,96 +164,110 @@ async function runInit() {
   mkdirSync(resolve(AGENT_DIR, 'skills', 'builtin'), { recursive: true });
   mkdirSync(resolve(AGENT_DIR, 'skills', 'custom'), { recursive: true });
 
-  console.log('  Step 1 of 5: LLM Provider\n');
-  const provider = await choose('  Which LLM provider?', [
+  // ── Step 1: LLM Provider ────────────────────────────────────────────────
+  const providerIdx = await arrowSelect('LLM Provider', [
     'Anthropic (Claude)  ← recommended',
     'OpenAI (GPT-4o)',
     'xAI (Grok)',
     'Google (Gemini)',
-    'Ollama (local, free)',
+    'Ollama (local — no API key)',
   ], 0);
-  const providerKey = ['anthropic', 'openai', 'xai', 'gemini', 'ollama'][provider];
+  const providerKey = ['anthropic', 'openai', 'xai', 'gemini', 'ollama'][providerIdx];
 
-  // Model selection per provider
   const MODELS = {
-    anthropic: [
-      'claude-sonnet-4-6  ← recommended (fast + smart)',
-      'claude-opus-4-6    (most capable, slower)',
-      'claude-haiku-4-5   (fastest, cheapest)',
-    ],
-    openai: [
-      'gpt-4o             ← recommended',
-      'gpt-4o-mini        (faster, cheaper)',
-      'o3-mini            (reasoning)',
-    ],
-    xai: [
-      'grok-3             ← recommended',
-      'grok-3-mini',
-    ],
-    gemini: [
-      'gemini-2.0-flash   ← recommended',
-      'gemini-2.0-pro',
-    ],
-    ollama: [
-      'llama3.1           ← recommended',
-      'mistral',
-      'codellama',
-    ],
+    anthropic: ['claude-sonnet-4-6  ← recommended', 'claude-opus-4-6  (most capable)', 'claude-haiku-4-5  (fastest)'],
+    openai:    ['gpt-4o  ← recommended', 'gpt-4o-mini', 'o3-mini'],
+    xai:       ['grok-3  ← recommended', 'grok-3-mini'],
+    gemini:    ['gemini-2.0-flash  ← recommended', 'gemini-2.0-pro'],
+    ollama:    ['llama3.1  ← recommended', 'mistral', 'codellama'],
   };
-
-  let model = '';
-  if (MODELS[providerKey]) {
-    console.log();
-    const modelIdx = await choose('  Which model?', MODELS[providerKey], 0);
-    model = MODELS[providerKey][modelIdx].split(/\s+/)[0];
-  }
+  const modelIdx = await arrowSelect('Which model?', MODELS[providerKey], 0);
+  const model = MODELS[providerKey][modelIdx].split(/\s+/)[0];
 
   let apiKey = '';
   if (providerKey !== 'ollama') {
-    apiKey = await ask(`\n  API Key: `);
-    if (!apiKey.trim()) {
-      console.log('  ⚠️  No API key provided. You can set it later in ~/.0agent/config.yaml');
+    apiKey = await arrowPassword(`${providerKey} API key`);
+    apiKey = apiKey.trim();
+    if (!apiKey) {
+      console.log('  \x1b[33m⚠\x1b[0m  No key — add it later in ~/.0agent/config.yaml');
     } else {
-      // Validate key format
-      const keyPrefixes = { anthropic: 'sk-ant-', openai: 'sk-', xai: 'xai-', gemini: 'AI' };
-      const expectedPrefix = keyPrefixes[providerKey];
-      if (expectedPrefix && !apiKey.startsWith(expectedPrefix)) {
-        console.log(`  ⚠️  Key doesn't look like a ${providerKey} key (expected: ${expectedPrefix}...)`);
+      const pfx = { anthropic: 'sk-ant-', openai: 'sk-', xai: 'xai-', gemini: 'AI' }[providerKey];
+      if (pfx && !apiKey.startsWith(pfx)) {
+        console.log(`  \x1b[33m⚠\x1b[0m  Unexpected key format (expected ${pfx}...)`);
       } else {
-        console.log('  ✓ API key format looks valid');
+        console.log('  \x1b[32m✓\x1b[0m  Key format valid');
       }
     }
   }
 
-  console.log('\n  Step 2 of 5: Embedding model\n');
-  const embedding = await choose('  Embedding backend?', [
-    'Local via Ollama (nomic-embed-text)  ← free, private',
-    'OpenAI text-embedding-3-small (cloud)',
-    'Skip (text-only mode)',
+  // ── Step 2: GitHub Memory ───────────────────────────────────────────────
+  const memChoice = await arrowSelect('Back up memory to GitHub?', [
+    'Yes — private repo, free, cross-device sync  ← recommended',
+    'No — local only',
   ], 0);
-  const embeddingProvider = ['nomic-ollama', 'openai', 'none'][embedding];
 
-  console.log('\n  Step 3 of 5: Sandbox backend\n');
+  let ghToken = '', ghOwner = '', ghRepo = '0agent-memory';
+  if (memChoice === 0) {
+    // Try gh CLI first
+    try {
+      const { execSync: ex } = await import('node:child_process');
+      ghToken = ex('gh auth token 2>/dev/null', { encoding: 'utf8' }).trim();
+      ghOwner = ex('gh api user --jq .login 2>/dev/null', { encoding: 'utf8' }).trim();
+      if (ghToken && ghOwner) {
+        console.log(`  \x1b[32m✓\x1b[0m  gh CLI — authenticated as \x1b[1m${ghOwner}\x1b[0m`);
+      }
+    } catch {}
+
+    if (!ghToken) {
+      console.log('\n  Create a GitHub token: \x1b[4mhttps://github.com/settings/tokens/new\x1b[0m');
+      console.log('  Required scope: \x1b[1mrepo\x1b[0m\n');
+      ghToken = await arrowPassword('GitHub token (ghp_...)');
+      ghToken = ghToken.trim();
+      if (ghToken) {
+        ghOwner = await verifyGitHubToken(ghToken) ?? '';
+        if (!ghOwner) {
+          console.log('  \x1b[31m✗\x1b[0m  Invalid token — skipping GitHub memory');
+          ghToken = '';
+        } else {
+          console.log(`  \x1b[32m✓\x1b[0m  Authenticated as \x1b[1m${ghOwner}\x1b[0m`);
+        }
+      }
+    }
+
+    if (ghToken && ghOwner) {
+      process.stdout.write(`  Creating private repo \x1b[1m${ghOwner}/0agent-memory\x1b[0m...`);
+      const ok = await createGitHubRepo(ghToken, '0agent-memory');
+      console.log(ok ? ' \x1b[32m✓\x1b[0m' : ' \x1b[33m(exists)\x1b[0m');
+    }
+  }
+
+  // ── Step 3: Embedding ────────────────────────────────────────────────────
+  const embIdx = await arrowSelect('Embeddings (for semantic memory search)?', [
+    'Local via Ollama (nomic-embed-text) — free, private',
+    'OpenAI text-embedding-3-small — cloud',
+    'Skip — text-only mode',
+  ], 0);
+  const embeddingProvider = ['nomic-ollama', 'openai', 'none'][embIdx];
+
+  // ── Step 4: Sandbox ──────────────────────────────────────────────────────
   const sandboxes = detectSandboxes();
-  console.log(`  Detected: ${sandboxes.join(', ') || 'process (fallback)'}`);
   const sandboxChoice = sandboxes[0] ?? 'process';
-  console.log(`  Using: ${sandboxChoice}`);
+  console.log(`\n  Sandbox: \x1b[32m${sandboxChoice}\x1b[0m detected`);
 
-  console.log('\n  Step 4 of 5: Seed graph\n');
-  const seed = await choose('  Start with a seed graph?', [
-    'software-engineering (skills + sprint workflow)  ← recommended',
-    'scratch (empty graph)',
+  // ── Step 5: Seed graph ───────────────────────────────────────────────────
+  const seedIdx = await arrowSelect('Starting knowledge?', [
+    'software-engineering — sprint workflow + 15 skills  ← recommended',
+    'Start from scratch',
   ], 0);
-  const seedName = seed === 0 ? 'software-engineering' : null;
-
-  // Step 5: confirm
-  console.log('\n  Step 5 of 5: Ready\n');
-  console.log(`  Provider:  ${providerKey}`);
-  console.log(`  Model:     ${model}`);
-  console.log(`  API Key:   ${apiKey ? apiKey.slice(0, 8) + '••••••••' : '(not set)'}`);
-  console.log(`  Sandbox:   ${sandboxChoice}`);
-  console.log(`  Seed:      ${seedName ?? 'scratch'}`);
-  console.log();
+  const seedName = seedIdx === 0 ? 'software-engineering' : null;
+
+  // ── Summary ───────────────────────────────────────────────────────────────
+  console.log('\n  \x1b[1mReady to launch\x1b[0m\n');
+  console.log(`  LLM:     \x1b[36m${providerKey}/${model}\x1b[0m`);
+  console.log(`  API Key: ${apiKey ? '\x1b[32m✓ set\x1b[0m (' + apiKey.slice(0, 8) + '••••)' : '\x1b[33mnot set\x1b[0m'}`);
+  console.log(`  Memory:  ${ghToken ? `\x1b[32mgithub.com/${ghOwner}/0agent-memory\x1b[0m` : '\x1b[2mlocal only\x1b[0m'}`);
+  console.log(`  Sandbox: \x1b[36m${sandboxChoice}\x1b[0m`);
+  console.log(`  Seed:    \x1b[36m${seedName ?? 'scratch'}\x1b[0m\n`);
 
   // Write config
   const dbPath    = resolve(AGENT_DIR, 'graph.db');
@@ -252,6 +303,7 @@ graph:
   hnsw_path: "${hnswPath}"
   object_store_path: "${objPath}"
 ${seedName ? `\nseed: "${seedName}"` : ''}
+${ghToken && ghOwner ? `\ngithub_memory:\n  enabled: true\n  token: "${ghToken}"\n  owner: "${ghOwner}"\n  repo: "${ghRepo}"` : ''}
 `;
 
   writeFileSync(CONFIG_PATH, config, 'utf8');
@@ -809,6 +861,191 @@ async function waitForTunnelUrl(proc, pattern, timeout) {
   });
 }
 
+// ─── Memory sync (GitHub backend) ─────────────────────────────────────────
+
+async function runMemoryCommand(memArgs) {
+  const sub = memArgs[0] ?? 'status';
+
+  switch (sub) {
+    // ── 0agent memory connect github ──────────────────────────────────────
+    case 'connect': {
+      const provider = memArgs[1] ?? 'github';
+      if (provider !== 'github') { console.log('  Only GitHub is supported: 0agent memory connect github'); break; }
+
+      console.log('\n  \x1b[1m0agent Memory — GitHub Sync\x1b[0m\n');
+      console.log('  Your knowledge graph will be backed up to a private GitHub repository.');
+      console.log('  Free, versioned, cross-device. No server needed.\n');
+
+      // ── Authentication ──
+      let token = '';
+
+      // Try gh CLI first (already logged in for most devs)
+      try {
+        const { execSync: ex } = await import('node:child_process');
+        token = ex('gh auth token 2>/dev/null', { encoding: 'utf8' }).trim();
+        if (token) {
+          const { execSync: ex2 } = await import('node:child_process');
+          const user = ex2('gh api user --jq .login 2>/dev/null', { encoding: 'utf8' }).trim();
+          console.log(`  \x1b[32m✓\x1b[0m Detected gh CLI — authenticated as \x1b[1m${user}\x1b[0m`);
+        }
+      } catch {}
+
+      // Fallback: GitHub Device Flow
+      if (!token) {
+        console.log('  \x1b[2mgh CLI not found — using GitHub token auth\x1b[0m\n');
+        console.log('  Create a token at: \x1b[4mhttps://github.com/settings/tokens/new\x1b[0m');
+        console.log('  Required scope: \x1b[1mrepo\x1b[0m\n');
+        token = await ask('  Paste token (starts with ghp_): ');
+        token = token.trim();
+        if (!token) { console.log('  No token provided.'); break; }
+      }
+
+      // Verify token
+      const owner = await verifyGitHubToken(token);
+      if (!owner) { console.log('  \x1b[31m✗\x1b[0m Invalid token or no access.'); break; }
+      console.log(`  \x1b[32m✓\x1b[0m Authenticated as \x1b[1m${owner}\x1b[0m`);
+
+      // ── Create repo ──
+      const repoName = memArgs[2] ?? '0agent-memory';
+      process.stdout.write(`  Creating private repo \x1b[1m${owner}/${repoName}\x1b[0m...`);
+      const created = await createGitHubRepo(token, repoName);
+      console.log(created ? ' \x1b[32m✓\x1b[0m' : ' \x1b[33m(already exists)\x1b[0m');
+
+      // ── Save to config ──
+      const YAML = await import('yaml');
+      const { readFileSync: rf, writeFileSync: wf, existsSync: ef } = await import('node:fs');
+      if (ef(CONFIG_PATH)) {
+        let cfg = rf(CONFIG_PATH, 'utf8');
+        // Remove old github_memory block if present
+        cfg = cfg.replace(/\ngithub_memory:[\s\S]*?(?=\n\w|\n$|$)/, '');
+        cfg += `\ngithub_memory:\n  enabled: true\n  token: "${token}"\n  owner: "${owner}"\n  repo: "${repoName}"\n`;
+        wf(CONFIG_PATH, cfg, 'utf8');
+      }
+
+      // ── Initial push ──
+      console.log('\n  Performing initial sync...');
+      await requireDaemon();
+      const result = await daemonMemorySync('push');
+      if (result?.pushed) {
+        console.log(`  \x1b[32m✓\x1b[0m Synced — ${result.nodes_synced} nodes, ${result.edges_synced} edges`);
+        console.log(`\n  Memory repo: \x1b[4mhttps://github.com/${owner}/${repoName}\x1b[0m`);
+        console.log('\n  From any machine, run:');
+        console.log(`    \x1b[36m0agent memory connect github --repo ${owner}/${repoName}\x1b[0m\n`);
+      } else {
+        console.log('  \x1b[33m⚠\x1b[0m Initial sync skipped — run `0agent memory sync` after daemon starts.');
+        console.log(`\n  Memory repo: \x1b[4mhttps://github.com/${owner}/${repoName}\x1b[0m\n`);
+      }
+      break;
+    }
+
+    // ── 0agent memory sync ────────────────────────────────────────────────
+    case 'sync': {
+      await requireDaemon();
+      process.stdout.write('  Syncing memory to GitHub...');
+      const result = await daemonMemorySync('push');
+      if (result?.pushed) {
+        console.log(` \x1b[32m✓\x1b[0m  ${result.nodes_synced} nodes, ${result.edges_synced} edges`);
+      } else {
+        console.log(` \x1b[31m✗\x1b[0m  ${result?.error ?? 'No GitHub memory configured'}`);
+        if (!result?.error) console.log('  Run: 0agent memory connect github');
+      }
+      break;
+    }
+
+    // ── 0agent memory pull ───────────────────────────────────────────────
+    case 'pull': {
+      await requireDaemon();
+      process.stdout.write('  Pulling memory from GitHub...');
+      const result = await daemonMemorySync('pull');
+      if (result?.pulled) {
+        console.log(` \x1b[32m✓\x1b[0m  +${result.nodes_synced} nodes, +${result.edges_synced} edges merged`);
+      } else {
+        console.log(` \x1b[31m✗\x1b[0m  ${result?.error ?? 'No GitHub memory configured'}`);
+      }
+      break;
+    }
+
+    // ── 0agent memory status ──────────────────────────────────────────────
+    case 'status': {
+      const YAML = await import('yaml');
+      const { readFileSync: rf, existsSync: ef } = await import('node:fs');
+      if (!ef(CONFIG_PATH)) { console.log('\n  Not initialised. Run: 0agent init\n'); break; }
+
+      const cfg = YAML.parse(rf(CONFIG_PATH, 'utf8'));
+      const ghMem = cfg.github_memory;
+
+      if (!ghMem?.enabled) {
+        console.log('\n  Memory sync: \x1b[33mnot connected\x1b[0m');
+        console.log('  Run: 0agent memory connect github\n');
+      } else {
+        console.log(`\n  Memory sync: \x1b[32m✓ connected\x1b[0m`);
+        console.log(`  Repo:  https://github.com/${ghMem.owner}/${ghMem.repo}`);
+        // Get last sync from daemon
+        try {
+          const res = await fetch(`${BASE_URL}/api/memory/status`).catch(() => null);
+          const data = res?.ok ? await res.json() : null;
+          if (data) {
+            console.log(`  Last push: ${data.pushed_at ? new Date(data.pushed_at).toLocaleString() : 'never'}`);
+            console.log(`  Last pull: ${data.pulled_at ? new Date(data.pulled_at).toLocaleString() : 'never'}`);
+          }
+        } catch {}
+        console.log();
+      }
+      break;
+    }
+
+    // ── 0agent memory disconnect ──────────────────────────────────────────
+    case 'disconnect': {
+      const { readFileSync: rf, writeFileSync: wf, existsSync: ef } = await import('node:fs');
+      if (ef(CONFIG_PATH)) {
+        let cfg = rf(CONFIG_PATH, 'utf8');
+        cfg = cfg.replace(/\ngithub_memory:[\s\S]*?(?=\n\w|\n$|$)/, '');
+        wf(CONFIG_PATH, cfg, 'utf8');
+      }
+      console.log('  \x1b[32m✓\x1b[0m GitHub memory sync disabled. Local graph unchanged.');
+      break;
+    }
+
+    default:
+      console.log('  Usage: 0agent memory connect github | sync | pull | status | disconnect');
+  }
+}
+
+async function verifyGitHubToken(token) {
+  try {
+    const res = await fetch('https://api.github.com/user', {
+      headers: { Authorization: `Bearer ${token}`, 'User-Agent': '0agent/1.0' },
+      signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok) return null;
+    const user = await res.json();
+    return user.login;
+  } catch { return null; }
+}
+
+async function createGitHubRepo(token, repoName) {
+  const res = await fetch('https://api.github.com/user/repos', {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', 'User-Agent': '0agent/1.0' },
+    body: JSON.stringify({
+      name: repoName,
+      description: '0agent memory — knowledge graph backed up automatically',
+      private: true,
+      auto_init: true,
+    }),
+    signal: AbortSignal.timeout(10000),
+  });
+  return res.ok || res.status === 422; // 422 = already exists
+}
+
+async function daemonMemorySync(direction) {
+  try {
+    const res = await fetch(`${BASE_URL}/api/memory/${direction}`, { method: 'POST' });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch { return null; }
+}
+
 // ─── Result preview — confirms the agent's work actually ran ────────────────
 
 async function showResultPreview(result) {

package/dist/daemon.mjs

@@ -1490,7 +1490,7 @@ var init_EdgeWeightUpdater = __esm({
         this.weightLog.append(event);
       }
       sleep(ms) {
-        return new Promise((resolve11) => setTimeout(resolve11, ms));
+        return new Promise((resolve12) => setTimeout(resolve12, ms));
       }
     };
   }
@@ -2613,7 +2613,7 @@ var init_AgentExecutor = __esm({
         }
       }
       shellExec(command, timeoutMs) {
-        return new Promise((resolve11) => {
+        return new Promise((resolve12) => {
           const chunks = [];
           const proc = spawn2("bash", ["-c", command], {
             cwd: this.cwd,
@@ -2624,10 +2624,10 @@ var init_AgentExecutor = __esm({
           proc.stderr.on("data", (d) => chunks.push(d.toString()));
           proc.on("close", (code) => {
             const output = chunks.join("").trim();
-            resolve11(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
+            resolve12(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
           });
           proc.on("error", (err) => {
-            resolve11(`Error: ${err.message}`);
+            resolve12(`Error: ${err.message}`);
           });
         });
       }
@@ -2933,11 +2933,11 @@ __export(ProactiveSurface_exports, {
   ProactiveSurface: () => ProactiveSurface
 });
 import { execSync as execSync4 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync9, statSync, readdirSync as readdirSync4 } from "node:fs";
-import { resolve as resolve8, join as join3 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync10, statSync, readdirSync as readdirSync5 } from "node:fs";
+import { resolve as resolve9, join as join3 } from "node:path";
 function readdirSafe(dir) {
   try {
-    return readdirSync4(dir);
+    return readdirSync5(dir);
   } catch {
     return [];
   }
@@ -2983,7 +2983,7 @@ var init_ProactiveSurface = __esm({
         return [...this.insights];
       }
       async poll() {
-        if (!existsSync9(resolve8(this.cwd, ".git"))) return;
+        if (!existsSync10(resolve9(this.cwd, ".git"))) return;
         const newInsights = [];
         const gitInsight = this.checkGitActivity();
         if (gitInsight) newInsights.push(gitInsight);
@@ -3027,13 +3027,13 @@ var init_ProactiveSurface = __esm({
         ];
         for (const dir of outputPaths) {
           try {
-            if (!existsSync9(dir)) continue;
+            if (!existsSync10(dir)) continue;
             const xmlFiles = readdirSafe(dir).filter((f) => f.endsWith(".xml"));
             for (const xml of xmlFiles) {
               const path = join3(dir, xml);
               const stat = statSync(path);
               if (stat.mtimeMs < this.lastPollAt) continue;
-              const content = readFileSync9(path, "utf8");
+              const content = readFileSync10(path, "utf8");
               const failures = [...content.matchAll(/<failure[^>]*message="([^"]+)"/g)].length;
               if (failures > 0) {
                 return this.makeInsight(
@@ -3088,9 +3088,9 @@ var init_ProactiveSurface = __esm({
 
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_src();
-import { writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync2, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "node:fs";
+import { resolve as resolve10 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 
 // packages/daemon/src/config/DaemonConfig.ts
 import { readFileSync, existsSync } from "node:fs";
@@ -3199,7 +3199,13 @@ var DaemonConfigSchema = z.object({
   decay: DecayConfigSchema.default({}),
   seed: z.string().optional(),
   self_improvement: SelfImprovementConfigSchema.default({}),
-  entity_nesting: EntityNestingConfigSchema.default({})
+  entity_nesting: EntityNestingConfigSchema.default({}),
+  github_memory: z.object({
+    enabled: z.boolean().default(false),
+    token: z.string().default(""),
+    owner: z.string().default(""),
+    repo: z.string().default("0agent-memory")
+  }).default({})
 });
 
 // packages/daemon/src/config/DaemonConfig.ts
@@ -3536,19 +3542,19 @@ var ProjectScanner = class {
   async getRunningPorts() {
     const open = [];
     await Promise.all(PORTS_TO_CHECK.map(
-      (port) => new Promise((resolve11) => {
+      (port) => new Promise((resolve12) => {
         const s = createServer();
         s.listen(port, "127.0.0.1", () => {
           s.close();
-          resolve11();
+          resolve12();
         });
         s.on("error", () => {
           open.push(port);
-          resolve11();
+          resolve12();
         });
         setTimeout(() => {
           s.close();
-          resolve11();
+          resolve12();
         }, 200);
       })
     ));
@@ -4291,7 +4297,7 @@ var SkillRegistry = class {
 };
 
 // packages/daemon/src/HTTPServer.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono10 } from "hono";
 import { serve } from "@hono/node-server";
 import { readFileSync as readFileSync6 } from "node:fs";
 import { resolve as resolve5, dirname as dirname3 } from "node:path";
@@ -4546,6 +4552,48 @@ function skillRoutes(deps) {
   return app;
 }
 
+// packages/daemon/src/routes/insights.ts
+import { Hono as Hono8 } from "hono";
+function insightsRoutes(deps) {
+  const app = new Hono8();
+  app.get("/", (c) => {
+    if (!deps.proactiveSurface) return c.json([]);
+    const seen = c.req.query("seen");
+    const insights = seen === "false" ? deps.proactiveSurface.getUnseen() : deps.proactiveSurface.getAll();
+    return c.json(insights);
+  });
+  app.post("/:id/seen", (c) => {
+    if (!deps.proactiveSurface) return c.json({ ok: false, error: "not available" }, 404);
+    deps.proactiveSurface.markSeen(c.req.param("id"));
+    return c.json({ ok: true });
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/memory.ts
+import { Hono as Hono9 } from "hono";
+function memoryRoutes(deps) {
+  const app = new Hono9();
+  app.post("/push", async (c) => {
+    const sync = deps.getSync();
+    if (!sync) return c.json({ error: "GitHub memory not configured. Run: 0agent memory connect github" }, 404);
+    const result = await sync.push();
+    return c.json(result);
+  });
+  app.post("/pull", async (c) => {
+    const sync = deps.getSync();
+    if (!sync) return c.json({ error: "GitHub memory not configured." }, 404);
+    const result = await sync.pull();
+    return c.json(result);
+  });
+  app.get("/status", (c) => {
+    const sync = deps.getSync();
+    if (!sync) return c.json({ configured: false });
+    return c.json({ configured: true, ...sync.getLastSyncTimes() });
+  });
+  return app;
+}
+
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
@@ -4571,7 +4619,7 @@ var HTTPServer = class {
   deps;
   constructor(deps) {
     this.deps = deps;
-    this.app = new Hono8();
+    this.app = new Hono10();
     this.app.route("/api/health", healthRoutes({ getStatus: deps.getStatus }));
     this.app.route("/api/sessions", sessionRoutes({ sessions: deps.sessions }));
     this.app.route("/api/graph", graphRoutes({ graph: deps.graph }));
@@ -4579,6 +4627,8 @@ var HTTPServer = class {
     this.app.route("/api/traces", traceRoutes({ traceStore: deps.traceStore }));
     this.app.route("/api/subagents", subagentRoutes());
     this.app.route("/api/skills", skillRoutes({ skillRegistry: deps.skillRegistry }));
+    this.app.route("/api/insights", insightsRoutes({ proactiveSurface: deps.proactiveSurface ?? null }));
+    this.app.route("/api/memory", memoryRoutes({ getSync: deps.getMemorySync ?? (() => null) }));
     const serveGraph = (c) => {
       try {
         const html = readFileSync6(GRAPH_HTML_PATH, "utf8");
@@ -4591,7 +4641,7 @@ var HTTPServer = class {
     this.app.get("/graph", serveGraph);
   }
   start() {
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -4599,20 +4649,20 @@ var HTTPServer = class {
           hostname: this.deps.host
         },
         () => {
-          resolve11();
+          resolve12();
         }
       );
     });
   }
   stop() {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       if (!this.server) {
-        resolve11();
+        resolve12();
         return;
       }
       this.server.close((err) => {
         if (err) reject(err);
-        else resolve11();
+        else resolve12();
       });
     });
   }
@@ -5148,6 +5198,372 @@ var TeamSync = class {
   }
 };
 
+// packages/daemon/src/GitHubMemorySync.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync9, readdirSync as readdirSync4 } from "node:fs";
+import { resolve as resolve8 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+var GITHUB_API = "https://api.github.com";
+async function ghFetch(path, token, opts) {
+  return fetch(`${GITHUB_API}${path}`, {
+    ...opts,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "Content-Type": "application/json",
+      "User-Agent": "0agent/1.0",
+      ...opts?.headers ?? {}
+    },
+    signal: AbortSignal.timeout(15e3)
+  });
+}
+async function getFileSha(token, owner, repo, path) {
+  try {
+    const res = await ghFetch(`/repos/${owner}/${repo}/contents/${path}`, token);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.sha;
+  } catch {
+    return null;
+  }
+}
+async function putFile(token, owner, repo, path, content, message) {
+  const sha = await getFileSha(token, owner, repo, path);
+  const body = {
+    message,
+    content: Buffer.from(content).toString("base64")
+  };
+  if (sha) body.sha = sha;
+  const res = await ghFetch(`/repos/${owner}/${repo}/contents/${path}`, token, {
+    method: "PUT",
+    body: JSON.stringify(body)
+  });
+  return res.ok;
+}
+async function getFile(token, owner, repo, path) {
+  try {
+    const res = await ghFetch(`/repos/${owner}/${repo}/contents/${path}`, token);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return Buffer.from(data.content, "base64").toString("utf8");
+  } catch {
+    return null;
+  }
+}
+var GitHubMemorySync = class {
+  constructor(config, adapter, graph) {
+    this.config = config;
+    this.adapter = adapter;
+    this.graph = graph;
+  }
+  lastPushAt = 0;
+  lastPullAt = 0;
+  pendingChanges = false;
+  /**
+   * Push current graph state to GitHub.
+   * Called automatically every 30 minutes and on `0agent memory sync`.
+   */
+  async push(message) {
+    const now = Date.now();
+    const commitMsg = message ?? `sync: ${new Date(now).toISOString()}`;
+    try {
+      const nodes = this.adapter.queryNodes({});
+      const nodesJson = JSON.stringify(nodes.map((n) => ({
+        id: n.id,
+        graph_id: n.graph_id,
+        label: n.label,
+        type: n.type,
+        visit_count: n.visit_count,
+        metadata: n.metadata,
+        subgraph_id: n.subgraph_id,
+        created_at: n.created_at,
+        last_seen: n.last_seen
+        // Omit embeddings — too large, recomputed locally
+      })), null, 2);
+      const edges = this.adapter.getAllEdges();
+      const edgesJson = JSON.stringify(edges.map((e) => ({
+        id: e.id,
+        graph_id: e.graph_id,
+        from_node: e.from_node,
+        to_node: e.to_node,
+        type: e.type,
+        weight: e.weight,
+        locked: e.locked,
+        decay_rate: e.decay_rate,
+        traversal_count: e.traversal_count,
+        created_at: e.created_at
+      })), null, 2);
+      const weightEvents = this.getRecentWeightEvents(500);
+      const weightEventsJsonl = weightEvents.map((e) => JSON.stringify(e)).join("\n");
+      const personalityMap = this.exportPersonalityProfiles();
+      const conversations = this.getConversations(1e3);
+      const convsJsonl = conversations.map((c) => JSON.stringify(c)).join("\n");
+      const { token, owner, repo } = this.config;
+      const pushes = [
+        putFile(token, owner, repo, "graph/nodes.json", nodesJson, commitMsg),
+        putFile(token, owner, repo, "graph/edges.json", edgesJson, commitMsg)
+      ];
+      if (weightEventsJsonl) {
+        pushes.push(putFile(token, owner, repo, "graph/weight_events.jsonl", weightEventsJsonl, commitMsg));
+      }
+      if (convsJsonl) {
+        pushes.push(putFile(token, owner, repo, "memory/conversations.jsonl", convsJsonl, commitMsg));
+      }
+      for (const [entityId, profile] of Object.entries(personalityMap)) {
+        pushes.push(
+          putFile(
+            token,
+            owner,
+            repo,
+            `memory/personalities/${entityId}.json`,
+            JSON.stringify(profile, null, 2),
+            commitMsg
+          )
+        );
+      }
+      const customSkillsDir = resolve8(homedir5(), ".0agent", "skills", "custom");
+      if (existsSync9(customSkillsDir)) {
+        for (const file of readdirSync4(customSkillsDir).filter((f) => f.endsWith(".yaml"))) {
+          const content = readFileSync9(resolve8(customSkillsDir, file), "utf8");
+          pushes.push(putFile(token, owner, repo, `skills/custom/${file}`, content, commitMsg));
+        }
+      }
+      const readme = this.generateReadme(nodes.length, edges.length);
+      pushes.push(putFile(token, owner, repo, "README.md", readme, commitMsg));
+      await Promise.all(pushes);
+      this.lastPushAt = now;
+      this.pendingChanges = false;
+      return { pushed: true, pulled: false, nodes_synced: nodes.length, edges_synced: edges.length, timestamp: now };
+    } catch (err) {
+      return {
+        pushed: false,
+        pulled: false,
+        nodes_synced: 0,
+        edges_synced: 0,
+        error: err instanceof Error ? err.message : String(err),
+        timestamp: now
+      };
+    }
+  }
+  /**
+   * Pull graph state from GitHub and merge into local SQLite.
+   * Safe: never overwrites locked edges or newer local data.
+   */
+  async pull() {
+    const now = Date.now();
+    try {
+      const { token, owner, repo } = this.config;
+      const [nodesJson, edgesJson] = await Promise.all([
+        getFile(token, owner, repo, "graph/nodes.json"),
+        getFile(token, owner, repo, "graph/edges.json")
+      ]);
+      let nodeCount = 0, edgeCount = 0;
+      if (nodesJson) {
+        const nodes = JSON.parse(nodesJson);
+        for (const n of nodes) {
+          const existing = this.graph.getNode(String(n.id));
+          if (!existing) {
+            this.graph.addNode({
+              id: String(n.id),
+              graph_id: String(n.graph_id ?? "root"),
+              label: String(n.label),
+              type: n.type,
+              created_at: Number(n.created_at ?? now),
+              last_seen: Number(n.last_seen ?? now),
+              visit_count: Number(n.visit_count ?? 1),
+              metadata: n.metadata ?? {},
+              subgraph_id: n.subgraph_id ? String(n.subgraph_id) : null,
+              embedding: null,
+              embedding_model: null,
+              embedding_at: null,
+              content: []
+            });
+            nodeCount++;
+          }
+        }
+      }
+      if (edgesJson) {
+        const edges = JSON.parse(edgesJson);
+        for (const e of edges) {
+          const existing = this.graph.getEdge(String(e.id));
+          if (!existing) {
+            this.graph.addEdge({
+              id: String(e.id),
+              graph_id: String(e.graph_id ?? "root"),
+              from_node: String(e.from_node),
+              to_node: String(e.to_node),
+              type: e.type,
+              weight: Number(e.weight ?? 0.5),
+              locked: Boolean(e.locked),
+              decay_rate: Number(e.decay_rate ?? 1e-3),
+              created_at: Number(e.created_at ?? now),
+              last_traversed: null,
+              traversal_count: Number(e.traversal_count ?? 0),
+              metadata: {}
+            });
+            edgeCount++;
+          } else if (!existing.locked) {
+            const remoteWeight = Number(e.weight ?? 0.5);
+            const blended = existing.weight * 0.6 + remoteWeight * 0.4;
+            if (Math.abs(blended - existing.weight) > 0.01) {
+              this.adapter.forceUpdateEdgeWeight(existing.id, blended);
+              edgeCount++;
+            }
+          }
+        }
+      }
+      await this.pullCustomSkills();
+      this.lastPullAt = now;
+      return { pushed: false, pulled: true, nodes_synced: nodeCount, edges_synced: edgeCount, timestamp: now };
+    } catch (err) {
+      return {
+        pushed: false,
+        pulled: false,
+        nodes_synced: 0,
+        edges_synced: 0,
+        error: err instanceof Error ? err.message : String(err),
+        timestamp: now
+      };
+    }
+  }
+  /** Mark that changes exist — scheduler will push on next interval. */
+  markDirty() {
+    this.pendingChanges = true;
+  }
+  hasPendingChanges() {
+    return this.pendingChanges;
+  }
+  getLastSyncTimes() {
+    return { pushed_at: this.lastPushAt, pulled_at: this.lastPullAt };
+  }
+  // ─── Repo creation ─────────────────────────────────────────────────────────
+  /**
+   * Create the private GitHub repo for memory storage.
+   * Returns the repo URL on success.
+   */
+  static async createRepo(token, owner, repoName) {
+    const res = await ghFetch("/user/repos", token, {
+      method: "POST",
+      body: JSON.stringify({
+        name: repoName,
+        description: "0agent memory \u2014 knowledge graph, personality profiles, conversation history",
+        private: true,
+        auto_init: true
+        // creates main branch with README
+      })
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      if (res.status !== 422) throw new Error(`Failed to create repo: ${err.message ?? res.status}`);
+    }
+    return `https://github.com/${owner}/${repoName}`;
+  }
+  /**
+   * Verify token works and return the authenticated username.
+   */
+  static async verifyToken(token) {
+    try {
+      const res = await ghFetch("/user", token);
+      if (!res.ok) return null;
+      const user = await res.json();
+      return user.login;
+    } catch {
+      return null;
+    }
+  }
+  // ─── Private helpers ───────────────────────────────────────────────────────
+  getRecentWeightEvents(limit) {
+    try {
+      const db = this.adapter.db;
+      return db.prepare(`SELECT * FROM weight_events ORDER BY created_at DESC LIMIT ?`).all(limit);
+    } catch {
+      return [];
+    }
+  }
+  getConversations(limit) {
+    try {
+      const db = this.adapter.db;
+      return db.prepare(`SELECT * FROM conversations ORDER BY created_at DESC LIMIT ?`).all(limit);
+    } catch {
+      return [];
+    }
+  }
+  exportPersonalityProfiles() {
+    const profiles = {};
+    try {
+      const profileNodes = this.adapter.queryNodes({ type: "signal" }).filter(
+        (n) => n.metadata?.is_personality_profile
+      );
+      for (const node of profileNodes) {
+        const entityId = node.metadata?.entity_id;
+        if (entityId && node.content?.[0]?.data) {
+          try {
+            profiles[entityId] = JSON.parse(node.content[0].data);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    return profiles;
+  }
+  async pullCustomSkills() {
+    const { token, owner, repo } = this.config;
+    const dir = resolve8(homedir5(), ".0agent", "skills", "custom");
+    try {
+      const res = await ghFetch(`/repos/${owner}/${repo}/contents/skills/custom`, token);
+      if (!res.ok) return;
+      const files = await res.json();
+      for (const file of files.filter((f) => f.name.endsWith(".yaml"))) {
+        const content = await getFile(token, owner, repo, `skills/custom/${file.name}`);
+        if (content) {
+          const { mkdirSync: mkdirSync7 } = await import("node:fs");
+          mkdirSync7(dir, { recursive: true });
+          writeFileSync6(resolve8(dir, file.name), content, "utf8");
+        }
+      }
+    } catch {
+    }
+  }
+  generateReadme(nodeCount, edgeCount) {
+    return `# 0agent Memory
+
+> Private knowledge graph \u2014 backed up automatically by [0agent](https://github.com/cadetmaze/0agentv1)
+
+**Last synced:** ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Contents
+
+| File | Description |
+|------|-------------|
+| \`graph/nodes.json\` | ${nodeCount} entities, strategies, plans, context nodes |
+| \`graph/edges.json\` | ${edgeCount} relationships with learned weights |
+| \`graph/weight_events.jsonl\` | Full learning history (append-only) |
+| \`memory/personalities/\` | Communication style + preferences per person |
+| \`memory/conversations.jsonl\` | Conversation history |
+| \`skills/custom/\` | Custom skill definitions |
+
+## Cross-device sync
+
+\`\`\`bash
+# On a new machine:
+0agent memory connect github --repo ${this.config.owner}/${this.config.repo}
+\`\`\`
+
+## Rollback
+
+\`\`\`bash
+# Restore to a previous state:
+git log --oneline                    # find the commit
+git checkout <commit> graph/         # restore graph files
+0agent memory import                 # import into local SQLite
+\`\`\`
+
+---
+*This repo is managed by 0agent. Do not edit files manually.*
+`;
+  }
+};
+
 // packages/daemon/src/ZeroAgentDaemon.ts
 var ZeroAgentDaemon = class {
   config = null;
@@ -5160,15 +5576,18 @@ var ZeroAgentDaemon = class {
   httpServer = null;
   skillRegistry = null;
   backgroundWorkers = null;
+  githubMemorySync = null;
+  memorySyncTimer = null;
+  proactiveSurfaceInstance = null;
   startedAt = 0;
   pidFilePath;
   constructor() {
-    this.pidFilePath = resolve9(homedir5(), ".0agent", "daemon.pid");
+    this.pidFilePath = resolve10(homedir6(), ".0agent", "daemon.pid");
   }
   async start(opts) {
     this.config = await loadConfig(opts?.config_path);
-    const dotDir = resolve9(homedir5(), ".0agent");
-    if (!existsSync10(dotDir)) {
+    const dotDir = resolve10(homedir6(), ".0agent");
+    if (!existsSync11(dotDir)) {
       mkdirSync6(dotDir, { recursive: true });
     }
     this.adapter = new SQLiteAdapter({ db_path: this.config.graph.db_path });
@@ -5192,6 +5611,19 @@ var ZeroAgentDaemon = class {
     } else {
       console.warn("[0agent] No LLM API key configured \u2014 tasks will not call the LLM");
     }
+    const ghMemCfg = this.config["github_memory"];
+    if (ghMemCfg?.enabled && ghMemCfg.token && ghMemCfg.owner && ghMemCfg.repo) {
+      this.githubMemorySync = new GitHubMemorySync(
+        { token: ghMemCfg.token, owner: ghMemCfg.owner, repo: ghMemCfg.repo },
+        this.adapter,
+        this.graph
+      );
+      console.log(`[0agent] Memory sync: github.com/${ghMemCfg.owner}/${ghMemCfg.repo}`);
+      this.githubMemorySync.pull().then((r) => {
+        if (r.pulled) console.log(`[0agent] Memory pulled: +${r.nodes_synced} nodes, +${r.edges_synced} edges`);
+      }).catch(() => {
+      });
+    }
     const cwd = process.env["ZEROAGENT_CWD"] ?? process.cwd();
     const identityManager = new IdentityManager(this.graph);
     const identity = await identityManager.init().catch(() => null);
@@ -5221,6 +5653,18 @@ var ZeroAgentDaemon = class {
       // enables ConversationStore + weight feedback
     });
     const teamSync = identity && teams.length > 0 ? new TeamSync(teamManager, this.adapter, identity.entity_node_id) : null;
+    if (this.githubMemorySync) {
+      const memSync = this.githubMemorySync;
+      this.memorySyncTimer = setInterval(async () => {
+        if (memSync.hasPendingChanges()) {
+          const result = await memSync.push().catch(() => null);
+          if (result?.pushed) {
+            console.log(`[0agent] Memory auto-synced: ${result.nodes_synced} nodes`);
+          }
+        }
+      }, 30 * 60 * 1e3);
+      if (typeof this.memorySyncTimer === "object") this.memorySyncTimer.unref?.();
+    }
     let proactiveSurface = null;
     try {
       const { ProactiveSurface: ProactiveSurface2 } = await Promise.resolve().then(() => (init_ProactiveSurface(), ProactiveSurface_exports));
@@ -5239,6 +5683,7 @@ var ZeroAgentDaemon = class {
       active_sessions: this.sessionManager.activeSessionCount()
     }));
     this.startedAt = Date.now();
+    const memSyncRef = this.githubMemorySync;
     this.httpServer = new HTTPServer({
       port: this.config.server.port,
       host: this.config.server.host,
@@ -5246,10 +5691,12 @@ var ZeroAgentDaemon = class {
       graph: this.graph,
       traceStore: this.traceStore,
       skillRegistry: this.skillRegistry,
-      getStatus: () => this.getStatus()
+      getStatus: () => this.getStatus(),
+      getMemorySync: () => memSyncRef,
+      proactiveSurface
     });
     await this.httpServer.start();
-    writeFileSync6(this.pidFilePath, String(process.pid), "utf8");
+    writeFileSync7(this.pidFilePath, String(process.pid), "utf8");
     console.log(
       `[0agent] Daemon started on ${this.config.server.host}:${this.config.server.port} (PID: ${process.pid})`
     );
@@ -5274,6 +5721,15 @@ var ZeroAgentDaemon = class {
       this.backgroundWorkers.stop();
       this.backgroundWorkers = null;
     }
+    if (this.githubMemorySync?.hasPendingChanges()) {
+      await this.githubMemorySync.push("sync: daemon shutdown").catch(() => {
+      });
+    }
+    if (this.memorySyncTimer) {
+      clearInterval(this.memorySyncTimer);
+      this.memorySyncTimer = null;
+    }
+    this.githubMemorySync = null;
     this.sessionManager = null;
     this.skillRegistry = null;
     this.inferenceEngine = null;
@@ -5283,7 +5739,7 @@ var ZeroAgentDaemon = class {
       this.graph = null;
     }
     this.adapter = null;
-    if (existsSync10(this.pidFilePath)) {
+    if (existsSync11(this.pidFilePath)) {
       try {
         unlinkSync2(this.pidFilePath);
       } catch {
@@ -5313,11 +5769,11 @@ var ZeroAgentDaemon = class {
 };
 
 // packages/daemon/src/start.ts
-import { resolve as resolve10 } from "node:path";
-import { homedir as homedir6 } from "node:os";
-import { existsSync as existsSync11 } from "node:fs";
-var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve10(homedir6(), ".0agent", "config.yaml");
-if (!existsSync11(CONFIG_PATH)) {
+import { resolve as resolve11 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { existsSync as existsSync12 } from "node:fs";
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve11(homedir7(), ".0agent", "config.yaml");
+if (!existsSync12(CONFIG_PATH)) {
   console.error(`
   0agent is not initialised.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0agent",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",