0agent 1.0.27 → 1.0.29

package/bin/0agent.js

@@ -126,6 +126,10 @@ switch (cmd) {
     await runMemoryCommand(args.slice(1));
     break;
 
+  case 'codespace':
+    await runCodespaceCommand(args.slice(1));
+    break;
+
   default:
     showHelp();
     break;
@@ -1095,6 +1099,58 @@ async function daemonMemorySync(direction) {
   } catch { return null; }
 }
 
+// ─── Codespace commands ───────────────────────────────────────────────────────
+
+async function runCodespaceCommand(csArgs) {
+  const sub = csArgs[0] ?? 'status';
+
+  switch (sub) {
+    case 'setup': {
+      console.log('\n  Setting up GitHub Codespace browser backend...\n');
+      const result = await fetch(`${BASE_URL}/api/codespace/setup`, { method: 'POST' }).catch(() => null);
+      const data = result?.ok ? await result.json().catch(() => null) : null;
+      if (data?.started) {
+        console.log(`  \x1b[32m✓\x1b[0m Codespace provisioning started`);
+        console.log(`  \x1b[2mFirst time: ~2-3 min. Check with: 0agent codespace status\x1b[0m\n`);
+      } else {
+        console.log(`  \x1b[33m⚠\x1b[0m ${data?.error ?? 'Configure GitHub memory first: 0agent memory connect github'}\n`);
+      }
+      break;
+    }
+    case 'status': {
+      const result = await fetch(`${BASE_URL}/api/codespace/status`).catch(() => null);
+      const data = result?.ok ? await result.json().catch(() => null) : null;
+      if (data) {
+        const state = data.state ?? 'unknown';
+        const icon = state === 'Available' ? '\x1b[32m✓\x1b[0m' : state === 'Shutdown' ? '\x1b[33m●\x1b[0m' : '\x1b[2m○\x1b[0m';
+        console.log(`\n  Browser backend: ${icon} ${state}`);
+        if (data.ready) console.log(`  Tunnel:          \x1b[32m✓ open\x1b[0m → http://localhost:3001`);
+        if (data.name) console.log(`  Codespace:       ${data.name}`);
+        console.log(`  Cost:            ~60 hours/month free on GitHub personal\n`);
+      } else {
+        console.log('\n  Codespace not configured. Run: 0agent codespace setup\n');
+      }
+      break;
+    }
+    case 'start': {
+      process.stdout.write('  Starting codespace...');
+      const result = await fetch(`${BASE_URL}/api/codespace/start`, { method: 'POST' }).catch(() => null);
+      const data = result?.ok ? await result.json().catch(() => null) : null;
+      console.log(data?.ok ? ' \x1b[32m✓\x1b[0m' : ` \x1b[31m✗\x1b[0m ${data?.error ?? 'failed'}`);
+      break;
+    }
+    case 'stop': {
+      process.stdout.write('  Stopping codespace (preserves state)...');
+      const result = await fetch(`${BASE_URL}/api/codespace/stop`, { method: 'POST' }).catch(() => null);
+      const data = result?.ok ? await result.json().catch(() => null) : null;
+      console.log(data?.ok ? ' \x1b[32m✓\x1b[0m Stopped. Hours saved.' : ` \x1b[31m✗\x1b[0m`);
+      break;
+    }
+    default:
+      console.log('  Usage: 0agent codespace setup | status | start | stop');
+  }
+}
+
 // ─── Result preview — confirms the agent's work actually ran ────────────────
 
 async function showResultPreview(result) {

package/bin/chat.js

@@ -189,6 +189,13 @@ function handleWsEvent(event) {
       lineBuffer += event.token;
       break;
     }
+    case 'schedule.fired': {
+      // Show when a scheduled job fires — even if user is idle
+      const ts = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+      process.stdout.write(`\n  ${fmt(C.magenta, '⏰')} [${ts}] Scheduled: ${fmt(C.bold, event.job_name)} — ${event.task}\n`);
+      if (!streaming) rl.prompt(true);
+      break;
+    }
     case 'session.completed': {
       spinner.stop();
       if (streaming) { process.stdout.write('\n'); streaming = false; }
@@ -380,6 +387,78 @@ async function handleCommand(input) {
     }
 
     // /skills
+    // /schedule — cron-like job scheduler
+    case '/schedule': {
+      const schedArgs = parts.slice(1);
+      const subCmd = schedArgs[0]?.toLowerCase() ?? 'list';
+
+      if (subCmd === 'list' || schedArgs.length === 0) {
+        const res = await fetch(`${BASE_URL}/api/schedule`).catch(() => null);
+        const jobs = res?.ok ? await res.json().catch(() => []) : [];
+        if (!Array.isArray(jobs) || jobs.length === 0) {
+          console.log('\n  No scheduled jobs. Add one:\n  ' +
+            fmt(C.dim, '/schedule add "run /retro" every Friday at 5pm') + '\n');
+        } else {
+          console.log('\n  Scheduled jobs:\n');
+          for (const j of jobs) {
+            const status = j.enabled ? fmt(C.green, '●') : fmt(C.dim, '○');
+            const next = j.next_run_human ?? 'unknown';
+            console.log(`  ${status} ${fmt(C.bold, j.id)}  ${j.name}`);
+            console.log(`     ${fmt(C.dim, j.schedule_human + ' · next: ' + next)}`);
+          }
+          console.log();
+        }
+      } else if (subCmd === 'add') {
+        // /schedule add "<task>" <schedule...>
+        // Parse: extract quoted task, rest is schedule
+        const rest = parts.slice(2).join(' ');
+        const quoted = rest.match(/^"([^"]+)"\s+(.+)$/) || rest.match(/^'([^']+)'\s+(.+)$/);
+        if (!quoted) {
+          console.log(`  ${fmt(C.dim, 'Usage: /schedule add "<task>" <schedule>')}`);
+          console.log(`  ${fmt(C.dim, 'Examples:')}`);
+          console.log(`  ${fmt(C.cyan, '  /schedule add "run /retro" every Friday at 5pm')}`);
+          console.log(`  ${fmt(C.cyan, '  /schedule add "run /review" every day at 9am')}`);
+          console.log(`  ${fmt(C.cyan, '  /schedule add "check the build" in 2 hours')}\n`);
+        } else {
+          const task = quoted[1];
+          const schedule = quoted[2];
+          const res = await fetch(`${BASE_URL}/api/schedule`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ task, schedule }),
+          }).catch(() => null);
+          const data = res?.ok ? await res.json().catch(() => null) : null;
+          if (data?.id) {
+            console.log(`  ${fmt(C.green, '✓')} Scheduled: ${fmt(C.bold, data.name)}`);
+            console.log(`  ${fmt(C.dim, data.schedule_human + ' · next: ' + data.next_run_human)}\n`);
+          } else {
+            console.log(`  ${fmt(C.red, '✗')} ${data?.error ?? 'Failed to create schedule'}\n`);
+          }
+        }
+      } else if (subCmd === 'delete' || subCmd === 'remove') {
+        const id = schedArgs[1];
+        if (!id) { console.log('  Usage: /schedule delete <id>\n'); break; }
+        const res = await fetch(`${BASE_URL}/api/schedule/${id}`, { method: 'DELETE' }).catch(() => null);
+        const data = res?.ok ? await res.json().catch(() => null) : null;
+        console.log(data?.ok
+          ? `  ${fmt(C.green, '✓')} Deleted ${id}\n`
+          : `  ${fmt(C.red, '✗')} ${data?.error ?? 'Not found'}\n`);
+      } else if (subCmd === 'pause') {
+        const id = schedArgs[1];
+        if (!id) { console.log('  Usage: /schedule pause <id>\n'); break; }
+        await fetch(`${BASE_URL}/api/schedule/${id}/pause`, { method: 'POST' });
+        console.log(`  ${fmt(C.green, '✓')} Paused ${id}\n`);
+      } else if (subCmd === 'resume') {
+        const id = schedArgs[1];
+        if (!id) { console.log('  Usage: /schedule resume <id>\n'); break; }
+        await fetch(`${BASE_URL}/api/schedule/${id}/resume`, { method: 'POST' });
+        console.log(`  ${fmt(C.green, '✓')} Resumed ${id}\n`);
+      } else {
+        console.log('  Usage: /schedule list | add "<task>" <schedule> | delete <id> | pause <id> | resume <id>\n');
+      }
+      break;
+    }
+
     case '/skills': {
       try {
         const skills = await fetch(`${BASE_URL}/api/skills`).then(r => r.json());
@@ -442,6 +521,7 @@ const rl = createInterface({
   historySize: 100,
   completer: (line) => {
     const commands = ['/model', '/key', '/status', '/skills', '/graph', '/clear', '/help',
+      '/schedule', '/schedule list', '/schedule add',
       '/review', '/build', '/debug', '/qa', '/research', '/refactor', '/test-writer', '/retro'];
     const hits = commands.filter(c => c.startsWith(line));
     return [hits.length ? hits : commands, line];
@@ -569,7 +649,7 @@ rl.on('line', async (input) => {
   const line = input.trim();
   if (!line) { rl.prompt(); return; }
 
-  if (line.startsWith('/') || ['/model','/key','/status','/skills','/graph','/clear','/help'].some(c => line.startsWith(c))) {
+  if (line.startsWith('/') || ['/model','/key','/status','/skills','/graph','/clear','/help','/schedule'].some(c => line.startsWith(c))) {
     await handleCommand(line);
     rl.prompt();
   } else {

package/dist/daemon.mjs

@@ -1,5 +1,7 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -7,6 +9,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/core/src/graph/GraphNode.ts
 function createNode(params) {
@@ -2418,6 +2429,80 @@ var init_FileCapability = __esm({
   }
 });
 
+// packages/daemon/src/capabilities/CodespaceBrowserCapability.ts
+var CodespaceBrowserCapability_exports = {};
+__export(CodespaceBrowserCapability_exports, {
+  CodespaceBrowserCapability: () => CodespaceBrowserCapability
+});
+var CodespaceBrowserCapability;
+var init_CodespaceBrowserCapability = __esm({
+  "packages/daemon/src/capabilities/CodespaceBrowserCapability.ts"() {
+    "use strict";
+    init_BrowserCapability();
+    CodespaceBrowserCapability = class {
+      constructor(manager) {
+        this.manager = manager;
+      }
+      name = "browser_open";
+      description = "Open a URL in a cloud Linux browser (GitHub Codespace). Full JS, screenshots, clicks. Falls back to local Chrome.";
+      fallback = new BrowserCapability();
+      provisioningPromise = null;
+      toolDefinition = {
+        name: "browser_open",
+        description: "Open URL in cloud Linux browser (GitHub Codespace). Handles JS-heavy SPAs, auth flows, screenshots. Fallback: local Chrome.",
+        input_schema: {
+          type: "object",
+          properties: {
+            url: { type: "string", description: "URL to open" },
+            action: { type: "string", description: '"read" (default) | "screenshot" | "links" | "click" | "fill" | "snapshot"' },
+            selector: { type: "string", description: "CSS selector for element to extract or interact with" },
+            wait_for: { type: "string", description: "CSS selector to wait for before extracting" },
+            wait_ms: { type: "number", description: "Additional wait after page load (for JS-heavy pages)" },
+            value: { type: "string", description: "Value to fill (for action: fill)" }
+          },
+          required: ["url"]
+        }
+      };
+      async execute(input, cwd) {
+        const start = Date.now();
+        try {
+          if (!this.manager.isReady()) {
+            if (!this.provisioningPromise) {
+              this.provisioningPromise = this.manager.getReadyUrl().finally(() => {
+                this.provisioningPromise = null;
+              });
+            }
+            await this.provisioningPromise;
+          }
+          const res = await fetch(`${this.manager.localUrl}/browse`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(input),
+            signal: AbortSignal.timeout(6e4)
+          });
+          const data = await res.json();
+          if (!data.ok) throw new Error(String(data.error ?? "Browse failed"));
+          return {
+            success: true,
+            output: String(data.data ?? ""),
+            structured: data,
+            duration_ms: Date.now() - start
+          };
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          console.warn("[CodespaceBrowser] Falling back to local Chrome:", errMsg);
+          const result = await this.fallback.execute(input, cwd);
+          return {
+            ...result,
+            fallback_used: "local-chrome",
+            duration_ms: Date.now() - start
+          };
+        }
+      }
+    };
+  }
+});
+
 // packages/daemon/src/capabilities/CapabilityRegistry.ts
 var CapabilityRegistry;
 var init_CapabilityRegistry = __esm({
@@ -2430,9 +2515,28 @@ var init_CapabilityRegistry = __esm({
     init_FileCapability();
     CapabilityRegistry = class {
       capabilities = /* @__PURE__ */ new Map();
-      constructor() {
+      /**
+       * Constructor optionally accepts a CodespaceManager.
+       * If provided and the gh CLI is available, uses CodespaceBrowserCapability
+       * for browser_open — cloud Linux browser via SSH tunnel.
+       *
+       * SECURITY: The registry is only instantiated inside AgentExecutor,
+       * which is only created for AUTHORISED subagents (trust_level: 1,
+       * task_type: browser_task). The main agent does NOT have direct access
+       * to browser_open without going through a subagent spawn.
+       */
+      constructor(codespaceManager) {
         this.register(new WebSearchCapability());
-        this.register(new BrowserCapability());
+        if (codespaceManager) {
+          try {
+            const { CodespaceBrowserCapability: CodespaceBrowserCapability2 } = (init_CodespaceBrowserCapability(), __toCommonJS(CodespaceBrowserCapability_exports));
+            this.register(new CodespaceBrowserCapability2(codespaceManager));
+          } catch {
+            this.register(new BrowserCapability());
+          }
+        } else {
+          this.register(new BrowserCapability());
+        }
         this.register(new ScraperCapability());
         this.register(new ShellCapability());
         this.register(new FileCapability());
@@ -2932,7 +3036,7 @@ var ProactiveSurface_exports = {};
 __export(ProactiveSurface_exports, {
   ProactiveSurface: () => ProactiveSurface
 });
-import { execSync as execSync4 } from "node:child_process";
+import { execSync as execSync5 } from "node:child_process";
 import { existsSync as existsSync12, readFileSync as readFileSync12, statSync, readdirSync as readdirSync5 } from "node:fs";
 import { resolve as resolve11, join as join3 } from "node:path";
 function readdirSafe(dir) {
@@ -3001,7 +3105,7 @@ var init_ProactiveSurface = __esm({
         try {
           const currentHead = this.getGitHead();
           if (!currentHead || currentHead === this.lastKnownHead) return null;
-          const log = execSync4(
+          const log = execSync5(
             `git log ${this.lastKnownHead}..${currentHead} --oneline --stat`,
             { cwd: this.cwd, timeout: 3e3, encoding: "utf8" }
           ).trim();
@@ -3077,7 +3181,7 @@ var init_ProactiveSurface = __esm({
       }
       getGitHead() {
         try {
-          return execSync4("git rev-parse HEAD", { cwd: this.cwd, timeout: 1e3, encoding: "utf8" }).trim();
+          return execSync5("git rev-parse HEAD", { cwd: this.cwd, timeout: 1e3, encoding: "utf8" }).trim();
         } catch {
           return "";
         }
@@ -4644,7 +4748,7 @@ var SkillRegistry = class {
 };
 
 // packages/daemon/src/HTTPServer.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono13 } from "hono";
 import { serve } from "@hono/node-server";
 import { readFileSync as readFileSync8 } from "node:fs";
 import { resolve as resolve7, dirname as dirname3 } from "node:path";
@@ -4989,6 +5093,442 @@ function llmRoutes() {
   return app;
 }
 
+// packages/daemon/src/routes/codespace.ts
+import { Hono as Hono11 } from "hono";
+function codespaceRoutes(deps) {
+  const app = new Hono11();
+  app.get("/status", async (c) => {
+    const mgr = deps.getManager();
+    if (!mgr) return c.json({ configured: false, state: "not_configured" });
+    const info = mgr.findExisting();
+    const ping = mgr.isReady() ? await mgr.ping().catch(() => null) : null;
+    return c.json({
+      configured: true,
+      state: info?.state ?? "not_found",
+      name: info?.name ?? null,
+      ready: mgr.isReady(),
+      browser_ok: ping?.ok ?? false
+    });
+  });
+  app.post("/setup", async (c) => {
+    const result = await deps.setup();
+    return c.json(result);
+  });
+  app.post("/start", async (c) => {
+    const mgr = deps.getManager();
+    if (!mgr) return c.json({ ok: false, error: "Not configured" }, 404);
+    try {
+      const url = await mgr.getReadyUrl();
+      return c.json({ ok: true, url });
+    } catch (err) {
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.post("/stop", async (c) => {
+    const mgr = deps.getManager();
+    if (!mgr) return c.json({ ok: false, error: "Not configured" }, 404);
+    try {
+      await mgr.stop();
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/schedule.ts
+import { Hono as Hono12 } from "hono";
+
+// packages/daemon/src/SchedulerManager.ts
+var DAYS = {
+  sunday: 0,
+  sun: 0,
+  monday: 1,
+  mon: 1,
+  tuesday: 2,
+  tue: 2,
+  tues: 2,
+  wednesday: 3,
+  wed: 3,
+  thursday: 4,
+  thu: 4,
+  thur: 4,
+  thurs: 4,
+  friday: 5,
+  fri: 5,
+  saturday: 6,
+  sat: 6
+};
+function parseTime(s) {
+  if (!s) return { hour: 9, minute: 0 };
+  const m = s.trim().match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i);
+  if (!m) throw new Error(`Cannot parse time: "${s}". Use format like "9am", "5:30pm", "14:00"`);
+  let hour = parseInt(m[1], 10);
+  const minute = parseInt(m[2] ?? "0", 10);
+  const ampm = m[3]?.toLowerCase();
+  if (ampm === "pm" && hour !== 12) hour += 12;
+  if (ampm === "am" && hour === 12) hour = 0;
+  return { hour, minute };
+}
+function parseSchedule(text) {
+  const t = text.trim().toLowerCase();
+  const inMatch = t.match(/^in\s+(\d+)\s+(hour|hours|hr|hrs|minute|minutes|min|mins)$/);
+  if (inMatch) {
+    const n = parseInt(inMatch[1], 10);
+    const isHours = inMatch[2].startsWith("h");
+    const at = Date.now() + n * (isHours ? 36e5 : 6e4);
+    return { spec: { type: "once", at }, human: text.trim() };
+  }
+  const tomorrowMatch = t.match(/^(?:tomorrow|tom)\s+at\s+(.+)$/);
+  if (tomorrowMatch) {
+    const { hour, minute } = parseTime(tomorrowMatch[1]);
+    const d = /* @__PURE__ */ new Date();
+    d.setDate(d.getDate() + 1);
+    d.setHours(hour, minute, 0, 0);
+    return { spec: { type: "once", at: d.getTime() }, human: text.trim() };
+  }
+  if (t === "every hour") return { spec: { type: "hourly", minute: 0 }, human: "every hour" };
+  const everyMinsMatch = t.match(/^every\s+(\d+)\s+minutes?$/);
+  if (everyMinsMatch) {
+    const interval = parseInt(everyMinsMatch[1], 10);
+    return { spec: { type: "interval_minutes", interval }, human: `every ${interval} minutes` };
+  }
+  const DEFAULT_TIMES = {
+    morning: "9am",
+    evening: "6pm",
+    night: "10pm",
+    noon: "12pm",
+    midnight: "12am"
+  };
+  const dailyMatch = t.match(/^every\s+(day|daily|morning|evening|night|noon|midnight)\s*(?:at\s+(.+))?$/);
+  if (dailyMatch) {
+    const period = dailyMatch[1];
+    const timeStr = dailyMatch[2] ?? DEFAULT_TIMES[period] ?? "9am";
+    const { hour, minute } = parseTime(timeStr);
+    const human = `every ${period}${dailyMatch[2] ? " at " + dailyMatch[2] : ""}`;
+    return { spec: { type: "daily", hour, minute }, human };
+  }
+  const weeklyMatch = t.match(/^every\s+(\w+)\s*(?:at\s+(.+))?$/);
+  if (weeklyMatch && DAYS[weeklyMatch[1]] !== void 0) {
+    const day = DAYS[weeklyMatch[1]];
+    const { hour, minute } = parseTime(weeklyMatch[2] ?? "9am");
+    const human = `every ${weeklyMatch[1]}${weeklyMatch[2] ? " at " + weeklyMatch[2] : ""}`;
+    return { spec: { type: "weekly", day, hour, minute }, human };
+  }
+  throw new Error(
+    `Could not understand schedule: "${text}"
+Try: "every Friday at 5pm" \xB7 "every day at 9am" \xB7 "every morning" \xB7 "in 2 hours" \xB7 "every 30 minutes"`
+  );
+}
+function scheduleToHuman(spec) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const hhmm = (h, m) => {
+    const ampm = h >= 12 ? "pm" : "am";
+    const h12 = h === 0 ? 12 : h > 12 ? h - 12 : h;
+    return m === 0 ? `${h12}${ampm}` : `${h12}:${pad(m)}${ampm}`;
+  };
+  const DAYS_REV = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  switch (spec.type) {
+    case "once":
+      return `once at ${new Date(spec.at).toLocaleString()}`;
+    case "hourly":
+      return `every hour`;
+    case "interval_minutes":
+      return `every ${spec.interval} minutes`;
+    case "daily":
+      return `every day at ${hhmm(spec.hour, spec.minute)}`;
+    case "weekly":
+      return `every ${DAYS_REV[spec.day]} at ${hhmm(spec.hour, spec.minute)}`;
+    case "monthly":
+      return `monthly on the ${spec.date}th at ${hhmm(spec.hour, spec.minute)}`;
+    default:
+      return "unknown schedule";
+  }
+}
+function nextRunAt(spec, now = Date.now()) {
+  const d = new Date(now);
+  const next = new Date(now);
+  switch (spec.type) {
+    case "once":
+      return spec.at;
+    case "hourly": {
+      next.setMinutes(spec.minute, 0, 0);
+      if (next.getTime() <= now) next.setTime(next.getTime() + 36e5);
+      return next.getTime();
+    }
+    case "interval_minutes": {
+      const minsUntil = spec.interval - d.getMinutes() % spec.interval;
+      return now + minsUntil * 6e4;
+    }
+    case "daily": {
+      next.setHours(spec.hour, spec.minute, 0, 0);
+      if (next.getTime() <= now) next.setDate(next.getDate() + 1);
+      return next.getTime();
+    }
+    case "weekly": {
+      const daysUntil = (spec.day - d.getDay() + 7) % 7 || 7;
+      next.setDate(d.getDate() + daysUntil);
+      next.setHours(spec.hour, spec.minute, 0, 0);
+      if (next.getTime() <= now) next.setDate(next.getDate() + 7);
+      return next.getTime();
+    }
+    case "monthly": {
+      next.setDate(spec.date);
+      next.setHours(spec.hour, spec.minute, 0, 0);
+      if (next.getTime() <= now) next.setMonth(next.getMonth() + 1);
+      return next.getTime();
+    }
+  }
+}
+var DDL = `
+  CREATE TABLE IF NOT EXISTS scheduled_jobs (
+    id            TEXT PRIMARY KEY,
+    name          TEXT NOT NULL,
+    task          TEXT NOT NULL,
+    skill         TEXT,
+    schedule_json TEXT NOT NULL,
+    schedule_human TEXT NOT NULL,
+    enabled       INTEGER NOT NULL DEFAULT 1,
+    last_run_at   INTEGER,
+    next_run_at   INTEGER NOT NULL,
+    run_count     INTEGER NOT NULL DEFAULT 0,
+    created_at    INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_jobs_next ON scheduled_jobs(next_run_at, enabled);
+`;
+var SchedulerStore = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  initialised = false;
+  init() {
+    if (this.initialised) return;
+    const db = this.adapter.db;
+    db.exec(DDL);
+    this.initialised = true;
+  }
+  save(job) {
+    this.init();
+    const db = this.adapter.db;
+    db.prepare(`
+      INSERT OR REPLACE INTO scheduled_jobs
+        (id, name, task, skill, schedule_json, schedule_human, enabled, last_run_at, next_run_at, run_count, created_at)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?)
+    `).run(
+      job.id,
+      job.name,
+      job.task,
+      job.skill ?? null,
+      JSON.stringify(job.schedule),
+      job.schedule_human,
+      job.enabled ? 1 : 0,
+      job.last_run_at ?? null,
+      job.next_run_at,
+      job.run_count,
+      job.created_at
+    );
+  }
+  delete(id) {
+    this.init();
+    const db = this.adapter.db;
+    db.prepare("DELETE FROM scheduled_jobs WHERE id = ?").run(id);
+  }
+  list() {
+    this.init();
+    const db = this.adapter.db;
+    const rows = db.prepare("SELECT * FROM scheduled_jobs ORDER BY next_run_at ASC").all();
+    return rows.map(this.rowToJob);
+  }
+  getDue(now) {
+    this.init();
+    const db = this.adapter.db;
+    const rows = db.prepare(
+      "SELECT * FROM scheduled_jobs WHERE enabled = 1 AND next_run_at <= ?"
+    ).all(now);
+    return rows.map(this.rowToJob);
+  }
+  rowToJob(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      task: row.task,
+      skill: row.skill,
+      schedule: JSON.parse(row.schedule_json),
+      schedule_human: row.schedule_human,
+      enabled: row.enabled === 1,
+      last_run_at: row.last_run_at,
+      next_run_at: row.next_run_at,
+      run_count: row.run_count,
+      created_at: row.created_at
+    };
+  }
+};
+var SchedulerManager = class {
+  constructor(adapter, sessions, eventBus) {
+    this.sessions = sessions;
+    this.eventBus = eventBus;
+    this.store = new SchedulerStore(adapter);
+    this.store.init();
+  }
+  store;
+  timer = null;
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.tick(), 3e4);
+    if (this.timer && typeof this.timer === "object" && "unref" in this.timer) {
+      this.timer.unref();
+    }
+    const init = setTimeout(() => this.tick(), 5e3);
+    if (typeof init === "object" && "unref" in init) init.unref();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Add a new scheduled job. */
+  add(params) {
+    const { spec, human } = parseSchedule(params.schedule);
+    const now = Date.now();
+    const job = {
+      id: crypto.randomUUID().slice(0, 8),
+      // short ID for easy reference
+      name: params.name ?? params.task.slice(0, 40),
+      task: params.task,
+      skill: params.skill,
+      schedule: spec,
+      schedule_human: human,
+      enabled: true,
+      next_run_at: nextRunAt(spec, now),
+      run_count: 0,
+      created_at: now
+    };
+    this.store.save(job);
+    return job;
+  }
+  /** Pause/resume a job. */
+  setPaused(id, paused) {
+    const jobs = this.store.list();
+    const job = jobs.find((j) => j.id === id);
+    if (!job) return false;
+    job.enabled = !paused;
+    this.store.save(job);
+    return true;
+  }
+  /** Delete a job. */
+  remove(id) {
+    const jobs = this.store.list();
+    const exists = jobs.some((j) => j.id === id);
+    if (!exists) return false;
+    this.store.delete(id);
+    return true;
+  }
+  /** List all jobs. */
+  list() {
+    return this.store.list();
+  }
+  // ─── Tick ─────────────────────────────────────────────────────────────────
+  async tick() {
+    const now = Date.now();
+    const due = this.store.getDue(now);
+    for (const job of due) {
+      if (job.last_run_at && now - job.last_run_at < 5e4) continue;
+      await this.fire(job);
+    }
+  }
+  async fire(job) {
+    job.last_run_at = Date.now();
+    job.run_count++;
+    if (job.schedule.type === "once") {
+      job.enabled = false;
+    } else {
+      job.next_run_at = nextRunAt(job.schedule, Date.now() + 6e4);
+    }
+    this.store.save(job);
+    this.eventBus.emit({
+      type: "schedule.fired",
+      job_id: job.id,
+      job_name: job.name,
+      task: job.task,
+      run_count: job.run_count
+    });
+    try {
+      const session = this.sessions.createSession({ task: job.task, skill: job.skill });
+      this.sessions.runExistingSession(session.id, { task: job.task, skill: job.skill }).then(() => {
+        this.eventBus.emit({ type: "schedule.completed", job_id: job.id, session_id: session.id });
+      }).catch((err) => {
+        this.eventBus.emit({ type: "schedule.error", job_id: job.id, error: String(err) });
+      });
+    } catch (err) {
+      this.eventBus.emit({ type: "schedule.error", job_id: job.id, error: String(err) });
+    }
+  }
+};
+
+// packages/daemon/src/routes/schedule.ts
+function scheduleRoutes(deps) {
+  const app = new Hono12();
+  const getScheduler = (c) => {
+    if (!deps.scheduler) {
+      return { error: c.json({ error: "Scheduler not available" }, 503) };
+    }
+    return { scheduler: deps.scheduler };
+  };
+  app.get("/", (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const jobs = scheduler.list().map((j) => ({
+      ...j,
+      schedule_human: j.schedule_human || scheduleToHuman(j.schedule),
+      next_run_human: new Date(j.next_run_at).toLocaleString()
+    }));
+    return c.json(jobs);
+  });
+  app.post("/", async (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const body = await c.req.json();
+    if (!body.task || !body.schedule) {
+      return c.json({ error: "task and schedule are required" }, 400);
+    }
+    try {
+      const job = scheduler.add({
+        task: body.task,
+        schedule: body.schedule,
+        name: body.name,
+        skill: body.skill
+      });
+      return c.json({
+        ...job,
+        next_run_human: new Date(job.next_run_at).toLocaleString()
+      }, 201);
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+  app.delete("/:id", (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const ok = scheduler.remove(c.req.param("id"));
+    return ok ? c.json({ ok: true }) : c.json({ error: "Job not found" }, 404);
+  });
+  app.post("/:id/pause", (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const ok = scheduler.setPaused(c.req.param("id"), true);
+    return ok ? c.json({ ok: true }) : c.json({ error: "Job not found" }, 404);
+  });
+  app.post("/:id/resume", (c) => {
+    const { scheduler, error } = getScheduler(c);
+    if (error) return error;
+    const ok = scheduler.setPaused(c.req.param("id"), false);
+    return ok ? c.json({ ok: true }) : c.json({ error: "Job not found" }, 404);
+  });
+  return app;
+}
+
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
@@ -5014,7 +5554,7 @@ var HTTPServer = class {
   deps;
   constructor(deps) {
     this.deps = deps;
-    this.app = new Hono11();
+    this.app = new Hono13();
     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 }));
@@ -5025,6 +5565,11 @@ var HTTPServer = class {
     this.app.route("/api/insights", insightsRoutes({ proactiveSurface: deps.proactiveSurface ?? null }));
     this.app.route("/api/memory", memoryRoutes({ getSync: deps.getMemorySync ?? (() => null) }));
     this.app.route("/api/llm", llmRoutes());
+    this.app.route("/api/schedule", scheduleRoutes({ scheduler: deps.scheduler ?? null }));
+    this.app.route("/api/codespace", codespaceRoutes({
+      getManager: deps.getCodespaceManager ?? (() => null),
+      setup: deps.setupCodespace ?? (async () => ({ started: false, error: "Not configured" }))
+    }));
     const serveGraph = (c) => {
       try {
         const html = readFileSync8(GRAPH_HTML_PATH, "utf8");
@@ -5428,6 +5973,7 @@ var GitHubMemorySync = class {
       }
       const readme = this.generateReadme(nodes.length, edges.length);
       pushes.push(putFile(token, owner, repo, "README.md", readme, commitMsg));
+      await this.ensureCodespaceFiles(token, owner, repo, commitMsg);
       await Promise.all(pushes);
       this.lastPushAt = now;
       this.pendingChanges = false;
@@ -5623,6 +6169,36 @@ var GitHubMemorySync = class {
     } catch {
     }
   }
+  /**
+   * Push the codespace browser server files to the memory repo.
+   * This makes the memory repo a valid Codespace template — one repo for everything.
+   * Only pushes if the files don't exist yet (idempotent).
+   */
+  async ensureCodespaceFiles(token, owner, repo, msg) {
+    const existing = await getFileSha(token, owner, repo, ".devcontainer/devcontainer.json");
+    if (existing) return;
+    const devcontainer = JSON.stringify({
+      name: "0agent Browser Sandbox",
+      image: "mcr.microsoft.com/devcontainers/javascript-node:22",
+      postCreateCommand: "cd /workspaces && npm install && npx playwright install chromium --with-deps && pip3 install scrapling --quiet 2>/dev/null || true",
+      postStartCommand: 'cd /workspaces && pkill -f "node server.js" 2>/dev/null; nohup node server.js > /tmp/browser-server.log 2>&1 &',
+      forwardPorts: [3e3],
+      portsAttributes: {
+        "3000": { label: "0agent Browser", onAutoForward: "silent", visibility: "private" }
+      }
+    }, null, 2);
+    const packageJson = JSON.stringify({
+      name: "0agent-browser-server",
+      version: "1.0.0",
+      dependencies: { playwright: "^1.42.0" }
+    }, null, 2);
+    await Promise.all([
+      putFile(token, owner, repo, ".devcontainer/devcontainer.json", devcontainer, msg),
+      putFile(token, owner, repo, "package.json", packageJson, msg),
+      // Note: server.js is too large to inline here — users pull it from the npm package at codespace start
+      putFile(token, owner, repo, ".gitignore", "node_modules/\n*.log\n", msg)
+    ]);
+  }
   generateReadme(nodeCount, edgeCount) {
     return `# 0agent Memory
 
@@ -5663,6 +6239,189 @@ git checkout <commit> graph/         # restore graph files
   }
 };
 
+// packages/daemon/src/CodespaceManager.ts
+import { execSync as execSync4, spawn as spawn3 } from "node:child_process";
+var BROWSER_PORT_REMOTE = 3e3;
+var BROWSER_PORT_LOCAL = 3001;
+var DISPLAY_NAME = "0agent-browser";
+var FORWARD_TIMEOUT_S = 60;
+var CodespaceManager = class {
+  forwardProcess = null;
+  _ready = false;
+  _localUrl = `http://localhost:${BROWSER_PORT_LOCAL}`;
+  memoryRepo;
+  // e.g. "cadetmaze/0agent-memory"
+  constructor(memoryRepo) {
+    this.memoryRepo = memoryRepo;
+  }
+  /** Is the tunnel open and browser server responding? */
+  isReady() {
+    return this._ready;
+  }
+  /** URL to call the browser server (via SSH tunnel). */
+  get localUrl() {
+    return this._localUrl;
+  }
+  // ─── Main entry point ──────────────────────────────────────────────────────
+  /**
+   * Ensure the codespace is running, browser server is started, and tunnel is open.
+   * Returns the local URL to call (http://localhost:3001).
+   * First call: 2-3 minutes (cold provision). Subsequent: 30s or instant.
+   */
+  async getReadyUrl() {
+    const name = await this.ensureRunning();
+    await this.startBrowserServer(name);
+    await this.openTunnel(name);
+    return this._localUrl;
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────────
+  /** Find existing 0agent-browser codespace, or create one from the memory repo. */
+  async getOrCreate() {
+    const existing = this.findExisting();
+    if (existing) return existing.name;
+    console.log(`[Codespace] Creating browser codespace from ${this.memoryRepo}...`);
+    console.log("[Codespace] First time: ~2-3 minutes. Subsequent starts: ~30 seconds.");
+    try {
+      const result = execSync4(
+        `gh codespace create --repo "${this.memoryRepo}" --machine basicLinux32gb --display-name "${DISPLAY_NAME}" --json name`,
+        { encoding: "utf8", timeout: 3e5 }
+      );
+      const parsed = JSON.parse(result.trim());
+      console.log(`[Codespace] Created: ${parsed.name}`);
+      return parsed.name;
+    } catch (err) {
+      throw new Error(`Failed to create codespace: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  /** Find the 0agent-browser codespace by display name. */
+  findExisting() {
+    try {
+      const out = execSync4("gh codespace list --json name,state,displayName,repository", {
+        encoding: "utf8",
+        timeout: 1e4
+      });
+      const list = JSON.parse(out.trim());
+      return list.find((c) => c.displayName === DISPLAY_NAME) ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /** Ensure the codespace is in Available state. */
+  async ensureRunning() {
+    const name = await this.getOrCreate();
+    const info = this.findExisting();
+    if (info?.state === "Shutdown") {
+      console.log("[Codespace] Starting stopped codespace (~30s)...");
+      execSync4(`gh codespace start --codespace "${name}"`, { timeout: 12e4 });
+      await this.waitForState(name, "Available", 60);
+      console.log("[Codespace] Codespace is running");
+    } else if (info?.state === "Starting") {
+      console.log("[Codespace] Codespace is starting...");
+      await this.waitForState(name, "Available", 120);
+    }
+    return name;
+  }
+  /** Start the browser server inside the codespace (idempotent). */
+  async startBrowserServer(name) {
+    try {
+      execSync4(
+        `gh codespace exec --codespace "${name}" -- bash -c "pgrep -f 'node server.js' > /dev/null 2>&1 || (cd /workspaces && nohup node server.js > /tmp/browser-server.log 2>&1 &)"`,
+        { timeout: 3e4 }
+      );
+    } catch {
+    }
+  }
+  /** Open an SSH tunnel via gh CLI: codespace:3000 → localhost:3001. */
+  async openTunnel(name) {
+    this.closeTunnel();
+    console.log(`[Codespace] Opening tunnel port ${BROWSER_PORT_REMOTE} \u2192 localhost:${BROWSER_PORT_LOCAL}...`);
+    this.forwardProcess = spawn3(
+      "gh",
+      ["codespace", "ports", "forward", `${BROWSER_PORT_REMOTE}:${BROWSER_PORT_LOCAL}`, "--codespace", name],
+      { stdio: ["ignore", "ignore", "ignore"] }
+    );
+    this.forwardProcess.unref();
+    this.forwardProcess.on("close", (code) => {
+      if (this._ready) {
+        console.log("[Codespace] Tunnel closed \u2014 reconnecting...");
+        this._ready = false;
+        this.openTunnel(name).catch(() => {
+        });
+      }
+    });
+    const deadline = Date.now() + FORWARD_TIMEOUT_S * 1e3;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      try {
+        const res = await fetch(`${this._localUrl}/health`, { signal: AbortSignal.timeout(2e3) });
+        if (res.ok) {
+          this._ready = true;
+          console.log("[Codespace] Browser server ready at " + this._localUrl);
+          return;
+        }
+      } catch {
+      }
+    }
+    throw new Error(`Browser server did not respond within ${FORWARD_TIMEOUT_S}s`);
+  }
+  closeTunnel() {
+    if (this.forwardProcess) {
+      try {
+        this.forwardProcess.kill("SIGTERM");
+      } catch {
+      }
+      this.forwardProcess = null;
+    }
+    this._ready = false;
+  }
+  /** Stop the codespace to save free-tier hours. State is preserved. */
+  async stop() {
+    this.closeTunnel();
+    const info = this.findExisting();
+    if (info?.state === "Available") {
+      execSync4(`gh codespace stop --codespace "${info.name}"`, { timeout: 3e4 });
+      console.log("[Codespace] Stopped (state preserved, restarts in 30s when needed)");
+    }
+  }
+  /** Delete the codespace entirely. */
+  async delete() {
+    this.closeTunnel();
+    const info = this.findExisting();
+    if (info) {
+      execSync4(`gh codespace delete --codespace "${info.name}" --force`, { timeout: 3e4 });
+      console.log("[Codespace] Deleted");
+    }
+  }
+  // ─── Health checking ───────────────────────────────────────────────────────
+  /** Ping the browser server. Returns null if not reachable. */
+  async ping() {
+    try {
+      const res = await fetch(`${this._localUrl}/health`, { signal: AbortSignal.timeout(3e3) });
+      return res.ok ? await res.json() : null;
+    } catch {
+      return null;
+    }
+  }
+  // ─── Helpers ───────────────────────────────────────────────────────────────
+  async waitForState(name, target, maxSeconds) {
+    for (let i = 0; i < maxSeconds / 2; i++) {
+      await new Promise((r) => setTimeout(r, 2e3));
+      const info = this.findExisting();
+      if (info?.state === target) return;
+    }
+    throw new Error(`Codespace did not reach ${target} state within ${maxSeconds}s`);
+  }
+  /** Check if gh CLI is installed and authenticated. */
+  static isAvailable() {
+    try {
+      execSync4("gh auth status", { stdio: "ignore", timeout: 5e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
 // packages/daemon/src/ZeroAgentDaemon.ts
 var ZeroAgentDaemon = class {
   config = null;
@@ -5678,6 +6437,8 @@ var ZeroAgentDaemon = class {
   githubMemorySync = null;
   memorySyncTimer = null;
   proactiveSurfaceInstance = null;
+  codespaceManager = null;
+  schedulerManager = null;
   startedAt = 0;
   pidFilePath;
   constructor() {
@@ -5718,6 +6479,13 @@ var ZeroAgentDaemon = class {
         this.graph
       );
       console.log(`[0agent] Memory sync: github.com/${ghMemCfg.owner}/${ghMemCfg.repo}`);
+      if (CodespaceManager.isAvailable()) {
+        const memRepo = `${ghMemCfg.owner}/${ghMemCfg.repo}`;
+        this.codespaceManager = new CodespaceManager(memRepo);
+        this.codespaceManager.getReadyUrl().catch(() => {
+        });
+        console.log(`[0agent] Browser backend: github.com codespace (from ${memRepo})`);
+      }
       this.githubMemorySync.pull().then((r) => {
         if (r.pulled) console.log(`[0agent] Memory pulled: +${r.nodes_synced} nodes, +${r.edges_synced} edges`);
       }).catch(() => {
@@ -5770,6 +6538,8 @@ var ZeroAgentDaemon = class {
       proactiveSurface = new ProactiveSurface2(this.graph, this.eventBus, cwd);
     } catch {
     }
+    this.schedulerManager = new SchedulerManager(this.adapter, this.sessionManager, this.eventBus);
+    this.schedulerManager.start();
     this.backgroundWorkers = new BackgroundWorkers({
       graph: this.graph,
       traceStore: this.traceStore,
@@ -5792,7 +6562,18 @@ var ZeroAgentDaemon = class {
       skillRegistry: this.skillRegistry,
       getStatus: () => this.getStatus(),
       getMemorySync: () => memSyncRef,
-      proactiveSurface
+      proactiveSurface,
+      getCodespaceManager: () => this.codespaceManager,
+      scheduler: this.schedulerManager,
+      setupCodespace: async () => {
+        if (!this.codespaceManager) return { started: false, error: "GitHub memory not configured. Run: 0agent memory connect github" };
+        try {
+          this.codespaceManager.getReadyUrl().catch(console.error);
+          return { started: true };
+        } catch (err) {
+          return { started: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
     });
     await this.httpServer.start();
     writeFileSync7(this.pidFilePath, String(process.pid), "utf8");
@@ -5829,6 +6610,10 @@ var ZeroAgentDaemon = class {
       this.memorySyncTimer = null;
     }
     this.githubMemorySync = null;
+    this.schedulerManager?.stop();
+    this.schedulerManager = null;
+    this.codespaceManager?.closeTunnel();
+    this.codespaceManager = null;
     this.sessionManager = null;
     this.skillRegistry = null;
     this.inferenceEngine = null;

package/package.json

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