feat: replace task queue with interrupt-first request model

Replace the task-based queue (TaskRunner, TaskStore, UsageStore) with an
interrupt-first RequestRunner. New messages now abort the active request
and start immediately instead of queuing. Simplify sessions to use an
active_sessions pointer table, remove userId from events, and add
first-user lock in the Telegram adapter.

Fix Codex provider retrying after abort by checking the signal before
entering the resume-failure retry path. Fix non-cancellable 3s crash
retry sleep in Claude Code provider. Remove duplicate line in CLAUDE.md.

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

Author: bluedbird

CLAUDE.md

@@ -16,18 +16,17 @@ bun run format           # Biome format
 
 ## Architecture
 
-Homie is an async Telegram agent that wraps the local `claude` CLI. Users send messages via Telegram, Homie routes them through a gateway to Claude Code, and returns results. Every message becomes a task — there is no casual chat mode.
+Homie is an interrupt-first Telegram agent that wraps local coding CLIs like Codex and Claude Code. Users send messages via Telegram, Homie routes them through a gateway to the local provider, and returns results. The latest message always wins for a chat.
 
 ### Data flow
 
 ```
 Telegram message → TelegramAdapter → Gateway.handleEvent()
-  ├─ Command (/list, /status, etc.) → CommandHandler → reply
-  └─ Chat message → TaskRunner.submit() (queued, background)
-       → SessionManager (history)
-       → Agent.run() → buildMessages() → ClaudeCodeProvider.generate()
-       → spawns `claude` CLI with stream-json output
-       → parse response, save usage
+  ├─ Command (/status, /abort, /clear, /help) → CommandHandler → reply
+  └─ Chat message → RequestRunner.submit() (interrupts active request)
+       → SessionStore (active session + history)
+       → Agent.run() → buildMessages() → provider.generate()
+       → spawns provider CLI and parses streamed output
        → reply to user
 ```
 
@@ -37,21 +36,21 @@ Telegram message → TelegramAdapter → Gateway.handleEvent()
 core (types, interfaces, errors) ← everything depends on this
 config (YAML loader) ← src/
 observability (logger) ← most packages
-persistence (SQLite stores) ← sessions, gateway, src/
-sessions (session manager) ← gateway, src/
+persistence (SQLite stores) ← gateway, src/
 providers (claude CLI wrapper) ← agent, src/
 agent (context + provider orchestration) ← gateway, src/
-gateway (routing, commands, task-runner) ← src/, telegram
+gateway (routing, commands, request-runner) ← src/, telegram
 channels/telegram (grammy adapter) ← src/
 ```
 
 ### Key patterns
 
-- **No classes.** All modules use factory functions returning interfaces (e.g., `createSessionManager(store): SessionManager`).
+- **No classes.** All modules use factory functions returning interfaces.
 - **No build step.** Bun resolves `.ts` workspace imports directly via `tsconfig.json` path aliases (`@homie/core` → `./packages/core/src`).
 - **SQLite via `bun:sqlite`** with WAL mode. Inline migrations run on `openDatabase()`. Stores are synchronous under the hood but expose async interfaces.
-- **Task queue.** One task runs at a time per chat. New messages queue up (max 10). Sessions are hidden — one per chat, used internally for Claude CLI `--session-id` continuity.
-- **Provider resilience:** Session resume via `--resume`, fallback to full history replay, 1 crash retry with 3s backoff.
+- **Interrupt-first requests.** One request runs at a time per chat. A new message aborts the old request and starts immediately.
+- **Sessions.** Chats can have multiple stored sessions, but only one active session at a time. `/clear` creates a new active session without deleting old history.
+- **Telegram ownership.** The first Telegram user to message the bot becomes the only allowed user until restart.
 - **Preflight checks:** Server startup validates Telegram bot token (`getMe` API) and Claude Code auth (minimal prompt) in parallel before booting.
 
 ### Conventions

README.md

@@ -13,7 +13,6 @@ No API keys. No cloud billing. Just your existing CLI subscriptions.
 - **Remote control** — Telegram is your interface, your machine does the work
 - **Local agents** — wraps CLI agents you already have (Claude Code today, more coming)
 - **Zero API cost** — rides your existing subscriptions, no billing keys needed
-- **Async by design** — fire and forget, check results when you're ready
 - **Self-hosted** — your machine, your data, your agents
 
 ## Install
@@ -38,16 +37,16 @@ homie
 
 Requires [Bun](https://bun.sh) and a supported local agent CLI installed and authenticated. Homie verifies your Telegram token and the configured provider on startup before accepting messages.
 
-## Every message is a task
+## Every message is a priority request
 
-Every message you send becomes a task. Homie runs it and replies with the result.
+Every message you send starts a request. Homie runs it and replies with the result. Send a photo or file and Homie downloads it to a temp path so the agent can read it natively.
 
-If Homie is already working on something, your message gets queued and runs next — up to 10 deep. Send a photo or file and Homie downloads it to a temp path so the agent can read it natively.
+The first Telegram user to message the bot becomes the only allowed user until Homie restarts.
 
 ```
-/list            Recent tasks and their status
-/status          Running task, queue, and uptime
-/abort           Cancel the running task and clear the queue
+/status          Current request
+/abort           Interrupt the active request
+/clear           Start a new session
 /help            Show commands
 ```
 
@@ -56,20 +55,22 @@ If Homie is already working on something, your message gets queued and runs next
 ```
 Telegram message
   → Adapter (parse text, photos, documents)
-    → Gateway (resolve session, route command or submit task)
-      → Task runner (queue, execute one at a time per chat)
+    → Gateway (resolve active session, route command or submit request)
+      → Request runner (interrupt previous request, execute latest request per chat)
         → Agent (build message history, call provider)
           → Provider CLI (spawn subprocess, stream JSON/JSONL)
             → parse response → reply to user
 ```
 
-**Provider.** Homie wraps local agent CLIs behind a shared runtime contract. Claude Code uses `--output-format stream-json`; Codex uses `exec --json`. Homie parses streamed events, token usage, and final output, then forwards progress and replies back to Telegram.
+**Provider.** Homie wraps local agent CLIs behind a shared runtime contract. Claude Code uses `--output-format stream-json`; Codex uses `exec --json`. Homie parses streamed events and final output, then forwards progress and replies back to Telegram.
 
-**Session continuity.** Each chat gets one hidden session. On the first task, Homie sends the full conversation history. On subsequent tasks, it attempts the provider's native resume flow. If resume fails, it falls back to replaying full history in a fresh run. Claude retries once after a crash; Codex currently fails fast.
+**Session continuity.** Each chat has one active session. On the first request in a session, Homie sends the full conversation history. On subsequent requests, it attempts the provider's native resume flow. If resume fails, it falls back to replaying full history in a fresh request. Claude retries once after a crash; Codex currently fails fast.
 
-**Queue.** One task runs at a time per chat. The rest sit in an in-memory queue (also tracked in SQLite so status survives restarts). When a task finishes, the next one starts automatically. Aborting kills the running task and clears the entire queue.
+**Interrupt-first flow.** One request is active per chat. A new message interrupts the active request and starts a fresh request immediately. Interrupted partial output is not added to conversation history.
 
-**Progress.** While a task runs, Homie sends typing indicators every 4 seconds and a status message every 30 seconds showing elapsed time and what the agent is doing ("Reading files...", "Editing code...", "Running commands...").
+**Fresh context.** `/clear` starts a brand new session for the chat without deleting old history. The next message runs from empty context.
+
+**Progress.** While a request is active, Homie sends typing indicators every 4 seconds and a status message every 30 seconds showing elapsed time and what the agent is doing ("Reading files...", "Editing code...", "Running commands...").
 
 ## Configure
 
@@ -78,7 +79,6 @@ Telegram message
 | Setting | Default | What it does |
 |---------|---------|-------------|
 | `telegram.botToken` | — | `TELEGRAM_BOT_TOKEN` env var (required) |
-| `telegram.allowedChatIds` | `[]` | Restrict to specific chats (empty = allow all) |
 | `provider.kind` | `claude-code` | Which CLI backend to use: `claude-code` or `codex` |
 | `provider.model` | `""` | Override the provider's default model; leave empty to follow the CLI default |
 | `provider.extraArgs` | `[]` | Extra CLI flags passed to the agent |
@@ -97,14 +97,13 @@ Recommended `provider.model`:
 src/                  Boot, preflight checks, wiring, graceful shutdown
 bin/                  CLI entry point (homie)
 packages/
-  core/             Types (Task, Session, Message), interfaces, errors
+  core/             Types (Session, Message), interfaces, errors
   config/           YAML loader with ${ENV_VAR} interpolation (zod)
   observability/    Structured JSON logger
-  persistence/      SQLite stores — tasks, sessions, messages, usage, kv
-  sessions/         Session manager — one session per chat, history, status
+  persistence/      SQLite stores — sessions, active sessions, messages
   providers/        Provider runtimes for Claude Code and Codex CLI
   agent/            Context builder — system prompt + history → provider messages
-  gateway/          Task runner (queue + execute), command handler
+  gateway/          Request runner (interrupt + execute), command handler
   channels/
     telegram/       Grammy adapter — polling, photos, documents, markdown
 ```

config/system.yaml

@@ -5,7 +5,6 @@ app:
 # Telegram (required)
 telegram:
   botToken: ${TELEGRAM_BOT_TOKEN}
-  allowedChatIds: []
 
 # Claude Code provider
 provider:

packages/agent/README.md

@@ -6,7 +6,7 @@ Orchestrates provider calls with context assembly. Provider-agnostic — works w
 
 1. Builds a message list from system prompt, history, and user input (`buildMessages`)
 2. Sends to the provider (any local agent CLI) and streams progress
-3. Returns text, usage stats, and resume status
+3. Returns text and resume status
 
 ## Usage
 
@@ -23,5 +23,5 @@ const result = await agent.run({
   signal: controller.signal,
 });
 
-// result.text, result.usage
+// result.text
 ```

packages/agent/src/agent.ts

@@ -1,10 +1,4 @@
-import type {
-  Message,
-  ProgressCallback,
-  ProviderAdapter,
-  ProviderMessage,
-  UsageStats,
-} from '@homie/core';
+import type { Message, ProgressCallback, ProviderAdapter, ProviderMessage } from '@homie/core';
 import { createLogger } from '@homie/observability';
 
 const log = createLogger('agent');
@@ -17,15 +11,13 @@ export interface AgentInput {
   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;
   /** False when session resume failed and full history was re-sent */
   resumed?: boolean;
 }
@@ -58,12 +50,10 @@ export function createAgent(provider: ProviderAdapter, config: AgentConfig): Age
 
       log.info('Agent run completed', {
         sessionId: input.sessionId,
-        costUsd: response.usage?.costUsd,
       });
 
       return {
         text,
-        usage: response.usage,
         resumed: response.resumed,
       };
     },

packages/channels/telegram/README.md

@@ -7,7 +7,7 @@ Telegram channel adapter using [grammy](https://grammy.dev) in polling mode. Fir
 - Text messages, photos, and documents with automatic file download
 - Markdown to Telegram MarkdownV2 conversion with fallback to plain text
 - Typing indicators and editable status messages for progress
-- Chat ID allowlisting (empty list = allow all)
+- First-user lock in memory for simple single-user access control
 - Bot command registration on startup
 
 ## Usage
@@ -17,7 +17,6 @@ import { createTelegramAdapter } from '@homie/telegram';
 
 const telegram = createTelegramAdapter({
   botToken: process.env.TELEGRAM_BOT_TOKEN,
-  allowedChatIds: [],
   onEvent: gateway.handleEvent,
   dataDir: './data',
 });

packages/channels/telegram/src/adapter.ts

@@ -102,14 +102,13 @@ function mimeFromPath(filePath: string): string {
 
 export function createTelegramAdapter(opts: {
   botToken: string;
-  allowedChatIds: Array<string | number>;
   onEvent: EventHandler;
   dataDir: string;
 }): ChannelAdapter {
   const bot = new Bot(opts.botToken);
   const handler = opts.onEvent;
-  const allowedChatIds = new Set(opts.allowedChatIds.map(String));
   const attachDir = join(opts.dataDir, 'attachments');
+  let authorizedUserId: string | null = null;
   mkdirSync(attachDir, { recursive: true });
 
   // --- Internal helpers (not exposed on the public interface) ---
@@ -206,8 +205,24 @@ export function createTelegramAdapter(opts: {
 
   // --- Shared message dispatch ---
 
-  function isAllowed(chatId: string): boolean {
-    return allowedChatIds.size === 0 || allowedChatIds.has(chatId);
+  function authorizeUser(userId: string | null, chatId: string): boolean {
+    if (!userId) {
+      log.warn('Rejected Telegram update without sender', { chatId });
+      return false;
+    }
+
+    if (!authorizedUserId) {
+      authorizedUserId = userId;
+      log.info('Authorized first Telegram user', { chatId, userId });
+      return true;
+    }
+
+    if (authorizedUserId !== userId) {
+      log.warn('Rejected message from unauthorized Telegram user', { chatId, userId });
+      return false;
+    }
+
+    return true;
   }
 
   function buildReplyAndProgress(chatId: string) {
@@ -231,8 +246,7 @@ export function createTelegramAdapter(opts: {
     const text = ctx.message.text;
     const messageId = String(ctx.message.message_id);
 
-    if (!isAllowed(chatId)) {
-      log.warn('Rejected message from unauthorized chat', { chatId });
+    if (!authorizeUser(userId, chatId)) {
       return;
     }
 
@@ -245,7 +259,6 @@ export function createTelegramAdapter(opts: {
           type: 'command',
           channel: 'telegram',
           chatId,
-          userId,
           command: cmdMatch[1] ?? '',
           args: (cmdMatch[2] ?? '').trim(),
           rawSourceId: messageId,
@@ -257,7 +270,7 @@ export function createTelegramAdapter(opts: {
     }
 
     await dispatch(
-      { type: 'chat', channel: 'telegram', chatId, userId, text, rawSourceId: messageId },
+      { type: 'chat', channel: 'telegram', chatId, text, rawSourceId: messageId },
       chatId,
     );
   });
@@ -268,7 +281,7 @@ export function createTelegramAdapter(opts: {
     const messageId = String(ctx.message.message_id);
     const caption = ctx.message.caption ?? '';
 
-    if (!isAllowed(chatId)) return;
+    if (!authorizeUser(userId, chatId)) return;
 
     // Telegram sends multiple sizes — pick the largest
     const photos = ctx.message.photo;
@@ -286,7 +299,6 @@ export function createTelegramAdapter(opts: {
         type: 'chat',
         channel: 'telegram',
         chatId,
-        userId,
         text: caption || 'Analyze this image',
         rawSourceId: messageId,
         attachments: [attachment],
@@ -302,7 +314,7 @@ export function createTelegramAdapter(opts: {
     const caption = ctx.message.caption ?? '';
     const doc = ctx.message.document;
 
-    if (!isAllowed(chatId)) return;
+    if (!authorizeUser(userId, chatId)) return;
 
     const attachment = await downloadFile(doc.file_id, doc.file_name ?? undefined);
     if (!attachment) {
@@ -315,7 +327,6 @@ export function createTelegramAdapter(opts: {
         type: 'chat',
         channel: 'telegram',
         chatId,
-        userId,
         text: caption || `Review this file: ${doc.file_name ?? 'document'}`,
         rawSourceId: messageId,
         attachments: [attachment],
@@ -336,9 +347,9 @@ export function createTelegramAdapter(opts: {
 
       try {
         await bot.api.setMyCommands([
-          { command: 'list', description: 'Recent tasks' },
-          { command: 'status', description: 'System status & running task' },
-          { command: 'abort', description: 'Cancel running task' },
+          { command: 'status', description: 'Current request status' },
+          { command: 'abort', description: 'Interrupt active request' },
+          { command: 'clear', description: 'Start a new session' },
           { command: 'help', description: 'Show help' },
         ]);
       } catch (err) {

packages/config/README.md

@@ -14,7 +14,7 @@ YAML configuration loader with environment variable interpolation and zod valida
 | Section    | Key fields                              |
 | ---------- | --------------------------------------- |
 | `app`      | `logLevel`, `dataDir`                   |
-| `telegram` | `botToken`, `allowedChatIds`            |
+| `telegram` | `botToken`                              |
 | `provider` | `kind`, `model`, `extraArgs`            |
 
 ## Usage

packages/config/src/schema.ts

@@ -7,7 +7,6 @@ export const AppConfigSchema = z.object({
   }),
   telegram: z.object({
     botToken: z.string().min(1, 'TELEGRAM_BOT_TOKEN is required'),
-    allowedChatIds: z.array(z.union([z.string(), z.number()])).default([]),
   }),
   provider: z.object({
     kind: z.enum(['claude-code', 'codex']).default('claude-code'),

packages/core/README.md

@@ -2,14 +2,14 @@
 
 Shared types, interfaces, and error classes used across all Homie packages.
 
-Defines the contracts between channels, providers, and persistence — any local agent CLI or messaging platform plugs in through these interfaces.
+Defines the contracts between channels, providers, and persistence.
 
 ## Exports
 
 ### Types
 
-- `Session`, `Message`, `Task`, `UsageStats` — domain models
-- `SessionStatus`, `MessageDirection`, `TaskStatus` — union types
+- `Session`, `Message` — domain models
+- `MessageDirection` — union types
 - `Attachment` — file attachment metadata
 - `InboundEvent`, `ChatMessageEvent`, `CommandEvent` — inbound event types
 
@@ -18,7 +18,6 @@ Defines the contracts between channels, providers, and persistence — any local
 - `ChannelAdapter` — start/stop/sendMessage for a messaging platform
 - `ProviderAdapter` — generate responses from a local agent CLI
 - `SessionStore` — persistence interface for sessions and messages
-- `TaskStore` — persistence interface for task queue and history
 - `EventHandler`, `ReplyFn`, `ProgressHandler`, `ProgressCallback` — callback types
 - `ProviderRequest`, `ProviderResponse` — provider I/O
 
@@ -31,6 +30,6 @@ Defines the contracts between channels, providers, and persistence — any local
 ## Usage
 
 ```ts
-import type { Session, Task, ChannelAdapter, ProviderAdapter } from '@homie/core';
+import type { Session, Message, ChannelAdapter, ProviderAdapter } from '@homie/core';
 import { ProviderError, getErrorMessage } from '@homie/core';
 ```