@orxataguy/tyr 1.0.37 → 1.0.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"
@@ -47,6 +47,7 @@
     "axios": "^1.13.2",
     "chalk": "^5.6.2",
     "cheerio": "^1.1.2",
+    "diff": "^9.0.0",
     "dotenv": "^17.2.3",
     "execa": "^6.1.0",
     "find-config": "^1.0.0",
@@ -57,6 +58,7 @@
     "tsx": "^4.21.0"
   },
   "devDependencies": {
+    "@types/diff": "^7.0.2",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.0.10",
     "@vitest/coverage-v8": "^3.2.4",

package/src/core/Container.ts

@@ -12,6 +12,8 @@ import { JiraManager } from '../lib/JiraManager.js';
 import { SetupManager } from '../lib/SetupManager.js';
 import { AIVendorManager } from '../lib/AIVendorManager.js';
 import { AIContextManager } from '../lib/AIContextManager.js';
+import { SandboxManager } from '../lib/SandboxManager.js';
+import { MemoryManager } from '../lib/MemoryManager.js';
 import { PromptTemplateManager } from '../lib/PromptTemplateManager.js';
 import { TokenManager } from '../lib/TokenManager.js';
 import { ChatManager } from '../lib/ChatManager.js';
@@ -38,6 +40,8 @@ export interface ServiceContainer {
     setup: SetupManager;
     aiVendor: AIVendorManager;
     aiContext: AIContextManager;
+    sandbox: SandboxManager;
+    memory: MemoryManager;
     prompts: PromptTemplateManager;
     tokens: TokenManager;
     chat: ChatManager;
@@ -58,7 +62,9 @@ export class Container {
         const web = new WebManager(logger);
         const fs = new FileSystemManager(logger);
         const aiVendor = new AIVendorManager(logger);
-        const aiContext = new AIContextManager(fs, shell, aiVendor, logger);
+        const git = new GitManager(shell, logger);
+        const sandbox = new SandboxManager(logger);
+        const aiContext = new AIContextManager(fs, shell, aiVendor, logger, git, sandbox);
 
         this.services = {
             logger,
@@ -70,13 +76,15 @@ export class Container {
             fs,
             pkg: new PackageManager(shell, logger),
             docker: new DockerManager(shell, logger),
-            git: new GitManager(shell, logger),
+            git,
             sys: new SystemManager(shell, logger),
             workspace: new WorkspaceManager(shell, fs, logger),
             jira: new JiraManager(web, shell, logger),
             setup: new SetupManager(shell, fs, logger),
             aiVendor,
             aiContext,
+            sandbox,
+            memory: new MemoryManager(fs, logger),
             prompts: new PromptTemplateManager(aiContext, logger),
             tokens: new TokenManager(logger),
             chat: new ChatManager(fs, logger),

package/src/core/sys/chat.ts

@@ -1,7 +1,7 @@
 import path from 'path';
 import { readFile } from 'fs/promises';
 import { TyrContext } from '../Kernel';
-import type { AIContentBlock, AIMessage } from '../../lib/AIVendorManager';
+import type { AIContentBlock, AIMessage, TaskPriority } from '../../lib/AIVendorManager';
 import type { ChatMessageContext } from '../../lib/ChatManager';
 
 function parseFlag(args: string[], name: string): string | undefined {
@@ -19,9 +19,25 @@ export default function chat({ logger, chat: chatManager, aiVendor, fail }: TyrC
         const port = portArg ? parseInt(portArg, 10) : undefined;
         const splitRatio = splitArg ? parseFloat(splitArg) : undefined;
 
+        // Which routing priority (model tier + thinking effort) answers a chat message with —
+        // see AIVendorManager.TaskPriority. Chat defaults to 'media-prioridad' (the same default
+        // ai:code uses) rather than something cheaper, since a wrong answer in an interactive
+        // back-and-forth is more disruptive than in a one-shot batch command.
+        const priority = (parseFlag(args, '--priority') as TaskPriority | undefined) ?? 'media-prioridad';
+
+        // Complexity/cost ceiling ("techo de complejidad"): no resolved priority may ever exceed
+        // this, no matter what --priority above (or a future per-message override) asks for. Falls
+        // back to AI_CHAT_MAX_PRIORITY so a chat session can be capped independently from ai:code /
+        // ai:describe (which fall back to the general AI_MAX_PRIORITY instead — see
+        // AIVendorManager.getPriorityCeiling()). --max-priority overrides both for this one run.
+        const maxPriority = (parseFlag(args, '--max-priority') as TaskPriority | undefined)
+            ?? (process.env.AI_CHAT_MAX_PRIORITY as TaskPriority | undefined);
+        if (maxPriority) aiVendor.setPriorityCeiling(maxPriority);
+
         // Default responder: forwards the conversation (plus any attached images) to the
-        // configured AI vendor. Replace with your own chatManager.onMessage(...) in a custom
-        // command if you want different behaviour.
+        // configured AI vendor, routed through the same priority/ceiling system as ai:code and
+        // ai:describe. Replace with your own chatManager.onMessage(...) in a custom command if you
+        // want different behaviour.
         chatManager.onMessage(async ({ message, history, dir: chatDir }: ChatMessageContext) => {
             const priorTurns: AIMessage[] = history.slice(0, -1).map((m) => ({
                 role: m.role === 'user' ? 'user' : 'assistant',
@@ -49,7 +65,7 @@ export default function chat({ logger, chat: chatManager, aiVendor, fail }: TyrC
                 { role: 'user', content: contentBlocks.length > 0 ? contentBlocks : message.text },
             ];
 
-            const result = await aiVendor.complete(messages);
+            const result = await aiVendor.completeWithPriority(messages, priority);
             return result.content;
         });
 
@@ -65,6 +81,7 @@ export default function chat({ logger, chat: chatManager, aiVendor, fail }: TyrC
             const session = await chatManager.open(dir, { port, splitRatio });
             logger.success(`Chat ready at: ${session.url}`);
             logger.info(`Browsing: ${session.dir}`);
+            logger.info(`Priority: ${priority}${maxPriority ? ` (ceiling: ${maxPriority})` : ''}`);
             logger.info('Press Ctrl+C to stop.');
         } catch (e: any) {
             fail(`Could not start chat: ${e.message}`, 'Check that the directory exists and the port is free.');

package/src/index.ts

@@ -4,3 +4,4 @@
 
 export type { TyrContext } from './core/Kernel.js';
 export type { TaskPriority } from './lib/AIVendorManager.js';
+export { TASK_PRIORITIES } from './lib/AIVendorManager.js';

package/src/lib/AIContextManager.ts

@@ -1,8 +1,11 @@
 import path from 'path';
 import { statSync } from 'fs';
+import { createPatch } from 'diff';
 
 import { FileSystemManager } from './FileSystemManager.js';
 import { ShellManager } from './ShellManager.js';
+import { GitManager } from './GitManager.js';
+import { SandboxManager, SandboxResult } from './SandboxManager.js';
 import { AIVendorManager, AIMessage, AIContentBlock, AITool, TaskPriority } from './AIVendorManager.js';
 import { TokenManager } from './TokenManager.js';
 import { Logger } from '../core/Logger.js';
@@ -252,6 +255,20 @@ export const AGENT_TOOLS: AITool[] = [
             required: ['packageName', 'path'],
         },
     },
+    {
+        name: 'git_diff',
+        description:
+            "Shows the project's current git status and diff (uncommitted changes vs. HEAD), if it " +
+            'is a git repository. Useful to see what has already been modified — by you earlier in ' +
+            'this session, or by the user — before making further edits. Read-only: this tool can ' +
+            'only inspect the working tree, it can NEVER stage (git add) or commit anything.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                staged: { type: 'boolean', description: 'If true, show the staged diff instead of the unstaged working-tree diff.' },
+            },
+        },
+    },
 ];
 
 export interface AgentRunOptions {
@@ -274,11 +291,20 @@ export interface ValidationResult {
     output?: string;
 }
 
+/** Unified diff for a single file changed by applyPatches(), meant to be shown to the human
+ *  verbatim (never re-transcribed by the model) — see runCodeAgent()'s callers. */
+export interface FileDiff {
+    path: string;
+    diff: string;
+}
+
 export interface CodeAgentResult extends AgentRunResult {
     filesChanged: string[];
     blockedWrites: string[];
     failedEdits: string[];
+    fileDiffs: FileDiff[];
     validation: ValidationResult;
+    sandbox: SandboxResult;
 }
 
 interface FilePatchEdit {
@@ -318,12 +344,16 @@ export class AIContextManager {
     private shell: ShellManager;
     private ai: AIVendorManager;
     private logger: Logger;
+    private git: GitManager;
+    private sandbox: SandboxManager;
 
-    constructor(fs: FileSystemManager, shell: ShellManager, ai: AIVendorManager, logger: Logger) {
+    constructor(fs: FileSystemManager, shell: ShellManager, ai: AIVendorManager, logger: Logger, git: GitManager, sandbox: SandboxManager) {
         this.fs = fs;
         this.shell = shell;
         this.ai = ai;
         this.logger = logger;
+        this.git = git;
+        this.sandbox = sandbox;
     }
 
     // === Guideline files (CLAUDE.md / AGENTS.md) =================================================
@@ -976,6 +1006,13 @@ export class AIContextManager {
         return this.truncateForTool(content);
     }
 
+    /** Read-only: status()/diff() never stage or commit anything (see GitManager). */
+    private async toolGitDiff(ctx: AgentToolContext, input: any): Promise<string> {
+        const status = await this.git.status(ctx.projectDir);
+        const diffText = await this.git.diff(ctx.projectDir, { staged: !!input?.staged });
+        return this.truncateForTool(`Status:\n${status}\n\nDiff:\n${diffText}`);
+    }
+
     private async executeAgentTool(ctx: AgentToolContext, name: string, input: any): Promise<string> {
         try {
             switch (name) {
@@ -987,6 +1024,7 @@ export class AIContextManager {
                 case 'read_dependency_manifest': return await this.toolReadDependencyManifest(ctx, input);
                 case 'list_dependency_files': return await this.toolListDependencyFiles(ctx, input);
                 case 'read_dependency_file': return await this.toolReadDependencyFile(ctx, input);
+                case 'git_diff': return await this.toolGitDiff(ctx, input);
                 default: return `Error: unknown tool "${name}".`;
             }
         } catch (err: any) {
@@ -1159,10 +1197,11 @@ export class AIContextManager {
         targetDir: string,
         blocks: FilePatchBlock[],
         seenFiles: Set<string>
-    ): Promise<{ filesChanged: string[]; blockedWrites: string[]; failedEdits: string[] }> {
+    ): Promise<{ filesChanged: string[]; blockedWrites: string[]; failedEdits: string[]; fileDiffs: FileDiff[] }> {
         const filesChanged: string[] = [];
         const blockedWrites: string[] = [];
         const failedEdits: string[] = [];
+        const fileDiffs: FileDiff[] = [];
 
         for (const block of blocks) {
             const resolvedPath = path.resolve(targetDir, block.relPath);
@@ -1188,7 +1227,8 @@ export class AIContextManager {
                 continue;
             }
 
-            let content = existed ? (await this.fs.read(resolvedPath)) ?? '' : '';
+            const beforeContent = existed ? ((await this.fs.read(resolvedPath)) ?? '') : '';
+            let content = beforeContent;
             let ok = true;
 
             for (const edit of block.edits) {
@@ -1203,13 +1243,15 @@ export class AIContextManager {
                 continue;
             }
 
-            await this.fs.write(resolvedPath, content.endsWith('\n') ? content : content + '\n');
+            const finalContent = content.endsWith('\n') ? content : content + '\n';
+            await this.fs.write(resolvedPath, finalContent);
             seenFiles.add(resolvedPath);
             this.logger.success(`${existed ? 'Modified' : 'Created'}: ${resolvedPath}`);
             filesChanged.push(block.relPath);
+            fileDiffs.push({ path: block.relPath, diff: createPatch(block.relPath, beforeContent, finalContent, '', '', { context: 3 }) });
         }
 
-        return { filesChanged, blockedWrites, failedEdits };
+        return { filesChanged, blockedWrites, failedEdits, fileDiffs };
     }
 
     // === Post-write validation (self-healing) ======================================================
@@ -1294,7 +1336,9 @@ export class AIContextManager {
         let filesChanged: string[] = [];
         let blockedWrites: string[] = [];
         let failedEdits: string[] = [];
+        let fileDiffs: FileDiff[] = [];
         let validation: ValidationResult = { ran: false, ok: true };
+        let sandboxResult: SandboxResult = { ran: false, ok: true };
 
         for (let attempt = 0; attempt <= MAX_SELF_HEAL_ATTEMPTS; attempt++) {
             const run = await this.runAgentLoop(messages, ctx, tokens, { ...options, priority });
@@ -1310,14 +1354,20 @@ export class AIContextManager {
             filesChanged = applied.filesChanged;
             blockedWrites = applied.blockedWrites;
             failedEdits = applied.failedEdits;
+            fileDiffs = applied.fileDiffs;
             if (filesChanged.length === 0) break;
 
             validation = await this.runValidation(targetDir);
-            if (validation.ok || attempt === MAX_SELF_HEAL_ATTEMPTS) break;
+            sandboxResult = validation.ok ? await this.sandbox.verify(targetDir) : { ran: false, ok: true };
+
+            const stepFailed = !validation.ok || !sandboxResult.ok;
+            if (!stepFailed || attempt === MAX_SELF_HEAL_ATTEMPTS) break;
 
             const nextPriority = this.ai.bumpPriority(priority);
+            const failureLabel = !validation.ok ? 'compilation/lint' : `the sandbox check (${sandboxResult.command})`;
+            const failureOutput = !validation.ok ? validation.output : sandboxResult.output;
             this.logger.warn(
-                `Post-write validation failed (attempt ${attempt + 1}/${MAX_SELF_HEAL_ATTEMPTS + 1}); asking the model to fix it and bumping priority: ${priority} → ${nextPriority}`
+                `Post-write ${failureLabel} failed (attempt ${attempt + 1}/${MAX_SELF_HEAL_ATTEMPTS + 1}); asking the model to fix it and bumping priority: ${priority} → ${nextPriority}`
             );
             priority = nextPriority;
 
@@ -1325,13 +1375,25 @@ export class AIContextManager {
             messages.push({
                 role: 'user',
                 content:
-                    `SYSTEM: Your change broke compilation/lint with the following error:\n\n${validation.output ?? '(no output captured)'}\n\n` +
+                    `SYSTEM: Your change broke ${failureLabel} with the following error:\n\n${failureOutput ?? '(no output captured)'}\n\n` +
                     'Fix it using more SEARCH/REPLACE blocks for the affected file(s). If you are not certain of a file\'s current ' +
                     'exact content after your previous edit, re-read it with read_file before writing a new SEARCH block against it.',
             });
         }
 
-        return { content: lastContent, promptTokens, completionTokens, toolCallsUsed, priorityUsed: priority, filesChanged, blockedWrites, failedEdits, validation };
+        return {
+            content: lastContent,
+            promptTokens,
+            completionTokens,
+            toolCallsUsed,
+            priorityUsed: priority,
+            filesChanged,
+            blockedWrites,
+            failedEdits,
+            fileDiffs,
+            validation,
+            sandbox: sandboxResult,
+        };
     }
 
     /**

package/src/lib/AIVendorManager.ts

@@ -261,8 +261,10 @@ function resolvePriorityRoute(priority: TaskPriority): { tier: ModelTier; thinki
     };
 }
 
-/** Ordered priority ladder, used by bumpPriority() to escalate one level at a time. */
-const PRIORITY_LADDER: TaskPriority[] = [
+/** Ordered priority ladder, used by bumpPriority() to escalate one level at a time and by
+ *  clampPriority() to enforce an optional ceiling. Exported so callers (e.g. a chat UI's effort
+ *  selector) can list the valid levels without hardcoding them. */
+export const TASK_PRIORITIES: TaskPriority[] = [
     'baja-prioridad',
     'baja-media-prioridad',
     'media-prioridad',
@@ -294,6 +296,7 @@ const PRIORITY_LADDER: TaskPriority[] = [
  */
 export class AIVendorManager {
     private logger: Logger;
+    private priorityCeilingOverride: TaskPriority | null = null;
 
     constructor(logger: Logger) {
         this.logger = logger;
@@ -360,9 +363,9 @@ export class AIVendorManager {
             .toLowerCase() as AIVendor;
 
         if (!PRIORITY_ROUTING[priority]) {
-            throw new TyrError(`Unknown task priority: '${priority}'`, null, `Use one of: ${PRIORITY_LADDER.join(', ')}`);
+            throw new TyrError(`Unknown task priority: '${priority}'`, null, `Use one of: ${TASK_PRIORITIES.join(', ')}`);
         }
-        const route = resolvePriorityRoute(priority);
+        const route = resolvePriorityRoute(this.clampPriority(priority));
 
         const tierModel = getEnvString(MODEL_TIER_ENV[vendor][route.tier], MODEL_TIER_DEFAULT[vendor]);
 
@@ -385,9 +388,44 @@ export class AIVendorManager {
      * priority = aiVendor.bumpPriority(priority); // one more level of thinking/model tier
      */
     public bumpPriority(priority: TaskPriority): TaskPriority {
-        const index = PRIORITY_LADDER.indexOf(priority);
-        if (index === -1 || index === PRIORITY_LADDER.length - 1) return priority;
-        return PRIORITY_LADDER[index + 1];
+        const index = TASK_PRIORITIES.indexOf(priority);
+        if (index === -1 || index === TASK_PRIORITIES.length - 1) return priority;
+        return this.clampPriority(TASK_PRIORITIES[index + 1]);
+    }
+
+    /**
+     * @method setPriorityCeiling
+     * @description Sets (or clears, with `null`) an upper bound no resolved priority may ever
+     * exceed for this instance — including self-healing escalations via bumpPriority(). Meant for
+     * a developer-controlled cap (e.g. a chat UI's effort selector) so the model can never reach
+     * an expensive tier the developer didn't authorize for the task at hand, no matter how many
+     * retries a validation/sandbox failure triggers. An instance override always wins over the
+     * AI_MAX_PRIORITY env var (see getPriorityCeiling()).
+     * @param {TaskPriority | null} priority - The highest allowed priority, or null to remove the cap.
+     * @example
+     * aiVendor.setPriorityCeiling('media-prioridad'); // never route to alta/muy-alta, even on retry
+     */
+    public setPriorityCeiling(priority: TaskPriority | null): void {
+        this.priorityCeilingOverride = priority;
+        this.logger.info(priority ? `[AI] Priority ceiling set to '${priority}'.` : '[AI] Priority ceiling cleared.');
+    }
+
+    /** Instance override (set via setPriorityCeiling) wins over the AI_MAX_PRIORITY env var, which
+     *  in turn is the default ceiling for non-interactive commands with no UI to set one live. */
+    private getPriorityCeiling(): TaskPriority | null {
+        if (this.priorityCeilingOverride) return this.priorityCeilingOverride;
+        const envCeiling = getEnvString('AI_MAX_PRIORITY') as TaskPriority | undefined;
+        return envCeiling && TASK_PRIORITIES.includes(envCeiling) ? envCeiling : null;
+    }
+
+    /** Clamps `priority` down to the current ceiling (if any and if it's actually lower). No-op
+     *  when no ceiling is configured, so this is fully backward compatible by default. */
+    private clampPriority(priority: TaskPriority): TaskPriority {
+        const ceiling = this.getPriorityCeiling();
+        if (!ceiling) return priority;
+        if (TASK_PRIORITIES.indexOf(priority) <= TASK_PRIORITIES.indexOf(ceiling)) return priority;
+        this.logger.info(`[AI] Priority '${priority}' clamped down to ceiling '${ceiling}'.`);
+        return ceiling;
     }
 
     /**

package/src/lib/ChatManager.ts

@@ -28,6 +28,15 @@ export interface ChatMessage {
     createdAt: number;
 }
 
+/** Opaque "effort ceiling" selector rendered in the chat header — ChatManager never interprets
+ *  these strings (it doesn't know what a TaskPriority is, by design), it just displays `levels`
+ *  and forwards whichever one the user picks via the 'priority:change' event. The caller (e.g.
+ *  a command wiring AIVendorManager) decides what the values mean and what to do with a change. */
+export interface ChatPriorityCeilingOptions {
+    levels: string[];
+    initial: string;
+}
+
 export interface ChatOpenOptions {
     /** Preferred port. If busy, the next free port is used instead (default: 4646). */
     port?: number;
@@ -36,6 +45,8 @@ export interface ChatOpenOptions {
     /** Initial fraction of the width given to the chat pane, 0.2–0.8 (default: 0.4). The user
      *  can still resize it live by dragging the divider between the two panes. */
     splitRatio?: number;
+    /** Renders an effort-ceiling dropdown in the chat header when provided. Omit to skip it entirely. */
+    priorityCeiling?: ChatPriorityCeilingOptions;
 }
 
 export interface ChatSession {
@@ -73,7 +84,8 @@ export type ChatEventName =
     | 'message:response'
     | 'message:error'
     | 'file:select'
-    | 'context:change';
+    | 'context:change'
+    | 'priority:change';
 
 interface InternalSession {
     id: string;
@@ -90,6 +102,9 @@ interface InternalSession {
      *  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>;
+    /** Current value of the effort-ceiling dropdown, if the caller opted into one via
+     *  ChatOpenOptions.priorityCeiling. `current` is mutated by POST /api/priority-ceiling. */
+    priorityCeiling?: { levels: string[]; current: string };
 }
 
 const DEFAULT_PORT = 4646;
@@ -370,6 +385,9 @@ export class ChatManager {
             splitRatio,
             title,
             contextFiles: new Set(),
+            priorityCeiling: options.priorityCeiling
+                ? { levels: options.priorityCeiling.levels, current: options.priorityCeiling.initial }
+                : undefined,
         };
 
         const server = http.createServer((req, res) => {
@@ -437,7 +455,7 @@ export class ChatManager {
         const session = this.sessions.get(sessionId);
         if (!session) return;
 
-        await this.emitSafe('chat:close', { sessionId });
+        await this.emitSafe('chat:close', { sessionId, dir: session.dir, history: session.history });
         await new Promise<void>((resolve) => session.server.close(() => resolve()));
 
         try {
@@ -520,6 +538,18 @@ export class ChatManager {
                 return;
             }
 
+            if (pathname === '/api/priority-ceiling' && req.method === 'POST') {
+                const body = await this.readJsonBody(req);
+                const value = typeof body?.value === 'string' ? body.value : '';
+                if (!session.priorityCeiling || !session.priorityCeiling.levels.includes(value)) {
+                    throw new TyrError('Invalid priority ceiling value', null, 'Send one of the values from BOOTSTRAP.priorityCeiling.levels.');
+                }
+                session.priorityCeiling.current = value;
+                await this.emitSafe('priority:change', { sessionId: session.id, dir: session.dir, value });
+                this.sendJson(res, 200, { ok: true, value });
+                return;
+            }
+
             if (pathname === '/api/tree' && req.method === 'GET') {
                 const rel = url.searchParams.get('path') ?? '';
                 const entries = await this.listChildren(session, rel);
@@ -727,6 +757,7 @@ export class ChatManager {
             dir: session.dir,
             splitRatio: session.splitRatio,
             title: session.title,
+            priorityCeiling: session.priorityCeiling ?? null,
         }).replace(/</g, '\\u003c');
 
         return `<!DOCTYPE html>
@@ -774,6 +805,7 @@ export class ChatManager {
   #send-btn { background: #4db8ff; color: #00121f; }
   #send-btn:disabled { opacity: 0.5; cursor: default; }
   #attach-btn { background: #333; color: #eee; }
+  #priority-select { display: none; background: #151515; color: #eee; border: 1px solid #333; border-radius: 6px; padding: 4px 8px; font-size: 12px; }
   #files-header span:last-child { color: #888; font-weight: 400; font-size: 12px; }
   #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; }
@@ -791,7 +823,7 @@ export class ChatManager {
 <body>
 <div id="app">
   <div id="chat-pane">
-    <header><span>💬 ${session.title}</span></header>
+    <header><span>💬 ${session.title}</span><select id="priority-select" title="Maximum effort/model tier this chat may ever use"></select></header>
     <div id="messages"></div>
     <div id="compose">
       <div id="pending-attachments"></div>
@@ -825,6 +857,7 @@ const BOOTSTRAP = ${bootstrap};
   const treeEl = document.getElementById('tree');
   const previewEl = document.getElementById('preview');
   const divider = document.getElementById('divider');
+  const prioritySelect = document.getElementById('priority-select');
 
   function applySplit(ratio) {
     app.style.setProperty('--chat-w', (ratio * 100) + '%');
@@ -844,6 +877,24 @@ const BOOTSTRAP = ${bootstrap};
   });
   window.addEventListener('mouseup', function () { dragging = false; document.body.style.cursor = ''; });
 
+  if (BOOTSTRAP.priorityCeiling) {
+    BOOTSTRAP.priorityCeiling.levels.forEach(function (level) {
+      const opt = document.createElement('option');
+      opt.value = level;
+      opt.textContent = level;
+      if (level === BOOTSTRAP.priorityCeiling.current) opt.selected = true;
+      prioritySelect.appendChild(opt);
+    });
+    prioritySelect.style.display = '';
+    prioritySelect.addEventListener('change', function () {
+      fetch('/api/priority-ceiling', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: prioritySelect.value }),
+      });
+    });
+  }
+
   function escapeHtml(s) {
     return String(s).replace(/[&<>"']/g, function (c) {
       return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c];

package/src/lib/GitManager.ts

@@ -1,3 +1,5 @@
+import { execa } from 'execa';
+
 import { ShellManager } from './ShellManager.js';
 import { Logger } from '../core/Logger.js';
 import { TyrError } from '../core/TyrError.js';
@@ -123,6 +125,54 @@ export class GitManager {
             throw new TyrError(`Could not initialize git repository at ${dir}`, e);
         }
     }
+
+    /**
+     * @method status
+     * @description Read-only `git status --porcelain` for an arbitrary directory. Unlike the rest
+     * of this class, this targets `dir` directly via execa instead of the shared ShellManager's
+     * mutate-then-run cwd (the same reasoning AIContextManager.runValidation() already has to work
+     * around by saving/restoring the shell's cwd itself) — a read-only, dir-scoped check has no
+     * business touching shared state. Never throws: returns a friendly string for "not a repo" or
+     * "git unavailable" instead, since this is called speculatively by the AI agent's tool loop.
+     * @param {string} dir - Absolute path to check.
+     * @returns {Promise<string>} Porcelain status output, or a friendly explanation if unavailable.
+     * @example
+     * const status = await git.status('/path/to/project');
+     */
+    public async status(dir: string): Promise<string> {
+        try {
+            const result = await execa('git', ['status', '--porcelain'], { cwd: dir, reject: false });
+            if (result.exitCode !== 0) {
+                return `Not a git repository, or git status failed: ${String(result.stderr || result.stdout).trim()}`;
+            }
+            return result.stdout.trim() || '(clean — no changes)';
+        } catch (e: any) {
+            return `git is not available: ${e?.message ?? String(e)}`;
+        }
+    }
+
+    /**
+     * @method diff
+     * @description Read-only `git diff` (working tree, or `--staged`) for an arbitrary directory.
+     * Same execa-direct, never-throws convention as status() — see its doc for why.
+     * @param {string} dir - Absolute path to diff.
+     * @param {{ staged?: boolean }} options - Pass `staged: true` for `git diff --staged`.
+     * @returns {Promise<string>} Unified diff text, or a friendly explanation if unavailable.
+     * @example
+     * const diff = await git.diff('/path/to/project');
+     */
+    public async diff(dir: string, options: { staged?: boolean } = {}): Promise<string> {
+        const args = ['diff', ...(options.staged ? ['--staged'] : [])];
+        try {
+            const result = await execa('git', args, { cwd: dir, reject: false });
+            if (result.exitCode !== 0) {
+                return `git diff failed: ${String(result.stderr || result.stdout).trim()}`;
+            }
+            return result.stdout.trim() || '(no differences)';
+        } catch (e: any) {
+            return `git is not available: ${e?.message ?? String(e)}`;
+        }
+    }
 }
 
 /**

package/src/lib/MemoryManager.ts

@@ -0,0 +1,283 @@
+import path from 'path';
+import crypto from 'crypto';
+import { homedir } from 'os';
+import yaml from 'js-yaml';
+
+import { FileSystemManager } from './FileSystemManager.js';
+import { Logger } from '../core/Logger.js';
+import { AIMessage } from './AIVendorManager.js';
+import { getEnvInt } from '../core/util/getenv.js';
+
+export type MemoryCommand = 'ai:chat' | 'ai:code' | 'ai:describe';
+
+export interface MemoryHistoryTurn {
+    role: 'user' | 'assistant';
+    text: string;
+}
+
+export interface MemoryConversationEntry {
+    command: MemoryCommand;
+    history: MemoryHistoryTurn[];
+    filesChanged: string[];
+}
+
+export interface MemoryMatch {
+    filePath: string;
+    date: string;
+    command: MemoryCommand;
+    summary: string;
+    score: number;
+}
+
+interface MemoryFrontmatter {
+    project: string;
+    date: string;
+    command: MemoryCommand;
+    filesChanged: string[];
+    topics: string[];
+}
+
+const MIN_RELEVANCE_SCORE = getEnvInt('MEMORY_MIN_RELEVANCE_SCORE', 2);
+const MAX_TOPICS = 12;
+const MAX_TIMELINE_TURNS = 40;
+const SUMMARY_EXCERPT_CHARS = 140;
+
+// Small, deliberately conservative stopword set (EN + ES) — just enough to keep the most common
+// filler words out of topic extraction, not a full NLP pipeline (see extractTopics()).
+const STOPWORDS = new Set([
+    'the', 'a', 'an', 'and', 'or', 'to', 'of', 'in', 'on', 'for', 'with', 'this', 'that', 'is',
+    'are', 'was', 'were', 'be', 'been', 'it', 'as', 'at', 'by', 'from', 'not', 'but', 'you', 'your',
+    'can', 'will', 'should', 'would', 'could', 'please', 'add', 'file', 'files',
+    'de', 'la', 'el', 'los', 'las', 'un', 'una', 'unos', 'unas', 'y', 'o', 'que', 'en', 'con', 'para',
+    'por', 'del', 'al', 'es', 'ser', 'está', 'esta', 'este', 'como', 'lo', 'se', 'su', 'sus', 'me',
+    'te', 'le', 'les', 'quiero', 'quieres', 'puedes', 'archivo', 'archivos',
+]);
+
+function sanitizeSlugPart(value: string): string {
+    return value.toLowerCase().replace(/[^a-z0-9-_]+/g, '-').replace(/^-+|-+$/g, '') || 'project';
+}
+
+function truncateText(text: string, maxChars: number): string {
+    const trimmed = text.trim().replace(/\s+/g, ' ');
+    return trimmed.length <= maxChars ? trimmed : `${trimmed.slice(0, maxChars)}…`;
+}
+
+/** Word tokens (letters, 3+ chars) plus filename-like tokens (basename.ext) — the same style of
+ *  cheap, deterministic tokenization used elsewhere in this codebase for mention detection. */
+function tokenize(text: string): string[] {
+    const words = (text.match(/[A-Za-z][A-Za-z0-9_]{2,}/g) ?? []).map((t) => t.toLowerCase());
+    const fileTokens = (text.match(/[\w./-]+\.[A-Za-z0-9]+/g) ?? []).map((t) => t.toLowerCase());
+    return [...words.filter((t) => !STOPWORDS.has(t)), ...fileTokens];
+}
+
+function basenameNoExt(relPath: string): string {
+    return path.basename(relPath, path.extname(relPath)).toLowerCase();
+}
+
+/** 100% deterministic — no AI call. Basenames of changed files always count as topics (highest
+ *  signal); everything else is ranked by raw frequency across the conversation's text. */
+function extractTopics(history: MemoryHistoryTurn[], filesChanged: string[]): string[] {
+    const fileBasenames = filesChanged.map(basenameNoExt);
+    const combinedText = history.map((h) => h.text).join(' ');
+
+    const freq = new Map<string, number>();
+    for (const token of tokenize(combinedText)) {
+        freq.set(token, (freq.get(token) ?? 0) + 1);
+    }
+
+    const ranked = [...freq.entries()]
+        .filter(([token]) => !fileBasenames.includes(token))
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, MAX_TOPICS)
+        .map(([token]) => token);
+
+    return [...new Set([...fileBasenames, ...ranked])];
+}
+
+function buildSummary(entry: MemoryConversationEntry): string {
+    const filesLine = entry.filesChanged.length > 0 ? `Files changed: ${entry.filesChanged.join(', ')}.` : 'No files changed.';
+    const firstUser = entry.history.find((h) => h.role === 'user');
+    const lastUser = [...entry.history].reverse().find((h) => h.role === 'user');
+
+    let messageLines = firstUser ? `First message: "${truncateText(firstUser.text, SUMMARY_EXCERPT_CHARS)}"` : '';
+    if (lastUser && lastUser !== firstUser) {
+        messageLines += ` Last message: "${truncateText(lastUser.text, SUMMARY_EXCERPT_CHARS)}"`;
+    }
+
+    return `${entry.history.length} message(s) exchanged. ${filesLine} ${messageLines}`.trim();
+}
+
+function buildTimeline(history: MemoryHistoryTurn[]): string {
+    const capped = history.slice(0, MAX_TIMELINE_TURNS);
+    const lines = capped.map((h) => `- ${h.role}: ${truncateText(h.text, 120)}`);
+    if (history.length > MAX_TIMELINE_TURNS) {
+        lines.push(`- (${history.length - MAX_TIMELINE_TURNS} earlier turn(s) omitted)`);
+    }
+    return lines.join('\n');
+}
+
+function parseFrontmatter(content: string): { data: MemoryFrontmatter; body: string } | null {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match) return null;
+    try {
+        const data = yaml.load(match[1]) as MemoryFrontmatter;
+        if (!data || typeof data !== 'object') return null;
+        return { data, body: match[2] };
+    } catch {
+        return null;
+    }
+}
+
+function extractSummarySection(body: string): string {
+    const match = body.match(/## Summary\n([\s\S]*?)(\n##|$)/);
+    return match ? match[1].trim() : '';
+}
+
+/**
+ * @class MemoryManager
+ * @description Global, cross-session memory of past ai:chat/ai:code/ai:describe conversations,
+ * stored as compacted Markdown files under ~/.tyr/.tyr-mem/<project-slug>/. Complements the
+ * per-project AGENTS.md/CLAUDE.md guidelines (see AIContextManager.getContext()) with "what we
+ * actually did here before" — grounded on real conversation history rather than hand-written docs.
+ *
+ * Both writing (recordConversation) and reading (findRelevant) are entirely deterministic — no AI
+ * call anywhere in this class. Compaction is built from data the caller already has (message text,
+ * files changed); retrieval is plain keyword-overlap scoring, scoped to the same project only, and
+ * returns nothing below a relevance threshold. This is a deliberate cost control: memory should
+ * only spend context-window tokens when it's actually likely to help, never as a blind dump.
+ */
+export class MemoryManager {
+    private fs: FileSystemManager;
+    private logger: Logger;
+    /** Resolved once at construction (same convention as TokenManager's usageFile) — homedir() is
+     *  read live at that point, so tests can point HOME elsewhere before constructing an instance. */
+    private memoryRoot: string;
+
+    constructor(fs: FileSystemManager, logger: Logger) {
+        this.fs = fs;
+        this.logger = logger;
+        this.memoryRoot = path.join(homedir(), '.tyr', '.tyr-mem');
+    }
+
+    private projectSlug(projectDir: string): string {
+        const resolved = path.resolve(projectDir);
+        const hash = crypto.createHash('sha1').update(resolved).digest('hex').slice(0, 8);
+        return `${sanitizeSlugPart(path.basename(resolved))}-${hash}`;
+    }
+
+    private projectMemoryDir(projectDir: string): string {
+        return path.join(this.memoryRoot, this.projectSlug(projectDir));
+    }
+
+    /**
+     * @method recordConversation
+     * @description Compacts and writes a conversation to disk under this project's memory folder.
+     * Compaction is entirely deterministic (turn count, files touched, truncated first/last
+     * message, capped timeline) — never an extra AI call.
+     * @param {string} projectDir - Absolute path to the project the conversation was about.
+     * @param {MemoryConversationEntry} entry - What happened: command, turns, files changed.
+     * @returns {Promise<string>} The path of the written memory file.
+     * @example
+     * await memory.recordConversation(targetDir, { command: 'ai:code', history, filesChanged });
+     */
+    public async recordConversation(projectDir: string, entry: MemoryConversationEntry): Promise<string> {
+        const isoStamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const shortId = crypto.randomUUID().slice(0, 8);
+        const filePath = path.join(this.projectMemoryDir(projectDir), `${isoStamp}-${shortId}.md`);
+
+        const frontmatter: MemoryFrontmatter = {
+            project: path.resolve(projectDir),
+            date: new Date().toISOString(),
+            command: entry.command,
+            filesChanged: entry.filesChanged,
+            topics: extractTopics(entry.history, entry.filesChanged),
+        };
+
+        const content =
+            `---\n${yaml.dump(frontmatter, { lineWidth: -1 })}---\n\n` +
+            `## Summary\n${buildSummary(entry)}\n\n` +
+            `## Timeline\n${buildTimeline(entry.history)}\n`;
+
+        await this.fs.write(filePath, content);
+        return filePath;
+    }
+
+    /**
+     * @method findRelevant
+     * @description Scores every memory file for this project by deterministic keyword overlap
+     * against `taskText`, returning only matches at or above a minimum relevance threshold — never
+     * an unfiltered dump. No AI call. Scoped to this project only (no cross-project search in v1).
+     * @param {string} projectDir - Absolute path to the project.
+     * @param {string} taskText - The current message/task to find relevant past work for.
+     * @param {number} limit - Max matches to return (default 3).
+     * @returns {Promise<MemoryMatch[]>} Matches sorted by score desc, then date desc.
+     * @example
+     * const matches = await memory.findRelevant(targetDir, message.text);
+     */
+    public async findRelevant(projectDir: string, taskText: string, limit: number = 3): Promise<MemoryMatch[]> {
+        const memoryDir = this.projectMemoryDir(projectDir);
+        const fileNames = (await this.fs.readdir(memoryDir)).filter((name) => name.endsWith('.md'));
+        if (fileNames.length === 0) return [];
+
+        const queryTokens = new Set(tokenize(taskText));
+        if (queryTokens.size === 0) return [];
+
+        const matches: MemoryMatch[] = [];
+        for (const fileName of fileNames) {
+            const filePath = path.join(memoryDir, fileName);
+            const content = await this.fs.read(filePath);
+            if (!content) continue;
+
+            const parsed = parseFrontmatter(content);
+            if (!parsed) continue;
+
+            const fileBasenames = new Set((parsed.data.filesChanged ?? []).map(basenameNoExt));
+            let score = 0;
+            for (const topic of parsed.data.topics ?? []) {
+                if (queryTokens.has(topic)) score += fileBasenames.has(topic) ? 2 : 1;
+            }
+            if (score < MIN_RELEVANCE_SCORE) continue;
+
+            matches.push({
+                filePath,
+                date: parsed.data.date,
+                command: parsed.data.command,
+                summary: extractSummarySection(parsed.body),
+                score,
+            });
+        }
+
+        return matches
+            .sort((a, b) => b.score - a.score || (a.date < b.date ? 1 : -1))
+            .slice(0, limit);
+    }
+
+    /**
+     * @method getContextMessage
+     * @description Convenience wrapper mirroring AIContextManager.getContext()'s shape: a single
+     * 'system' message ready to splice into a prompt, or `null` when nothing relevant was found —
+     * so callers can skip it cheaply exactly like they already do for other optional context.
+     * @param {string} projectDir - Absolute path to the project.
+     * @param {string} taskText - The current message/task to find relevant past work for.
+     * @returns {Promise<AIMessage | null>}
+     * @example
+     * const memoryMessage = await memory.getContextMessage(targetDir, message.text);
+     * if (memoryMessage) messages.push(memoryMessage);
+     */
+    public async getContextMessage(projectDir: string, taskText: string): Promise<AIMessage | null> {
+        const matches = await this.findRelevant(projectDir, taskText);
+        if (matches.length === 0) return null;
+
+        const sections = matches.map((m) => `### ${m.command} — ${m.date}\n${m.summary}`);
+        return {
+            role: 'system',
+            content: `Relevant past work on this project (from memory):\n\n${sections.join('\n\n')}`,
+        };
+    }
+}
+
+/**
+ * @object MemoryManagerTests
+ * @description Test parameters to validate MemoryManager functionality.
+ */
+export const MemoryManagerTests = {};

package/src/lib/SandboxManager.ts

@@ -0,0 +1,152 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import os from 'os';
+import path from 'path';
+import { execa } from 'execa';
+
+import { Logger } from '../core/Logger.js';
+import { getEnvInt } from '../core/util/getenv.js';
+
+// Kept textually in sync with AIContextManager's own DEFAULT_IGNORED_DIRS — not imported from
+// there on purpose, so SandboxManager stays independent of AIContextManager's internals.
+const IGNORED_DIRS = new Set<string>([
+    'node_modules', '.git', '.hg', '.svn',
+    '.turbo', '.next', '.nuxt', '.cache', '.parcel-cache',
+    '.vscode', '.idea',
+    'dist', 'build', 'out', 'coverage', '.nyc_output',
+    'target', 'vendor',
+]);
+
+// npm's own placeholder for a project with no real tests yet — never worth "running".
+const NPM_DEFAULT_TEST_SCRIPT = /^echo\s+"Error: no test specified"\s*&&\s*exit\s+1$/i;
+
+const SANDBOX_TIMEOUT_MS = getEnvInt('SANDBOX_TIMEOUT_MS', 120000);
+const MAX_OUTPUT_CHARS = 8000;
+
+export interface SandboxResult {
+    ran: boolean;
+    ok: boolean;
+    /** The `npm run <script>` command actually executed, if any. */
+    command?: string;
+    /** Captured stdout/stderr, only populated on failure (truncated). */
+    output?: string;
+}
+
+function truncate(text: string, maxChars: number = MAX_OUTPUT_CHARS): string {
+    if (text.length <= maxChars) return text;
+    return `${text.slice(0, maxChars)}\n... (truncated, ${text.length - maxChars} more characters)`;
+}
+
+/**
+ * @class SandboxManager
+ * @description Runs a project's own test/build command in an isolated temp copy, as an extra
+ * verification step on top of AIContextManager's compile/lint validation — "does this actually
+ * work", not just "does it typecheck". Copies source files (skipping the same kind of noise
+ * directories the rest of the codebase already ignores) into a fresh temp directory, symlinks the
+ * original `node_modules` in rather than reinstalling (fast, and installing isn't this class's
+ * job), and executes with a hard timeout. Never touches the real project directory. Not a real OS
+ * sandbox (no container, no network/resource limits) — a deliberate scope choice, cheap to run
+ * for a personal tool; revisit if this ever needs to run untrusted code.
+ */
+export class SandboxManager {
+    private logger: Logger;
+
+    constructor(logger: Logger) {
+        this.logger = logger;
+    }
+
+    /**
+     * @method verify
+     * @description Copies `projectDir` into a temp directory and runs its `test` script (or
+     * `build` if there's no real `test` script), reporting pass/fail. Returns `{ran: false, ok:
+     * true}` — the same "assume ok, nothing to check" convention AIContextManager's
+     * runValidation() uses — when the project has no package.json or no test/build script.
+     * @param {string} projectDir - Absolute path to the project to verify.
+     * @returns {Promise<SandboxResult>}
+     * @example
+     * const result = await sandbox.verify('/path/to/project');
+     * if (!result.ran || result.ok) { ... } // "assume ok" when nothing was checked
+     */
+    public async verify(projectDir: string): Promise<SandboxResult> {
+        const script = await this.detectScript(projectDir);
+        if (!script) return { ran: false, ok: true };
+
+        const tempDir = fsSync.mkdtempSync(path.join(os.tmpdir(), 'tyr-sandbox-'));
+        try {
+            await this.copySource(projectDir, tempDir);
+            this.linkNodeModules(projectDir, tempDir);
+
+            const command = `npm run ${script}`;
+            try {
+                const result = await execa('npm', ['run', script], {
+                    cwd: tempDir,
+                    timeout: SANDBOX_TIMEOUT_MS,
+                    reject: false,
+                });
+                const ok = result.exitCode === 0;
+                return {
+                    ran: true,
+                    ok,
+                    command,
+                    output: ok ? undefined : truncate(String(result.stderr || result.stdout || 'Unknown sandbox failure')),
+                };
+            } catch (e: any) {
+                return { ran: true, ok: false, command, output: truncate(e?.message ?? String(e)) };
+            }
+        } finally {
+            fsSync.rmSync(tempDir, { recursive: true, force: true });
+        }
+    }
+
+    private async detectScript(projectDir: string): Promise<'test' | 'build' | null> {
+        const pkgPath = path.join(projectDir, 'package.json');
+        if (!fsSync.existsSync(pkgPath)) return null;
+
+        let scripts: Record<string, string> = {};
+        try {
+            const raw = await fs.readFile(pkgPath, 'utf-8');
+            scripts = JSON.parse(raw).scripts ?? {};
+        } catch {
+            return null;
+        }
+
+        if (scripts.test && !NPM_DEFAULT_TEST_SCRIPT.test(scripts.test.trim())) return 'test';
+        if (scripts.build) return 'build';
+        return null;
+    }
+
+    private async copySource(srcDir: string, destDir: string): Promise<void> {
+        const entries = await fs.readdir(srcDir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || IGNORED_DIRS.has(entry.name)) continue;
+            if (entry.isSymbolicLink()) continue;
+
+            const srcPath = path.join(srcDir, entry.name);
+            const destPath = path.join(destDir, entry.name);
+
+            if (entry.isDirectory()) {
+                await fs.mkdir(destPath, { recursive: true });
+                await this.copySource(srcPath, destPath);
+            } else if (entry.isFile()) {
+                await fs.copyFile(srcPath, destPath);
+            }
+        }
+    }
+
+    private linkNodeModules(projectDir: string, tempDir: string): void {
+        const original = path.join(projectDir, 'node_modules');
+        if (!fsSync.existsSync(original)) return;
+        try {
+            fsSync.symlinkSync(original, path.join(tempDir, 'node_modules'), 'dir');
+        } catch (e: any) {
+            this.logger.warn(`Sandbox: could not symlink node_modules (${e?.message ?? e}); the check may fail if dependencies are needed.`);
+        }
+    }
+}
+
+/**
+ * @object SandboxManagerTests
+ * @description Test parameters to validate SandboxManager functionality.
+ */
+export const SandboxManagerTests = {};