feat: persist attachments, extract execution state, simplify provider boot

- Persist attachment metadata in message_attachments table
- Move attachment rendering from request-runner to agent layer
- Filter prior history by ID to prevent duplicate user messages
- Extract execution state into injectable ExecutionStateStore
- Add provider.kind to config, replace detectProvider with checkProvider
- Remove dead detectProvider code and DETECTION_ORDER
- Export schema from persistence barrel, use in tests

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bluedbird

packages/agent/src/agent.ts

@@ -1,4 +1,10 @@
-import type { Message, ProgressCallback, ProviderAdapter, ProviderMessage } from '@homie/core';
+import type {
+  Attachment,
+  Message,
+  ProgressCallback,
+  ProviderAdapter,
+  ProviderMessage,
+} from '@homie/core';
 import { createLogger } from '@homie/observability';
 
 const log = createLogger('agent');
@@ -8,6 +14,7 @@ const SYSTEM_PROMPT = 'You are Homie. Keep responses concise (Telegram chat).';
 export interface AgentInput {
   sessionId: string;
   text: string;
+  attachments?: Attachment[];
   history: Message[];
   /** When true, skip resume and send full history (e.g. after an interrupted run) */
   forceFullHistory?: boolean;
@@ -65,13 +72,28 @@ function buildMessages(input: AgentInput): ProviderMessage[] {
 
   for (const msg of input.history) {
     if (msg.direction === 'in') {
-      messages.push({ role: 'user', content: msg.text });
+      messages.push({ role: 'user', content: renderUserMessage(msg.text, msg.attachments) });
     } else if (msg.direction === 'out') {
       messages.push({ role: 'assistant', content: msg.text });
     }
   }
 
-  messages.push({ role: 'user', content: input.text });
+  messages.push({ role: 'user', content: renderUserMessage(input.text, input.attachments) });
 
   return messages;
 }
+
+function renderUserMessage(text: string, attachments?: Attachment[]): string {
+  if (!attachments || attachments.length === 0) {
+    return text;
+  }
+
+  const refs = attachments.map((attachment) => {
+    const label = attachment.fileName
+      ? `${attachment.fileName} (${attachment.mimeType})`
+      : attachment.mimeType;
+    return `[Attached file: ${attachment.filePath}] (${label})`;
+  });
+
+  return `${refs.join('\n')}\n\n${text}`;
+}

packages/config/src/schema.ts

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

packages/core/src/interfaces.ts

@@ -1,3 +1,4 @@
+import type { Attachment } from './events';
 import type { Message, Session } from './types';
 
 // --- Channel ---
@@ -79,6 +80,7 @@ export interface SessionStore {
     direction: Message['direction'],
     text: string,
     rawSourceId?: string | null,
+    attachments?: Attachment[],
   ): Promise<Message>;
   listRecentMessages(sessionId: string, limit: number): Promise<Message[]>;
 }

packages/core/src/types.ts

@@ -1,3 +1,5 @@
+import type { Attachment } from './events';
+
 export type MessageDirection = 'in' | 'out';
 
 export interface Session {
@@ -13,6 +15,7 @@ export interface Message {
   sessionId: string;
   direction: MessageDirection;
   text: string;
+  attachments?: Attachment[];
   createdAt: string;
   rawSourceId: string | null;
 }

packages/gateway/src/commands.test.ts

@@ -2,8 +2,7 @@ import { Database } from 'bun:sqlite';
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
 import { createAgent } from '@homie/agent';
 import { AbortError, type ProviderAdapter } from '@homie/core';
-import { schema } from '@homie/persistence/src/migrations';
-import { createSessionStore } from '@homie/persistence/src/session-store';
+import { createSessionStore, schema } from '@homie/persistence';
 import { type CommandContext, createCommandHandler } from './commands';
 import { createRequestRunner } from './request-runner';
 

packages/gateway/src/execution-state.ts

@@ -0,0 +1,99 @@
+import type { Attachment, ProgressHandler, ReplyFn } from '@homie/core';
+
+export interface ActiveRequestState {
+  abort: AbortController;
+  done: Promise<void>;
+  text: string;
+  startedAt: number;
+  lastToolHint: string;
+}
+
+export interface QueuedRequestState {
+  channel: string;
+  chatId: string;
+  text: string;
+  rawSourceId: string | null;
+  agentType?: string | null;
+  agentModel?: string | null;
+  reply: ReplyFn;
+  progress?: ProgressHandler;
+  attachments?: Attachment[];
+}
+
+export interface ExecutionStateStore {
+  getActive(key: string): ActiveRequestState | undefined;
+  setActive(key: string, active: ActiveRequestState): void;
+  deleteActive(key: string, active?: ActiveRequestState): void;
+  hasStarting(key: string): boolean;
+  markStarting(key: string): void;
+  clearStarting(key: string): void;
+  getQueued(key: string): QueuedRequestState | undefined;
+  setQueued(key: string, request: QueuedRequestState): void;
+  deleteQueued(key: string): void;
+  getLastSubmittedText(key: string): string | undefined;
+  setLastSubmittedText(key: string, text: string): void;
+  consumeStaleResume(key: string): boolean;
+  markStaleResume(key: string): void;
+  clearStaleResume(key: string): void;
+}
+
+export function createInMemoryExecutionStateStore(): ExecutionStateStore {
+  const activeRequests = new Map<string, ActiveRequestState>();
+  const pendingQueue = new Map<string, QueuedRequestState>();
+  const lastSubmittedText = new Map<string, string>();
+  const starting = new Set<string>();
+  const staleResume = new Set<string>();
+
+  return {
+    getActive(key) {
+      return activeRequests.get(key);
+    },
+    setActive(key, active) {
+      activeRequests.set(key, active);
+    },
+    deleteActive(key, active) {
+      if (!active) {
+        activeRequests.delete(key);
+        return;
+      }
+      if (activeRequests.get(key) === active) {
+        activeRequests.delete(key);
+      }
+    },
+    hasStarting(key) {
+      return starting.has(key);
+    },
+    markStarting(key) {
+      starting.add(key);
+    },
+    clearStarting(key) {
+      starting.delete(key);
+    },
+    getQueued(key) {
+      return pendingQueue.get(key);
+    },
+    setQueued(key, request) {
+      pendingQueue.set(key, request);
+    },
+    deleteQueued(key) {
+      pendingQueue.delete(key);
+    },
+    getLastSubmittedText(key) {
+      return lastSubmittedText.get(key);
+    },
+    setLastSubmittedText(key, text) {
+      lastSubmittedText.set(key, text);
+    },
+    consumeStaleResume(key) {
+      const had = staleResume.has(key);
+      staleResume.delete(key);
+      return had;
+    },
+    markStaleResume(key) {
+      staleResume.add(key);
+    },
+    clearStaleResume(key) {
+      staleResume.delete(key);
+    },
+  };
+}

packages/gateway/src/gateway.test.ts

@@ -2,8 +2,7 @@ import { Database } from 'bun:sqlite';
 import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
 import { createAgent } from '@homie/agent';
 import type { ChatMessageEvent, CommandEvent, ProviderAdapter } from '@homie/core';
-import { schema } from '@homie/persistence/src/migrations';
-import { createSessionStore } from '@homie/persistence/src/session-store';
+import { createSessionStore, schema } from '@homie/persistence';
 import { createGateway } from './gateway';
 
 function createTestDb(): Database {

packages/gateway/src/request-runner.test.ts

@@ -2,8 +2,7 @@ import { Database } from 'bun:sqlite';
 import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
 import { type Agent, createAgent } from '@homie/agent';
 import { AbortError, type ProviderAdapter } from '@homie/core';
-import { schema } from '@homie/persistence/src/migrations';
-import { createSessionStore } from '@homie/persistence/src/session-store';
+import { createSessionStore, schema } from '@homie/persistence';
 import { createRequestRunner, type RequestRunner } from './request-runner';
 
 function createTestDb(): Database {
@@ -129,6 +128,51 @@ describe('RequestRunner', () => {
       expect(messages[1]?.text).toBe('done');
     });
 
+    test('passes attachment metadata through persisted history', async () => {
+      const replies: string[] = [];
+      await runner.submit({
+        channel: 'telegram',
+        chatId: 'chat1',
+        text: 'review attached',
+        rawSourceId: '1',
+        attachments: [
+          {
+            filePath: '/tmp/spec.md',
+            mimeType: 'text/markdown',
+            fileName: 'spec.md',
+          },
+        ],
+        reply: async (text) => {
+          replies.push(text);
+        },
+      });
+      await new Promise((r) => setTimeout(r, 50));
+
+      const messages = await sessionStore.listRecentMessages(sessionId, 10);
+      expect(messages[0]?.attachments).toEqual([
+        {
+          filePath: '/tmp/spec.md',
+          mimeType: 'text/markdown',
+          fileName: 'spec.md',
+        },
+      ]);
+      expect(replies).toContain('done');
+    });
+
+    test('does not duplicate the latest user message in provider input', async () => {
+      const { params } = submitParams('hello once');
+      await runner.submit(params);
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(provider.generate).toHaveBeenCalledTimes(1);
+      const [input] = (provider.generate as ReturnType<typeof mock>).mock.calls[0] as [
+        { messages: Array<{ role: string; content: string }> },
+      ];
+      const userMessages = input.messages.filter((message) => message.role === 'user');
+      expect(userMessages).toHaveLength(1);
+      expect(userMessages[0]?.content).toBe('hello once');
+    });
+
     test('replies with generic failure on provider error', async () => {
       (provider.generate as ReturnType<typeof mock>).mockImplementation(async () => {
         throw new Error('boom');