@inetafrica/open-claudia 2.0.1 → 2.0.3

package/bin/cli.js

@@ -29,6 +29,82 @@ function startBot(botFile, args) {
   require(path.join(botDir, botFile));
 }
 
+function sendViaLoopback(kind, restArgs) {
+  const http = require("http");
+  const filePath = restArgs[0];
+  if (!filePath) {
+    console.error(`Usage: open-claudia ${kind} <path>${kind === "send-voice" ? "" : " [caption]"}`);
+    process.exit(2);
+  }
+  const caption = restArgs.slice(1).join(" ");
+  if (!fs.existsSync(filePath)) {
+    console.error(`File not found: ${filePath}`);
+    process.exit(2);
+  }
+
+  const channelId = process.env.OC_CHANNEL_ID;
+  const adapterId = process.env.OC_CHANNEL_ADAPTER;
+  let sendUrl = process.env.OC_SEND_URL;
+  let sendToken = process.env.OC_SEND_TOKEN;
+
+  if (!sendUrl || !sendToken) {
+    const info = readLoopbackInfo();
+    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.");
+    process.exit(2);
+  }
+
+  const u = new URL(sendUrl);
+  const fileName = path.basename(filePath);
+  const stat = fs.statSync(filePath);
+  const params = new URLSearchParams({ channelId, adapter: adapterId, fileName });
+  if (caption) params.set("caption", caption);
+
+  const req = http.request({
+    method: "POST",
+    hostname: u.hostname,
+    port: u.port,
+    path: `/${kind}?${params.toString()}`,
+    headers: {
+      Authorization: `Bearer ${sendToken}`,
+      "Content-Type": "application/octet-stream",
+      "Content-Length": stat.size,
+    },
+  }, (res) => {
+    let body = "";
+    res.on("data", (c) => { body += c; });
+    res.on("end", () => {
+      if (res.statusCode >= 200 && res.statusCode < 300) {
+        console.log(`Sent ${fileName} (${stat.size} bytes).`);
+        process.exit(0);
+      } else {
+        console.error(`Loopback ${res.statusCode}: ${body}`);
+        process.exit(1);
+      }
+    });
+  });
+  req.on("error", (e) => { console.error("Loopback request failed:", e.message); process.exit(1); });
+  fs.createReadStream(filePath).pipe(req);
+}
+
+function readLoopbackInfo() {
+  try {
+    const dir = path.join(configDir, "loopback");
+    if (!fs.existsSync(dir)) return null;
+    const entries = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    let newest = null;
+    for (const f of entries) {
+      const full = path.join(dir, f);
+      const stat = fs.statSync(full);
+      if (!newest || stat.mtimeMs > newest.mtimeMs) newest = { full, mtimeMs: stat.mtimeMs };
+    }
+    if (!newest) return null;
+    return JSON.parse(fs.readFileSync(newest.full, "utf-8"));
+  } catch (e) { return null; }
+}
+
 function findBotProcesses() {
   try {
     if (process.platform === "win32") {
@@ -150,6 +226,19 @@ switch (command) {
     break;
   }
 
+  case "send-file":
+  case "send-photo":
+  case "send-voice": {
+    sendViaLoopback(command, args.slice(1));
+    break;
+  }
+
+  case "tw":
+  case "transcript-window": {
+    require("./transcript-window").run(args.slice(1));
+    break;
+  }
+
   default:
     console.log(`
 Open Claudia — AI Coding Assistant via Telegram
@@ -164,6 +253,15 @@ Commands:
   open-claudia health   Run environment health checks
   open-claudia logs     View recent logs
 
+Send tools (only work inside an active bot-spawned task):
+  open-claudia send-file <path> [caption]
+  open-claudia send-photo <path> [caption]
+  open-claudia send-voice <path>
+
+Memory tools:
+  open-claudia transcript-window <pattern>   Search project transcript, show hits with context
+                                             (alias: tw; --help for options)
+
 Start options:
   --web           Also start the web UI
   --quick         Skip slow health checks (Claude auth, Telegram API)

package/bin/transcript-window.js

@@ -0,0 +1,202 @@
+// Search the project transcript JSONL for a pattern and print each hit
+// with surrounding turns of context, capped to keep the output bounded.
+//
+// One JSONL line = one user or assistant turn. Output is plain text:
+// match header, separator-delimited context blocks (before, HIT, after).
+//
+// Path resolution:
+//   1. --path <file> flag
+//   2. OC_TRANSCRIPT_PATH env (injected by core/runner.js for bot-spawned tasks)
+//   3. error out — we don't try to guess
+
+const fs = require("fs");
+
+const DEFAULTS = {
+  before: 2,
+  after: 2,
+  maxTurns: 10,
+  maxChars: 1200,
+};
+
+function parseArgs(argv) {
+  const out = {
+    pattern: null,
+    before: DEFAULTS.before,
+    after: DEFAULTS.after,
+    maxTurns: DEFAULTS.maxTurns,
+    maxChars: DEFAULTS.maxChars,
+    regex: false,
+    path: null,
+    json: false,
+    help: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") { out.help = true; continue; }
+    if (a === "--regex") { out.regex = true; continue; }
+    if (a === "--json") { out.json = true; continue; }
+    if (a === "--before") { out.before = parseInt(argv[++i], 10); continue; }
+    if (a === "--after") { out.after = parseInt(argv[++i], 10); continue; }
+    if (a === "--max-turns") { out.maxTurns = parseInt(argv[++i], 10); continue; }
+    if (a === "--max-chars") { out.maxChars = parseInt(argv[++i], 10); continue; }
+    if (a === "--path") { out.path = argv[++i]; continue; }
+    if (a.startsWith("--")) {
+      console.error(`Unknown flag: ${a}`);
+      process.exit(2);
+    }
+    if (out.pattern === null) { out.pattern = a; continue; }
+    console.error(`Unexpected argument: ${a}`);
+    process.exit(2);
+  }
+  if (!Number.isFinite(out.before) || out.before < 0) out.before = DEFAULTS.before;
+  if (!Number.isFinite(out.after) || out.after < 0) out.after = DEFAULTS.after;
+  if (!Number.isFinite(out.maxTurns) || out.maxTurns < 1) out.maxTurns = DEFAULTS.maxTurns;
+  if (!Number.isFinite(out.maxChars) || out.maxChars < 100) out.maxChars = DEFAULTS.maxChars;
+  return out;
+}
+
+function printHelp() {
+  console.log(`Usage: open-claudia transcript-window <pattern> [options]
+
+Search the active project transcript and print each hit with surrounding turns.
+
+Options:
+  --before N        Turns of context before each hit (default ${DEFAULTS.before})
+  --after N         Turns of context after each hit (default ${DEFAULTS.after})
+  --max-turns K     Stop after K hits (default ${DEFAULTS.maxTurns})
+  --max-chars C     Cap per-turn text length (default ${DEFAULTS.maxChars})
+  --regex           Treat pattern as a regex (default: literal, case-insensitive)
+  --path <file>     Transcript path (default: OC_TRANSCRIPT_PATH env)
+  --json            Emit JSONL of matched windows instead of pretty text
+
+Exit codes: 0 hits found, 1 no hits, 2 usage error, 3 transcript unreadable.`);
+}
+
+function resolveTranscriptPath(flagPath) {
+  if (flagPath) return flagPath;
+  if (process.env.OC_TRANSCRIPT_PATH) return process.env.OC_TRANSCRIPT_PATH;
+  return null;
+}
+
+function loadTurns(transcriptPath) {
+  const raw = fs.readFileSync(transcriptPath, "utf-8");
+  const turns = [];
+  let lineNo = 0;
+  for (const line of raw.split("\n")) {
+    lineNo++;
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      turns.push({
+        lineNo,
+        timestamp: obj.timestamp || "",
+        role: obj.role || "",
+        text: typeof obj.text === "string" ? obj.text : "",
+        sessionId: obj.sessionId || "",
+      });
+    } catch (e) {
+      // skip malformed line
+    }
+  }
+  return turns;
+}
+
+function buildMatcher(pattern, regex) {
+  if (regex) {
+    try { return new RegExp(pattern); }
+    catch (e) {
+      console.error(`Invalid regex: ${e.message}`);
+      process.exit(2);
+    }
+  }
+  const lc = pattern.toLowerCase();
+  return { test: (s) => s.toLowerCase().includes(lc) };
+}
+
+function truncate(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + `\n[...truncated, ${text.length - maxChars} more chars]`;
+}
+
+function formatTurn(turn, label, maxChars) {
+  return [
+    `--- ${label}  line ${turn.lineNo}  ${turn.timestamp}  ${turn.role} ---`,
+    truncate(turn.text, maxChars),
+  ].join("\n");
+}
+
+function run(argv) {
+  const opts = parseArgs(argv);
+  if (opts.help || !opts.pattern) {
+    printHelp();
+    process.exit(opts.help ? 0 : 2);
+  }
+  const transcriptPath = resolveTranscriptPath(opts.path);
+  if (!transcriptPath) {
+    console.error("No transcript path. Pass --path <file>, or run inside an active bot-spawned task (OC_TRANSCRIPT_PATH).");
+    process.exit(2);
+  }
+  if (!fs.existsSync(transcriptPath)) {
+    console.error(`Transcript not found: ${transcriptPath}`);
+    process.exit(3);
+  }
+
+  let turns;
+  try { turns = loadTurns(transcriptPath); }
+  catch (e) {
+    console.error(`Failed to read transcript: ${e.message}`);
+    process.exit(3);
+  }
+
+  const matcher = buildMatcher(opts.pattern, opts.regex);
+  const hits = [];
+  for (let i = 0; i < turns.length; i++) {
+    if (matcher.test(turns[i].text)) {
+      hits.push(i);
+      if (hits.length >= opts.maxTurns) break;
+    }
+  }
+
+  if (hits.length === 0) {
+    console.error(`No matches for ${JSON.stringify(opts.pattern)} in ${transcriptPath}`);
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    for (let h = 0; h < hits.length; h++) {
+      const idx = hits[h];
+      const window = [];
+      for (let j = Math.max(0, idx - opts.before); j <= Math.min(turns.length - 1, idx + opts.after); j++) {
+        window.push({ ...turns[j], offset: j - idx });
+      }
+      process.stdout.write(JSON.stringify({ matchIndex: h + 1, matchLine: turns[idx].lineNo, window }) + "\n");
+    }
+    process.exit(0);
+  }
+
+  console.log(`Transcript: ${transcriptPath}`);
+  console.log(`Pattern: ${JSON.stringify(opts.pattern)}${opts.regex ? " (regex)" : ""}`);
+  console.log(`Hits: ${hits.length}  Window: -${opts.before}/+${opts.after} turns  Per-turn cap: ${opts.maxChars} chars`);
+  console.log("");
+
+  for (let h = 0; h < hits.length; h++) {
+    const idx = hits[h];
+    const start = Math.max(0, idx - opts.before);
+    const end = Math.min(turns.length - 1, idx + opts.after);
+    console.log(`===== match ${h + 1}/${hits.length}  line ${turns[idx].lineNo} =====`);
+    for (let j = start; j <= end; j++) {
+      const offset = j - idx;
+      const label = offset === 0 ? "HIT" : (offset < 0 ? `ctx ${offset}` : `ctx +${offset}`);
+      console.log(formatTurn(turns[j], label, opts.maxChars));
+    }
+    console.log("");
+  }
+
+  process.exit(0);
+}
+
+module.exports = { run, parseArgs, loadTurns };
+
+if (require.main === module) {
+  run(process.argv.slice(2));
+}

package/bot.js

@@ -17,6 +17,7 @@ const { initCrons } = require("./core/cron");
 const { onMessage, onAction } = require("./core/router");
 const { publicCommands } = require("./core/commands");
 const registry = require("./core/adapter-registry");
+const loopback = require("./core/loopback");
 require("./core/handlers"); // side-effect: register slash commands
 
 const CURRENT_VERSION = require(path.join(__dirname, "package.json")).version;
@@ -42,6 +43,7 @@ async function gracefulShutdown(signal) {
     }
   }
   for (const a of adapters) { try { await a.stop(); } catch (e) {} }
+  try { loopback.stop(); } catch (e) {}
   try {
     const mediaDir = path.join(CONFIG_DIR, "media");
     if (fs.existsSync(mediaDir)) {
@@ -159,6 +161,13 @@ setInterval(checkForUpdates, 5 * 60 * 1000);
 
   initCrons();
 
+  try {
+    const lb = await loopback.start(registry);
+    console.log(`Loopback send endpoint: ${lb.url}`);
+  } catch (e) {
+    console.error("Loopback start failed:", e.message);
+  }
+
   for (const adapter of adapters) {
     try {
       await adapter.start();

package/channels/kazee/adapter.js

@@ -121,13 +121,16 @@ class KazeeAdapter {
 
     const text = (msg.content || "").toString();
     const isCommand = text.trim().startsWith("/");
-    const type = isCommand ? "command" : (msg.type === "voice" || msg.type === "audio" || msg.type === "image" || msg.type === "file" ? msg.type : "text");
+    // chat-central's message.type enum has no "voice" — voice notes arrive
+    // as type "audio". Map the channel types we accept onto router types.
+    const KNOWN_TYPES = { voice: "voice", audio: "audio", image: "photo", video: "document", file: "document" };
+    const routerType = isCommand ? "command" : (KNOWN_TYPES[msg.type] || "text");
     const envelope = {
       adapter: this,
       channelId,
       canonicalUserId: canonicalForChannel("kazee", userId),
       userId,
-      type: type === "image" ? "photo" : type === "file" ? "document" : type,
+      type: routerType,
       text,
       messageId: msg._id || msg.id,
       replyToId: msg.replyTo,
@@ -136,14 +139,28 @@ class KazeeAdapter {
     };
 
     if (msg.attachments && msg.attachments.length) {
-      envelope.media = msg.attachments.map((a) => ({
-        type: a.type || (a.mimeType?.startsWith("image/") ? "photo" : "document"),
-        fileId: a.url || a._id,
-        fileName: a.name || a.filename,
-        mimeType: a.mimeType,
-        size: a.size,
-      }));
-      if (envelope.type === "text") envelope.type = envelope.media[0].type === "image" ? "photo" : envelope.media[0].type;
+      envelope.media = msg.attachments.map((a) => {
+        let kind = a.type;
+        if (!kind) {
+          const mime = (a.mimeType || "").toLowerCase();
+          if (mime.startsWith("image/")) kind = "photo";
+          else if (mime.startsWith("audio/")) kind = "audio";
+          else if (mime.startsWith("video/")) kind = "video";
+          else kind = "document";
+        } else if (kind === "image") kind = "photo";
+        else if (kind === "file") kind = "document";
+        return {
+          type: kind,
+          fileId: a.url || a._id,
+          fileName: a.name || a.filename,
+          mimeType: a.mimeType,
+          size: a.size,
+        };
+      });
+      if (envelope.type === "text") {
+        const k = envelope.media[0].type;
+        envelope.type = k === "video" ? "document" : k;
+      }
     }
 
     this._emit("message", envelope);
@@ -203,6 +220,11 @@ class KazeeAdapter {
     return ok;
   }
 
+  async sendPhoto(channelId, filePath, caption) {
+    // Kazee's sendFile picks the right message type by extension already.
+    return this.sendFile(channelId, filePath, caption);
+  }
+
   async sendFile(channelId, filePath, caption) {
     try {
       const buffer = fs.readFileSync(filePath);

package/channels/telegram/adapter.js

@@ -92,7 +92,34 @@ class TelegramAdapter {
     this.bot.on("audio", (msg) => this._emit("message", this._envelopeMedia(msg, "audio", msg.audio)));
     this.bot.on("photo", (msg) => {
       const photo = msg.photo[msg.photo.length - 1];
-      this._emit("message", this._envelopeMedia(msg, "photo", photo));
+      if (!msg.media_group_id) {
+        this._emit("message", this._envelopeMedia(msg, "photo", photo));
+        return;
+      }
+      // Telegram delivers an album as N separate `photo` updates sharing
+      // the same media_group_id. Buffer briefly so the handler gets one
+      // envelope with media[] of all photos instead of N separate turns.
+      if (!this._photoGroups) this._photoGroups = new Map();
+      let batch = this._photoGroups.get(msg.media_group_id);
+      if (!batch) {
+        batch = { firstMsg: msg, items: [], timer: null };
+        this._photoGroups.set(msg.media_group_id, batch);
+      }
+      if (msg.caption && !batch.firstMsg.caption) batch.firstMsg.caption = msg.caption;
+      batch.items.push({
+        type: "photo",
+        fileId: photo.file_id,
+        fileName: photo.file_name,
+        mimeType: photo.mime_type,
+        size: photo.file_size,
+      });
+      if (batch.timer) clearTimeout(batch.timer);
+      batch.timer = setTimeout(() => {
+        this._photoGroups.delete(msg.media_group_id);
+        const env = this._envelopeMedia(batch.firstMsg, "photo", photo);
+        env.media = batch.items;
+        this._emit("message", env);
+      }, 600);
     });
     this.bot.on("document", (msg) => this._emit("message", this._envelopeMedia(msg, "document", msg.document)));
 
@@ -251,6 +278,16 @@ class TelegramAdapter {
     }
   }
 
+  async sendPhoto(channelId, filePath, caption) {
+    try {
+      await this.bot.sendPhoto(channelId, filePath, caption ? { caption } : {});
+      return true;
+    } catch (e) {
+      console.error("Send photo error:", e.message);
+      return false;
+    }
+  }
+
   async typing(channelId) {
     try { await this.bot.sendChatAction(channelId, "typing"); } catch (e) {}
   }

package/core/config.js

@@ -47,7 +47,8 @@ const WORKSPACE = config.WORKSPACE;
 const CLAUDE_PATH = config.CLAUDE_PATH;
 const CURSOR_PATH = config.CURSOR_PATH || null;
 const CODEX_PATH = config.CODEX_PATH || null;
-const AUTO_COMPACT_TOKENS = parseInt(config.AUTO_COMPACT_TOKENS || process.env.AUTO_COMPACT_TOKENS || "280000", 10);
+const AUTO_COMPACT_TOKENS = parseInt(config.AUTO_COMPACT_TOKENS || process.env.AUTO_COMPACT_TOKENS || "380000", 10);
+const MIN_COMPACT_INTERVAL_MS = parseInt(config.MIN_COMPACT_INTERVAL_MS || process.env.MIN_COMPACT_INTERVAL_MS || "1800000", 10);
 const PROJECT_TRANSCRIPTS = configTruthy(config.PROJECT_TRANSCRIPTS || process.env.PROJECT_TRANSCRIPTS, true);
 const TRANSCRIPT_MAX_ENTRY_CHARS = parseInt(config.TRANSCRIPT_MAX_ENTRY_CHARS || process.env.TRANSCRIPT_MAX_ENTRY_CHARS || "12000", 10);
 const TRANSCRIPTS_DIR = config.TRANSCRIPTS_DIR || process.env.TRANSCRIPTS_DIR || path.join(CONFIG_DIR, "transcripts");
@@ -185,6 +186,7 @@ module.exports = {
   resolvedCursorPath,
   resolvedCodexPath,
   AUTO_COMPACT_TOKENS,
+  MIN_COMPACT_INTERVAL_MS,
   PROJECT_TRANSCRIPTS,
   TRANSCRIPT_MAX_ENTRY_CHARS,
   TRANSCRIPTS_DIR,

package/core/loopback.js

@@ -0,0 +1,123 @@
+// Bot ↔ subprocess send channel. Each running bot publishes a tiny HTTP
+// server on 127.0.0.1:<random-port> and writes {port, token} to a
+// per-PID file under CONFIG_DIR/loopback. Subprocesses spawned through
+// runClaude inherit OC_SEND_URL, OC_SEND_TOKEN, OC_CHANNEL_ID, and
+// OC_CHANNEL_ADAPTER in their env; the `open-claudia send-file /
+// send-voice / send-photo` CLI subcommands POST a file back through
+// this endpoint so the active channel's adapter can deliver it.
+//
+// Bound to 127.0.0.1 only and gated by a random token so other local
+// processes can't impersonate the bot.
+
+const fs = require("fs");
+const path = require("path");
+const http = require("http");
+const os = require("os");
+const crypto = require("crypto");
+const { CONFIG_DIR } = require("./config");
+
+const INFO_DIR = path.join(CONFIG_DIR, "loopback");
+const INFO_FILE = path.join(INFO_DIR, `${process.pid}.json`);
+
+let server = null;
+let token = null;
+let registry = null;
+
+function info() {
+  if (!server) return null;
+  const addr = server.address();
+  return { port: addr.port, token, pid: process.pid, url: `http://127.0.0.1:${addr.port}` };
+}
+
+function writeInfo() {
+  fs.mkdirSync(INFO_DIR, { recursive: true });
+  fs.writeFileSync(INFO_FILE, JSON.stringify(info(), null, 2), { mode: 0o600 });
+}
+
+function deleteInfo() {
+  try { fs.unlinkSync(INFO_FILE); } catch (e) {}
+}
+
+function reply(res, code, body) {
+  const data = JSON.stringify(body);
+  res.writeHead(code, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) });
+  res.end(data);
+}
+
+function authOk(req) {
+  return (req.headers["authorization"] || "") === `Bearer ${token}`;
+}
+
+function readBodyToFile(req, dest) {
+  return new Promise((resolve, reject) => {
+    const out = fs.createWriteStream(dest);
+    req.pipe(out);
+    out.on("finish", () => resolve());
+    out.on("error", reject);
+    req.on("error", reject);
+  });
+}
+
+const KINDS = new Set(["send-file", "send-voice", "send-photo"]);
+
+async function handle(req, res) {
+  try {
+    if (req.method !== "POST") return reply(res, 405, { error: "method not allowed" });
+    if (!authOk(req)) return reply(res, 401, { error: "unauthorized" });
+    const url = new URL(req.url, "http://127.0.0.1");
+    const kind = url.pathname.slice(1);
+    if (!KINDS.has(kind)) return reply(res, 404, { error: "not found" });
+    const channelId = url.searchParams.get("channelId");
+    const adapterId = url.searchParams.get("adapter");
+    const caption = url.searchParams.get("caption") || "";
+    const fileName = url.searchParams.get("fileName") || `file-${Date.now()}.bin`;
+    if (!channelId || !adapterId) return reply(res, 400, { error: "missing channelId/adapter" });
+    const adapter = registry.findAdapter(adapterId);
+    if (!adapter) return reply(res, 400, { error: `unknown adapter ${adapterId}` });
+
+    const safeName = path.basename(fileName).replace(/[^A-Za-z0-9._-]/g, "_") || `file-${Date.now()}`;
+    const tmp = path.join(os.tmpdir(), `oc-loopback-${process.pid}-${Date.now()}-${safeName}`);
+    await readBodyToFile(req, tmp);
+
+    let ok = false;
+    try {
+      if (kind === "send-voice") {
+        ok = await adapter.sendVoice(channelId, tmp); // adapter unlinks on success/failure
+      } else if (kind === "send-photo" && typeof adapter.sendPhoto === "function") {
+        ok = await adapter.sendPhoto(channelId, tmp, caption);
+      } else {
+        ok = await adapter.sendFile(channelId, tmp, caption);
+      }
+    } finally {
+      if (kind !== "send-voice") { try { fs.unlinkSync(tmp); } catch (e) {} }
+    }
+    return reply(res, ok ? 200 : 500, { ok });
+  } catch (e) {
+    console.error("loopback handle error:", e.message);
+    return reply(res, 500, { error: e.message });
+  }
+}
+
+function start(adapterRegistry) {
+  if (server) return Promise.resolve(info());
+  registry = adapterRegistry;
+  token = crypto.randomBytes(24).toString("hex");
+  server = http.createServer(handle);
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      writeInfo();
+      resolve(info());
+    });
+  });
+}
+
+function stop() {
+  if (server) try { server.close(); } catch (e) {}
+  server = null;
+  deleteInfo();
+}
+
+process.on("exit", deleteInfo);
+
+module.exports = { start, stop, info, INFO_DIR, INFO_FILE };

package/core/router.js

@@ -145,11 +145,15 @@ async function handlePhoto(envelope) {
   const state = currentState();
   if (!state.currentSession) return send("Pick a project first.");
   try {
-    const media = envelope.media?.[0];
-    if (!media) return;
-    const p = await envelope.adapter.downloadMedia(media);
+    const items = envelope.media || [];
+    if (!items.length) return;
+    const paths = [];
+    for (const m of items) paths.push(await envelope.adapter.downloadMedia(m));
     const caption = envelope.caption || "Describe this image. If code/UI/error — explain and fix.";
-    await runClaude(`Image at ${p}\n\nView it, then: ${caption}`, state.currentSession.dir, envelope.messageId);
+    const prompt = paths.length === 1
+      ? `Image at ${paths[0]}\n\nView it, then: ${caption}`
+      : `Images:\n${paths.map((p, i) => `${i + 1}. ${p}`).join("\n")}\n\nView all ${paths.length}, then: ${caption}`;
+    await runClaude(prompt, state.currentSession.dir, envelope.messageId);
   } catch (err) { await send(`Image failed: ${err.message}`); }
 }
 

package/core/runner.js

@@ -6,7 +6,7 @@
 const { spawn } = require("child_process");
 const {
   CLAUDE_PATH, resolvedCursorPath, resolvedCodexPath,
-  AUTO_COMPACT_TOKENS, MAX_PROCESS_TIMEOUT, botSubprocessEnv,
+  AUTO_COMPACT_TOKENS, MIN_COMPACT_INTERVAL_MS, MAX_PROCESS_TIMEOUT, botSubprocessEnv,
 } = require("./config");
 const { currentState, saveState, recordSession, userOwnsClaudeSession } = require("./state");
 const { chatContext, currentChannelId, currentAdapter } = require("./context");
@@ -20,6 +20,27 @@ const {
   promptWithTranscriptPointer, stripTranscriptPointerForStorage,
 } = require("./transcripts");
 const { getClaudeOAuthToken, claudeAuthRecoveryMessage, isClaudeAuthErrorText, claudeUsageLimitMessage, isClaudeUsageLimitText, runClaudeAuthStatusDiagnostic, claudeSubprocessEnv } = require("./auth-flow");
+const loopback = require("./loopback");
+
+function chatEnvOverlay() {
+  const adapter = currentAdapter();
+  const channelId = currentChannelId();
+  const lb = loopback.info();
+  const overlay = {};
+  if (adapter && adapter.id) overlay.OC_CHANNEL_ADAPTER = adapter.id;
+  if (channelId) overlay.OC_CHANNEL_ID = String(channelId);
+  if (lb) {
+    overlay.OC_SEND_URL = lb.url;
+    overlay.OC_SEND_TOKEN = lb.token;
+  }
+  const tinfo = transcriptProjectInfo();
+  if (tinfo && tinfo.transcriptPath) overlay.OC_TRANSCRIPT_PATH = tinfo.transcriptPath;
+  return overlay;
+}
+
+function subprocessEnv() {
+  return { ...claudeSubprocessEnv(), ...chatEnvOverlay() };
+}
 
 function parseStreamEvents(data) {
   const events = [];
@@ -52,8 +73,11 @@ function getActiveSessionKey(state = currentState()) {
 function shouldAutoCompact(state = currentState(), opts = {}) {
   if (opts.skipAutoCompact || opts.fresh || opts.continueSession || state.isCompacting) return false;
   if (!state[getActiveSessionKey(state)]) return false;
-  const threshold = Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 280000;
-  return (state.sessionUsage?.lastInputTokens || 0) >= threshold;
+  const threshold = Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 380000;
+  if ((state.sessionUsage?.lastInputTokens || 0) < threshold) return false;
+  const minInterval = Number.isFinite(MIN_COMPACT_INTERVAL_MS) ? MIN_COMPACT_INTERVAL_MS : 1800000;
+  if (state.lastCompactedAt && (Date.now() - state.lastCompactedAt) < minInterval) return false;
+  return true;
 }
 
 function buildClaudeArgs(prompt, opts = {}) {
@@ -126,7 +150,7 @@ function preflightClaudeAuthMessage() {
     const { execSync } = require("child_process");
     const output = execSync(`"${CLAUDE_PATH}" auth status`, {
       cwd: process.env.HOME || require("os").homedir(),
-      env: claudeSubprocessEnv(),
+      env: subprocessEnv(),
       encoding: "utf8",
       timeout: 10000,
       stdio: ["ignore", "pipe", "pipe"],
@@ -162,13 +186,20 @@ function claudeEmptyFailureMessage(code, stderrText = "") {
 function compactSummaryPrompt() {
   return [
     "Summarize this conversation for a fresh compacted continuation.",
-    "Include only durable context needed to continue effectively:",
-    "- current user goal and constraints",
-    "- important decisions and preferences",
-    "- files/repos touched and current code state",
-    "- commands/tests already run and results",
-    "- open TODOs, blockers, and exact next step",
-    "Do not include secrets, raw tokens, or irrelevant chat transcript.",
+    "Write a brief that lets your future self resume work without re-asking the user.",
+    "",
+    "Include:",
+    "- Current user goal and any active side threads or sub-goals.",
+    "- Locked-in constraints, preferences, and decisions (with the WHY when non-obvious).",
+    "- Infrastructure / release facts: how things deploy, publish, or release; which CI handles what; required env or secrets; commands the user said NOT to run locally.",
+    "- Files and repos touched, current branch / commit / tag state, what is committed vs uncommitted, what is pushed vs local.",
+    "- Commands already run and their results — so you do not re-run completed setup and do not re-attempt failed steps.",
+    "- Open TODOs, blockers, and the exact next step.",
+    "- User pushback or corrections this session — your future self must not repeat the mistake. Quote the correction if short.",
+    "- Stable paths, IDs, PIDs, owner IDs, and reference URLs the work depends on.",
+    "",
+    "Do not include: secrets, raw tokens, full file dumps, or chat pleasantries.",
+    "Be concrete. Names of files, commands, flags, tags, and commits beat paraphrase. If a fact was load-bearing in this session, write it down verbatim.",
   ].join("\n");
 }
 
@@ -178,6 +209,17 @@ function compactSeedPrompt(summary) {
     "Treat the following summary as the prior conversation context. Do not repeat it back unless asked.",
     "Continue from this state in future turns.",
     "",
+    "Before telling the user you lack context on something they reference:",
+    "1. Check the summary below.",
+    "2. Search the project transcript with `open-claudia transcript-window <pattern>`.",
+    "   It returns each hit with surrounding turns of context, capped per turn so it stays bounded.",
+    "   Useful flags: --before N / --after N (default 2), --max-turns K (default 10), --regex.",
+    "   Fall back to `grep -n -C 5 <pattern> <transcript-path>` (path in your system prompt under",
+    "   'Project Transcript Memory') only if the helper does not fit your search.",
+    "Only ask the user if both turn up nothing.",
+    "",
+    "If a fact in the summary contradicts current repo state (a file path, a command, a flag, a version), trust what you observe now and proceed without flagging it unless the user asks.",
+    "",
     "Compacted summary:",
     summary,
   ].join("\n");
@@ -218,7 +260,7 @@ async function runClaudeCapture(prompt, cwd, opts = {}) {
     const args = buildClaudeArgs(prompt, { ...opts, skipAutoCompact: true });
     const proc = spawn(getActiveBinary(), args, {
       cwd,
-      env: claudeSubprocessEnv(),
+      env: subprocessEnv(),
       stdio: ["ignore", "pipe", "pipe"],
       detached: process.platform !== "win32",
     });
@@ -347,17 +389,6 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     return;
   }
 
-  if (shouldAutoCompact(state, opts)) {
-    try {
-      await compactActiveSession(cwd, {
-        notify: true,
-        message: "Context is getting large, compacting first so this stays fast…",
-      });
-    } catch (e) {
-      await send(`Compaction failed: ${redactSensitive(e.message)}\nContinuing in the existing session.`, { replyTo: replyToMsgId });
-    }
-  }
-
   appendProjectTranscript("user", prompt, {
     sourceMessageId: replyToMsgId || null,
     fresh: !!opts.fresh,
@@ -377,7 +408,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   const binaryPath = getActiveBinary();
   const proc = spawn(binaryPath, args, {
     cwd,
-    env: claudeSubprocessEnv(),
+    env: subprocessEnv(),
     stdio: ["ignore", "pipe", "pipe"],
     detached: process.platform !== "win32",
   });

package/core/system-prompt.js

@@ -45,7 +45,11 @@ ${soul}
 ${transcriptPointerNote(state)}
 
 ## Delivery
-Reply normally in your final answer. If you must send a large file, image, or artifact directly, use the channel API/CLI; never print or embed bot tokens in prompts, commands, logs, or messages.
+Reply normally in your final answer. To send a file, image, or voice clip back to the current chat, run the bot CLI from inside this task — channel context is already in the env:
+- \`open-claudia send-file <path> [caption]\` — any document/binary
+- \`open-claudia send-photo <path> [caption]\` — image with inline preview
+- \`open-claudia send-voice <path>\` — ogg/opus voice note
+Never print or embed bot tokens in prompts, commands, logs, or messages.
 
 ## Guidelines
 - Keep responses concise — many users are on mobile.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {