@inetafrica/open-claudia 1.20.0 → 2.0.0

package/core/state.js

@@ -0,0 +1,261 @@
+// Per-user state buckets and persistence. State is keyed by canonical
+// user id (`telegram:<chatId>` by default, `<email>` after /link) so
+// linked channels share the same conversation, settings, and usage.
+
+const fs = require("fs");
+const { STATE_FILE, SESSIONS_FILE, CHAT_ID } = require("./config");
+const {
+  normalizeCanonicalUserId,
+  canonicalForTelegram,
+  canonicalForStoredUserKey,
+  setIdentityMapping,
+} = require("./identity");
+const { currentChannelId, currentCanonicalUserId } = require("./context");
+
+function loadStateFile() {
+  try { return JSON.parse(fs.readFileSync(STATE_FILE, "utf-8")); } catch (e) { return {}; }
+}
+
+function mergeSavedState(existing, next) {
+  return {
+    ...existing,
+    ...next,
+    settings: { ...(existing.settings || {}), ...(next.settings || {}) },
+    sessionUsage: { ...(existing.sessionUsage || {}), ...(next.sessionUsage || {}) },
+  };
+}
+
+// Multi-user state. Legacy top-level shapes are migrated to
+// `{ users: { "<canonicalId>": {...} } }` on load.
+const savedState = (() => {
+  const raw = loadStateFile();
+  const users = {};
+  if (raw && raw.users && typeof raw.users === "object") {
+    for (const [key, value] of Object.entries(raw.users)) {
+      const userId = canonicalForStoredUserKey(key);
+      users[userId] = mergeSavedState(users[userId] || {}, value || {});
+    }
+    return { users };
+  }
+  return { users: { [canonicalForTelegram(CHAT_ID || "")]: raw || {} } };
+})();
+
+const userStates = new Map();
+
+function freshSettings() {
+  return { model: null, effort: null, budget: null, permissionMode: null, worktree: false, backend: "claude" };
+}
+
+function freshUsage() {
+  return { turns: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0, lastInputTokens: 0 };
+}
+
+function createUserState(userId) {
+  const saved = (savedState.users && savedState.users[userId]) || {};
+  const settings = saved.settings || freshSettings();
+  if (!settings.backend) settings.backend = "claude";
+  return {
+    userId: String(userId),
+    channelId: currentChannelId(),
+    currentSession: saved.currentSession || null,
+    runningProcess: null,
+    statusMessageId: null,
+    streamBuffer: "",
+    streamInterval: null,
+    lastSessionId: saved.lastSessionId || null,
+    cursorSessionId: saved.cursorSessionId || null,
+    codexSessionId: saved.codexSessionId || null,
+    messageQueue: [],
+    isFirstMessage: !saved.lastSessionId,
+    lastInputWasVoice: false,
+    sessionUsage: saved.sessionUsage || freshUsage(),
+    settings,
+    onboardingStep: null,
+    onboardingData: {},
+    pendingVaultUnlock: false,
+    pendingVaultAction: null,
+    pendingClaudeAuthProcess: null,
+    pendingClaudeAuthLabel: null,
+    pendingCodexAuthProcess: null,
+    pendingCodexAuthLabel: null,
+    isCompacting: false,
+    lastCompactedAt: saved.lastCompactedAt || 0,
+  };
+}
+
+function getUserState(userId) {
+  const id = normalizeCanonicalUserId(userId);
+  if (!userStates.has(id)) userStates.set(id, createUserState(id));
+  const state = userStates.get(id);
+  state.channelId = currentChannelId() || state.channelId;
+  return state;
+}
+
+function currentState() {
+  return getUserState(currentCanonicalUserId() || canonicalForTelegram(CHAT_ID || ""));
+}
+
+function resetSessionUsage(state = currentState()) {
+  state.sessionUsage = freshUsage();
+}
+
+function resetSettings(state = currentState()) {
+  state.settings = freshSettings();
+}
+
+function saveState() {
+  const data = { users: { ...(savedState.users || {}) } };
+  for (const [id, s] of userStates) {
+    data.users[id] = {
+      currentSession: s.currentSession,
+      lastSessionId: s.lastSessionId,
+      cursorSessionId: s.cursorSessionId,
+      codexSessionId: s.codexSessionId,
+      settings: s.settings,
+      sessionUsage: s.sessionUsage,
+      lastCompactedAt: s.lastCompactedAt || 0,
+    };
+  }
+  savedState.users = data.users;
+  try { fs.writeFileSync(STATE_FILE, JSON.stringify(data)); } catch (e) {}
+}
+
+// ── Sessions ────────────────────────────────────────────────────────
+
+function loadSessions() {
+  let raw;
+  try { raw = JSON.parse(fs.readFileSync(SESSIONS_FILE, "utf-8")); } catch (e) { return {}; }
+  if (!raw || typeof raw !== "object") return {};
+  const looksLegacy = Object.values(raw).some((v) => Array.isArray(v));
+  if (looksLegacy) return { [canonicalForTelegram(CHAT_ID || "")]: raw };
+  const migrated = {};
+  for (const [key, value] of Object.entries(raw)) {
+    const userId = canonicalForStoredUserKey(key);
+    migrated[userId] = { ...(migrated[userId] || {}) };
+    for (const [project, list] of Object.entries(value || {})) {
+      migrated[userId][project] = [
+        ...(migrated[userId][project] || []),
+        ...(Array.isArray(list) ? list : []),
+      ].slice(-20);
+    }
+  }
+  return migrated;
+}
+
+function saveSessions(sessions) {
+  try { fs.writeFileSync(SESSIONS_FILE, JSON.stringify(sessions, null, 2)); } catch (e) {}
+}
+
+function recordSession(userId, projectName, sessionId, title) {
+  const all = loadSessions();
+  const id = normalizeCanonicalUserId(userId);
+  if (!all[id]) all[id] = {};
+  if (!all[id][projectName]) all[id][projectName] = [];
+  const arr = all[id][projectName];
+  const existing = arr.find((s) => s.id === sessionId);
+  if (existing) {
+    if (title) existing.title = title;
+    existing.lastUsed = new Date().toISOString();
+  } else {
+    arr.push({
+      id: sessionId,
+      title: title || "Untitled",
+      created: new Date().toISOString(),
+      lastUsed: new Date().toISOString(),
+    });
+  }
+  all[id][projectName] = arr.slice(-20);
+  saveSessions(all);
+}
+
+function getProjectSessions(userId, projectName) {
+  const all = loadSessions();
+  return ((all[normalizeCanonicalUserId(userId)] || {})[projectName] || []).slice().reverse();
+}
+
+function getLastProjectSession(userId, projectName) {
+  const sessions = getProjectSessions(userId, projectName);
+  return sessions.length > 0 ? sessions[0] : null;
+}
+
+// Cross-user leakage guard: only resume a Claude session id we have
+// recorded for this user. Stops migration glitches from handing one
+// person's conversation to another.
+function userOwnsClaudeSession(userId, sessionId) {
+  if (!sessionId) return false;
+  const all = loadSessions();
+  const bucket = all[normalizeCanonicalUserId(userId)];
+  if (!bucket) return false;
+  for (const list of Object.values(bucket)) {
+    if (Array.isArray(list) && list.some((s) => s && s.id === sessionId)) return true;
+  }
+  return false;
+}
+
+function migrateUserData(fromUserId, toUserId) {
+  const from = normalizeCanonicalUserId(fromUserId);
+  const to = normalizeCanonicalUserId(toUserId);
+  if (!from || !to || from === to) return;
+
+  if (savedState.users && savedState.users[from]) {
+    savedState.users[to] = mergeSavedState(savedState.users[to] || {}, savedState.users[from]);
+    delete savedState.users[from];
+  }
+
+  if (userStates.has(from)) {
+    const fromState = userStates.get(from);
+    if (userStates.has(to)) {
+      const toState = userStates.get(to);
+      Object.assign(toState, mergeSavedState(toState, fromState));
+      toState.userId = to;
+    } else {
+      fromState.userId = to;
+      userStates.set(to, fromState);
+    }
+    userStates.delete(from);
+  }
+
+  const sessions = loadSessions();
+  if (sessions[from]) {
+    sessions[to] = { ...(sessions[to] || {}) };
+    for (const [project, list] of Object.entries(sessions[from])) {
+      sessions[to][project] = [
+        ...(sessions[to][project] || []),
+        ...(Array.isArray(list) ? list : []),
+      ].slice(-20);
+    }
+    delete sessions[from];
+    saveSessions(sessions);
+  }
+
+  saveState();
+}
+
+// Wraps identity.setIdentityMapping with state migration so callers don't
+// have to remember to migrate after re-linking.
+function linkIdentity(transport, channelId, canonicalUserId) {
+  const result = setIdentityMapping(transport, channelId, canonicalUserId);
+  if (result.shouldMigrate) migrateUserData(result.previousUserId, result.userId);
+  return result;
+}
+
+module.exports = {
+  userStates,
+  savedState,
+  freshSettings,
+  freshUsage,
+  createUserState,
+  getUserState,
+  currentState,
+  resetSessionUsage,
+  resetSettings,
+  saveState,
+  loadSessions,
+  saveSessions,
+  recordSession,
+  getProjectSessions,
+  getLastProjectSession,
+  userOwnsClaudeSession,
+  migrateUserData,
+  linkIdentity,
+};

package/core/system-prompt.js

@@ -0,0 +1,66 @@
+// Builds the soul + runtime context block prepended to every Claude
+// request. Channel-aware: the "Interface" line names the actual channel
+// the request is coming from.
+
+const fs = require("fs");
+const path = require("path");
+const { SOUL_FILE, CRONS_FILE, VAULT_FILE, FILES_DIR, BOT_DIR, WHISPER_CLI, FFMPEG } = require("./config");
+const { currentState } = require("./state");
+const { currentAdapter } = require("./context");
+const { vault } = require("./vault-store");
+const { transcriptPointerNote } = require("./transcripts");
+
+function loadSoul() {
+  try { return fs.readFileSync(SOUL_FILE, "utf-8"); }
+  catch (e) { return "You are a helpful AI coding assistant."; }
+}
+
+function buildSystemPrompt() {
+  const state = currentState();
+  const soul = loadSoul();
+  const hasVoice = WHISPER_CLI && FFMPEG;
+  const adapter = currentAdapter();
+  const channelLabel = adapter
+    ? (adapter.type === "kazee" ? "Kazee Chat" : adapter.type === "telegram" ? "Telegram" : adapter.type)
+    : "Telegram";
+
+  return `
+${soul}
+
+## Runtime Context
+- Interface: ${channelLabel} chat through Open Claudia.
+- Active project path: ${state.currentSession ? state.currentSession.dir : "none"}
+- Voice notes: ${hasVoice ? "enabled" : "disabled"}
+- Vault: ${vault.isUnlocked() ? "unlocked" : "locked"}
+- Session: ${state.lastSessionId ? "resuming existing conversation" : "new conversation"}
+
+## Stable Local Paths
+- Bot code: ${path.join(BOT_DIR, "bot.js")}
+- Personality file: ${SOUL_FILE}
+- Cron config: ${CRONS_FILE}
+- Vault file: ${VAULT_FILE}
+- Bot environment: ${path.join(BOT_DIR, ".env")} (sensitive; never expose values)
+- Received user files directory: ${FILES_DIR}
+
+${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.
+
+## Guidelines
+- Keep responses concise — many users are on mobile.
+- Markdown: *bold*, _italic_, \`code\`, \`\`\`code blocks\`\`\` work on both Telegram and Kazee. Skip headers (#) and links [text](url).
+- For long output (logs, diffs, large code), save to a file and send it as an artifact instead of pasting walls of text.
+- Act on screenshots (fix bugs, implement designs) — don't just describe what you see.
+- When the user sends a file, it is saved in the received files directory above. Read it with the Read tool.
+- When the user sends a credential, token, or API key, store it in the vault immediately using the vault CLI or bot commands. Tell them it's stored and that you've deleted their message for security.
+- When asked to change your personality, edit the personality file above.
+- When asked about yourself, you are Open Claudia — an AI coding assistant running Claude Code via Telegram or Kazee.
+- If a task will take a while, let the user know upfront.
+- Don't ask for confirmation on simple tasks — just do them.
+- NEVER start long-running processes (dev servers, watchers, tails) in the foreground. They block all further messages. Instead, run them in the background: \`nohup command &\` or \`command &disown\`. Then report the PID so the user can stop it later.
+- If asked to "start" or "run" a dev server, ALWAYS background it.
+`.trim();
+}
+
+module.exports = { loadSoul, buildSystemPrompt };

package/core/transcripts.js

@@ -0,0 +1,71 @@
+// Per-project transcript memory: thin wrapper around ProjectTranscripts
+// that adds the channel/state context most callers want.
+
+const fs = require("fs");
+const { ProjectTranscripts } = require("../project-transcripts");
+const {
+  CONFIG_DIR, PROJECT_TRANSCRIPTS, TRANSCRIPTS_DIR, TRANSCRIPT_MAX_ENTRY_CHARS,
+} = require("./config");
+const { redactSensitive } = require("./redact");
+const { currentChannelId } = require("./context");
+const { currentState } = require("./state");
+
+const projectTranscripts = new ProjectTranscripts({
+  configDir: CONFIG_DIR,
+  enabled: PROJECT_TRANSCRIPTS,
+  transcriptsDir: TRANSCRIPTS_DIR,
+  maxEntryChars: TRANSCRIPT_MAX_ENTRY_CHARS,
+  redact: redactSensitive,
+});
+if (PROJECT_TRANSCRIPTS) {
+  try { fs.mkdirSync(projectTranscripts.transcriptsDir, { recursive: true, mode: 0o700 }); } catch (e) {}
+}
+
+function transcriptProjectInfo(state = currentState()) {
+  if (!state.currentSession) return null;
+  return projectTranscripts.pointer(state.currentSession.dir, state.currentSession.name, state.userId);
+}
+
+function transcriptPointerNote(state = currentState()) {
+  if (!state.currentSession) return "";
+  return projectTranscripts.buildPointerNote(state.currentSession.dir, state.currentSession.name, state.userId);
+}
+
+function appendProjectTranscript(role, text, metadata = {}, state = currentState(), getActiveSessionId) {
+  if (!state.currentSession) return null;
+  try {
+    const transport = (state.userId || "").split(":")[0] || "telegram";
+    return projectTranscripts.append({
+      role,
+      text,
+      userId: state.userId,
+      chat: { transport, id: String(currentChannelId() || "") },
+      projectName: state.currentSession.name,
+      projectPath: state.currentSession.dir,
+      backend: state.settings.backend,
+      sessionId: typeof getActiveSessionId === "function" ? getActiveSessionId() : null,
+      metadata,
+    });
+  } catch (e) {
+    console.error("Transcript write failed:", redactSensitive(e.message));
+    return null;
+  }
+}
+
+function promptWithTranscriptPointer(prompt, state = currentState()) {
+  if (!state.currentSession) return prompt;
+  return projectTranscripts.withPointer(prompt, state.currentSession.dir, state.currentSession.name, state.userId);
+}
+
+function stripTranscriptPointerForStorage(prompt) {
+  return String(prompt || "").replace(/^## Project Transcript Memory\n[\s\S]*?\n\nCurrent user request:\n/, "");
+}
+
+module.exports = {
+  projectTranscripts,
+  transcriptProjectInfo,
+  transcriptPointerNote,
+  appendProjectTranscript,
+  promptWithTranscriptPointer,
+  stripTranscriptPointerForStorage,
+};

package/core/vault-store.js

@@ -0,0 +1,9 @@
+// Single shared vault. Module is just an instance holder so every
+// importer gets the same Vault.
+
+const Vault = require("../vault");
+const { VAULT_FILE } = require("./config");
+
+const vault = new Vault(VAULT_FILE);
+
+module.exports = { vault };

package/docker-entrypoint.sh

@@ -6,13 +6,30 @@ ENV_FILE="$CONFIG_DIR/.env"
 
 mkdir -p "$CONFIG_DIR"
 
-# If .env doesn't exist and env vars are set, auto-configure
-if [ ! -f "$ENV_FILE" ] && [ -n "$TELEGRAM_BOT_TOKEN" ]; then
+# If .env doesn't exist and a channel token is set, auto-configure.
+# CHANNELS env selects which channels to enable; defaults to telegram for
+# backwards compat with v1 installs.
+if [ ! -f "$ENV_FILE" ] && { [ -n "$TELEGRAM_BOT_TOKEN" ] || [ -n "$KAZEE_BOT_TOKEN" ]; }; then
   echo "Auto-configuring from environment variables..."
 
+  if [ -z "$CHANNELS" ]; then
+    if [ -n "$TELEGRAM_BOT_TOKEN" ] && [ -n "$KAZEE_BOT_TOKEN" ]; then
+      CHANNELS="telegram,kazee"
+    elif [ -n "$KAZEE_BOT_TOKEN" ]; then
+      CHANNELS="kazee"
+    else
+      CHANNELS="telegram"
+    fi
+  fi
+
   cat > "$ENV_FILE" <<ENVEOF
-TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN}
+CHANNELS=${CHANNELS}
+TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN:-}
 TELEGRAM_CHAT_ID=${TELEGRAM_CHAT_ID:-}
+KAZEE_URL=${KAZEE_URL:-}
+KAZEE_BOT_TOKEN=${KAZEE_BOT_TOKEN:-}
+KAZEE_BOT_USER_ID=${KAZEE_BOT_USER_ID:-}
+KAZEE_OWNER_USER_ID=${KAZEE_OWNER_USER_ID:-}
 WORKSPACE=${WORKSPACE:-$HOME/Workspace}
 CLAUDE_PATH=${CLAUDE_PATH:-claude}
 SOUL_FILE=$CONFIG_DIR/soul.md
@@ -30,7 +47,7 @@ ENVEOF
   # Create default soul
   if [ ! -f "$CONFIG_DIR/soul.md" ]; then
     cat > "$CONFIG_DIR/soul.md" <<'SOUL'
-You are a helpful AI coding assistant running via Telegram.
+You are a helpful AI coding assistant.
 Keep responses concise — this is a mobile screen.
 Act on screenshots, fix bugs, implement designs.
 SOUL

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "1.20.0",
-  "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram",
+  "version": "2.0.0",
+  "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {
     "open-claudia": "./bin/cli.js"
@@ -20,6 +20,8 @@
     "setup.js",
     "web.js",
     "config-dir.js",
+    "core/",
+    "channels/",
     "bin/",
     "k8s/",
     "Dockerfile",
@@ -44,6 +46,7 @@
   },
   "dependencies": {
     "node-cron": "^4.2.1",
-    "node-telegram-bot-api": "^0.67.0"
+    "node-telegram-bot-api": "^0.67.0",
+    "socket.io-client": "^4.7.5"
   }
 }

package/project-transcripts.js

@@ -21,8 +21,10 @@ function safeName(value) {
   return String(value || "project").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "project";
 }
 
-function projectHash(projectPath) {
-  return crypto.createHash("sha256").update(normalizeProjectPath(projectPath)).digest("hex").slice(0, 24);
+function projectHash(projectPath, userId) {
+  const normalized = normalizeProjectPath(projectPath);
+  const seed = userId ? `${String(userId)} ${normalized}` : normalized;
+  return crypto.createHash("sha256").update(seed).digest("hex").slice(0, 24);
 }
 
 function mkdirp(dir) {
@@ -39,13 +41,14 @@ class ProjectTranscripts {
     this.redact = redact;
   }
 
-  projectInfo(projectPath, projectName) {
+  projectInfo(projectPath, projectName, userId) {
     const normalizedPath = normalizeProjectPath(projectPath);
-    const hash = projectHash(normalizedPath);
+    const hash = projectHash(normalizedPath, userId);
     const name = projectName || path.basename(normalizedPath) || "project";
     const baseName = `${hash}-${safeName(name)}`;
     return {
       hash,
+      userId: userId || null,
       projectName: name,
       projectPath: normalizedPath,
       transcriptPath: path.join(this.transcriptsDir, `${baseName}.jsonl`),
@@ -54,13 +57,13 @@ class ProjectTranscripts {
     };
   }
 
-  pointer(projectPath, projectName) {
+  pointer(projectPath, projectName, userId) {
     if (!this.enabled || !projectPath) return null;
-    return this.projectInfo(projectPath, projectName);
+    return this.projectInfo(projectPath, projectName, userId);
   }
 
-  buildPointerNote(projectPath, projectName) {
-    const info = this.pointer(projectPath, projectName);
+  buildPointerNote(projectPath, projectName, userId) {
+    const info = this.pointer(projectPath, projectName, userId);
     if (!info) return "";
     return [
       "## Project Transcript Memory",
@@ -71,8 +74,8 @@ class ProjectTranscripts {
     ].join("\n");
   }
 
-  withPointer(prompt, projectPath, projectName) {
-    const note = this.buildPointerNote(projectPath, projectName);
+  withPointer(prompt, projectPath, projectName, userId) {
+    const note = this.buildPointerNote(projectPath, projectName, userId);
     if (!note) return prompt;
     return `${note}\n\nCurrent user request:\n${prompt}`;
   }
@@ -96,13 +99,14 @@ class ProjectTranscripts {
 
   append(entry) {
     if (!this.enabled || !entry || !entry.projectPath) return null;
-    const info = this.projectInfo(entry.projectPath, entry.projectName);
+    const canonicalUserId = entry.userId || entry.canonicalUserId || null;
+    const info = this.projectInfo(entry.projectPath, entry.projectName, canonicalUserId);
     mkdirp(this.transcriptsDir);
     const textData = this.truncateText(entry.text);
     const now = new Date().toISOString();
     const record = {
       timestamp: entry.timestamp || now,
-      canonicalUserId: entry.userId || entry.canonicalUserId || null,
+      canonicalUserId,
       chat: entry.chat || null,
       project: { name: info.projectName, path: info.projectPath, hash: info.hash },
       backend: entry.backend || null,
@@ -118,6 +122,7 @@ class ProjectTranscripts {
     fs.appendFileSync(info.transcriptPath, JSON.stringify(record) + "\n", { mode: 0o600 });
     const metadata = {
       projectHash: info.hash,
+      canonicalUserId,
       projectName: info.projectName,
       projectPath: info.projectPath,
       transcriptPath: info.transcriptPath,

package/setup.js

@@ -488,7 +488,9 @@ function updateEnvKey(key, value) {
 
 // ── Main setup (resumable) ─────────────────────────────────────────
 
-const STEPS = ["prerequisites", "telegram", "auth", "workspace", "vault", "config", "daemon"];
+const STEPS = ["prerequisites", "telegram", "auth", "channels", "workspace", "vault", "config", "daemon"];
+
+const { validateKazee } = require("./core/kazee-probe");
 
 async function main() {
   // Check if this is an auth subcommand
@@ -666,6 +668,36 @@ async function main() {
     saveSetupState(state);
   }
 
+  // ── Step: Extra channels (Kazee) ─────────────────────────────────
+  if (!state.completedSteps.includes("channels")) {
+    console.log("\n  Extra Channels (optional)\n");
+    const addKazee = await ask("  Add a Kazee channel now? (y/n) [n]: ");
+    if (addKazee.toLowerCase() === "y") {
+      while (true) {
+        const url = (await ask("  Kazee bot API URL (e.g. https://chat.example.com/api): ")).trim();
+        if (!/^https?:\/\//i.test(url)) { console.log("  That doesn't look like a URL."); continue; }
+        const token = (await ask("  Kazee bot token: ")).trim();
+        if (!token) { console.log("  Empty token."); continue; }
+        console.log("  Validating against Kazee /me…");
+        const check = await validateKazee({ url, token });
+        if (!check.ok) {
+          console.log(`  Validation failed: ${check.error}`);
+          const retry = await ask("  Try again? (y/n) [y]: ");
+          if (retry.toLowerCase() === "n") break;
+          continue;
+        }
+        const ownerUserId = (await ask("  Kazee owner user id (blank to skip): ")).trim();
+        state.data.kazee = { url: url.replace(/\/$/, ""), token, ownerUserId };
+        console.log("  Kazee channel configured.");
+        break;
+      }
+    } else {
+      console.log("  Skipped — you can add a channel later with /channel add kazee.");
+    }
+    state.completedSteps.push("channels");
+    saveSetupState(state);
+  }
+
   // ── Step: Workspace ──────────────────────────────────────────────
   if (!state.completedSteps.includes("workspace")) {
     const defaultWorkspace = path.join(CONFIG_DIR, "Workspace");
@@ -704,7 +736,9 @@ async function main() {
   // ── Step: Write config ───────────────────────────────────────────
   if (!state.completedSteps.includes("config")) {
     const d = state.data;
-    const env = [
+    const channels = ["telegram"];
+    if (d.kazee) channels.push("kazee");
+    const envLines = [
       `TELEGRAM_BOT_TOKEN=${d.token}`,
       `TELEGRAM_CHAT_ID=${d.chatId}`,
       `WORKSPACE=${d.workspace}`,
@@ -716,8 +750,15 @@ async function main() {
       `SOUL_FILE=${SOUL_FILE}`,
       `CRONS_FILE=${CRONS_FILE}`,
       `AUTH_FILE=${AUTH_FILE}`,
+      `CHANNELS=${channels.join(",")}`,
       `ONBOARDED=false`,
-    ].join("\n");
+    ];
+    if (d.kazee) {
+      envLines.push(`KAZEE_URL=${d.kazee.url}`);
+      envLines.push(`KAZEE_BOT_TOKEN=${d.kazee.token}`);
+      envLines.push(`KAZEE_OWNER_USER_ID=${d.kazee.ownerUserId || ""}`);
+    }
+    const env = envLines.join("\n");
 
     fs.writeFileSync(ENV_FILE, env);
     console.log(`  Config saved: ${ENV_FILE}\n`);