@inetafrica/open-claudia 2.14.8 → 3.0.0

package/bin/cli.js

@@ -11,22 +11,17 @@ const botDir = path.join(__dirname, "..");
 const configDir = require(path.join(botDir, "config-dir"));
 const health = require(path.join(botDir, "health"));
 
-function getBotFile() {
-  const modeFile = path.join(configDir, ".bot-mode");
-  try {
-    const mode = fs.readFileSync(modeFile, "utf-8").trim();
-    if (mode === "agent") return "bot-agent.js";
-  } catch (e) {}
-  return "bot.js";
+function getBotMode() {
+  return require(path.join(botDir, "core", "side-chat")).readRuntimeMode(configDir);
 }
 
-function startBot(botFile, args) {
+function startBot(args) {
   // Start web UI alongside bot if WEB_UI=true or --web flag
   if (process.env.WEB_UI === "true" || args.includes("--web")) {
     const { startWebServer } = require(path.join(botDir, "web.js"));
     startWebServer();
   }
-  require(path.join(botDir, botFile));
+  require(path.join(botDir, "bot.js"));
 }
 
 function sendViaLoopback(kind, restArgs) {
@@ -52,7 +47,7 @@ function sendViaLoopback(kind, restArgs) {
     if (info) { sendUrl = info.url; sendToken = info.token; }
   }
   if (!sendUrl || !sendToken || !channelId || !adapterId) {
-    console.error("No active chat context. This command only works from inside a running Claude task spawned by the bot.");
+    console.error("No active chat context. This command only works from inside an Open Claudia agent task spawned by the bot.");
     process.exit(2);
   }
 
@@ -132,13 +127,17 @@ function findBotProcesses() {
 
 switch (command) {
   case "setup":
-    require(path.join(botDir, "setup.js"));
+    require(path.join(botDir, "setup.js")).main().catch((error) => {
+      console.error(error.stack || error.message);
+      process.exitCode = 1;
+    });
     break;
 
-  // PreToolUse hook target (tool-first deny-gate, 5b). Claude pipes the tool
-  // payload on stdin; exit 2 + stderr = deny (message fed back to the model),
-  // exit 0 = allow. Every failure mode fails OPEN — a broken gate must never
-  // brick the agent's shell.
+  // Provider-neutral PreToolUse target. Claude and Codex both pipe the Bash
+  // payload on stdin; exit 2 + stderr denies the command and exit 0 allows it.
+  // Transport initialization is mandatory in the provider adapters. Payload
+  // compatibility remains fail-open so an unknown future event shape cannot
+  // brick every shell command.
   case "deny-gate-hook": {
     let code = 0;
     try {
@@ -172,7 +171,7 @@ switch (command) {
 
   case "start": {
     const skipHealthCheck = args.includes("--skip-health") || args.includes("--force");
-    const botFile = getBotFile();
+    const botMode = getBotMode();
 
     // Run health checks before starting (unless skipped)
     if (!skipHealthCheck) {
@@ -187,15 +186,15 @@ switch (command) {
           console.log("Warnings:");
           for (const w of results.warnings) console.log(`  - ${w}`);
         }
-        console.log(`Starting Open Claudia (${botFile === "bot-agent.js" ? "agent" : "direct"} mode)...`);
-        startBot(botFile, args);
+        console.log(`Starting Open Claudia (${botMode} mode, modular runtime)...`);
+        startBot(args);
       }).catch((err) => {
         console.error("Health check failed:", err.message);
         process.exit(1);
       });
     } else {
-      console.log(`Starting Open Claudia (${botFile === "bot-agent.js" ? "agent" : "direct"} mode)...`);
-      startBot(botFile, args);
+      console.log(`Starting Open Claudia (${botMode} mode, modular runtime)...`);
+      startBot(args);
     }
     break;
   }
@@ -215,9 +214,9 @@ switch (command) {
     const { startWebServer: startWeb, isConfigured } = require(path.join(botDir, "web.js"));
     startWeb();
     if (isConfigured()) {
-      const botFile = getBotFile();
-      console.log(`Bot config found. Starting bot (${botFile === "bot-agent.js" ? "agent" : "direct"} mode)...`);
-      require(path.join(botDir, botFile));
+      const botMode = getBotMode();
+      console.log(`Bot config found. Starting bot (${botMode} mode, modular runtime)...`);
+      require(path.join(botDir, "bot.js"));
     } else {
       console.log("No config found. Complete setup in the web UI.");
     }
@@ -232,7 +231,10 @@ switch (command) {
     }
     // Legacy: open-claudia auth (no subcommand) → setup.js auth mode
     process.argv = [process.argv[0], process.argv[1], "--auth"];
-    require(path.join(botDir, "setup.js"));
+    require(path.join(botDir, "setup.js")).main().catch((error) => {
+      console.error(error.stack || error.message);
+      process.exitCode = 1;
+    });
     break;
   }
 
@@ -419,12 +421,12 @@ Memory tools:
   open-claudia dream [--dry-run]             Run the memory consolidation pass now
 
 Background work (only inside an active bot-spawned task):
-  open-claudia schedule-wakeup <when> "<prompt>"   One-shot future wake-up; resumes session
-  open-claudia cron-add "<sched>" "<prompt>"       Recurring cron job
+  open-claudia schedule-wakeup <when> "<prompt>"   One-shot; resumes the captured selected provider session
+  open-claudia cron-add "<sched>" "<prompt>"       Recurring job pinned to the selected provider session
   open-claudia cron-list                           List all wakeups + crons on this channel
   open-claudia cron-remove <id>                    Remove a scheduled job
   open-claudia task add|list|start|done|remove     Per-channel todo (survives restarts)
-  open-claudia agent "<prompt>" [--role X]         Spawn a throwaway sub-agent for research
+  open-claudia agent "<prompt>" [--role X] [--provider active|claude|codex]  Spawn a provider-isolated sub-agent
 
 Cluster control (self-management of this bot's own deployment via the broker):
   open-claudia cluster status|logs|restart|start|stop|scale <0|1>|sync
@@ -438,7 +440,7 @@ Multi-user / cross-channel:
 
 Start options:
   --web           Also start the web UI
-  --quick         Skip slow health checks (Claude auth, Telegram API)
+  --quick         Skip slow provider auth and channel API checks
   --skip-health   Bypass all health checks (not recommended)
 
 Health options:

package/bin/dream.js

@@ -10,8 +10,8 @@ Run the dream memory-consolidation pass now.
 
   open-claudia dream [--dry-run]
 
-Reviews all context packs and entities with a stronger model (DREAM_MODEL,
-default sonnet): merges duplicate packs, builds umbrella/parent trees,
+Reviews all context packs and entities with the configured high-tier utility
+provider: merges duplicate packs, builds umbrella/parent trees,
 tightens descriptions and tags, dedupes entities, cross-links notes, and
 may gently evolve the persona. Merged-away packs/entities are backed up
 under ~/.open-claudia/backup/dream-<stamp>/ first.
@@ -24,17 +24,11 @@ async function run(args) {
   const dream = require(path.join(__dirname, "..", "core", "dream"));
 
   if (args.includes("--dry-run")) {
-    const { spawnSubagent } = require(path.join(__dirname, "..", "core", "subagent"));
     console.error("Dreaming (dry run)… this can take a minute or two.");
     try {
-      const { text } = await spawnSubagent(dream.buildDreamPrompt(), {
-        model: dream.DREAM_MODEL,
-        timeoutMs: 8 * 60 * 1000,
-        systemPrompt: "You are a background memory consolidation process. Reply with ONLY the requested JSON object. No prose, no markdown, no tool use.",
-      });
-      const decision = dream.parseDream(text);
-      if (!decision) { console.error("Unparseable model output:"); console.log(text); process.exit(1); }
-      console.log(JSON.stringify(decision, null, 2));
+      const preview = await dream.previewDream();
+      console.error(`Dream provider: ${preview.provider || "unknown"}/${preview.model || "default"}`);
+      console.log(JSON.stringify(preview.decision, null, 2));
       process.exit(0);
     } catch (e) { console.error(`dream failed: ${e.message}`); process.exit(1); }
   }

package/bin/loopback-client.js

@@ -31,6 +31,11 @@ function context() {
     const info = readLoopbackInfo();
     if (info) { sendUrl = info.url; sendToken = info.token; }
   }
+  let providerSettings = {};
+  try {
+    const parsed = JSON.parse(process.env.OC_PROVIDER_SETTINGS || "{}");
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) providerSettings = parsed;
+  } catch (_) {}
   return {
     sendUrl,
     sendToken,
@@ -38,8 +43,16 @@ function context() {
     adapterId: process.env.OC_CHANNEL_ADAPTER,
     userId: process.env.OC_CHANNEL_USER_ID || null,
     canonicalUserId: process.env.OC_CANONICAL_USER_ID || null,
-    sessionId: process.env.OC_LAST_SESSION_ID || null,
-    sessionKey: process.env.OC_LAST_SESSION_KEY || null,
+    provider: process.env.OC_PROVIDER || null,
+    providerSettings,
+    project: process.env.OC_PROJECT || null,
+    projectDir: process.env.OC_PROJECT_DIR || null,
+    runId: process.env.OC_RUN_ID || null,
+    sessionId: process.env.OC_SESSION_ID || process.env.OC_LAST_SESSION_ID || null,
+    previousSessionId: process.env.OC_PREVIOUS_SESSION_ID || null,
+    occurrenceId: process.env.OC_OCCURRENCE_ID || null,
+    scheduledJobId: process.env.OC_SCHEDULED_JOB_ID || null,
+    originRunId: process.env.OC_ORIGIN_RUN_ID || null,
   };
 }
 
@@ -55,14 +68,25 @@ function requireContext() {
 function postJson(kind, body) {
   const ctx = requireContext();
   const u = new URL(ctx.sendUrl);
+  const requestedProject = body && body.project ? String(body.project) : ctx.project;
+  const sameProject = !ctx.project || !requestedProject || requestedProject === ctx.project;
   const payload = JSON.stringify({
+    ...body,
     channelId: ctx.channelId,
     adapter: ctx.adapterId,
     userId: ctx.userId,
     canonicalUserId: ctx.canonicalUserId,
-    sessionId: ctx.sessionId,
-    sessionKey: ctx.sessionKey,
-    ...body,
+    provider: ctx.provider,
+    providerSettings: ctx.providerSettings,
+    project: requestedProject,
+    projectDir: sameProject ? ctx.projectDir : null,
+    originProject: ctx.project,
+    originProjectDir: ctx.projectDir,
+    originRunId: ctx.runId,
+    sessionId: sameProject ? ctx.sessionId : null,
+    previousSessionId: sameProject ? ctx.previousSessionId : null,
+    parentOccurrenceId: ctx.occurrenceId,
+    parentScheduledJobId: ctx.scheduledJobId,
   });
   return new Promise((resolve, reject) => {
     const req = http.request({

package/bin/schedule.js

@@ -15,8 +15,9 @@ Crons (recurring):
   open-claudia cron-list                         # all wakeups + crons for this channel
   open-claudia cron-remove <id>                  # remove by id from cron-list
 
-Each fire wakes the agent up in the same channel and resumes the Claude session
-that was active when the schedule was created (so context carries over).
+Each fire wakes the agent in the same channel and resumes the selected provider
+session captured when the schedule was created. Provider/project switches made
+later do not retarget already-scheduled work.
 `;
 
 const DUR = /^(\d+)\s*(s|sec|secs|m|min|mins|h|hr|hrs|d|day|days)$/i;
@@ -68,7 +69,9 @@ async function runScheduleWakeup(args) {
   const prompt = rest.slice(1).join(" ");
   if (!prompt) { console.error("Missing prompt."); process.exit(2); }
   try {
-    const res = await postJson("schedule-wakeup", { fireAt: when, prompt, label: label || prompt.slice(0, 60), project });
+    const request = { fireAt: when, prompt, label: label || prompt.slice(0, 60) };
+    if (project) request.project = project;
+    const res = await postJson("schedule-wakeup", request);
     console.log(`Scheduled wakeup ${res.job.id} for ${new Date(when).toISOString()}.`);
     process.exit(0);
   } catch (e) { console.error(e.message); process.exit(1); }
@@ -83,7 +86,9 @@ async function runCronAdd(args) {
   const prompt = rest.slice(1).join(" ");
   if (!schedule || !prompt) { console.error("Usage: cron-add \"<schedule>\" \"<prompt>\""); process.exit(2); }
   try {
-    const res = await postJson("cron-add", { schedule, prompt, label: label || prompt.slice(0, 60), project });
+    const request = { schedule, prompt, label: label || prompt.slice(0, 60) };
+    if (project) request.project = project;
+    const res = await postJson("cron-add", request);
     console.log(`Added cron ${res.job.id} (${schedule}).`);
     process.exit(0);
   } catch (e) { console.error(e.message); process.exit(1); }
@@ -93,8 +98,17 @@ async function runCronList() {
   try {
     const res = await postJson("job-list", {});
     const list = res.jobs || [];
-    if (list.length === 0) { console.log("No jobs."); process.exit(0); }
+    const archived = res.archived || [];
+    if (list.length === 0 && archived.length === 0) { console.log("No jobs."); process.exit(0); }
     for (const j of list) console.log(fmtJob(j));
+    if (archived.length) {
+      if (list.length) console.log("");
+      console.log("Archived (disabled by provider migration — will not fire):");
+      for (const j of archived) {
+        const label = j.label || (j.prompt ? String(j.prompt).slice(0, 50) : "(no label)");
+        console.log(`${j.id}  ${j.kind || "job"}  ${label}  — ${j.archiveReason || "archived"}`);
+      }
+    }
     process.exit(0);
   } catch (e) { console.error(e.message); process.exit(1); }
 }

package/bin/tool.js

@@ -371,7 +371,8 @@ async function run(args) {
       // calling this tool) gate on the tier the OUTERMOST invocation approved
       // instead — argv flags can't fabricate approval.
       const gate = tools.runGate(t, toolArgs, process.env);
-      const commandLine = ["open-claudia tool run", t.name, ...toolArgs].join(" ");
+      const approvals = require("../core/approvals");
+      const commandLine = approvals.formatApprovedCommand(["open-claudia", "tool", "run", t.name, ...toolArgs]);
       let approvedVia = "";
 
       // ── Phase 3.5: per-speaker external gate ──────────────────────────────
@@ -403,6 +404,20 @@ async function run(args) {
           } else {
             const esc = await enforcer.escalate({
               speaker, kind: "action", command: commandLine, tier: gate.tier, reason: vet.reason,
+              canonicalUserId: process.env.OC_CANONICAL_USER_ID || "",
+              userId: process.env.OC_CHANNEL_USER_ID || "",
+              provider: process.env.OC_PROVIDER || "",
+              providerSettings: (() => {
+                try {
+                  const value = JSON.parse(process.env.OC_PROVIDER_SETTINGS || "{}");
+                  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+                } catch (_) { return {}; }
+              })(),
+              project: process.env.OC_PROJECT || "",
+              projectDir: process.env.OC_PROJECT_DIR || "",
+              sessionId: process.env.OC_SESSION_ID || process.env.OC_LAST_SESSION_ID || "",
+              previousSessionId: process.env.OC_PREVIOUS_SESSION_ID || "",
+              originRunId: process.env.OC_RUN_ID || process.env.OC_ORIGIN_RUN_ID || "",
             });
             if (esc.escalated) {
               console.error(`🛡️ Held for owner approval — ${speaker.name || "the external contact"} is outside mandate for this ${gate.tier} action.`);
@@ -416,7 +431,6 @@ async function run(args) {
       }
 
       if (approvalId) {
-        const approvals = require("../core/approvals");
         if (String(process.env.OPEN_CLAUDIA_TOOL_STACK || "").trim()) {
           console.error("⛔ --approval tokens are only honored on top-level runs, not nested tool calls.");
           process.exitCode = 3; return;
@@ -436,7 +450,7 @@ async function run(args) {
         // wakeup carrying a one-shot --approval token. Anything but an explicit
         // approve = the command never runs.
         const canAsk = gate.tier === "destructive" && !gate.nested && !gate.undeclared
-          && process.env.OC_SEND_URL && process.env.OC_SEND_TOKEN && process.env.OC_CHANNEL_ID && process.env.OC_CHANNEL_ADAPTER;
+          && process.env.OC_SEND_URL && process.env.OC_CHANNEL_ID && process.env.OC_CHANNEL_ADAPTER;
         if (!canAsk) { console.error(gate.message); process.exitCode = 3; return; }
         console.error(`Destructive run without --yes-destructive — asking for chat approval of the exact command...`);
         let decision = "denied";
@@ -447,7 +461,6 @@ async function run(args) {
             tool: t.name, verb: tools.invokedVerb(toolArgs), tier: gate.tier, command: commandLine,
           });
           reqId = res.id;
-          const approvals = require("../core/approvals");
           decision = await approvals.waitForDecision(res.id);
           if (decision === "timeout") {
             approvals.detach(res.id);
@@ -464,8 +477,13 @@ async function run(args) {
             `Re-run with --yes-destructive only after the user explicitly approves.`);
           process.exitCode = 3; return;
         }
+        const redeemed = approvals.consume(reqId, commandLine);
+        if (!redeemed.ok) {
+          console.error(`⛔ Approval ${reqId || "(missing)"} rejected: ${redeemed.reason}. The run stays blocked.`);
+          process.exitCode = 3; return;
+        }
         approvedVia = "chat-approval";
-        console.error(`✅ Approved in chat — running.`);
+        console.error(`✅ Approval ${reqId} redeemed (single use) — running.`);
       }
 
       const missing = tools.missingRequires(t);