@orxataguy/tyr 1.0.34 → 1.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"

package/src/lib/AIContextManager.ts

@@ -292,7 +292,11 @@ interface FilePatchBlock {
 }
 
 const FILE_BLOCK_REGEX = />>>FILE:\s*(.+?)\s*\n([\s\S]*?)\n<<<END/g;
-const SEARCH_REPLACE_REGEX = /<<<<<<<\s*SEARCH\s*\n([\s\S]*?)\n=======\s*\n([\s\S]*?)\n>>>>>>>\s*REPLACE/g;
+// The `\n?` before `=======` (rather than a mandatory `\n`) matters for brand-new files: the
+// model is told to leave the SEARCH section EMPTY, and it naturally writes "SEARCH\n======="
+// with no blank line in between rather than "SEARCH\n\n=======" — a mandatory `\n` there made
+// every new-file creation silently produce zero matches (no blocks, "no changes generated").
+const SEARCH_REPLACE_REGEX = /<<<<<<<\s*SEARCH\s*\n([\s\S]*?)\n?=======\s*\n([\s\S]*?)\n>>>>>>>\s*REPLACE/g;
 
 /**
  * @class AIContextManager

package/src/lib/AIVendorManager.ts

@@ -43,9 +43,10 @@ export interface AITool {
 
 /**
  * Nivel de "esfuerzo de razonamiento" (extended thinking) pedido al modelo, independiente del
- * vendor concreto. Se traduce a `thinking.budget_tokens` en Anthropic y a `reasoning_effort` en
- * los modelos de OpenAI que lo soportan (serie 'o'); Gemini no tiene un equivalente público en
- * este momento y el valor se ignora silenciosamente para ese vendor.
+ * vendor concreto. Se traduce a `thinking.budget_tokens` en Anthropic, a
+ * `generationConfig.thinkingConfig.thinkingBudget` en Gemini 2.5+ (mismo concepto de presupuesto
+ * de tokens que Anthropic) y a `reasoning_effort` en los modelos de OpenAI que lo soportan (serie
+ * 'o'), que solo acepta un vocabulario fijo (low/medium/high) en lugar de un número de tokens.
  */
 export type ThinkingEffort = 'none' | 'low' | 'medium' | 'high' | 'max';
 
@@ -144,8 +145,10 @@ const MODEL_TIER_DEFAULT: Record<string,string> = {
     gemini: 'gemini-2.5-flash-lite',
    };
 
-/** budget_tokens sent to Anthropic's `thinking` param per effort level. 'none' disables thinking. */
-const THINKING_BUDGETS: Record<ThinkingEffort, number> = {
+/** budget_tokens sent to Anthropic's `thinking` param per effort level. 'none' disables thinking.
+ *  Each is overridable via env var (see ANTHROPIC_THINKING_BUDGET_ENV); these are the fallback
+ *  values used when the corresponding env var is not set. */
+const ANTHROPIC_THINKING_BUDGETS: Record<ThinkingEffort, number> = {
     none: 0,
     low: 1024,
     medium: 4096,
@@ -153,20 +156,111 @@ const THINKING_BUDGETS: Record<ThinkingEffort, number> = {
     max: 16384,
 };
 
+const ANTHROPIC_THINKING_BUDGET_ENV: Record<ThinkingEffort, string> = {
+    none: 'ANTHROPIC_THINKING_BUDGET_NONE',
+    low: 'ANTHROPIC_THINKING_BUDGET_LOW',
+    medium: 'ANTHROPIC_THINKING_BUDGET_MEDIUM',
+    high: 'ANTHROPIC_THINKING_BUDGET_HIGH',
+    max: 'ANTHROPIC_THINKING_BUDGET_MAX',
+};
+
+/** Gemini 2.5+'s `generationConfig.thinkingConfig.thinkingBudget` is the same token-budget concept
+ *  as Anthropic's, so it reuses the same default magnitudes — overridable independently via its
+ *  own env vars since Gemini's actual valid range differs by model (flash allows 0, pro doesn't). */
+const GEMINI_THINKING_BUDGETS: Record<ThinkingEffort, number> = {
+    none: 0,
+    low: 1024,
+    medium: 4096,
+    high: 8192,
+    max: 16384,
+};
+
+const GEMINI_THINKING_BUDGET_ENV: Record<ThinkingEffort, string> = {
+    none: 'GEMINI_THINKING_BUDGET_NONE',
+    low: 'GEMINI_THINKING_BUDGET_LOW',
+    medium: 'GEMINI_THINKING_BUDGET_MEDIUM',
+    high: 'GEMINI_THINKING_BUDGET_HIGH',
+    max: 'GEMINI_THINKING_BUDGET_MAX',
+};
+
+function resolveThinkingBudget(
+    effort: ThinkingEffort,
+    defaults: Record<ThinkingEffort, number>,
+    env: Record<ThinkingEffort, string>
+): number {
+    return getEnvInt(env[effort], defaults[effort]);
+}
+
+/** OpenAI's reasoning models (serie 'o', gpt-5*) solo aceptan un vocabulario fijo para
+ *  `reasoning_effort` — no un número de tokens — así que aquí se mapea ThinkingEffort a esas
+ *  cadenas en lugar de a un budget. 'none' está ausente a propósito: esos modelos no permiten
+ *  desactivar el razonamiento, así que ThinkingEffort 'none' simplemente omite el parámetro
+ *  (ver openaiReasoningFields). Cada nivel es overridable vía env var por si OpenAI cambia el
+ *  vocabulario aceptado (p.ej. añade 'minimal') sin tener que tocar código. */
+const OPENAI_REASONING_EFFORTS: Partial<Record<ThinkingEffort, string>> = {
+    low: 'low',
+    medium: 'medium',
+    high: 'high',
+    max: 'high',
+};
+
+const OPENAI_REASONING_EFFORT_ENV: Partial<Record<ThinkingEffort, string>> = {
+    low: 'OPENAI_REASONING_EFFORT_LOW',
+    medium: 'OPENAI_REASONING_EFFORT_MEDIUM',
+    high: 'OPENAI_REASONING_EFFORT_HIGH',
+    max: 'OPENAI_REASONING_EFFORT_MAX',
+};
+
+function resolveOpenAIReasoningEffort(effort: ThinkingEffort): string | undefined {
+    const envVar = OPENAI_REASONING_EFFORT_ENV[effort];
+    const override = envVar ? getEnvString(envVar) : undefined;
+    return override ?? OPENAI_REASONING_EFFORTS[effort];
+}
+
 /**
  * Task-priority → (model tier, thinking effort) matrix. This is the routing table requested by
  * the architecture spec: callers pick a priority by *intent* ("this is a trivial file", "this
  * previous attempt failed"), not by model name, and AIVendorManager decides what that costs.
+ * Each entry is overridable via env var (see PRIORITY_ROUTING_ENV); these are the fallback values
+ * used when the corresponding env var is unset or holds an invalid tier/thinking value.
  */
 const PRIORITY_ROUTING: Record<TaskPriority, { tier: ModelTier; thinking: ThinkingEffort }> = {
     'baja-prioridad': { tier: 'cheap', thinking: 'none' },
-    'baja-media-prioridad': { tier: 'cheap', thinking: 'max' },
+    'baja-media-prioridad': { tier: 'cheap', thinking: 'high' },
     'media-prioridad': { tier: 'balanced', thinking: 'none' },
     'media-alta-prioridad': { tier: 'balanced', thinking: 'high' },
     'alta-prioridad': { tier: 'balanced', thinking: 'max' },
     'muy-alta-prioridad': { tier: 'flagship', thinking: 'max' },
 };
 
+const PRIORITY_ROUTING_ENV: Record<TaskPriority, { tier: string; thinking: string }> = {
+    'baja-prioridad': { tier: 'AI_PRIORITY_BAJA_TIER', thinking: 'AI_PRIORITY_BAJA_THINKING' },
+    'baja-media-prioridad': { tier: 'AI_PRIORITY_BAJA_MEDIA_TIER', thinking: 'AI_PRIORITY_BAJA_MEDIA_THINKING' },
+    'media-prioridad': { tier: 'AI_PRIORITY_MEDIA_TIER', thinking: 'AI_PRIORITY_MEDIA_THINKING' },
+    'media-alta-prioridad': { tier: 'AI_PRIORITY_MEDIA_ALTA_TIER', thinking: 'AI_PRIORITY_MEDIA_ALTA_THINKING' },
+    'alta-prioridad': { tier: 'AI_PRIORITY_ALTA_TIER', thinking: 'AI_PRIORITY_ALTA_THINKING' },
+    'muy-alta-prioridad': { tier: 'AI_PRIORITY_MUY_ALTA_TIER', thinking: 'AI_PRIORITY_MUY_ALTA_THINKING' },
+};
+
+const VALID_MODEL_TIERS: ModelTier[] = ['cheap', 'balanced', 'flagship'];
+const VALID_THINKING_EFFORTS: ThinkingEffort[] = ['none', 'low', 'medium', 'high', 'max'];
+
+/** Resolves the (tier, thinking) route for a priority, letting env vars override either half of
+ *  PRIORITY_ROUTING independently. An env var holding anything other than a valid tier/thinking
+ *  value is ignored in favor of the hardcoded default, rather than passed through to the vendor. */
+function resolvePriorityRoute(priority: TaskPriority): { tier: ModelTier; thinking: ThinkingEffort } {
+    const defaults = PRIORITY_ROUTING[priority];
+    const envVars = PRIORITY_ROUTING_ENV[priority];
+
+    const tierOverride = getEnvString(envVars.tier)?.toLowerCase() as ModelTier | undefined;
+    const thinkingOverride = getEnvString(envVars.thinking)?.toLowerCase() as ThinkingEffort | undefined;
+
+    return {
+        tier: tierOverride && VALID_MODEL_TIERS.includes(tierOverride) ? tierOverride : defaults.tier,
+        thinking: thinkingOverride && VALID_THINKING_EFFORTS.includes(thinkingOverride) ? thinkingOverride : defaults.thinking,
+    };
+}
+
 /** Ordered priority ladder, used by bumpPriority() to escalate one level at a time. */
 const PRIORITY_LADDER: TaskPriority[] = [
     'baja-prioridad',
@@ -257,10 +351,10 @@ export class AIVendorManager {
             .toString()
             .toLowerCase() as AIVendor;
 
-        const route = PRIORITY_ROUTING[priority];
-        if (!route) {
+        if (!PRIORITY_ROUTING[priority]) {
             throw new TyrError(`Unknown task priority: '${priority}'`, null, `Use one of: ${PRIORITY_LADDER.join(', ')}`);
         }
+        const route = resolvePriorityRoute(priority);
 
         const tierModel = getEnvString(MODEL_TIER_ENV[vendor][route.tier], MODEL_TIER_DEFAULT[vendor]);
 
@@ -472,7 +566,7 @@ export class AIVendorManager {
     /** Anthropic's extended thinking requires temperature === 1 and max_tokens strictly greater
      *  than budget_tokens; both are enforced here so callers never have to remember it. */
     private anthropicThinkingFields(config: VendorConfig): { thinking?: any; temperature: number; max_tokens: number } {
-        const budget = THINKING_BUDGETS[config.thinking];
+        const budget = resolveThinkingBudget(config.thinking, ANTHROPIC_THINKING_BUDGETS, ANTHROPIC_THINKING_BUDGET_ENV);
         if (!budget) return { temperature: config.temperature, max_tokens: config.maxTokens };
 
         return {
@@ -482,15 +576,39 @@ export class AIVendorManager {
         };
     }
 
+    /** True for OpenAI's reasoning-capable model families ('o' models: o1, o3... and the gpt-5
+     *  line), which share two API quirks handled below: they reject the legacy `max_tokens` body
+     *  field (Use `max_completion_tokens` instead — see buildRequest) and, when reasoning is on,
+     *  reject a custom `temperature`. */
+    private isOpenAIReasoningModel(model: string): boolean {
+        return /^(o\d|gpt-5)/i.test(model);
+    }
+
     /** OpenAI's `reasoning_effort` only exists on the 'o' reasoning model family and only accepts
-     *  low/medium/high (no 'none'/'max') — mapped from our vendor-agnostic ThinkingEffort. Those
-     *  models also reject a custom `temperature`, so it's omitted whenever reasoning_effort is set. */
-    private openaiReasoningFields(config: VendorConfig): { reasoning_effort?: string; temperature?: number } {
-        const isReasoningModel = /^o\d/.test(config.model);
-        if (!isReasoningModel || config.thinking === 'none') return { temperature: config.temperature };
-
-        const effortMap: Partial<Record<ThinkingEffort, string>> = { low: 'low', medium: 'medium', high: 'high', max: 'high' };
-        return { reasoning_effort: effortMap[config.thinking] };
+     *  a fixed vocabulary (no 'none') — mapped from our vendor-agnostic ThinkingEffort via
+     *  OPENAI_REASONING_EFFORTS/_ENV. Those models also reject a custom `temperature`, so it's
+     *  omitted whenever reasoning_effort is set.
+     *
+     *  `reasoning_effort` combined with function `tools` on /v1/chat/completions is itself
+     *  rejected with a 400 ("...are not supported... Please use /v1/responses instead") on at
+     *  least the gpt-5 nano tier — so it's omitted whenever tools are present, trading explicit
+     *  effort control for the request actually working; the model still reasons, just without an
+     *  explicit tier hint. */
+    private openaiReasoningFields(config: VendorConfig, hasTools: boolean): { reasoning_effort?: string; temperature?: number } {
+        if (!this.isOpenAIReasoningModel(config.model) || config.thinking === 'none' || hasTools) {
+            return { temperature: config.temperature };
+        }
+
+        return { reasoning_effort: resolveOpenAIReasoningEffort(config.thinking) };
+    }
+
+    /** Gemini 2.5+'s `thinkingConfig.thinkingBudget` is omitted entirely for 'none' rather than
+     *  sent as 0, because 0 is invalid on Pro models (which can't fully disable thinking) — only
+     *  Flash accepts it. Omitting the field is the safe "off" behavior across both. */
+    private geminiThinkingFields(config: VendorConfig): { thinkingConfig?: { thinkingBudget: number } } {
+        if (config.thinking === 'none') return {};
+        const budget = resolveThinkingBudget(config.thinking, GEMINI_THINKING_BUDGETS, GEMINI_THINKING_BUDGET_ENV);
+        return { thinkingConfig: { thinkingBudget: budget } };
     }
 
     private buildRequest(config: VendorConfig, messages: AIMessage[], stream: boolean, tools?: AITool[]): VendorRequest {
@@ -519,7 +637,12 @@ export class AIVendorManager {
             }
 
             case 'openai': {
-                const reasoningFields = this.openaiReasoningFields(config);
+                const reasoningFields = this.openaiReasoningFields(config, !!vendorTools);
+                // Reasoning-family models (o1/o3/gpt-5...) reject the legacy `max_tokens` field
+                // with a 400 and require `max_completion_tokens` instead.
+                const tokenField = this.isOpenAIReasoningModel(config.model)
+                    ? { max_completion_tokens: config.maxTokens }
+                    : { max_tokens: config.maxTokens };
                 return {
                     url: 'https://api.openai.com/v1/chat/completions',
                     headers: {
@@ -532,7 +655,7 @@ export class AIVendorManager {
                             ...(system ? [{ role: 'system', content: system }] : []),
                             ...this.buildOpenAIMessages(turns),
                         ],
-                        max_tokens: config.maxTokens,
+                        ...tokenField,
                         stream,
                         ...reasoningFields,
                         ...(stream ? { stream_options: { include_usage: true } } : {}),
@@ -543,6 +666,7 @@ export class AIVendorManager {
 
             case 'gemini': {
                 const action = stream ? 'streamGenerateContent?alt=sse&' : 'generateContent?';
+                const thinkingFields = this.geminiThinkingFields(config);
                 return {
                     url: `https://generativelanguage.googleapis.com/v1beta/models/${config.model}:${action}key=${config.apiKey}`,
                     headers: { 'content-type': 'application/json' },
@@ -552,6 +676,7 @@ export class AIVendorManager {
                         generationConfig: {
                             temperature: config.temperature,
                             maxOutputTokens: config.maxTokens,
+                            ...thinkingFields,
                         },
                         ...(vendorTools ? { tools: vendorTools } : {}),
                     },

package/src/lib/ChatManager.ts

@@ -53,6 +53,13 @@ export interface ChatMessageContext {
     /** Full conversation so far, including the message that triggered this call. */
     history: ChatMessage[];
     dir: string;
+    /** Id of the session this message belongs to — pass it to addToContext()/removeFromContext()
+     *  /getContext() to read or grow the "context of interest" file set while producing a reply. */
+    sessionId: string;
+    /** Snapshot (sorted, relative to `dir`) of the context-of-interest file set at the moment the
+     *  handler was invoked. Mutations made via addToContext() during the handler are NOT reflected
+     *  here — call getContext(sessionId) again for the live set. */
+    context: string[];
 }
 
 /** Function that produces the assistant's reply text for a user message. Registered via
@@ -65,7 +72,8 @@ export type ChatEventName =
     | 'message:send'
     | 'message:response'
     | 'message:error'
-    | 'file:select';
+    | 'file:select'
+    | 'context:change';
 
 interface InternalSession {
     id: string;
@@ -77,6 +85,11 @@ interface InternalSession {
     attachments: Map<string, ChatAttachment>;
     splitRatio: number;
     title: string;
+    /** "Context of interest" — relative (forward-slash) paths of files the conversation is
+     *  currently grounded on: added by a double-click in the file browser, or programmatically
+     *  via addToContext() (e.g. a command detecting a file mention, or the AI itself asking for
+     *  one through a tool). Highlighted in the file browser (see /api/context). */
+    contextFiles: Set<string>;
 }
 
 const DEFAULT_PORT = 4646;
@@ -118,6 +131,14 @@ function mimeFromExt(ext: string): string {
  *
  * Attached images are written to a per-session temp directory (via os.tmpdir()) that is removed
  * when the session is stopped or the process exits (SIGINT/SIGTERM/exit are all hooked).
+ *
+ * Each session also tracks a "context of interest" file set (addToContext() / removeFromContext()
+ * / toggleContext() / getContext()) — files the file browser highlights and that ChatMessageContext
+ * exposes to the onMessage handler, so a caller can ground replies on specific files without the
+ * model having to re-discover them every turn. The manager only tracks *which* paths are of
+ * interest and validates them (must exist, must be a file, must stay inside `dir`); reading their
+ * content and deciding what counts as "mentioned" is left to the onMessage handler, same division
+ * of responsibility as AI content generation itself.
  */
 export class ChatManager {
     private fsManager: FileSystemManager;
@@ -178,6 +199,110 @@ export class ChatManager {
         this.emitter.off(event, listener);
     }
 
+    private normalizeRelPath(relPath: string): string {
+        return (relPath || '')
+            .replace(/\\/g, '/')
+            .replace(/^(\.\/)+/, '')
+            .replace(/^\/+/, '')
+            .replace(/\/+$/, '');
+    }
+
+    /**
+     * @method getContext
+     * @description Returns the session's current "context of interest" — relative paths, sorted.
+     * @param {string} sessionId - The id of the session (see ChatMessageContext.sessionId).
+     * @returns {string[]} Sorted relative paths.
+     * @example
+     * const files = chat.getContext(sessionId);
+     */
+    public getContext(sessionId: string): string[] {
+        const session = this.sessions.get(sessionId);
+        if (!session) return [];
+        return [...session.contextFiles].sort();
+    }
+
+    /**
+     * @method addToContext
+     * @description Adds one or more files to the session's context of interest. Each path is
+     * validated (must resolve inside the session's directory, must exist, must be a file) and
+     * silently skipped if it fails — invalid input never throws, since callers (mention detection,
+     * an AI tool call) work off untrusted text. Fires 'context:change' once if anything was added.
+     * @param {string} sessionId - The id of the session.
+     * @param {string[]} relPaths - Paths relative to the session's directory.
+     * @returns {Promise<string[]>} The subset of paths that were actually added (newly, validly).
+     * @example
+     * const added = await chat.addToContext(sessionId, ['src/index.ts']);
+     */
+    public async addToContext(sessionId: string, relPaths: string[]): Promise<string[]> {
+        const session = this.sessions.get(sessionId);
+        if (!session) return [];
+
+        const added: string[] = [];
+        for (const raw of relPaths) {
+            const normalized = this.normalizeRelPath(raw);
+            if (!normalized || session.contextFiles.has(normalized)) continue;
+
+            let abs: string;
+            try {
+                abs = this.resolveSafe(session, normalized);
+            } catch {
+                continue;
+            }
+            if (!fsSync.existsSync(abs) || !fsSync.statSync(abs).isFile()) continue;
+
+            session.contextFiles.add(normalized);
+            added.push(normalized);
+        }
+
+        if (added.length > 0) {
+            await this.emitSafe('context:change', { sessionId, dir: session.dir, files: this.getContext(sessionId) });
+        }
+        return added;
+    }
+
+    /**
+     * @method removeFromContext
+     * @description Removes a single file from the session's context of interest, if present.
+     * Fires 'context:change' when it actually removes something.
+     * @param {string} sessionId - The id of the session.
+     * @param {string} relPath - Path relative to the session's directory.
+     * @example
+     * await chat.removeFromContext(sessionId, 'src/index.ts');
+     */
+    public async removeFromContext(sessionId: string, relPath: string): Promise<void> {
+        const session = this.sessions.get(sessionId);
+        if (!session) return;
+
+        const normalized = this.normalizeRelPath(relPath);
+        if (session.contextFiles.delete(normalized)) {
+            await this.emitSafe('context:change', { sessionId, dir: session.dir, files: this.getContext(sessionId) });
+        }
+    }
+
+    /**
+     * @method toggleContext
+     * @description Adds `relPath` to the context of interest if absent, removes it if present —
+     * the file browser's double-click behaviour. Same validation as addToContext() on the add path.
+     * @param {string} sessionId - The id of the session.
+     * @param {string} relPath - Path relative to the session's directory.
+     * @returns {Promise<{ added: boolean; files: string[] }>} Whether the path ended up added, and the resulting set.
+     * @example
+     * const { added } = await chat.toggleContext(sessionId, 'src/index.ts');
+     */
+    public async toggleContext(sessionId: string, relPath: string): Promise<{ added: boolean; files: string[] }> {
+        const session = this.sessions.get(sessionId);
+        if (!session) return { added: false, files: [] };
+
+        const normalized = this.normalizeRelPath(relPath);
+        if (session.contextFiles.has(normalized)) {
+            await this.removeFromContext(sessionId, normalized);
+            return { added: false, files: this.getContext(sessionId) };
+        }
+
+        const added = await this.addToContext(sessionId, [normalized]);
+        return { added: added.length > 0, files: this.getContext(sessionId) };
+    }
+
     private async emitSafe(event: ChatEventName, payload: any): Promise<void> {
         for (const listener of this.emitter.listeners(event)) {
             try {
@@ -244,6 +369,7 @@ export class ChatManager {
             attachments: new Map(),
             splitRatio,
             title,
+            contextFiles: new Set(),
         };
 
         const server = http.createServer((req, res) => {
@@ -380,6 +506,20 @@ export class ChatManager {
                 return;
             }
 
+            if (pathname === '/api/context' && req.method === 'GET') {
+                this.sendJson(res, 200, { files: this.getContext(session.id) });
+                return;
+            }
+
+            if (pathname === '/api/context/toggle' && req.method === 'POST') {
+                const body = await this.readJsonBody(req);
+                const relPath = typeof body?.path === 'string' ? body.path : '';
+                if (!relPath) throw new TyrError('Missing path', null, 'Send { path } to /api/context/toggle.');
+                const result = await this.toggleContext(session.id, relPath);
+                this.sendJson(res, 200, result);
+                return;
+            }
+
             if (pathname === '/api/tree' && req.method === 'GET') {
                 const rel = url.searchParams.get('path') ?? '';
                 const entries = await this.listChildren(session, rel);
@@ -417,7 +557,7 @@ export class ChatManager {
             if (pathname === '/api/message' && req.method === 'POST') {
                 const body = await this.readJsonBody(req);
                 const message = await this.handleMessage(session, body);
-                this.sendJson(res, 200, { message });
+                this.sendJson(res, 200, { message, context: this.getContext(session.id) });
                 return;
             }
 
@@ -555,7 +695,13 @@ export class ChatManager {
 
         try {
             const handler = this.messageHandler ?? this.defaultHandler;
-            const replyText = await handler({ message: userMessage, history: session.history, dir: session.dir });
+            const replyText = await handler({
+                message: userMessage,
+                history: session.history,
+                dir: session.dir,
+                sessionId: session.id,
+                context: this.getContext(session.id),
+            });
 
             const assistantMessage: ChatMessage = {
                 id: crypto.randomUUID(),
@@ -599,10 +745,22 @@ export class ChatManager {
   #divider:hover { background: #4db8ff; }
   header { padding: 12px 16px; border-bottom: 1px solid #333; font-weight: 600; display: flex; justify-content: space-between; align-items: center; }
   #messages { flex: 1; overflow-y: auto; padding: 16px; display: flex; flex-direction: column; gap: 12px; }
-  .msg { max-width: 85%; padding: 10px 14px; border-radius: 10px; line-height: 1.45; white-space: pre-wrap; word-break: break-word; font-size: 14px; }
+  .msg { max-width: 85%; padding: 10px 14px; border-radius: 10px; line-height: 1.45; word-break: break-word; font-size: 14px; }
   .msg.user { align-self: flex-end; background: #2563eb22; border: 1px solid #2563eb55; }
   .msg.assistant { align-self: flex-start; background: #2d2d2d; border: 1px solid #3a3a3a; }
   .msg.error { align-self: flex-start; background: #4d1f1f; border: 1px solid #7a2b2b; color: #ffb4b4; }
+  .msg > *:first-child { margin-top: 0; }
+  .msg > *:last-child { margin-bottom: 0; }
+  .msg p { margin: 0 0 8px 0; }
+  .msg h1, .msg h2, .msg h3, .msg h4, .msg h5, .msg h6 { margin: 10px 0 6px 0; line-height: 1.3; }
+  .msg ul, .msg ol { margin: 4px 0 8px 22px; padding: 0; }
+  .msg li { margin: 2px 0; }
+  .msg pre { background: #111; padding: 8px 10px; border-radius: 6px; overflow-x: auto; margin: 6px 0; }
+  .msg code { background: #00000055; padding: 1px 4px; border-radius: 4px; font-family: 'SFMono-Regular', Consolas, monospace; font-size: 0.9em; }
+  .msg pre code { background: none; padding: 0; }
+  .msg blockquote { margin: 6px 0; padding-left: 10px; border-left: 3px solid #555; color: #aaa; }
+  .msg hr { border: none; border-top: 1px solid #444; margin: 10px 0; }
+  .msg a { color: #4db8ff; }
   .attachments { display: flex; gap: 6px; margin-top: 8px; flex-wrap: wrap; }
   .attachments img { width: 72px; height: 72px; object-fit: cover; border-radius: 6px; border: 1px solid #444; }
   #compose { border-top: 1px solid #333; padding: 12px; display: flex; flex-direction: column; gap: 8px; }
@@ -620,6 +778,9 @@ export class ChatManager {
   #tree { flex: 1; overflow-y: auto; padding: 8px; }
   .tree-row { display: flex; align-items: center; gap: 6px; padding: 4px 6px; border-radius: 6px; cursor: pointer; font-size: 13px; white-space: nowrap; }
   .tree-row:hover { background: #262626; }
+  .tree-row.in-context { background: #4db8ff26; border: 1px solid #4db8ff88; }
+  .tree-row.in-context:hover { background: #4db8ff3a; }
+  .tree-row.in-context::after { content: '📌'; margin-left: 4px; opacity: 0.85; }
   .tree-children { margin-left: 16px; display: none; }
   .tree-children.open { display: block; }
   #preview { border-top: 1px solid #333; max-height: 45%; overflow: auto; padding: 12px; font-family: 'SFMono-Regular', Consolas, monospace; font-size: 12.5px; }
@@ -652,7 +813,7 @@ export class ChatManager {
 <script>
 const BOOTSTRAP = ${bootstrap};
 (function () {
-  const state = { pending: [], treeCache: {} };
+  const state = { pending: [], treeCache: {}, context: new Set() };
 
   const app = document.getElementById('app');
   const messagesEl = document.getElementById('messages');
@@ -689,10 +850,130 @@ const BOOTSTRAP = ${bootstrap};
     });
   }
 
+  // Minimal, dependency-free Markdown renderer. The whole input is HTML-escaped FIRST, and every
+  // tag below is introduced by this code afterwards — untrusted text (from the model or the user)
+  // is never interpreted as raw HTML, only as Markdown syntax on top of already-safe text.
+  var BACKTICK = '\\u0060';
+
+  function isSafeUrl(url) {
+    if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(url)) return true;
+    return /^(https?|mailto):/i.test(url);
+  }
+
+  function renderInline(text) {
+    const codeRe = new RegExp(BACKTICK + '([^' + BACKTICK + ']+)' + BACKTICK, 'g');
+    text = text.replace(codeRe, function (m, code) { return '<code>' + code + '</code>'; });
+    text = text.replace(/\\*\\*([^*]+)\\*\\*/g, '<strong>$1</strong>');
+    text = text.replace(/__([^_]+)__/g, '<strong>$1</strong>');
+    text = text.replace(/\\*([^*]+)\\*/g, '<em>$1</em>');
+    text = text.replace(/(^|[^\\w])_([^_]+)_(?!\\w)/g, '$1<em>$2</em>');
+    text = text.replace(/\\[([^\\]]+)\\]\\(([^)]+)\\)/g, function (m, label, url) {
+      const safeUrl = isSafeUrl(url) ? url : '#';
+      return '<a href="' + safeUrl + '" target="_blank" rel="noopener noreferrer">' + label + '</a>';
+    });
+    return text;
+  }
+
+  function renderMarkdown(raw) {
+    const escaped = escapeHtml(raw || '');
+    const lines = escaped.split('\\n');
+    const fence = BACKTICK + BACKTICK + BACKTICK;
+    const out = [];
+    let paragraph = [];
+
+    function flushParagraph() {
+      if (paragraph.length > 0) {
+        out.push('<p>' + paragraph.map(renderInline).join('<br>') + '</p>');
+        paragraph = [];
+      }
+    }
+
+    let i = 0;
+    while (i < lines.length) {
+      const line = lines[i];
+
+      if (line.indexOf(fence) === 0) {
+        flushParagraph();
+        const lang = line.slice(fence.length).trim().replace(/[^a-zA-Z0-9_-]/g, '');
+        const codeLines = [];
+        i++;
+        while (i < lines.length && lines[i].indexOf(fence) !== 0) {
+          codeLines.push(lines[i]);
+          i++;
+        }
+        i++;
+        const langClass = lang ? ' class="language-' + lang + '"' : '';
+        out.push('<pre><code' + langClass + '>' + codeLines.join('\\n') + '</code></pre>');
+        continue;
+      }
+
+      const headerMatch = line.match(/^(#{1,6})\\s+(.*)$/);
+      if (headerMatch) {
+        flushParagraph();
+        const level = headerMatch[1].length;
+        out.push('<h' + level + '>' + renderInline(headerMatch[2]) + '</h' + level + '>');
+        i++;
+        continue;
+      }
+
+      if (/^(-{3,}|\\*{3,})\\s*$/.test(line)) {
+        flushParagraph();
+        out.push('<hr>');
+        i++;
+        continue;
+      }
+
+      if (/^&gt;\\s?/.test(line)) {
+        flushParagraph();
+        const quoteLines = [];
+        while (i < lines.length && /^&gt;\\s?/.test(lines[i])) {
+          quoteLines.push(lines[i].replace(/^&gt;\\s?/, ''));
+          i++;
+        }
+        out.push('<blockquote><p>' + quoteLines.map(renderInline).join('<br>') + '</p></blockquote>');
+        continue;
+      }
+
+      if (/^[-*+]\\s+/.test(line)) {
+        flushParagraph();
+        const items = [];
+        while (i < lines.length && /^[-*+]\\s+/.test(lines[i])) {
+          items.push('<li>' + renderInline(lines[i].replace(/^[-*+]\\s+/, '')) + '</li>');
+          i++;
+        }
+        out.push('<ul>' + items.join('') + '</ul>');
+        continue;
+      }
+
+      if (/^\\d+\\.\\s+/.test(line)) {
+        flushParagraph();
+        const oitems = [];
+        while (i < lines.length && /^\\d+\\.\\s+/.test(lines[i])) {
+          oitems.push('<li>' + renderInline(lines[i].replace(/^\\d+\\.\\s+/, '')) + '</li>');
+          i++;
+        }
+        out.push('<ol>' + oitems.join('') + '</ol>');
+        continue;
+      }
+
+      if (line.trim() === '') {
+        flushParagraph();
+        i++;
+        continue;
+      }
+
+      paragraph.push(line);
+      i++;
+    }
+
+    flushParagraph();
+    return out.join('');
+  }
+
   function renderMessage(msg) {
     const div = document.createElement('div');
     div.className = 'msg ' + (msg.role === 'user' ? 'user' : (msg.role === 'error' ? 'error' : 'assistant'));
-    div.innerHTML = escapeHtml(msg.text || '').replace(/\\n/g, '<br>');
+    div.innerHTML = renderMarkdown(msg.text || '');
     if (msg.attachments && msg.attachments.length) {
       const wrap = document.createElement('div');
       wrap.className = 'attachments';
@@ -787,6 +1068,10 @@ const BOOTSTRAP = ${bootstrap};
     }).then(function (result) {
       if (!result.ok) throw new Error((result.data && result.data.error) || 'Request failed');
       renderMessage(result.data.message);
+      if (result.data.context) {
+        state.context = new Set(result.data.context);
+        applyContextHighlight();
+      }
     }).catch(function (e) {
       renderMessage({ role: 'error', text: 'Error: ' + e.message, attachments: [] });
     }).then(function () {
@@ -810,10 +1095,36 @@ const BOOTSTRAP = ${bootstrap};
     });
   }
 
+  function loadContext() {
+    return fetch('/api/context').then(function (r) { return r.json(); }).then(function (data) {
+      state.context = new Set(data.files || []);
+    });
+  }
+
+  function applyContextHighlight() {
+    const rows = treeEl.querySelectorAll('.tree-row[data-path]');
+    rows.forEach(function (row) {
+      row.classList.toggle('in-context', state.context.has(row.getAttribute('data-path')));
+    });
+  }
+
+  function toggleContext(relPath) {
+    fetch('/api/context/toggle', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ path: relPath }),
+    }).then(function (r) { return r.json(); }).then(function (data) {
+      state.context = new Set(data.files || []);
+      applyContextHighlight();
+    });
+  }
+
   function buildNode(entry, container) {
     const row = document.createElement('div');
     row.className = 'tree-row';
+    row.dataset.path = entry.path;
     row.textContent = folderIcon(entry.isDir) + ' ' + entry.name;
+    if (!entry.isDir && state.context.has(entry.path)) row.classList.add('in-context');
     container.appendChild(row);
 
     if (entry.isDir) {
@@ -832,6 +1143,10 @@ const BOOTSTRAP = ${bootstrap};
       });
     } else {
       row.addEventListener('click', function () { openFile(entry.path); });
+      row.addEventListener('dblclick', function (e) {
+        e.preventDefault();
+        toggleContext(entry.path);
+      });
     }
   }
 
@@ -868,7 +1183,7 @@ const BOOTSTRAP = ${bootstrap};
   }
 
   loadHistory();
-  loadTree();
+  loadContext().then(loadTree);
   input.focus();
 })();
 </script>