@inetafrica/open-claudia 2.15.0 → 3.0.0

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);