chore: remove dead code, eliminate thin layers, fix lint warnings

- Remove dead exports: detectClaudeCli, formatCost, KvStore (write-only)
- Eliminate SessionManager layer — absorb addMessage into SessionStore
- Inline agent context-builder and prompts into agent.ts
- Deduplicate result-parsing in claude-code provider
- Extract buildReplyAndProgress helper in telegram adapter
- Fix all 7 noNonNullAssertion lint warnings
- Wrap session message insert + update in db.transaction()

Net: -281 lines, 77 tests pass, 0 lint warnings.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: bluedbird

packages/agent/src/agent.ts

@@ -1,9 +1,28 @@
-import type { ProviderAdapter, UsageStats } from '@homie/core';
+import type {
+  Message,
+  ProgressCallback,
+  ProviderAdapter,
+  ProviderMessage,
+  UsageStats,
+} from '@homie/core';
 import { createLogger } from '@homie/observability';
-import { type AgentInput, buildMessages } from './context-builder';
 
 const log = createLogger('agent');
 
+const SYSTEM_PROMPT = 'You are Homie. Keep responses concise (Telegram chat).';
+
+export interface AgentInput {
+  sessionId: string;
+  text: string;
+  history: Message[];
+  /** When true, skip resume and send full history (e.g. after an interrupted run) */
+  forceFullHistory?: boolean;
+  userId?: string;
+  onProgress?: ProgressCallback;
+  /** Signal to abort the in-flight agent run */
+  signal?: AbortSignal;
+}
+
 export interface AgentOutput {
   text: string;
   usage?: UsageStats;
@@ -50,3 +69,19 @@ export function createAgent(provider: ProviderAdapter, config: AgentConfig): Age
     },
   };
 }
+
+function buildMessages(input: AgentInput): ProviderMessage[] {
+  const messages: ProviderMessage[] = [{ role: 'system', content: SYSTEM_PROMPT }];
+
+  for (const msg of input.history) {
+    if (msg.direction === 'in') {
+      messages.push({ role: 'user', content: msg.text });
+    } else if (msg.direction === 'out') {
+      messages.push({ role: 'assistant', content: msg.text });
+    }
+  }
+
+  messages.push({ role: 'user', content: input.text });
+
+  return messages;
+}

packages/agent/src/context-builder.test.ts

@@ -1,2 +1,7 @@
-export { type Agent, type AgentConfig, type AgentOutput, createAgent } from './agent';
-export { type AgentInput, buildMessages } from './context-builder';
+export {
+  type Agent,
+  type AgentConfig,
+  type AgentInput,
+  type AgentOutput,
+  createAgent,
+} from './agent';

packages/agent/src/context-builder.ts

@@ -48,18 +48,18 @@ function toMarkdownV2(text: string): string {
       // `inline code`
       const inner = match[2].slice(1, -1);
       tokens.push({ raw: `\`${escapeV2Pre(inner)}\`` });
-    } else if (match[3]) {
+    } else if (match[3] && match[4]) {
       // **bold** → *bold*
-      tokens.push({ raw: `*${escapeV2(match[4]!)}*` });
-    } else if (match[5]) {
+      tokens.push({ raw: `*${escapeV2(match[4])}*` });
+    } else if (match[5] && match[6]) {
       // __italic__ → _italic_
-      tokens.push({ raw: `_${escapeV2(match[6]!)}_` });
-    } else if (match[7]) {
+      tokens.push({ raw: `_${escapeV2(match[6])}_` });
+    } else if (match[7] && match[8]) {
       // *italic* (single) — in standard markdown this is italic
-      tokens.push({ raw: `_${escapeV2(match[8]!)}_` });
-    } else if (match[9]) {
+      tokens.push({ raw: `_${escapeV2(match[8])}_` });
+    } else if (match[9] && match[10]) {
       // _italic_
-      tokens.push({ raw: `_${escapeV2(match[10]!)}_` });
+      tokens.push({ raw: `_${escapeV2(match[10])}_` });
     }
 
     cursor = match.index + match[0].length;
@@ -210,11 +210,16 @@ export function createTelegramAdapter(opts: {
     return allowedChatIds.size === 0 || allowedChatIds.has(chatId);
   }
 
-  async function dispatch(event: ChatMessageEvent, chatId: string): Promise<void> {
+  function buildReplyAndProgress(chatId: string) {
     const reply = async (replyText: string) => {
       await sendMessage({ chatId }, { text: replyText });
     };
     const progress = buildProgress(chatId);
+    return { reply, progress };
+  }
+
+  async function dispatch(event: ChatMessageEvent, chatId: string): Promise<void> {
+    const { reply, progress } = buildReplyAndProgress(chatId);
     await handler(event, reply, progress);
   }
 
@@ -234,17 +239,14 @@ export function createTelegramAdapter(opts: {
     const cmdMatch = text.match(/^\/(\w+)(?:\s+(.*))?$/s);
 
     if (cmdMatch) {
-      const reply = async (replyText: string) => {
-        await sendMessage({ chatId }, { text: replyText });
-      };
-      const progress = buildProgress(chatId);
+      const { reply, progress } = buildReplyAndProgress(chatId);
       await handler(
         {
           type: 'command',
           channel: 'telegram',
           chatId,
           userId,
-          command: cmdMatch[1]!,
+          command: cmdMatch[1] ?? '',
           args: (cmdMatch[2] ?? '').trim(),
           rawSourceId: messageId,
         },

packages/agent/src/index.ts

@@ -74,7 +74,12 @@ export interface ProviderAdapter {
 export interface SessionStore {
   getOrCreateByChat(channel: string, chatId: string, userId?: string | null): Promise<Session>;
   getById(sessionId: string): Promise<Session | null>;
-  appendMessage(message: Message): Promise<void>;
+  addMessage(
+    sessionId: string,
+    direction: Message['direction'],
+    text: string,
+    rawSourceId?: string | null,
+  ): Promise<Message>;
   listRecentMessages(sessionId: string, limit: number): Promise<Message[]>;
   setSessionStatus(sessionId: string, status: import('./types').SessionStatus): Promise<void>;
   resetStuckSessions(): Promise<number>;

packages/agent/src/prompts.ts

@@ -1,12 +1,11 @@
 import { Database } from 'bun:sqlite';
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
 import { createAgent } from '@homie/agent';
-import { AbortError, type Message, type ProviderAdapter } from '@homie/core';
+import { AbortError, type ProviderAdapter } from '@homie/core';
 import { schema } from '@homie/persistence/src/migrations';
 import { createSessionStore } from '@homie/persistence/src/session-store';
 import { createTaskStore } from '@homie/persistence/src/task-store';
 import { createUsageStore } from '@homie/persistence/src/usage-store';
-import { createSessionManager } from '@homie/sessions';
 import { type CommandContext, createCommandHandler } from './commands';
 import { createTaskRunner } from './task-runner';
 
@@ -43,34 +42,25 @@ describe('CommandHandler', () => {
 
   /** Helper: create a message and return its ID */
   async function addMessage(text: string): Promise<string> {
-    const msg: Message = {
-      id: crypto.randomUUID(),
-      sessionId,
-      direction: 'in',
-      text,
-      createdAt: new Date().toISOString(),
-      rawSourceId: null,
-    };
-    await sessionStore.appendMessage(msg);
+    const msg = await sessionStore.addMessage(sessionId, 'in', text);
     return msg.id;
   }
 
   beforeEach(async () => {
     db = createTestDb();
     sessionStore = createSessionStore(db);
-    const sessionManager = createSessionManager(sessionStore);
     const usageStore = createUsageStore(db);
     taskStore = createTaskStore(db);
 
-    const session = await sessionManager.resolveSession('telegram', 'chat1', 'user1');
+    const session = await sessionStore.getOrCreateByChat('telegram', 'chat1', 'user1');
     sessionId = session.id;
 
     const provider: ProviderAdapter = {
       generate: async () => ({ content: 'ok', usage: undefined }),
     };
     const agent = createAgent(provider, { model: 'test' });
     const runner = createTaskRunner({
-      sessionManager,
+      sessionStore,
       agent,
       taskStore,
       usageStore,
@@ -209,10 +199,9 @@ describe('CommandHandler', () => {
     };
     const agent = createAgent(blockingProvider, { model: 'test' });
     const abortSessionStore = createSessionStore(db);
-    const sessionManager = createSessionManager(abortSessionStore);
     const usageStore = createUsageStore(db);
     const blockingRunner = createTaskRunner({
-      sessionManager,
+      sessionStore: abortSessionStore,
       agent,
       taskStore,
       usageStore,
@@ -224,7 +213,7 @@ describe('CommandHandler', () => {
       usageStore,
     });
 
-    const session = await sessionManager.resolveSession('telegram', 'chat-abort', 'user1');
+    const session = await abortSessionStore.getOrCreateByChat('telegram', 'chat-abort', 'user1');
     await blockingRunner.submit({
       channel: 'telegram',
       chatId: 'chat-abort',

packages/channels/telegram/src/adapter.ts

@@ -1,7 +1,6 @@
 import { describe, expect, test } from 'bun:test';
 import {
   elapsedSince,
-  formatCost,
   formatElapsed,
   formatTokens,
   shortId,
@@ -51,22 +50,6 @@ describe('timeSince', () => {
   });
 });
 
-describe('formatCost', () => {
-  test('zero', () => {
-    expect(formatCost(0)).toBe('$0.00');
-  });
-
-  test('small amounts use 4 decimals', () => {
-    expect(formatCost(0.0042)).toBe('$0.0042');
-    expect(formatCost(0.001)).toBe('$0.0010');
-  });
-
-  test('larger amounts use 2 decimals', () => {
-    expect(formatCost(0.12)).toBe('$0.12');
-    expect(formatCost(1.5)).toBe('$1.50');
-  });
-});
-
 describe('formatTokens', () => {
   test('small counts', () => {
     expect(formatTokens(0)).toBe('0');

packages/core/src/interfaces.ts

@@ -18,13 +18,6 @@ export function timeSince(iso: string): string {
   return `${days}d`;
 }
 
-/** Format USD cost (e.g. "$0.12", "$0.0042") */
-export function formatCost(usd: number): string {
-  if (usd === 0) return '$0.00';
-  if (usd < 0.01) return `$${usd.toFixed(4)}`;
-  return `$${usd.toFixed(2)}`;
-}
-
 /** Format token count (e.g. "45.2k", "1.2M") */
 export function formatTokens(count: number): string {
   if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;