@dotsetlabs/dotclaw 1.1.0

package/scripts/configure.js

@@ -0,0 +1,200 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import readline from 'readline';
+
+// Get DOTCLAW_HOME from environment or default to ~/.dotclaw
+const DOTCLAW_HOME = process.env.DOTCLAW_HOME || path.join(os.homedir(), '.dotclaw');
+const CONFIG_DIR = path.join(DOTCLAW_HOME, 'config');
+const DATA_DIR = path.join(DOTCLAW_HOME, 'data');
+const ENV_PATH = path.join(DOTCLAW_HOME, '.env');
+const MODEL_CONFIG_PATH = path.join(CONFIG_DIR, 'model.json');
+const RUNTIME_CONFIG_PATH = path.join(CONFIG_DIR, 'runtime.json');
+
+function parseEnv(content) {
+  const lines = content.split('\n');
+  const map = new Map();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1).trim();
+    map.set(key, value);
+  }
+  return map;
+}
+
+function updateEnvContent(existing, updates) {
+  const lines = existing.split('\n');
+  const keys = new Set(Object.keys(updates));
+  const output = lines.map(line => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) return line;
+    const idx = trimmed.indexOf('=');
+    if (idx === -1) return line;
+    const key = trimmed.slice(0, idx).trim();
+    if (!keys.has(key)) return line;
+    return `${key}=${updates[key]}`;
+  });
+
+  for (const [key, value] of Object.entries(updates)) {
+    const exists = lines.some(line => line.trim().startsWith(`${key}=`));
+    if (!exists) {
+      output.push(`${key}=${value}`);
+    }
+  }
+
+  return output.join('\n').replace(/\n+$/, '\n');
+}
+
+function mask(value) {
+  if (!value) return 'missing';
+  if (value.length <= 8) return 'set';
+  return `${value.slice(0, 4)}…${value.slice(-2)}`;
+}
+
+async function promptForValue(rl, label, currentValue, optional = false) {
+  const suffix = optional ? ' (optional)' : '';
+  const prompt = `${label}${suffix} [current: ${mask(currentValue)}]: `;
+  return new Promise(resolve => {
+    rl.question(prompt, answer => {
+      const value = answer.trim();
+      if (!value) {
+        resolve(currentValue || '');
+        return;
+      }
+      resolve(value);
+    });
+  });
+}
+
+function loadRuntimeConfig() {
+  if (!fs.existsSync(RUNTIME_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(RUNTIME_CONFIG_PATH, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveRuntimeConfig(config) {
+  fs.mkdirSync(path.dirname(RUNTIME_CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(RUNTIME_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+}
+
+async function main() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+
+  const envContent = fs.existsSync(ENV_PATH) ? fs.readFileSync(ENV_PATH, 'utf-8') : '';
+  const envMap = parseEnv(envContent);
+  const runtimeConfig = loadRuntimeConfig();
+
+  const nonInteractive = ['1', 'true', 'yes'].includes((process.env.DOTCLAW_CONFIGURE_NONINTERACTIVE || process.env.DOTCLAW_BOOTSTRAP_NONINTERACTIVE || '').toLowerCase());
+
+  let modelConfig = {
+    model: 'moonshotai/kimi-k2.5',
+    allowlist: [],
+    updated_at: new Date().toISOString()
+  };
+  if (fs.existsSync(MODEL_CONFIG_PATH)) {
+    try {
+      modelConfig = JSON.parse(fs.readFileSync(MODEL_CONFIG_PATH, 'utf-8'));
+    } catch {
+      // keep defaults
+    }
+  }
+
+  const runtimeAgent = runtimeConfig.agent || {};
+  const runtimeOpenrouter = runtimeAgent.openrouter || {};
+
+  let telegramToken = envMap.get('TELEGRAM_BOT_TOKEN') || '';
+  let openrouterKey = envMap.get('OPENROUTER_API_KEY') || '';
+  let openrouterModel = modelConfig.model;
+  let openrouterSiteUrl = runtimeOpenrouter.siteUrl || '';
+  let openrouterSiteName = runtimeOpenrouter.siteName || '';
+  let braveKey = envMap.get('BRAVE_SEARCH_API_KEY') || '';
+  let allowlistInput = '';
+
+  if (nonInteractive) {
+    telegramToken = process.env.TELEGRAM_BOT_TOKEN || telegramToken;
+    openrouterKey = process.env.OPENROUTER_API_KEY || openrouterKey;
+    braveKey = process.env.BRAVE_SEARCH_API_KEY || braveKey;
+
+    if (!telegramToken) {
+      console.error('TELEGRAM_BOT_TOKEN is required for non-interactive configuration.');
+      process.exit(1);
+    }
+    if (!openrouterKey) {
+      console.error('OPENROUTER_API_KEY is required for non-interactive configuration.');
+      process.exit(1);
+    }
+  } else {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    telegramToken = await promptForValue(rl, 'TELEGRAM_BOT_TOKEN', telegramToken);
+    openrouterKey = await promptForValue(rl, 'OPENROUTER_API_KEY', openrouterKey);
+    openrouterModel = await promptForValue(rl, 'OPENROUTER_MODEL', openrouterModel);
+    openrouterSiteUrl = await promptForValue(rl, 'OPENROUTER_SITE_URL', openrouterSiteUrl, true);
+    openrouterSiteName = await promptForValue(rl, 'OPENROUTER_SITE_NAME', openrouterSiteName, true);
+    braveKey = await promptForValue(rl, 'BRAVE_SEARCH_API_KEY', braveKey, true);
+
+    allowlistInput = await new Promise(resolve => {
+      rl.question('Model allowlist (comma-separated, blank = allow all): ', answer => {
+        resolve(answer.trim());
+      });
+    });
+
+    rl.close();
+  }
+
+  const updates = {
+    TELEGRAM_BOT_TOKEN: telegramToken,
+    OPENROUTER_API_KEY: openrouterKey
+  };
+  if (braveKey) updates.BRAVE_SEARCH_API_KEY = braveKey;
+
+  const nextEnv = updateEnvContent(envContent || '', updates);
+  fs.writeFileSync(ENV_PATH, nextEnv);
+  try {
+    fs.chmodSync(ENV_PATH, 0o600);
+  } catch {
+    // best-effort
+  }
+
+  const allowlist = allowlistInput
+    ? allowlistInput.split(',').map(item => item.trim()).filter(Boolean)
+    : (Array.isArray(modelConfig.allowlist) ? modelConfig.allowlist : []);
+
+  const nextModelConfig = {
+    ...modelConfig,
+    model: openrouterModel,
+    allowlist,
+    updated_at: new Date().toISOString()
+  };
+
+  fs.writeFileSync(MODEL_CONFIG_PATH, JSON.stringify(nextModelConfig, null, 2) + '\n');
+
+  const nextRuntimeConfig = { ...runtimeConfig };
+  if (!nextRuntimeConfig.agent) nextRuntimeConfig.agent = {};
+  if (!nextRuntimeConfig.agent.openrouter) nextRuntimeConfig.agent.openrouter = {};
+  nextRuntimeConfig.agent.openrouter.siteUrl = openrouterSiteUrl || '';
+  nextRuntimeConfig.agent.openrouter.siteName = openrouterSiteName || '';
+
+  if (!nextRuntimeConfig.host) nextRuntimeConfig.host = {};
+  if (!nextRuntimeConfig.host.memory) nextRuntimeConfig.host.memory = {};
+  if (!nextRuntimeConfig.host.memory.embeddings) nextRuntimeConfig.host.memory.embeddings = {};
+  nextRuntimeConfig.host.memory.embeddings.openrouterSiteUrl = openrouterSiteUrl || '';
+  nextRuntimeConfig.host.memory.embeddings.openrouterSiteName = openrouterSiteName || '';
+
+  saveRuntimeConfig(nextRuntimeConfig);
+
+  console.log('Configuration updated.');
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/doctor.js

@@ -0,0 +1,164 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+
+// Get DOTCLAW_HOME from environment or default to ~/.dotclaw
+const DOTCLAW_HOME = process.env.DOTCLAW_HOME || path.join(os.homedir(), '.dotclaw');
+const CONFIG_DIR = path.join(DOTCLAW_HOME, 'config');
+const DATA_DIR = path.join(DOTCLAW_HOME, 'data');
+const GROUPS_DIR = path.join(DOTCLAW_HOME, 'groups');
+const STORE_DIR = path.join(DATA_DIR, 'store');
+const LOGS_DIR = path.join(DOTCLAW_HOME, 'logs');
+const TRACES_DIR = path.join(DOTCLAW_HOME, 'traces');
+const PROMPTS_DIR = path.join(DOTCLAW_HOME, 'prompts');
+
+function log(label, value) {
+  console.log(`${label}: ${value}`);
+}
+
+function checkDocker() {
+  try {
+    execSync('docker info', { stdio: 'pipe', timeout: 10000 });
+    log('Docker', 'OK');
+  } catch {
+    log('Docker', 'NOT RUNNING');
+  }
+}
+
+function checkPathAccess(label, dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK);
+    log(label, 'read/write OK');
+  } catch (err) {
+    log(label, `permission error (${err instanceof Error ? err.message : String(err)})`);
+  }
+}
+
+function countFiles(dir) {
+  try {
+    if (!fs.existsSync(dir)) return 0;
+    return fs.readdirSync(dir).length;
+  } catch {
+    return 0;
+  }
+}
+
+function checkSystemd(service) {
+  try {
+    const output = execSync(`systemctl is-active ${service}`, { stdio: 'pipe' }).toString().trim();
+    log(`systemd ${service}`, output);
+  } catch {
+    log(`systemd ${service}`, 'not available');
+  }
+}
+
+function diskSpace(dir) {
+  try {
+    const output = execSync(`df -k "${dir}"`, { stdio: 'pipe' }).toString();
+    const lines = output.trim().split('\n');
+    const last = lines[lines.length - 1];
+    const parts = last.split(/\s+/);
+    const availKb = parseInt(parts[3], 10);
+    if (Number.isFinite(availKb)) {
+      const availGb = (availKb / (1024 * 1024)).toFixed(2);
+      return `${availGb} GB available`;
+    }
+    return 'unknown';
+  } catch (err) {
+    return `error (${err instanceof Error ? err.message : String(err)})`;
+  }
+}
+
+function loadRuntimeConfig() {
+  const runtimePath = path.join(CONFIG_DIR, 'runtime.json');
+  if (!fs.existsSync(runtimePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(runtimePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+log('Node', process.version);
+if (typeof process.getuid === 'function') {
+  log('UID', String(process.getuid()));
+}
+if (typeof process.getgid === 'function') {
+  log('GID', String(process.getgid()));
+}
+checkDocker();
+log('DOTCLAW_HOME', DOTCLAW_HOME);
+checkPathAccess('config/', CONFIG_DIR);
+checkPathAccess('data/', DATA_DIR);
+checkPathAccess('groups/', GROUPS_DIR);
+checkPathAccess('data/store/', STORE_DIR);
+checkPathAccess('logs/', LOGS_DIR);
+log('Disk space', diskSpace(DOTCLAW_HOME));
+
+const runtimeConfig = loadRuntimeConfig();
+if (runtimeConfig) {
+  log('runtime.json', 'present');
+  const containerMode = runtimeConfig?.host?.container?.mode;
+  if (containerMode) {
+    log('Container mode', String(containerMode));
+  }
+  const maxAgents = runtimeConfig?.host?.concurrency?.maxAgents;
+  if (Number.isFinite(maxAgents)) {
+    log('Max concurrent agents', String(maxAgents));
+  }
+  const warmStart = runtimeConfig?.host?.concurrency?.warmStart;
+  if (typeof warmStart === 'boolean') {
+    log('Warm start', String(warmStart));
+  }
+  const blockPrivate = runtimeConfig?.agent?.tools?.webfetch?.blockPrivate;
+  if (typeof blockPrivate === 'boolean') {
+    log('WebFetch block private', String(blockPrivate));
+  }
+  const traceDir = runtimeConfig?.host?.trace?.dir || TRACES_DIR;
+  const promptsDir = runtimeConfig?.host?.promptPacksDir || PROMPTS_DIR;
+  log('Trace files', String(countFiles(traceDir)));
+  log('Prompt packs', String(countFiles(promptsDir)));
+} else {
+  log('runtime.json', 'missing');
+}
+
+const envPath = path.join(DOTCLAW_HOME, '.env');
+log('.env', fs.existsSync(envPath) ? 'present' : 'missing');
+
+if (fs.existsSync(envPath)) {
+  const envContent = fs.readFileSync(envPath, 'utf-8');
+  const hasOpenRouter = envContent.includes('OPENROUTER_API_KEY=');
+  const hasBrave = envContent.includes('BRAVE_SEARCH_API_KEY=');
+  const hasTelegram = envContent.includes('TELEGRAM_BOT_TOKEN=');
+  log('TELEGRAM_BOT_TOKEN', hasTelegram ? 'set' : 'missing');
+  log('OPENROUTER_API_KEY', hasOpenRouter ? 'set' : 'missing');
+  log('BRAVE_SEARCH_API_KEY', hasBrave ? 'set (optional, enables WebSearch)' : 'missing');
+}
+
+checkSystemd('dotclaw.service');
+checkSystemd('autotune.timer');
+
+if (typeof process.getuid === 'function' && process.getuid() === 0) {
+  log('Warning', 'Running as root. For best security, run as a non-root user.');
+}
+
+const modelConfigPath = path.join(CONFIG_DIR, 'model.json');
+if (fs.existsSync(modelConfigPath)) {
+  try {
+    const modelConfig = JSON.parse(fs.readFileSync(modelConfigPath, 'utf-8'));
+    log('Model', modelConfig.model || 'missing');
+    log('Model allowlist', Array.isArray(modelConfig.allowlist) && modelConfig.allowlist.length > 0 ? modelConfig.allowlist.join(', ') : 'none (allow all)');
+  } catch (err) {
+    log('Model config', `error (${err instanceof Error ? err.message : String(err)})`);
+  }
+} else {
+  log('Model config', 'missing');
+}
+
+const behaviorConfigPath = path.join(CONFIG_DIR, 'behavior.json');
+log('Behavior config', fs.existsSync(behaviorConfigPath) ? behaviorConfigPath : 'missing');
+
+const memoryDbPath = path.join(STORE_DIR, 'memory.db');
+log('Memory DB', fs.existsSync(memoryDbPath) ? 'present' : 'missing');

package/scripts/init.js

@@ -0,0 +1,209 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get DOTCLAW_HOME from environment or default to ~/.dotclaw
+const DOTCLAW_HOME = process.env.DOTCLAW_HOME || path.join(os.homedir(), '.dotclaw');
+const CONFIG_DIR = path.join(DOTCLAW_HOME, 'config');
+const DATA_DIR = path.join(DOTCLAW_HOME, 'data');
+const STORE_DIR = path.join(DATA_DIR, 'store');
+const GROUPS_DIR = path.join(DOTCLAW_HOME, 'groups');
+const LOGS_DIR = path.join(DOTCLAW_HOME, 'logs');
+const TRACES_DIR = path.join(DOTCLAW_HOME, 'traces');
+const PROMPTS_DIR = path.join(DOTCLAW_HOME, 'prompts');
+const ENV_PATH = path.join(DOTCLAW_HOME, '.env');
+const MOUNT_ALLOWLIST_DIR = path.join(os.homedir(), '.config', 'dotclaw');
+const MOUNT_ALLOWLIST_PATH = path.join(MOUNT_ALLOWLIST_DIR, 'mount-allowlist.json');
+
+// Package root for copying example configs
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const CONFIG_EXAMPLES_DIR = path.join(PACKAGE_ROOT, 'config-examples');
+
+function log(message) {
+  console.log(message);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function ensureFile(filePath, contents) {
+  if (!fs.existsSync(filePath)) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, contents);
+    return true;
+  }
+  return false;
+}
+
+function checkDocker() {
+  try {
+    execSync('docker info', { stdio: 'pipe', timeout: 10000 });
+    log('Docker: OK');
+  } catch {
+    log('Docker: NOT RUNNING');
+    log('Start Docker Desktop (macOS) or run: sudo systemctl start docker (Linux)');
+  }
+}
+
+function initFiles() {
+  // Create directory structure
+  ensureDir(DOTCLAW_HOME);
+  ensureDir(CONFIG_DIR);
+  ensureDir(DATA_DIR);
+  ensureDir(STORE_DIR);
+  ensureDir(GROUPS_DIR);
+  ensureDir(path.join(GROUPS_DIR, 'main'));
+  ensureDir(path.join(GROUPS_DIR, 'global'));
+  ensureDir(LOGS_DIR);
+  ensureDir(TRACES_DIR);
+  ensureDir(PROMPTS_DIR);
+  ensureDir(MOUNT_ALLOWLIST_DIR);
+
+  // Set restrictive permissions
+  try {
+    fs.chmodSync(DOTCLAW_HOME, 0o700);
+    fs.chmodSync(CONFIG_DIR, 0o700);
+    fs.chmodSync(DATA_DIR, 0o700);
+  } catch {
+    // Best-effort; permissions may be controlled by the OS or user policy.
+  }
+
+  // Config files
+  const registeredGroupsPath = path.join(DATA_DIR, 'registered_groups.json');
+  const modelConfigPath = path.join(CONFIG_DIR, 'model.json');
+  const behaviorConfigPath = path.join(CONFIG_DIR, 'behavior.json');
+  const toolPolicyPath = path.join(CONFIG_DIR, 'tool-policy.json');
+  const toolBudgetsPath = path.join(CONFIG_DIR, 'tool-budgets.json');
+  const runtimeConfigPath = path.join(CONFIG_DIR, 'runtime.json');
+
+  // Seed CLAUDE.md templates if missing
+  const mainClaudePath = path.join(GROUPS_DIR, 'main', 'CLAUDE.md');
+  const globalClaudePath = path.join(GROUPS_DIR, 'global', 'CLAUDE.md');
+  const mainClaudeExample = path.join(CONFIG_EXAMPLES_DIR, 'groups', 'main', 'CLAUDE.md');
+  const globalClaudeExample = path.join(CONFIG_EXAMPLES_DIR, 'groups', 'global', 'CLAUDE.md');
+  if (!fs.existsSync(mainClaudePath) && fs.existsSync(mainClaudeExample)) {
+    fs.copyFileSync(mainClaudeExample, mainClaudePath);
+  }
+  if (!fs.existsSync(globalClaudePath) && fs.existsSync(globalClaudeExample)) {
+    fs.copyFileSync(globalClaudeExample, globalClaudePath);
+  }
+
+  const createdRegistered = ensureFile(registeredGroupsPath, '{}\n');
+  const createdModelConfig = ensureFile(modelConfigPath, JSON.stringify({
+    model: 'moonshotai/kimi-k2.5',
+    allowlist: [
+      'moonshotai/kimi-k2.5',
+      'openai/gpt-5-mini',
+      'openai/gpt-5-nano'
+    ],
+    overrides: {
+      'moonshotai/kimi-k2.5': {
+        context_window: 32000,
+        max_output_tokens: 2048,
+        tokens_per_char: 0.6,
+        tokens_per_message: 4,
+        tokens_per_request: 50
+      }
+    },
+    updated_at: new Date().toISOString()
+  }, null, 2) + '\n');
+  const createdBehaviorConfig = ensureFile(behaviorConfigPath, JSON.stringify({
+    tool_calling_bias: 0.5,
+    memory_importance_threshold: 0.55,
+    response_style: 'balanced',
+    caution_bias: 0.5,
+    last_updated: new Date().toISOString()
+  }, null, 2) + '\n');
+  const toolPolicyExamplePath = path.join(CONFIG_EXAMPLES_DIR, 'tool-policy.json');
+  const toolPolicyPayload = fs.existsSync(toolPolicyExamplePath)
+    ? fs.readFileSync(toolPolicyExamplePath, 'utf-8')
+    : JSON.stringify({ default: {} }, null, 2);
+  const createdToolPolicy = ensureFile(
+    toolPolicyPath,
+    toolPolicyPayload.endsWith('\n') ? toolPolicyPayload : toolPolicyPayload + '\n'
+  );
+
+  const toolBudgetsExamplePath = path.join(CONFIG_EXAMPLES_DIR, 'tool-budgets.json');
+  const toolBudgetsPayload = fs.existsSync(toolBudgetsExamplePath)
+    ? fs.readFileSync(toolBudgetsExamplePath, 'utf-8')
+    : JSON.stringify({ default: { per_day: {} } }, null, 2);
+  const createdToolBudgets = ensureFile(
+    toolBudgetsPath,
+    toolBudgetsPayload.endsWith('\n') ? toolBudgetsPayload : toolBudgetsPayload + '\n'
+  );
+
+  // Copy runtime config from examples if available
+  const runtimeExamplePath = path.join(CONFIG_EXAMPLES_DIR, 'runtime.json');
+  const runtimePayload = fs.existsSync(runtimeExamplePath)
+    ? fs.readFileSync(runtimeExamplePath, 'utf-8')
+    : '{\n  "host": {},\n  "agent": {}\n}\n';
+  const createdRuntimeConfig = ensureFile(
+    runtimeConfigPath,
+    runtimePayload.endsWith('\n') ? runtimePayload : runtimePayload + '\n'
+  );
+
+  // Mount allowlist template (kept outside DotClaw home)
+  const allowlistTemplate = JSON.stringify({
+    allowedRoots: [],
+    blockedPatterns: [],
+    nonMainReadOnly: true
+  }, null, 2) + '\n';
+  const createdAllowlist = ensureFile(MOUNT_ALLOWLIST_PATH, allowlistTemplate);
+  if (createdAllowlist) {
+    try {
+      fs.chmodSync(MOUNT_ALLOWLIST_PATH, 0o600);
+    } catch {
+      // best-effort
+    }
+  }
+
+  // Environment file
+  const envSample = [
+    '# DotClaw Secrets',
+    '# These values are required for DotClaw to function.',
+    '',
+    'TELEGRAM_BOT_TOKEN=your_bot_token_here',
+    'OPENROUTER_API_KEY=your_openrouter_api_key',
+    '',
+    '# Optional: Brave Search for web search capability',
+    'BRAVE_SEARCH_API_KEY=your_brave_search_api_key'
+  ].join('\n');
+
+  const createdEnv = ensureFile(ENV_PATH, envSample);
+  if (createdEnv) {
+    try {
+      fs.chmodSync(ENV_PATH, 0o600);
+    } catch {
+      // Best-effort; permissions may be controlled by the OS or user policy.
+    }
+  }
+
+  log(`DOTCLAW_HOME: ${DOTCLAW_HOME}`);
+  log(`registered_groups.json: ${createdRegistered ? 'created' : 'exists'}`);
+  log(`model.json: ${createdModelConfig ? 'created' : 'exists'}`);
+  log(`behavior.json: ${createdBehaviorConfig ? 'created' : 'exists'}`);
+  log(`tool-policy.json: ${createdToolPolicy ? 'created' : 'exists'}`);
+  log(`tool-budgets.json: ${createdToolBudgets ? 'created' : 'exists'}`);
+  log(`runtime.json: ${createdRuntimeConfig ? 'created' : 'exists'}`);
+  log(`.env: ${createdEnv ? 'created (edit this file)' : 'exists'}`);
+  log(`mount-allowlist.json: ${createdAllowlist ? 'created (edit to enable mounts)' : 'exists'}`);
+}
+
+function printNextSteps() {
+  log('\nNext steps:');
+  log(`1) Edit ${ENV_PATH} with your Telegram bot token and OpenRouter API key`);
+  log(`2) (Optional) Edit ${path.join(CONFIG_DIR, 'runtime.json')} for tuning`);
+  log('3) Build the container: dotclaw build');
+  log('4) Register your chat: dotclaw register');
+  log('5) Start the service: dotclaw start');
+}
+
+checkDocker();
+initFiles();
+printNextSteps();