instar 0.6.14 → 0.7.0

package/.claude/skills/setup-wizard/skill.md

@@ -24,43 +24,68 @@ This wizard runs in a terminal that may be narrow (80-120 chars). Long text gets
 **Good** (fits in terminal):
 > Everything here is just a starting point. You can change any of it later — or just tell your agent to adjust itself.
 
-## Phase 1: Welcome & Use Case Selection
+## Phase 1: Context Detection & Welcome
 
-Start with a brief welcome, then immediately ask HOW they want to use Instar.
+**Do NOT ask "how do you want to use Instar?"** Instead, detect the context automatically and present an intelligent default.
+
+### Step 1a: Detect Environment
+
+Run these checks BEFORE showing anything to the user:
+
+```bash
+# Check if we're inside a git repository
+git rev-parse --show-toplevel 2>/dev/null
+
+# Get the repo name if it exists
+basename "$(git rev-parse --show-toplevel 2>/dev/null)" 2>/dev/null
+
+# Check for common project indicators
+ls package.json Cargo.toml pyproject.toml go.mod Gemfile pom.xml 2>/dev/null
+```
+
+### Step 1b: Present Context-Aware Welcome
+
+**If inside a git repository:**
 
 ---
 
 **Welcome to Instar!**
 
-Instar turns Claude Code into a persistent agent you just talk to — through Telegram, not the terminal. This setup gets you there. Two ways to use it:
+I see you're in **[repo-name]** — I'll set up a persistent agent for this project.
+
+Your agent will monitor, build, and maintain this codebase. You'll talk to it through Telegram — no terminal needed after setup.
+
+---
+
+Then proceed directly — no "project vs general" question needed. The context made it obvious.
+
+If the user objects ("actually I want a personal agent, not a project agent"), accommodate immediately: "Got it — setting up a personal agent instead."
+
+**If NOT inside a git repository:**
 
 ---
 
-Present a question with two clear options:
+**Welcome to Instar!**
+
+You're not inside a project, so I'll set up a personal agent — a persistent AI companion you talk to through Telegram.
+
+It can research, schedule tasks, manage files, and grow over time.
+
+---
 
-1. **Project Agent** — Add an agent to an existing codebase. It monitors, builds, and maintains your project.
-2. **General Agent** — A personal agent on your computer. Like having a persistent AI assistant you talk to through Telegram.
+Then ask: "What should your agent be called?" (default: "my-agent")
 
-This choice determines the defaults, but the agent can always grow into more.
+### Key principle: Telegram is the interface, always
 
-### If "Project Agent" selected:
-- Use the current working directory as the project
-- Default jobs focus on health checks, code monitoring, reflection
-- The agent's identity centers on the project
+Regardless of project or personal agent, **Telegram is how you talk to your agent**. This should be clear from the very first message. Don't present it as an optional add-on — it's the destination of this entire setup.
 
-### If "General Agent" selected:
-- Ask for a name for the agent (this becomes the directory name)
-- Create the directory in the current location or home dir
-- Default jobs focus on communication, scheduling, research
-- **Telegram is essential** — without it, a general agent has no natural interface
-- Frame the identity around being a personal assistant, not a code monitor
-- The AGENT.md should emphasize: "I'm your personal agent. Talk to me through Telegram."
+The terminal session is the on-ramp. Telegram is where the agent experience lives.
 
 ## Phase 2: Identity Bootstrap — The Birth Conversation
 
 **This is the most important part.** Have a conversation to understand who the user is and who their agent will become. Keep it natural and concise.
 
-For **General Agents**: emphasize that this agent will be their persistent companion. It grows, learns, and communicates through Telegram. It's not a project tool — it's a presence.
+For **Personal Agents**: emphasize that this agent will be their persistent companion. It grows, learns, and communicates through Telegram. It's not a project tool — it's a presence.
 
 For **Project Agents**: emphasize that this agent will own the project's health and development. It monitors, builds, and maintains.
 
@@ -225,30 +250,11 @@ This project uses instar for persistent agent capabilities.
 - **Research before escalating** — Check tools first. Build solutions. "Needs human" is last resort.
 ```
 
-## Phase 3: Technical Configuration
-
-Now that identity is established, move to the technical setup. This feels more natural — the user already knows what they're building and why.
-
-### 3a. Project Detection
-
-- The project directory is passed in the prompt (e.g., "The project to set up is at: /path/to/project")
-- All files should be written there, not in the instar package directory
-- Check if `.instar/config.json` already exists (offer to reconfigure or skip)
-- Verify prerequisites: check that `tmux` and `claude` CLI are available
-
-```bash
-which tmux
-which claude
-```
-
-### 3b. Server Configuration
+## Phase 3: Telegram Setup — The Destination
 
-- **Port** (default: 4040) — "The agent runs a small HTTP server for health checks and internal communication."
-- **Max sessions** (default: 3) — "This limits how many Claude sessions can run at once. 2-3 is usually right."
+**Telegram comes BEFORE technical configuration.** It's the whole point — everything else supports getting the user onto Telegram.
 
-### 3c. Telegram Setup — The Destination
-
-**This terminal session is the on-ramp. Telegram is where the agent experience truly begins.** Frame it that way:
+Frame it clearly:
 
 > Right now we're in a terminal. Telegram is where your agent comes alive:
 > - **Just talk** — no commands, no terminal, just conversation
@@ -256,9 +262,7 @@ which claude
 > - **Mobile access** — your agent is always reachable
 > - **Proactive** — your agent reaches out when something matters
 
-The goal of this setup is to get the user onto Telegram as fast as possible. Everything else (jobs, config, technical setup) supports that destination.
-
-For **General Agents**: Telegram is essential. Without it, there IS no natural interface. Be direct: "This is how you'll talk to your agent."
+For **Personal Agents**: Telegram is essential. Without it, there IS no natural interface. Be direct: "This is how you'll talk to your agent."
 
 For **Project Agents**: Telegram is strongly recommended. Frame it as: "Your agent can message you about builds, issues, and progress — you just reply."
 
@@ -382,7 +386,32 @@ curl -s "https://api.telegram.org/bot${TOKEN}/getUpdates?timeout=5"
    - Look for `chat.id` where `chat.type` is "supergroup" or "group"
    - If auto-detection fails, guide manual entry
 
-### 3d. Job Scheduler (Optional)
+## Phase 4: Technical Configuration
+
+Now that identity and Telegram are established, handle the remaining technical setup. These should feel like sensible defaults, not interrogation.
+
+### 4a. Project Detection
+
+- The project directory is passed in the prompt (e.g., "The project to set up is at: /path/to/project")
+- All files should be written there, not in the instar package directory
+- Check if `.instar/config.json` already exists (offer to reconfigure or skip)
+- Verify prerequisites: check that `tmux` and `claude` CLI are available
+
+```bash
+which tmux
+which claude
+```
+
+### 4b. Server Configuration
+
+Present sensible defaults — don't make the user think about these unless they want to:
+
+- **Port** (default: 4040) — "The agent runs a small local server."
+- **Max sessions** (default: 3) — "How many Claude sessions can run at once."
+
+Ask as a single confirmation: "I'll use port 4040 with up to 3 sessions. Want to change these?" If yes, ask for specifics. If no, move on.
+
+### 4c. Job Scheduler (Optional)
 
 - Ask if they want scheduled jobs
 - If yes, walk through adding a first job:
@@ -393,7 +422,7 @@ curl -s "https://api.telegram.org/bot${TOKEN}/getUpdates?timeout=5"
   - **Execution type**: prompt (AI instruction), script (shell script), or skill (slash command)
 - Offer to add more jobs
 
-### 3e. Write Configuration Files
+### 4d. Write Configuration Files
 
 Create the directory structure and write config files:
 
@@ -438,7 +467,7 @@ mkdir -p .instar/state/sessions .instar/state/jobs .instar/logs
 
 **`.instar/users.json`**: Array of user objects from the identity conversation.
 
-### 3f. Update .gitignore
+### 4e. Update .gitignore
 
 Append if not present:
 ```
@@ -447,7 +476,7 @@ Append if not present:
 .instar/logs/
 ```
 
-## Phase 4: Summary & Launch
+## Phase 5: Summary & Launch
 
 Show what was created briefly, then get the user to their agent.
 
@@ -485,4 +514,4 @@ Offer to start the server.
 
 ## Starting
 
-Begin by reading the project directory, checking for existing config, and then launching into the welcome explanation followed by the identity conversation. Let the conversation flow naturally.
+Begin by detecting the environment (git repo check, project file check), then present the context-aware welcome. Let the conversation flow naturally from there.

package/.vercel/README.txt

@@ -0,0 +1,11 @@
+> Why do I have a folder named ".vercel" in my project?
+The ".vercel" folder is created when you link a directory to a Vercel project.
+
+> What does the "project.json" file contain?
+The "project.json" file contains:
+- The ID of the Vercel project that you linked ("projectId")
+- The ID of the user or team your Vercel project is owned by ("orgId")
+
+> Should I commit the ".vercel" folder?
+No, you should not share the ".vercel" folder with anyone.
+Upon creation, it will be automatically added to your ".gitignore" file.

package/.vercel/project.json

@@ -0,0 +1 @@
+{"projectId":"prj_evM5LcItYL3IAmw8zNvEPGrHeaya","orgId":"team_dHctwIDcV3X9ydapQlCPHFGI","projectName":"claude-agent-kit"}

package/dist/commands/init.js

@@ -1336,6 +1336,15 @@ fi
 # For startup/resume/clear — output a compact orientation
 echo "=== SESSION START ==="
 
+# Telegram-spawned session awareness
+# When auto-created for a Telegram topic, prime the agent to respond immediately
+if [ -n "\$INSTAR_TELEGRAM_TOPIC" ]; then
+  echo ""
+  echo "This session was auto-spawned for Telegram topic \$INSTAR_TELEGRAM_TOPIC."
+  echo "A message from your user triggered this session and will arrive momentarily."
+  echo "IMMEDIATELY acknowledge it via your Telegram relay — they are waiting."
+fi
+
 # Identity summary (first 20 lines of AGENT.md — enough for name + role)
 if [ -f "$INSTAR_DIR/AGENT.md" ]; then
   echo ""

package/dist/commands/server.js

@@ -18,6 +18,8 @@ import { JobScheduler } from '../scheduler/JobScheduler.js';
 import { AgentServer } from '../server/AgentServer.js';
 import { TelegramAdapter } from '../messaging/TelegramAdapter.js';
 import { RelationshipManager } from '../core/RelationshipManager.js';
+import { ClaudeCliIntelligenceProvider } from '../core/ClaudeCliIntelligenceProvider.js';
+import { AnthropicIntelligenceProvider } from '../core/AnthropicIntelligenceProvider.js';
 import { FeedbackManager } from '../core/FeedbackManager.js';
 import { DispatchManager } from '../core/DispatchManager.js';
 import { UpdateChecker } from '../core/UpdateChecker.js';
@@ -25,6 +27,8 @@ import { registerPort, unregisterPort, startHeartbeat } from '../core/PortRegist
 import { TelegraphService } from '../publishing/TelegraphService.js';
 import { PrivateViewer } from '../publishing/PrivateViewer.js';
 import { TunnelManager } from '../tunnel/TunnelManager.js';
+import { EvolutionManager } from '../core/EvolutionManager.js';
+import { QuotaTracker } from '../monitoring/QuotaTracker.js';
 /**
  * Respawn a session for a topic, including thread history in the bootstrap.
  * This prevents "thread drift" where respawned sessions lose context.
@@ -218,9 +222,9 @@ function wireTelegramRouting(telegram, sessionManager) {
             const ctxPath = path.join(tmpDir, `ctx-${topicId}-${Date.now()}.txt`);
             fs.writeFileSync(ctxPath, contextLines.join('\n'));
             const bootstrapMessage = `[telegram:${topicId}] ${text} (IMPORTANT: Read ${ctxPath} for Telegram relay instructions — you MUST relay your response back.)`;
-            sessionManager.spawnInteractiveSession(bootstrapMessage, storedName).then((newSessionName) => {
+            sessionManager.spawnInteractiveSession(bootstrapMessage, storedName, { telegramTopicId: topicId }).then((newSessionName) => {
                 telegram.registerTopicSession(topicId, newSessionName);
-                telegram.sendToTopic(topicId, `Session created.`).catch(() => { });
+                telegram.sendToTopic(topicId, `Session starting up — reading your message now. One moment.`).catch(() => { });
                 console.log(`[telegram→session] Auto-spawned "${newSessionName}" for topic ${topicId}`);
             }).catch((err) => {
                 console.error(`[telegram→session] Auto-spawn failed:`, err);
@@ -351,12 +355,51 @@ export async function startServer(options) {
         const sessionManager = new SessionManager(config.sessions, state);
         let relationships;
         if (config.relationships) {
+            // Wire LLM intelligence for identity resolution.
+            // Priority: Claude CLI (subscription, zero extra cost) > Anthropic API (explicit opt-in only)
+            const claudePath = config.sessions.claudePath;
+            let intelligenceMode = 'heuristic-only';
+            // Check if user explicitly opted into API-based intelligence
+            // (intelligenceProvider is a config-file-only field, not in the TypeScript type)
+            const explicitProvider = config.relationships.intelligenceProvider;
+            if (explicitProvider === 'anthropic-api') {
+                // User explicitly chose API — respect their decision
+                const apiProvider = AnthropicIntelligenceProvider.fromEnv();
+                if (apiProvider) {
+                    config.relationships.intelligence = apiProvider;
+                    intelligenceMode = 'LLM-supervised (Anthropic API — user choice)';
+                }
+                else {
+                    console.log(pc.yellow('  intelligenceProvider: "anthropic-api" set but ANTHROPIC_API_KEY not found'));
+                }
+            }
+            else if (claudePath) {
+                // Default: use Claude CLI via subscription (zero extra cost)
+                config.relationships.intelligence = new ClaudeCliIntelligenceProvider(claudePath);
+                intelligenceMode = 'LLM-supervised (Claude CLI subscription)';
+            }
             relationships = new RelationshipManager(config.relationships);
-            console.log(pc.green(`  Relationships loaded: ${relationships.getAll().length} tracked`));
+            const count = relationships.getAll().length;
+            console.log(pc.green(`  Relationships loaded: ${count} tracked (${intelligenceMode})`));
+        }
+        // Set up quota tracking if enabled
+        let quotaTracker;
+        if (config.monitoring?.quotaTracking) {
+            const quotaFile = config.monitoring.quotaStateFile
+                || path.join(config.stateDir, 'quota-state.json');
+            quotaTracker = new QuotaTracker({
+                quotaFile,
+                thresholds: config.scheduler?.quotaThresholds ?? { normal: 50, elevated: 60, critical: 80, shutdown: 95 },
+            });
+            console.log(pc.green(`  Quota tracking enabled (${quotaFile})`));
         }
         let scheduler;
         if (config.scheduler.enabled) {
             scheduler = new JobScheduler(config.scheduler, sessionManager, state, config.stateDir);
+            if (quotaTracker) {
+                scheduler.canRunJob = quotaTracker.canRunJob.bind(quotaTracker);
+                scheduler.setQuotaTracker(quotaTracker);
+            }
             scheduler.start();
             console.log(pc.green('  Scheduler started'));
         }
@@ -454,7 +497,13 @@ export async function startServer(options) {
                 stateDir: config.stateDir,
             });
         }
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, publisher, viewer, tunnel });
+        // Set up evolution system (always enabled — the feedback loop infrastructure)
+        const evolution = new EvolutionManager({
+            stateDir: config.stateDir,
+            ...(config.evolution || {}),
+        });
+        console.log(pc.green('  Evolution system enabled'));
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, quotaTracker, publisher, viewer, tunnel, evolution });
         await server.start();
         // Start tunnel AFTER server is listening
         if (tunnel) {

package/dist/commands/setup.js

@@ -69,8 +69,23 @@ export async function runSetup(opts) {
     console.log(pc.dim('  Security is enforced through behavioral hooks, identity grounding, and'));
     console.log(pc.dim('  scoped access — not permission dialogs. See: README.md > Security Model'));
     console.log();
+    // Detect git context to pass to the conversational wizard
+    const projectDir = process.cwd();
+    let gitContext = '';
+    try {
+        const gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd: projectDir,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        const repoName = path.basename(gitRoot);
+        gitContext = ` This directory is inside a git repository "${repoName}" at ${gitRoot}.`;
+    }
+    catch {
+        gitContext = ' This directory is NOT inside a git repository.';
+    }
     // Launch Claude Code from the instar package root (where .claude/skills/ lives)
-    // and pass the target project directory in the prompt.
+    // and pass the target project directory + git context in the prompt.
     //
     // --dangerously-skip-permissions is required here because the setup wizard
     // runs in instar's OWN package directory (instarRoot), not the user's
@@ -78,10 +93,9 @@ export async function runSetup(opts) {
     // user's project directory, which breaks the interactive flow. The wizard
     // only writes to well-defined locations (.instar/, .claude/, CLAUDE.md).
     const instarRoot = findInstarRoot();
-    const projectDir = process.cwd();
     const child = spawn(claudePath, [
         '--dangerously-skip-permissions',
-        `/setup-wizard The project to set up is at: ${projectDir}`,
+        `/setup-wizard The project to set up is at: ${projectDir}.${gitContext}`,
     ], {
         cwd: instarRoot,
         stdio: 'inherit',
@@ -126,6 +140,22 @@ function findInstarRoot() {
     // Fallback: assume we're in dist/commands/ — go up to root
     return path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', '..');
 }
+/**
+ * Detect whether the current directory is inside a git repository.
+ */
+function detectGitRepo(dir) {
+    try {
+        const root = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd: dir,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return { isRepo: true, repoRoot: root, repoName: path.basename(root) };
+    }
+    catch {
+        return { isRepo: false };
+    }
+}
 /**
  * Classic inquirer-based setup wizard.
  * The original interactive setup experience.
@@ -133,7 +163,7 @@ function findInstarRoot() {
 async function runClassicSetup() {
     console.log();
     console.log(pc.bold('  Welcome to Instar'));
-    console.log(pc.dim('  Persistent agent infrastructure for any Claude Code project'));
+    console.log(pc.dim('  Turn Claude Code into a persistent agent you talk to through Telegram.'));
     console.log();
     // ── Step 0: Check and install prerequisites ─────────────────────
     const prereqs = await ensurePrerequisites();
@@ -143,19 +173,59 @@ async function runClassicSetup() {
     const tmuxPath = prereqs.results.find(r => r.name === 'tmux').path;
     // Use a scoped name to avoid shadowing the outer runSetup's claudePath
     const claudePath = prereqs.results.find(r => r.name === 'Claude CLI').path;
-    // ── Step 1: Project ──────────────────────────────────────────────
+    // ── Step 1: Detect context and determine mode ─────────────────
     const detectedDir = process.cwd();
-    const detectedName = path.basename(detectedDir);
-    const projectDir = detectedDir; // Always use cwd
-    const projectName = await input({
-        message: 'Project name',
-        default: detectedName,
-    });
+    const gitInfo = detectGitRepo(detectedDir);
+    let projectDir;
+    let projectName;
+    let isProjectAgent;
+    if (gitInfo.isRepo) {
+        // Inside a git repository — suggest project agent
+        console.log(`  ${pc.green('✓')} Detected git repository: ${pc.cyan(gitInfo.repoName)}`);
+        console.log(pc.dim(`    ${gitInfo.repoRoot}`));
+        console.log();
+        console.log(pc.dim('  Your agent will live alongside this project — monitoring, building,'));
+        console.log(pc.dim('  and maintaining it. You talk to it through Telegram.'));
+        console.log();
+        const useThisRepo = await confirm({
+            message: `Set up an agent for ${gitInfo.repoName}?`,
+            default: true,
+        });
+        if (useThisRepo) {
+            projectDir = gitInfo.repoRoot;
+            projectName = await input({
+                message: 'Agent name',
+                default: gitInfo.repoName,
+            });
+            isProjectAgent = true;
+        }
+        else {
+            // They want a general agent instead
+            projectName = await input({
+                message: 'What should your agent be called?',
+                default: 'my-agent',
+            });
+            projectDir = detectedDir;
+            isProjectAgent = false;
+        }
+    }
+    else {
+        // Not in a git repo — this is a general/personal agent
+        console.log(pc.dim('  No git repository detected — setting up a personal agent.'));
+        console.log(pc.dim('  A personal agent lives on your machine and you talk to it through Telegram.'));
+        console.log();
+        projectName = await input({
+            message: 'What should your agent be called?',
+            default: 'my-agent',
+        });
+        projectDir = detectedDir;
+        isProjectAgent = false;
+    }
     // Check if already initialized
     const stateDir = path.join(projectDir, '.instar');
     if (fs.existsSync(path.join(stateDir, 'config.json'))) {
         const overwrite = await confirm({
-            message: 'Agent kit already initialized here. Reconfigure?',
+            message: 'Agent already initialized here. Reconfigure?',
             default: false,
         });
         if (!overwrite) {
@@ -163,7 +233,19 @@ async function runClassicSetup() {
             return;
         }
     }
-    // ── Step 2: Server port + sessions ─────────────────────────────
+    // ── Step 2: Telegram — the primary interface ───────────────────
+    console.log();
+    console.log(pc.bold('  Telegram — How You Talk to Your Agent'));
+    console.log();
+    console.log(pc.dim('  Once connected, you just talk — no commands, no terminal.'));
+    console.log(pc.dim('  Topic threads, message history, mobile access, proactive notifications.'));
+    if (!isProjectAgent) {
+        console.log();
+        console.log(pc.dim('  For a personal agent, Telegram IS the interface.'));
+    }
+    console.log();
+    const telegramConfig = await promptForTelegram();
+    // ── Step 3: Server config (sensible defaults) ──────────────────
     const port = await number({
         message: 'Server port',
         default: 4040,
@@ -182,14 +264,6 @@ async function runClassicSetup() {
             return true;
         },
     }) ?? 3;
-    // ── Step 3: Telegram (BEFORE users, so we know context) ────────
-    console.log();
-    console.log(pc.bold('  Telegram — Where Your Agent Lives'));
-    console.log(pc.dim('  Telegram is where the real experience begins.'));
-    console.log(pc.dim('  Once connected, you just talk — no commands, no terminal.'));
-    console.log(pc.dim('  Topic threads, message history, mobile access, proactive notifications.'));
-    console.log();
-    const telegramConfig = await promptForTelegram();
     // ── Step 4: User setup ─────────────────────────────────────────
     console.log();
     const addUser = await confirm({

package/dist/core/AnthropicIntelligenceProvider.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AnthropicIntelligenceProvider — OPTIONAL IntelligenceProvider using the Anthropic Messages API.
+ *
+ * ⚠️  This provider uses API tokens (extra cost). For most Instar agents, the
+ * ClaudeCliIntelligenceProvider (which uses the Claude subscription) is the
+ * correct default. Only use this provider when:
+ *   - The user explicitly sets intelligenceProvider: "anthropic-api" in config
+ *   - The Claude CLI is not available
+ *   - The user has a specific reason to prefer direct API access
+ *
+ * No SDK dependency — direct fetch calls, following the TelegramAdapter pattern.
+ */
+import type { IntelligenceProvider, IntelligenceOptions } from './types.js';
+export declare class AnthropicIntelligenceProvider implements IntelligenceProvider {
+    private apiKey;
+    constructor(apiKey: string);
+    /**
+     * Create a provider from environment variables, or null if no key available.
+     * Follows the same graceful degradation pattern as TelegramAdapter's voice providers.
+     */
+    static fromEnv(): AnthropicIntelligenceProvider | null;
+    evaluate(prompt: string, options?: IntelligenceOptions): Promise<string>;
+}
+//# sourceMappingURL=AnthropicIntelligenceProvider.d.ts.map

package/dist/core/AnthropicIntelligenceProvider.js

@@ -0,0 +1,68 @@
+/**
+ * AnthropicIntelligenceProvider — OPTIONAL IntelligenceProvider using the Anthropic Messages API.
+ *
+ * ⚠️  This provider uses API tokens (extra cost). For most Instar agents, the
+ * ClaudeCliIntelligenceProvider (which uses the Claude subscription) is the
+ * correct default. Only use this provider when:
+ *   - The user explicitly sets intelligenceProvider: "anthropic-api" in config
+ *   - The Claude CLI is not available
+ *   - The user has a specific reason to prefer direct API access
+ *
+ * No SDK dependency — direct fetch calls, following the TelegramAdapter pattern.
+ */
+const ANTHROPIC_API_URL = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_API_VERSION = '2023-06-01';
+/** Model mapping: abstract tiers → concrete Anthropic model IDs */
+const MODEL_MAP = {
+    fast: 'claude-haiku-4-5-20251001',
+    balanced: 'claude-sonnet-4-5-20250514',
+    capable: 'claude-opus-4-0-20250514',
+};
+const DEFAULT_MODEL = 'fast';
+export class AnthropicIntelligenceProvider {
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * Create a provider from environment variables, or null if no key available.
+     * Follows the same graceful degradation pattern as TelegramAdapter's voice providers.
+     */
+    static fromEnv() {
+        const apiKey = process.env['ANTHROPIC_API_KEY'];
+        if (!apiKey) {
+            return null;
+        }
+        return new AnthropicIntelligenceProvider(apiKey);
+    }
+    async evaluate(prompt, options) {
+        const model = MODEL_MAP[options?.model ?? DEFAULT_MODEL] ?? MODEL_MAP[DEFAULT_MODEL];
+        const maxTokens = options?.maxTokens ?? 100;
+        const temperature = options?.temperature ?? 0;
+        const response = await fetch(ANTHROPIC_API_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+                'anthropic-version': ANTHROPIC_API_VERSION,
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: maxTokens,
+                temperature,
+                messages: [
+                    { role: 'user', content: prompt },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'unknown error');
+            throw new Error(`Anthropic API error ${response.status}: ${errorText}`);
+        }
+        const data = await response.json();
+        // Extract text from the response
+        const textBlock = data.content?.find((block) => block.type === 'text');
+        return textBlock?.text ?? '';
+    }
+}
+//# sourceMappingURL=AnthropicIntelligenceProvider.js.map

package/dist/core/ClaudeCliIntelligenceProvider.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ClaudeCliIntelligenceProvider — Default IntelligenceProvider using the Claude CLI.
+ *
+ * Uses `claude -p` (print mode) to make judgment calls via the user's existing
+ * Claude subscription. Zero extra cost — the subscription is already paid for.
+ *
+ * This is the DEFAULT provider for Instar agents. The Anthropic API provider
+ * (AnthropicIntelligenceProvider) is an explicit opt-in alternative for users
+ * who intentionally choose direct API access.
+ *
+ * Preference hierarchy:
+ *   1. Claude CLI (subscription) — default, always available
+ *   2. Anthropic API — explicit user choice only
+ */
+import type { IntelligenceProvider, IntelligenceOptions } from './types.js';
+export declare class ClaudeCliIntelligenceProvider implements IntelligenceProvider {
+    private claudePath;
+    constructor(claudePath: string);
+    evaluate(prompt: string, options?: IntelligenceOptions): Promise<string>;
+}
+//# sourceMappingURL=ClaudeCliIntelligenceProvider.d.ts.map