@a1hvdy/cc-openclaw 0.9.2 → 0.11.0

package/dist/src/command-router/cc-handler.js

@@ -14,271 +14,29 @@
  *   /cc resume [id|slug]   — resume by session ID (8-char hex) or slug
  *   /cc list               — show resumable sessions for this chat
  */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as crypto from 'node:crypto';
-import { request as httpsRequest } from 'node:https';
 import { defaultRegisterGuard } from '../lib/register-guard.js';
 import { VENDOR_FILES } from '../lib/vendor-paths.js';
+import { loadBotToken, sendDirectReply, hasBotToken, buildPhase2FlagsLine, buildObservabilityLines, } from './turn-formatter.js';
+import { loadSessionIndex, saveSession, scanAllSessions, makeSlug, generateSessionId, sessionMapKey, launchSession, recoverSessions, } from './launch-policy.js';
+import { handleContinuation, handleResume, } from './resume-policy.js';
 // ── Constants ─────────────────────────────────────────────────────────────
 const PLUGIN_TAG = '[cc-openclaw/command-router]';
 const CC_PLUGIN_PATH = VENDOR_FILES.sessionManager;
-const SESSIONS_DIR = '/home/a1xai/.openclaw/sessions';
-const SESSIONS_INDEX_PATH = path.join(SESSIONS_DIR, 'index.json');
-const DEFAULT_CWD = '/home/a1xai/.openclaw';
-const IDLE_TIMEOUT_MS = 15 * 60 * 1000; // 15 min
-const ACK_TIMEOUT_MS = 5_000;
-// v0.6.0 — post-turn context-management thresholds for Telegram/Savvy path.
-// The OpenAI-compat HTTP path has its own AUTO_COMPACT_THRESHOLD; cc-handler
-// (Telegram path) was missing this entirely — long sessions accumulated
-// indefinitely until manual kill. Importing instead of redefining so a
-// single source of truth in constants.ts stays canonical.
-import { CC_AUTO_COMPACT_THRESHOLD, CC_HARD_RESET_THRESHOLD } from '../constants.js';
-// Track last compaction attempt per session — avoid hammering /compact when
-// a turn finishes near-threshold and the next turn pushes it over again
-// before /compact's effect lands. 60s cooldown is plenty.
-const _lastCompactAt = new Map();
-const COMPACT_COOLDOWN_MS = 60_000;
-/**
- * Post-turn context-pressure check. Called after every successful sendMessage.
- * - At ≥ CC_HARD_RESET_THRESHOLD: stop the session (recreated on next turn).
- *   Surfaces a Telegram message so the user knows context was reset.
- * - At ≥ CC_AUTO_COMPACT_THRESHOLD: in-place /compact via stdin. ~10-30s,
- *   non-blocking for the current turn (fire-and-forget; the compaction lands
- *   before the user's next message hits the queue per the per-session
- *   promise chain in SessionManager.sendMessage).
- *
- * Idempotent: cooldown prevents duplicate /compact calls within 60s.
- * Non-fatal: failures logged + swallowed so a compaction error never breaks
- * the user-visible answer-delivery path.
- */
-async function _postTurnContextCheck(mgr, sessionName, chatId, threadId) {
-    try {
-        const status = mgr.getStatus(sessionName);
-        const pct = status?.stats?.contextPercent ?? 0;
-        if (pct >= CC_HARD_RESET_THRESHOLD) {
-            logger.warn(`${PLUGIN_TAG} [ctx-mgmt] ${sessionName} at ${pct}% — hard-resetting session`);
-            try {
-                await mgr.stopSession(sessionName);
-            }
-            catch (e) {
-                logger.warn(`${PLUGIN_TAG} hard-reset stopSession failed: ${e instanceof Error ? e.message : String(e)}`);
-            }
-            if (chatId) {
-                try {
-                    await sendDirectReply(chatId, threadId, `⚠️ Session context reached ${pct}% — auto-reset. Your next message starts fresh.`);
-                }
-                catch { /* best effort */ }
-            }
-            return;
-        }
-        if (pct >= CC_AUTO_COMPACT_THRESHOLD) {
-            const lastAttempt = _lastCompactAt.get(sessionName) || 0;
-            if (Date.now() - lastAttempt < COMPACT_COOLDOWN_MS) {
-                return; // recent compact attempt — let it settle
-            }
-            _lastCompactAt.set(sessionName, Date.now());
-            logger.info(`${PLUGIN_TAG} [ctx-mgmt] ${sessionName} at ${pct}% — running /compact`);
-            if (typeof mgr.compactSession === 'function') {
-                // Fire-and-forget: SessionManager serializes via per-session promise chain,
-                // so the next user turn will block on this compact (correct behavior).
-                mgr.compactSession(sessionName).catch((e) => {
-                    logger.warn(`${PLUGIN_TAG} compactSession failed for ${sessionName}: ${e instanceof Error ? e.message : String(e)}`);
-                });
-            }
-        }
-    }
-    catch (e) {
-        logger.warn(`${PLUGIN_TAG} _postTurnContextCheck error: ${e instanceof Error ? e.message : String(e)}`);
-    }
-}
-// Max age for session recovery on warm restart.
-const RECOVERY_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h
-const OPENCLAW_CONFIG_PATH = '/home/a1xai/.openclaw/openclaw.json';
-// ── Telegram Direct Send ──────────────────────────────────────────────────
-let BOT_TOKEN = '';
-function loadBotToken() {
-    if (BOT_TOKEN)
-        return;
-    try {
-        const raw = fs.readFileSync(OPENCLAW_CONFIG_PATH, 'utf8');
-        const cfg = JSON.parse(raw);
-        const tg = cfg.channels?.telegram;
-        if (tg?.accounts) {
-            const acctKey = tg.defaultAccount || 'default';
-            const acct = tg.accounts[acctKey] || {};
-            BOT_TOKEN = acct.botToken || '';
-        }
-        if (BOT_TOKEN)
-            logger.info(`${PLUGIN_TAG} Bot token loaded for direct replies`);
-    }
-    catch (err) {
-        logger.warn(`${PLUGIN_TAG} Failed to load bot token: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-function telegramApiDirect(method, params) {
-    return new Promise((resolve, reject) => {
-        const body = JSON.stringify(params);
-        const options = {
-            hostname: 'api.telegram.org',
-            path: `/bot${BOT_TOKEN}/${method}`,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Content-Length': Buffer.byteLength(body),
-            },
-        };
-        const req = httpsRequest(options, (res) => {
-            let data = '';
-            res.on('data', (chunk) => (data += chunk));
-            res.on('end', () => {
-                try {
-                    resolve(JSON.parse(data));
-                }
-                catch {
-                    resolve({ ok: false });
-                }
-            });
-        });
-        req.on('error', reject);
-        req.setTimeout(10_000, () => req.destroy(new Error('Telegram API timeout')));
-        req.write(body);
-        req.end();
-    });
-}
-async function sendDirectReply(chatId, threadId, text) {
-    if (!BOT_TOKEN || !chatId)
-        return null;
-    try {
-        const params = {
-            chat_id: chatId,
-            text,
-            disable_web_page_preview: true,
-        };
-        if (threadId)
-            params.message_thread_id = Number(threadId);
-        const res = await telegramApiDirect('sendMessage', params);
-        if (!res.ok) {
-            logger.warn(`${PLUGIN_TAG} Direct reply failed: ${JSON.stringify(res.description || res)}`);
-            return null;
-        }
-        return res.result?.message_id ?? null;
-    }
-    catch (err) {
-        logger.warn(`${PLUGIN_TAG} Direct reply error: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-}
-// ── Slug Generator ────────────────────────────────────────────────────────
-const FILLER_WORDS = new Set([
-    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-    'should', 'may', 'might', 'shall', 'can', 'to', 'of', 'in', 'for',
-    'on', 'with', 'at', 'by', 'from', 'it', 'its', 'this', 'that', 'and',
-    'or', 'but', 'not', 'so', 'if', 'then', 'than', 'just', 'also',
-    'very', 'really', 'please', 'me', 'my', 'i',
-]);
-function makeSlug(instruction) {
-    const tokens = instruction
-        .toLowerCase()
-        .replace(/[^a-z0-9\s-]/g, '')
-        .split(/\s+/)
-        .filter((t) => t.length > 0 && !FILLER_WORDS.has(t));
-    const suffix = Date.now().toString(36).slice(-4);
-    if (tokens.length === 0) {
-        return `task-${suffix}`;
-    }
-    let slug = tokens.slice(0, 4).join('-');
-    if (slug.length > 24) {
-        slug = slug.slice(0, 24).replace(/-$/, '');
-    }
-    return `${slug}-${suffix}`;
-}
-// ── Session ID Generator ──────────────────────────────────────────────────
-function generateSessionId() {
-    return crypto.randomBytes(4).toString('hex');
-}
-// ── Session Index ─────────────────────────────────────────────────────────
-let sessionIndex = {};
-function loadSessionIndex() {
-    try {
-        if (fs.existsSync(SESSIONS_INDEX_PATH)) {
-            sessionIndex = JSON.parse(fs.readFileSync(SESSIONS_INDEX_PATH, 'utf8'));
-        }
-    }
-    catch {
-        sessionIndex = {};
-    }
-}
-function saveSessionIndex() {
-    try {
-        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
-        const tmp = SESSIONS_INDEX_PATH + '.tmp';
-        fs.writeFileSync(tmp, JSON.stringify(sessionIndex, null, 2));
-        fs.renameSync(tmp, SESSIONS_INDEX_PATH);
-    }
-    catch { /* best effort */ }
-}
-// ── Session Store ─────────────────────────────────────────────────────────
-function saveSession(meta) {
-    const dir = path.join(SESSIONS_DIR, meta.slug);
-    fs.mkdirSync(dir, { recursive: true });
-    const filePath = path.join(dir, 'session.json');
-    const tmp = filePath + '.tmp';
-    fs.writeFileSync(tmp, JSON.stringify(meta, null, 2));
-    fs.renameSync(tmp, filePath);
-    if (meta.id) {
-        sessionIndex[meta.id] = meta.slug;
-        saveSessionIndex();
-    }
-}
-function loadSession(slug) {
-    const filePath = path.join(SESSIONS_DIR, slug, 'session.json');
-    try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-function loadSessionById(id) {
-    const slug = sessionIndex[id];
-    if (slug)
-        return loadSession(slug);
-    const all = scanAllSessions();
-    const match = all.find((s) => s.id === id);
-    if (match) {
-        sessionIndex[id] = match.slug;
-        saveSessionIndex();
-    }
-    return match ?? null;
-}
-function scanAllSessions() {
-    const results = [];
-    try {
-        if (!fs.existsSync(SESSIONS_DIR))
-            return results;
-        const entries = fs.readdirSync(SESSIONS_DIR, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const meta = loadSession(entry.name);
-            if (meta && meta.slug && meta.chatId) {
-                results.push(meta);
-            }
-        }
-    }
-    catch {
-        // Best effort — if sessions dir is unreadable, return empty
-    }
-    return results;
-}
+// DispatchResult is imported from ./launch-policy.js (shared with resume-policy.ts).
+// CcConfig and SessionManagerLike are imported from ./launch-policy.js
+// (Phase 5 v0.11.0 decomposition — single source of truth for shared types).
 // ── Plugin Entry ──────────────────────────────────────────────────────────
+// (Slug generator, session ID generator, session index, session store, and
+//  sessionMapKey were extracted to launch-policy.ts in Phase 5 v0.11.0.)
 let logger = console;
 let sessionManager = null;
 const activeSessions = new Map();
-function sessionMapKey(chatId, threadId) {
-    return threadId ? `${chatId}:${threadId}` : String(chatId);
+// PolicyDeps builder — cc-handler.ts owns singletons; policy functions receive
+// them explicitly per PRP §7 Q3. Call sites use `_deps()` to avoid repeating
+// the three-field literal. `sessionManager!` is safe: every call site has
+// already null-checked or the surrounding service.start guarantees it.
+function _deps() {
+    return { sessionManager: sessionManager, activeSessions, logger };
 }
 // ── parseCcCommand — pure exported parser ─────────────────────────────────
 /**
@@ -344,11 +102,6 @@ export function parseCcCommand(input) {
     return { subcommand: 'new', prompt: afterCc };
 }
 // ── Status Handler ────────────────────────────────────────────────────────
-function buildPhase2FlagsLine() {
-    const allowBuiltins = process.env.CC_OPENCLAW_ALLOW_BUILTINS === '1';
-    const toolStream = process.env.CC_OPENCLAW_TOOL_STREAM === '1';
-    return `Flags: builtins=${allowBuiltins ? 'on' : 'off'} | toolstream=${toolStream ? 'on' : 'off'}`;
-}
 function handleStatus(chatId, threadId) {
     const key = sessionMapKey(chatId, threadId);
     const active = activeSessions.get(key);
@@ -379,53 +132,6 @@ function handleStatus(chatId, threadId) {
         text: `Active: [${id}] ${active.slug} (${turns} turn${turns > 1 ? 's' : ''}, ${elapsed}s)\n${obsLines}\n${flagsLine}`,
     };
 }
-/**
- * Pillar C v0.4.0 — compose observability lines for /cc status panel.
- * Reads from Pillar A metrics, Pillar B trajectory tail, and status-tee
- * quota snapshot. Each source is independently fault-tolerant: if one
- * fails, the line shows "?" rather than crashing the panel.
- */
-function buildObservabilityLines() {
-    const lines = [];
-    // Plan quota (status-tee)
-    try {
-        // Lazy require so this file remains testable without status-tee
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { readQuotaSnapshot, formatQuotaLine } = require('../lib/status-tee-reader.js');
-        lines.push(formatQuotaLine(readQuotaSnapshot()));
-    }
-    catch {
-        lines.push('Plan: ?%');
-    }
-    // Workers + uptime + last error (Pillar A metrics)
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { metricsRegistry } = require('../health/metrics.js');
-        const out = metricsRegistry.serializePrometheus();
-        const workersMatch = /cc_openclaw_workers (\d+)/.exec(out);
-        const uptimeMatch = /cc_openclaw_uptime_seconds (\d+)/.exec(out);
-        const lastErrMatch = /cc_openclaw_last_error_seconds (\d+)/.exec(out);
-        const errorsMatch = /cc_openclaw_errors_total (\d+)/.exec(out);
-        const workers = workersMatch ? workersMatch[1] : '?';
-        const uptime = uptimeMatch ? Math.floor(parseInt(uptimeMatch[1], 10) / 60) : '?';
-        lines.push(`Workers: ${workers} | Uptime: ${uptime}m`);
-        const errCount = errorsMatch ? parseInt(errorsMatch[1], 10) : 0;
-        const lastErrTs = lastErrMatch ? parseInt(lastErrMatch[1], 10) : 0;
-        if (errCount === 0 || lastErrTs === 0) {
-            lines.push('Last error: none');
-        }
-        else {
-            const agoSec = Math.floor(Date.now() / 1000) - lastErrTs;
-            const agoLabel = agoSec < 60 ? `${agoSec}s` : agoSec < 3600 ? `${Math.floor(agoSec / 60)}m` : `${Math.floor(agoSec / 3600)}h`;
-            lines.push(`Last error: ${agoLabel} ago (${errCount} total)`);
-        }
-    }
-    catch {
-        lines.push('Workers: ? | Uptime: ?');
-        lines.push('Last error: ?');
-    }
-    return lines.join('\n');
-}
 // ── List Handler ──────────────────────────────────────────────────────────
 function handleList(chatId, threadId) {
     const sessions = scanAllSessions()
@@ -455,78 +161,7 @@ function handleList(chatId, threadId) {
     };
 }
 // ── Continuation Handler ──────────────────────────────────────────────────
-function handleContinuation(prompt, chatId, threadId) {
-    if (!sessionManager) {
-        return {
-            handled: true,
-            text: 'Claude Code handler not ready — try again in a few seconds.',
-        };
-    }
-    const key = sessionMapKey(chatId, threadId);
-    const active = activeSessions.get(key);
-    if (!active) {
-        return {
-            handled: true,
-            text: 'No active session to continue. Start one with /cc <prompt> or /cc resume',
-        };
-    }
-    if (active.needsRehydration) {
-        if (!active.meta.claudeSessionId) {
-            activeSessions.delete(key);
-            return {
-                handled: true,
-                text: 'Recovered session has no Claude ID — start fresh with /cc <prompt>',
-            };
-        }
-        logger.info(`${PLUGIN_TAG} /cc+ rehydrating recovered session: slug=${active.slug} chat=${chatId} thread=${threadId || 'none'}`);
-        let resolveAckId;
-        const ackIdPromise = new Promise((r) => {
-            resolveAckId = r;
-        });
-        (async () => {
-            try {
-                await rehydrateSession(active.meta, chatId, threadId);
-                active.needsRehydration = false;
-                await continueTurn(active, prompt, chatId, threadId, ackIdPromise);
-            }
-            catch (err) {
-                logger.error(`${PLUGIN_TAG} Rehydrate+continue ${active.slug} failed: ${err instanceof Error ? err.message : String(err)}`);
-                scheduleIdle(key, active);
-            }
-        })();
-        return {
-            handled: true,
-            text: `⏳ [${active.meta.id || '?'}] Resuming & continuing ${active.slug}...`,
-            _resolveAckId: resolveAckId,
-        };
-    }
-    try {
-        sessionManager.getStatus(active.sessionName);
-    }
-    catch {
-        activeSessions.delete(key);
-        return {
-            handled: true,
-            text: 'Previous session expired. Use /cc resume or start fresh with /cc <prompt>',
-        };
-    }
-    if (active.idleTimer)
-        clearTimeout(active.idleTimer);
-    logger.info(`${PLUGIN_TAG} /cc+ continuation: slug=${active.slug} chat=${chatId} thread=${threadId || 'none'}`);
-    let resolveAckId;
-    const ackIdPromise = new Promise((r) => {
-        resolveAckId = r;
-    });
-    continueTurn(active, prompt, chatId, threadId, ackIdPromise).catch((err) => {
-        logger.error(`${PLUGIN_TAG} Continuation ${active.slug} failed: ${err instanceof Error ? err.message : String(err)}`);
-        scheduleIdle(key, active);
-    });
-    return {
-        handled: true,
-        text: `⏳ [${active.meta.id || '?'}] Continuing ${active.slug}...`,
-        _resolveAckId: resolveAckId,
-    };
-}
+// handleContinuation moved to resume-policy.ts in Step 4 of v0.11.0 decomposition.
 // ── Stop Handler ──────────────────────────────────────────────────────────
 function handleStop(chatId, threadId) {
     if (!sessionManager) {
@@ -563,327 +198,12 @@ function handleStop(chatId, threadId) {
     };
 }
 // ── Resume Handler ────────────────────────────────────────────────────────
-function handleResume(chatId, threadId, targetSlug) {
-    if (!sessionManager) {
-        return { handled: true, text: 'Claude Code handler not ready.' };
-    }
-    const key = sessionMapKey(chatId, threadId);
-    const currentActive = activeSessions.get(key);
-    if (currentActive) {
-        return {
-            handled: true,
-            text: `Already have active session: ${currentActive.slug}\nUse /cc stop first, or /cc+ to continue it.`,
-        };
-    }
-    let meta = null;
-    if (targetSlug) {
-        const isSessionId = /^[0-9a-f]{8}$/i.test(targetSlug);
-        if (isSessionId) {
-            meta = loadSessionById(targetSlug.toLowerCase());
-        }
-        if (!meta) {
-            meta = loadSession(targetSlug);
-        }
-        if (!meta) {
-            return { handled: true, text: `Session "${targetSlug}" not found.` };
-        }
-        if (meta.chatId !== chatId) {
-            return {
-                handled: true,
-                text: `Session "${targetSlug}" belongs to a different chat.`,
-            };
-        }
-    }
-    else {
-        const candidates = scanAllSessions()
-            .filter((s) => s.chatId === chatId &&
-            (s.threadId || undefined) === (threadId || undefined) &&
-            !!s.claudeSessionId)
-            .sort((a, b) => {
-            const timeA = new Date(a.lastContinuedAt || a.completedAt || a.startedAt).getTime();
-            const timeB = new Date(b.lastContinuedAt || b.completedAt || b.startedAt).getTime();
-            return timeB - timeA;
-        });
-        if (candidates.length === 0) {
-            return {
-                handled: true,
-                text: 'No resumable session found. Start fresh with /cc <prompt>',
-            };
-        }
-        meta = candidates[0];
-    }
-    if (!meta.claudeSessionId) {
-        return {
-            handled: true,
-            text: `Session ${meta.slug} has no Claude session ID — cannot resume.\nStart fresh with /cc <prompt>`,
-        };
-    }
-    const { slug, id: resumeId } = meta;
-    logger.info(`${PLUGIN_TAG} /cc resume: id=${resumeId} slug=${slug} claudeId=${meta.claudeSessionId} chat=${chatId} thread=${threadId || 'none'}`);
-    rehydrateSession(meta, chatId, threadId).catch((err) => {
-        logger.error(`${PLUGIN_TAG} Resume ${slug} failed: ${err instanceof Error ? err.message : String(err)}`);
-        meta.state = 'failed';
-        meta.error = `Resume failed: ${err instanceof Error ? err.message : String(err)}`;
-        try {
-            saveSession(meta);
-        }
-        catch { /* best effort */ }
-        const active = activeSessions.get(key);
-        if (active?.slug === slug) {
-            if (active.idleTimer)
-                clearTimeout(active.idleTimer);
-            activeSessions.delete(key);
-        }
-    });
-    return { handled: true, text: `⏳ [${resumeId || '?'}] Resuming ${slug}...` };
-}
-// ── Session Launcher ──────────────────────────────────────────────────────
-async function launchSession(sessionName, prompt, slug, meta, chatId, threadId, ackIdPromise) {
-    logger.info(`${PLUGIN_TAG} Starting session ${sessionName}...`);
-    const key = sessionMapKey(chatId, threadId);
-    // v0.8.0 Fix 4: drop customSessionId pre-assignment. Pre-v0.8.0 we
-    // generated a UUID via crypto.randomUUID() and forced it into claude.exe
-    // via --session-id, then stored that same UUID as meta.claudeSessionId.
-    // Risk: if Claude CLI's --session-id semantics ever drift (e.g. it stops
-    // honoring the override and assigns its own UUID anyway), the stored
-    // meta.claudeSessionId no longer matches the actual JSONL filename in
-    // ~/.claude/projects/, breaking resume. Adopt the openai-compat pattern:
-    // let claude.exe assign its own UUID via system.init event, then read it
-    // back. meta.claudeSessionId is updated after the first turn completes
-    // (line below — `meta.claudeSessionId = result?.sessionId`). One source
-    // of truth: the CLI's authoritative session_id.
-    meta.state = 'starting';
-    try {
-        saveSession(meta);
-    }
-    catch { /* best effort */ }
-    await sessionManager.startSession({
-        name: sessionName,
-        cwd: DEFAULT_CWD,
-        engine: 'claude',
-        permissionMode: 'bypassPermissions',
-        effort: 'high',
-    });
-    meta.state = 'running';
-    try {
-        saveSession(meta);
-    }
-    catch { /* best effort */ }
-    const prevActive = activeSessions.get(key);
-    if (prevActive && prevActive.sessionName !== sessionName) {
-        if (prevActive.idleTimer)
-            clearTimeout(prevActive.idleTimer);
-        try {
-            await sessionManager.stopSession(prevActive.sessionName);
-        }
-        catch { /* may already be gone */ }
-    }
-    const activeEntry = { sessionName, slug, meta, idleTimer: null };
-    activeSessions.set(key, activeEntry);
-    logger.info(`${PLUGIN_TAG} Session ${sessionName} started — sending prompt...`);
-    const opts = { telegramChatId: chatId };
-    if (threadId)
-        opts.telegramThreadId = threadId;
-    const ackMsgId = await Promise.race([
-        ackIdPromise,
-        new Promise((r) => setTimeout(() => r(null), ACK_TIMEOUT_MS)),
-    ]);
-    if (ackMsgId)
-        opts.telegramAckMessageId = ackMsgId;
-    const result = await sessionManager.sendMessage(sessionName, prompt, opts);
-    meta.state = 'idle';
-    meta.turns = 1;
-    meta.completedAt = new Date().toISOString();
-    meta.output = (result?.output || '').slice(0, 2000);
-    meta.claudeSessionId = result?.sessionId ?? meta.claudeSessionId;
-    try {
-        saveSession(meta);
-    }
-    catch { /* best effort */ }
-    // v0.6.0: post-turn context-pressure check.
-    // Fires /compact at CC_AUTO_COMPACT_THRESHOLD (70%) and hard-resets at
-    // CC_HARD_RESET_THRESHOLD (90%). Was previously absent — Telegram path
-    // had no context-management at all, requiring manual session kill.
-    void _postTurnContextCheck(sessionManager, sessionName, chatId, threadId);
-    // 2026-05-07 FIX — direct answer delivery via cc-handler.
-    // The live-card pipeline's queue.sendMessage path was silently dropping
-    // /cc answer text (gateOpens=true but Telegram never received). Diagnosed
-    // via stderr instrumentation 2026-05-07: result.output = "10" extracted
-    // correctly but never reached the user. cc-handler is the orchestrator —
-    // it has authoritative knowledge of (chatId, threadId, answer text).
-    // Delivering directly here closes the loop reliably. If/when cc-openclaw
-    // Phase 2 ships native tool-stream wire fidelity, this can stay as the
-    // belt-and-suspenders final-delivery guarantee.
-    if (result?.output && chatId) {
-        try {
-            await sendDirectReply(chatId, threadId, result.output);
-        }
-        catch (e) {
-            logger.warn(`${PLUGIN_TAG} Direct answer delivery failed for ${sessionName}: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
-    logger.info(`${PLUGIN_TAG} Session ${sessionName} turn 1 complete — idle for ${IDLE_TIMEOUT_MS / 1000}s`);
-    scheduleIdle(key, activeEntry);
-}
-// ── Rehydrate Session ─────────────────────────────────────────────────────
-async function rehydrateSession(meta, chatId, threadId) {
-    const { slug, sessionName, claudeSessionId } = meta;
-    const key = sessionMapKey(chatId, threadId);
-    logger.info(`${PLUGIN_TAG} Rehydrating ${sessionName} with claudeSessionId=${claudeSessionId}...`);
-    await sessionManager.startSession({
-        name: sessionName,
-        cwd: meta.cwd || DEFAULT_CWD,
-        engine: 'claude',
-        permissionMode: 'bypassPermissions',
-        effort: 'high',
-        resumeSessionId: claudeSessionId,
-    });
-    const prevActive = activeSessions.get(key);
-    if (prevActive && prevActive.sessionName !== sessionName) {
-        if (prevActive.idleTimer)
-            clearTimeout(prevActive.idleTimer);
-        try {
-            await sessionManager.stopSession(prevActive.sessionName);
-        }
-        catch { /* ignore */ }
-    }
-    meta.state = 'idle';
-    meta.threadId = threadId;
-    meta.lastContinuedAt = new Date().toISOString();
-    try {
-        saveSession(meta);
-    }
-    catch { /* best effort */ }
-    const activeEntry = { sessionName, slug, meta, idleTimer: null };
-    activeSessions.set(key, activeEntry);
-    logger.info(`${PLUGIN_TAG} Session ${sessionName} resumed — idle for ${IDLE_TIMEOUT_MS / 1000}s`);
-    scheduleIdle(key, activeEntry);
-}
-// ── Continuation Turn ─────────────────────────────────────────────────────
-async function continueTurn(active, prompt, chatId, threadId, ackIdPromise) {
-    const { sessionName, meta } = active;
-    const key = sessionMapKey(chatId, threadId);
-    meta.state = 'running';
-    try {
-        saveSession(meta);
-    }
-    catch { /* best effort */ }
-    const opts = { telegramChatId: chatId };
-    if (threadId)
-        opts.telegramThreadId = threadId;
-    const ackMsgId = await Promise.race([
-        ackIdPromise,
-        new Promise((r) => setTimeout(() => r(null), ACK_TIMEOUT_MS)),
-    ]);
-    if (ackMsgId)
-        opts.telegramAckMessageId = ackMsgId;
-    const result = await sessionManager.sendMessage(sessionName, prompt, opts);
-    meta.state = 'idle';
-    meta.turns = (meta.turns || 1) + 1;
-    meta.lastContinuedAt = new Date().toISOString();
-    meta.output = (result?.output || '').slice(0, 2000);
-    meta.claudeSessionId = result?.sessionId ?? meta.claudeSessionId;
-    try {
-        saveSession(meta);
-    }
-    catch { /* best effort */ }
-    // v0.6.0: post-turn context-pressure check (continuation turn).
-    // Same logic as the start path — see _postTurnContextCheck.
-    void _postTurnContextCheck(sessionManager, sessionName, chatId, threadId);
-    // 2026-05-07 FIX — direct answer delivery (continuation turn).
-    // See start-path comment for rationale.
-    if (result?.output && chatId) {
-        try {
-            await sendDirectReply(chatId, threadId, result.output);
-        }
-        catch (e) {
-            logger.warn(`${PLUGIN_TAG} Direct answer delivery failed for ${sessionName} (continuation): ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
-    logger.info(`${PLUGIN_TAG} Session ${sessionName} turn ${meta.turns} complete`);
-    scheduleIdle(key, active);
-}
-// ── Idle Timer ────────────────────────────────────────────────────────────
-function scheduleIdle(key, active) {
-    if (active.idleTimer)
-        clearTimeout(active.idleTimer);
-    active.idleTimer = setTimeout(() => {
-        logger.info(`${PLUGIN_TAG} Session ${active.sessionName} idle timeout — stopping`);
-        try {
-            sessionManager
-                ?.stopSession(active.sessionName)
-                .catch((e) => logger.warn(`${PLUGIN_TAG} idle stop error: ${e.message}`));
-        }
-        catch { /* may already be gone */ }
-        activeSessions.delete(key);
-        active.meta.state = 'idle';
-        active.meta.completedAt = new Date().toISOString();
-        try {
-            saveSession(active.meta);
-        }
-        catch { /* best effort */ }
-    }, IDLE_TIMEOUT_MS);
-}
-// ── Warm-Restart Recovery ─────────────────────────────────────────────────
-function recoverSessions() {
-    const now = Date.now();
-    const allSessions = scanAllSessions();
-    let indexDirty = false;
-    for (const meta of allSessions) {
-        if (!meta.id) {
-            meta.id = generateSessionId();
-            sessionIndex[meta.id] = meta.slug;
-            indexDirty = true;
-            try {
-                saveSession(meta);
-            }
-            catch { /* best effort */ }
-            logger.info(`${PLUGIN_TAG} Backfilled session ID ${meta.id} for ${meta.slug}`);
-        }
-        else if (!sessionIndex[meta.id]) {
-            sessionIndex[meta.id] = meta.slug;
-            indexDirty = true;
-        }
-    }
-    if (indexDirty)
-        saveSessionIndex();
-    let recovered = 0;
-    for (const meta of allSessions) {
-        if (!['running', 'idle', 'timed_out'].includes(meta.state))
-            continue;
-        const lastActivity = new Date(meta.lastContinuedAt || meta.completedAt || meta.startedAt).getTime();
-        if (now - lastActivity > RECOVERY_MAX_AGE_MS)
-            continue;
-        if (!meta.claudeSessionId)
-            continue;
-        const recoverKey = sessionMapKey(meta.chatId, meta.threadId);
-        if (activeSessions.has(recoverKey))
-            continue;
-        if (meta.state === 'running') {
-            meta.state = 'interrupted';
-            try {
-                saveSession(meta);
-            }
-            catch { /* best effort */ }
-        }
-        const activeEntry = {
-            sessionName: meta.sessionName,
-            slug: meta.slug,
-            meta,
-            idleTimer: null,
-            needsRehydration: true,
-        };
-        activeSessions.set(recoverKey, activeEntry);
-        recovered++;
-        logger.info(`${PLUGIN_TAG} Recovered session ${meta.slug} for chat ${meta.chatId} thread=${meta.threadId || 'none'} (was ${meta.state === 'interrupted' ? 'running' : 'idle'})`);
-    }
-    if (recovered > 0) {
-        logger.info(`${PLUGIN_TAG} Warm-restart recovery: ${recovered} session(s) restored`);
-    }
-    else {
-        logger.info(`${PLUGIN_TAG} Warm-restart recovery: no recent sessions to restore`);
-    }
-}
+// handleResume moved to resume-policy.ts in Step 4 of v0.11.0 decomposition.
+// rehydrateSession and continueTurn also moved there (called only by the
+// resume-policy handlers, so they live alongside them).
+// ── Session Launcher / Idle Timer / Recovery ──────────────────────────────
+// launchSession, scheduleIdle, recoverSessions moved to launch-policy.ts
+// in Step 3 of v0.11.0 decomposition.
 // ── Plugin Object & register() ────────────────────────────────────────────
 /**
  * Register the cc-handler plugin with the OpenClaw API.
@@ -917,7 +237,7 @@ export function register(api) {
         catch {
             logger.warn(`${PLUGIN_TAG} Could not read openclaw-claude-code config — using defaults`);
         }
-        loadBotToken();
+        loadBotToken(logger);
         // ── Lifecycle service ────────────────────────────────────────────────
         api.registerService({
             id: 'telegram-cc-handler',
@@ -956,7 +276,7 @@ export function register(api) {
                     }
                     sessionManager = new SessionManager(ccConfig);
                     logger.info(`${PLUGIN_TAG} SessionManager ready — /cc commands active`);
-                    recoverSessions();
+                    recoverSessions(_deps());
                 }
                 catch (err) {
                     logger.error(`${PLUGIN_TAG} Failed to init SessionManager: ${err instanceof Error ? err.message : String(err)}`);
@@ -998,7 +318,9 @@ export function register(api) {
                 const prompt = ccPlusMatch[1].trim();
                 if (!prompt)
                     return { handled: true, text: 'Usage: /cc+ <prompt>' };
-                return handleContinuation(prompt, chatId, threadId);
+                if (!sessionManager)
+                    return { handled: true, text: 'Claude Code handler not ready — try again in a few seconds.' };
+                return handleContinuation(_deps(), prompt, chatId, threadId);
             }
             if (!content.match(/^\/cc(\s|$)/i))
                 return undefined;
@@ -1008,7 +330,9 @@ export function register(api) {
                 const prompt = continueMatch[1].trim();
                 if (!prompt)
                     return { handled: true, text: 'Usage: /cc continue <prompt>' };
-                return handleContinuation(prompt, chatId, threadId);
+                if (!sessionManager)
+                    return { handled: true, text: 'Claude Code handler not ready — try again in a few seconds.' };
+                return handleContinuation(_deps(), prompt, chatId, threadId);
             }
             if (afterCc.toLowerCase() === 'stop') {
                 return handleStop(chatId, threadId);
@@ -1016,7 +340,9 @@ export function register(api) {
             const resumeMatch = afterCc.match(/^resume(?:\s+(.+))?$/i);
             if (resumeMatch) {
                 const targetSlug = (resumeMatch[1] || '').trim() || null;
-                return handleResume(chatId, threadId, targetSlug);
+                if (!sessionManager)
+                    return { handled: true, text: 'Claude Code handler not ready.' };
+                return handleResume(_deps(), chatId, threadId, targetSlug);
             }
             if (afterCc.toLowerCase() === 'status') {
                 return handleStatus(chatId, threadId);
@@ -1077,7 +403,7 @@ export function register(api) {
                 resolveAckId = r;
             });
             const launchKey = sessionMapKey(chatId, threadId);
-            launchSession(sessionName, prompt, slug, meta, chatId, threadId, ackIdPromise).catch((err) => {
+            launchSession(_deps(), sessionName, prompt, slug, meta, chatId, threadId, ackIdPromise).catch((err) => {
                 logger.error(`${PLUGIN_TAG} Session ${sessionName} failed: ${err.message}`);
                 try {
                     const isTimeout = /timeout/i.test(err.message);
@@ -1108,7 +434,7 @@ export function register(api) {
                 return result;
             if (event && typeof event === 'object')
                 event.content = '';
-            if (result.text && BOT_TOKEN) {
+            if (result.text && hasBotToken()) {
                 const convId = (ctx.conversationId || '').replace(/^telegram:/i, '');
                 const tm = convId.match(/^(-?\d+):topic:(\d+)$/);
                 const ackChat = tm
@@ -1118,7 +444,7 @@ export function register(api) {
                         : event.senderId || '';
                 const ackThread = tm ? tm[2] : undefined;
                 logger.info(`${PLUGIN_TAG} direct-send ack to chat=${ackChat} thread=${ackThread || 'none'}`);
-                const ackMessageId = await sendDirectReply(ackChat, ackThread, result.text);
+                const ackMessageId = await sendDirectReply(ackChat, ackThread, result.text, logger);
                 if (result._resolveAckId) {
                     result._resolveAckId(ackMessageId ?? null);
                 }