oh-my-opencode-slim 0.7.0 → 0.8.0

package/dist/cli/model-key-normalization.d.ts

@@ -0,0 +1 @@
+export declare function buildModelKeyAliases(input: string): string[];

package/dist/cli/opencode-models.d.ts

@@ -12,3 +12,7 @@ export declare function discoverProviderFreeModels(providerID: string): Promise<
     models: OpenCodeFreeModel[];
     error?: string;
 }>;
+export declare function discoverProviderModels(providerID: string): Promise<{
+    models: DiscoveredModel[];
+    error?: string;
+}>;

package/dist/cli/paths.d.ts

@@ -3,5 +3,7 @@ export declare function getOpenCodeConfigPaths(): string[];
 export declare function getConfigJson(): string;
 export declare function getConfigJsonc(): string;
 export declare function getLiteConfig(): string;
+export declare function getLiteConfigJsonc(): string;
+export declare function getExistingLiteConfigPath(): string;
 export declare function getExistingConfigPath(): string;
 export declare function ensureConfigDir(): void;

package/dist/cli/precedence-resolver.d.ts

@@ -0,0 +1,16 @@
+import type { AgentResolutionProvenance } from './types';
+export interface AgentLayerInput {
+    agentName: string;
+    openCodeDirectOverride?: string;
+    manualUserPlan?: string[];
+    pinnedModel?: string;
+    dynamicRecommendation?: string[];
+    providerFallbackPolicy?: string[];
+    systemDefault: string[];
+}
+export interface ResolvedAgentLayerResult {
+    model: string;
+    chain: string[];
+    provenance: AgentResolutionProvenance;
+}
+export declare function resolveAgentWithPrecedence(input: AgentLayerInput): ResolvedAgentLayerResult;

package/dist/cli/scoring-v2/engine.d.ts

@@ -0,0 +1,4 @@
+import type { DiscoveredModel, ExternalSignalMap } from '../types';
+import type { ScoredCandidate, ScoringAgentName } from './types';
+export declare function scoreCandidateV2(model: DiscoveredModel, agent: ScoringAgentName, externalSignals?: ExternalSignalMap): ScoredCandidate;
+export declare function rankModelsV2(models: DiscoveredModel[], agent: ScoringAgentName, externalSignals?: ExternalSignalMap): ScoredCandidate[];

package/dist/cli/scoring-v2/features.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredModel, ExternalSignalMap } from '../types';
+import type { FeatureVector, ScoringAgentName } from './types';
+export declare function extractFeatureVector(model: DiscoveredModel, agent: ScoringAgentName, externalSignals?: ExternalSignalMap): FeatureVector;

package/dist/cli/scoring-v2/index.d.ts

@@ -0,0 +1,4 @@
+export { rankModelsV2, scoreCandidateV2 } from './engine';
+export { extractFeatureVector } from './features';
+export type { FeatureVector, ScoredCandidate, ScoringAgentName, } from './types';
+export { getFeatureWeights } from './weights';

package/dist/cli/scoring-v2/types.d.ts

@@ -0,0 +1,17 @@
+import type { DiscoveredModel, ExternalSignalMap } from '../types';
+export type ScoreFeatureName = 'status' | 'context' | 'output' | 'versionBonus' | 'reasoning' | 'toolcall' | 'attachment' | 'quality' | 'coding' | 'latencyPenalty' | 'pricePenalty';
+export type FeatureVector = Record<ScoreFeatureName, number>;
+export type FeatureWeights = Record<ScoreFeatureName, number>;
+export type ScoringAgentName = 'orchestrator' | 'oracle' | 'designer' | 'explorer' | 'librarian' | 'fixer';
+export interface ScoringContext {
+    agent: ScoringAgentName;
+    externalSignals?: ExternalSignalMap;
+}
+export interface ScoredCandidate {
+    model: DiscoveredModel;
+    totalScore: number;
+    scoreBreakdown: {
+        features: FeatureVector;
+        weighted: FeatureVector;
+    };
+}

package/dist/cli/scoring-v2/weights.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureWeights, ScoringAgentName } from './types';
+export declare function getFeatureWeights(agent: ScoringAgentName): FeatureWeights;

package/dist/cli/system.d.ts

@@ -1,4 +1,6 @@
+export declare function resolveOpenCodePath(): string;
 export declare function isOpenCodeInstalled(): Promise<boolean>;
 export declare function isTmuxInstalled(): Promise<boolean>;
 export declare function getOpenCodeVersion(): Promise<string | null>;
+export declare function getOpenCodePath(): string | null;
 export declare function fetchLatestVersion(packageName: string): Promise<string | null>;

package/dist/cli/types.d.ts

@@ -11,7 +11,12 @@ export interface InstallArgs {
     tmux?: BooleanArg;
     skills?: BooleanArg;
     opencodeFree?: BooleanArg;
+    balancedSpend?: BooleanArg;
     opencodeFreeModel?: string;
+    aaKey?: string;
+    openrouterKey?: string;
+    dryRun?: boolean;
+    modelsOnly?: boolean;
 }
 export interface OpenCodeFreeModel {
     providerID: string;
@@ -43,10 +48,41 @@ export interface DynamicAgentAssignment {
     model: string;
     variant?: string;
 }
+export type ScoringEngineVersion = 'v1' | 'v2-shadow' | 'v2';
+export type ResolutionLayerName = 'opencode-direct-override' | 'manual-user-plan' | 'pinned-model' | 'dynamic-recommendation' | 'provider-fallback-policy' | 'system-default';
+export interface AgentResolutionProvenance {
+    winnerLayer: ResolutionLayerName;
+    winnerModel: string;
+}
+export interface DynamicPlanScoringMeta {
+    engineVersionApplied: 'v1' | 'v2';
+    shadowCompared: boolean;
+    diffs?: Record<string, {
+        v1TopModel?: string;
+        v2TopModel?: string;
+    }>;
+}
 export interface DynamicModelPlan {
     agents: Record<string, DynamicAgentAssignment>;
     chains: Record<string, string[]>;
+    provenance?: Record<string, AgentResolutionProvenance>;
+    scoring?: DynamicPlanScoringMeta;
+}
+export interface ExternalModelSignal {
+    qualityScore?: number;
+    codingScore?: number;
+    latencySeconds?: number;
+    inputPricePer1M?: number;
+    outputPricePer1M?: number;
+    source: 'artificial-analysis' | 'openrouter' | 'merged';
 }
+export type ExternalSignalMap = Record<string, ExternalModelSignal>;
+export type ManualAgentConfig = {
+    primary: string;
+    fallback1: string;
+    fallback2: string;
+    fallback3: string;
+};
 export interface OpenCodeConfig {
     plugin?: string[];
     provider?: Record<string, unknown>;
@@ -69,11 +105,19 @@ export interface InstallConfig {
     availableOpenCodeFreeModels?: OpenCodeFreeModel[];
     selectedChutesPrimaryModel?: string;
     selectedChutesSecondaryModel?: string;
-    availableChutesFreeModels?: OpenCodeFreeModel[];
+    availableChutesModels?: DiscoveredModel[];
     dynamicModelPlan?: DynamicModelPlan;
+    scoringEngineVersion?: ScoringEngineVersion;
+    artificialAnalysisApiKey?: string;
+    openRouterApiKey?: string;
+    balanceProviderUsage?: boolean;
     hasTmux: boolean;
     installSkills: boolean;
     installCustomSkills: boolean;
+    setupMode: 'quick' | 'manual';
+    manualAgentConfigs?: Record<string, ManualAgentConfig>;
+    dryRun?: boolean;
+    modelsOnly?: boolean;
 }
 export interface ConfigMergeResult {
     success: boolean;

package/dist/config/constants.d.ts

@@ -3,6 +3,7 @@ export declare const SUBAGENT_NAMES: readonly ["explorer", "librarian", "oracle"
 export declare const ORCHESTRATOR_NAME: "orchestrator";
 export declare const ALL_AGENT_NAMES: readonly ["orchestrator", "explorer", "librarian", "oracle", "designer", "fixer"];
 export type AgentName = (typeof ALL_AGENT_NAMES)[number];
+export declare const SUBAGENT_DELEGATION_RULES: Record<AgentName, readonly string[]>;
 export declare const DEFAULT_MODELS: Record<AgentName, string>;
 export declare const POLL_INTERVAL_MS = 500;
 export declare const POLL_INTERVAL_SLOW_MS = 1000;

package/dist/config/schema.d.ts

@@ -1,5 +1,53 @@
 import { z } from 'zod';
 declare const FALLBACK_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "fixer"];
+declare const MANUAL_AGENT_NAMES: readonly ["orchestrator", "oracle", "designer", "explorer", "librarian", "fixer"];
+export declare const ManualAgentPlanSchema: z.ZodObject<{
+    primary: z.ZodString;
+    fallback1: z.ZodString;
+    fallback2: z.ZodString;
+    fallback3: z.ZodString;
+}, z.core.$strip>;
+export declare const ManualPlanSchema: z.ZodObject<{
+    orchestrator: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    oracle: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    designer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    explorer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    librarian: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+    fixer: z.ZodObject<{
+        primary: z.ZodString;
+        fallback1: z.ZodString;
+        fallback2: z.ZodString;
+        fallback3: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type ManualAgentName = (typeof MANUAL_AGENT_NAMES)[number];
+export type ManualAgentPlan = z.infer<typeof ManualAgentPlanSchema>;
+export type ManualPlan = z.infer<typeof ManualPlanSchema>;
 export type FallbackAgentName = (typeof FALLBACK_AGENT_NAMES)[number];
 export declare const AgentOverrideConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
@@ -57,11 +105,55 @@ export declare const FailoverConfigSchema: z.ZodObject<{
         explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
         librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
         fixer: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
+    }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
 }, z.core.$strip>;
 export type FailoverConfig = z.infer<typeof FailoverConfigSchema>;
 export declare const PluginConfigSchema: z.ZodObject<{
     preset: z.ZodOptional<z.ZodString>;
+    scoringEngineVersion: z.ZodOptional<z.ZodEnum<{
+        v1: "v1";
+        "v2-shadow": "v2-shadow";
+        v2: "v2";
+    }>>;
+    balanceProviderUsage: z.ZodOptional<z.ZodBoolean>;
+    manualPlan: z.ZodOptional<z.ZodObject<{
+        orchestrator: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        oracle: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        designer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        explorer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        librarian: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+        fixer: z.ZodObject<{
+            primary: z.ZodString;
+            fallback1: z.ZodString;
+            fallback2: z.ZodString;
+            fallback3: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strict>>;
     presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         temperature: z.ZodOptional<z.ZodNumber>;
@@ -101,7 +193,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
             explorer: z.ZodOptional<z.ZodArray<z.ZodString>>;
             librarian: z.ZodOptional<z.ZodArray<z.ZodString>>;
             fixer: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
+        }, z.core.$catchall<z.ZodArray<z.ZodString>>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PluginConfig = z.infer<typeof PluginConfigSchema>;

package/dist/index.js

@@ -3338,6 +3338,14 @@ var SUBAGENT_NAMES = [
 ];
 var ORCHESTRATOR_NAME = "orchestrator";
 var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
+var SUBAGENT_DELEGATION_RULES = {
+  orchestrator: SUBAGENT_NAMES,
+  fixer: ["explorer"],
+  designer: ["explorer"],
+  explorer: [],
+  librarian: [],
+  oracle: []
+};
 var DEFAULT_MODELS = {
   orchestrator: "kimi-for-coding/k2p5",
   oracle: "openai/gpt-5.2-codex",
@@ -16939,6 +16947,34 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 // src/config/schema.ts
+var ProviderModelIdSchema = exports_external.string().regex(/^[^/\s]+\/[^\s]+$/, "Expected provider/model format (provider/.../model)");
+var ManualAgentPlanSchema = exports_external.object({
+  primary: ProviderModelIdSchema,
+  fallback1: ProviderModelIdSchema,
+  fallback2: ProviderModelIdSchema,
+  fallback3: ProviderModelIdSchema
+}).superRefine((value, ctx) => {
+  const unique = new Set([
+    value.primary,
+    value.fallback1,
+    value.fallback2,
+    value.fallback3
+  ]);
+  if (unique.size !== 4) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "primary and fallbacks must be unique per agent"
+    });
+  }
+});
+var ManualPlanSchema = exports_external.object({
+  orchestrator: ManualAgentPlanSchema,
+  oracle: ManualAgentPlanSchema,
+  designer: ManualAgentPlanSchema,
+  explorer: ManualAgentPlanSchema,
+  librarian: ManualAgentPlanSchema,
+  fixer: ManualAgentPlanSchema
+}).strict();
 var AgentModelChainSchema = exports_external.array(exports_external.string()).min(1);
 var FallbackChainsSchema = exports_external.object({
   orchestrator: AgentModelChainSchema.optional(),
@@ -16947,7 +16983,7 @@ var FallbackChainsSchema = exports_external.object({
   explorer: AgentModelChainSchema.optional(),
   librarian: AgentModelChainSchema.optional(),
   fixer: AgentModelChainSchema.optional()
-}).strict();
+}).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
@@ -16979,6 +17015,9 @@ var FailoverConfigSchema = exports_external.object({
 });
 var PluginConfigSchema = exports_external.object({
   preset: exports_external.string().optional(),
+  scoringEngineVersion: exports_external.enum(["v1", "v2-shadow", "v2"]).optional(),
+  balanceProviderUsage: exports_external.boolean().optional(),
+  manualPlan: ManualPlanSchema.optional(),
   presets: exports_external.record(exports_external.string(), PresetSchema).optional(),
   agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
   disabled_mcps: exports_external.array(exports_external.string()).optional(),
@@ -17430,7 +17469,7 @@ Each specialist delivers 10x results in their domain:
 - @explorer \u2192 Parallel discovery when you need to find unknowns, not read knowns
 - @librarian \u2192 Complex/evolving APIs where docs prevent errors, not basic usage
 - @oracle \u2192 High-stakes decisions where wrong choice is costly, not routine calls
-- @designer \u2192 User-facing experiences where polish matters, not internal logic  
+- @designer \u2192 User-facing experiences where polish matters, not internal logic
 - @fixer \u2192 Parallel execution of clear specs, not explaining trivial changes
 
 **Delegation efficiency:**
@@ -17522,6 +17561,8 @@ ${customAppendPrompt}`;
 function applyOverrides(agent, override) {
   if (override.model)
     agent.config.model = override.model;
+  if (override.variant)
+    agent.config.variant = override.variant;
   if (override.temperature !== undefined)
     agent.config.temperature = override.temperature;
 }
@@ -17829,6 +17870,16 @@ async function closeTmuxPane(paneId) {
     return false;
   }
   try {
+    log("[tmux] closeTmuxPane: sending Ctrl+C for graceful shutdown", {
+      paneId
+    });
+    const ctrlCProc = spawn([tmux, "send-keys", "-t", paneId, "C-c"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await ctrlCProc.exited;
+    await new Promise((r) => setTimeout(r, 250));
+    log("[tmux] closeTmuxPane: killing pane", { paneId });
     const proc = spawn([tmux, "kill-pane", "-t", paneId], {
       stdout: "pipe",
       stderr: "pipe"
@@ -17959,6 +18010,7 @@ function generateTaskId() {
 class BackgroundTaskManager {
   tasks = new Map;
   tasksBySessionId = new Map;
+  agentBySessionId = new Map;
   client;
   directory;
   tmuxEnabled;
@@ -17978,6 +18030,20 @@ class BackgroundTaskManager {
     };
     this.maxConcurrentStarts = this.backgroundConfig.maxConcurrentStarts;
   }
+  getSubagentRules(agentName) {
+    return SUBAGENT_DELEGATION_RULES[agentName] ?? ["explorer"];
+  }
+  isAgentAllowed(parentSessionId, requestedAgent) {
+    const parentAgentName = this.agentBySessionId.get(parentSessionId) ?? "orchestrator";
+    const allowedSubagents = this.getSubagentRules(parentAgentName);
+    if (allowedSubagents.length === 0)
+      return false;
+    return allowedSubagents.includes(requestedAgent);
+  }
+  getAllowedSubagents(parentSessionId) {
+    const parentAgentName = this.agentBySessionId.get(parentSessionId) ?? "orchestrator";
+    return this.getSubagentRules(parentAgentName);
+  }
   launch(opts) {
     const task = {
       id: generateTaskId(),
@@ -18037,6 +18103,13 @@ class BackgroundTaskManager {
       })
     ]);
   }
+  calculateToolPermissions(agentName) {
+    const allowedSubagents = this.getSubagentRules(agentName);
+    if (allowedSubagents.length === 0) {
+      return { background_task: false, task: false };
+    }
+    return { background_task: true, task: true };
+  }
   async startTask(task) {
     task.status = "starting";
     this.activeStarts++;
@@ -18057,15 +18130,17 @@ class BackgroundTaskManager {
       }
       task.sessionId = session.data.id;
       this.tasksBySessionId.set(session.data.id, task.id);
+      this.agentBySessionId.set(session.data.id, task.agent);
       task.status = "running";
       if (this.tmuxEnabled) {
         await new Promise((r) => setTimeout(r, 500));
       }
+      const toolPermissions = this.calculateToolPermissions(task.agent);
       const promptQuery = { directory: this.directory };
       const resolvedVariant = resolveAgentVariant(this.config, task.agent);
       const basePromptBody = applyAgentVariant(resolvedVariant, {
         agent: task.agent,
-        tools: { background_task: false, task: false },
+        tools: toolPermissions,
         parts: [{ type: "text", text: task.prompt }]
       });
       const timeoutMs = this.config?.fallback?.timeoutMs ?? FALLBACK_FAILOVER_TIMEOUT_MS;
@@ -18133,6 +18208,33 @@ class BackgroundTaskManager {
       await this.extractAndCompleteTask(task);
     }
   }
+  async handleSessionDeleted(event) {
+    if (event.type !== "session.deleted")
+      return;
+    const sessionId = event.properties?.info?.id ?? event.properties?.sessionID;
+    if (!sessionId)
+      return;
+    const taskId = this.tasksBySessionId.get(sessionId);
+    if (!taskId)
+      return;
+    const task = this.tasks.get(taskId);
+    if (!task)
+      return;
+    if (task.status === "running" || task.status === "pending") {
+      log(`[background-manager] Session deleted, cancelling task: ${task.id}`);
+      task.status = "cancelled";
+      task.completedAt = new Date;
+      task.error = "Session deleted";
+      this.tasksBySessionId.delete(sessionId);
+      this.agentBySessionId.delete(sessionId);
+      const resolver = this.completionResolvers.get(taskId);
+      if (resolver) {
+        resolver(task);
+        this.completionResolvers.delete(taskId);
+      }
+      log(`[background-manager] Task cancelled due to session deletion: ${task.id}`);
+    }
+  }
   async extractAndCompleteTask(task) {
     if (!task.sessionId)
       return;
@@ -18175,6 +18277,12 @@ class BackgroundTaskManager {
     }
     if (task.sessionId) {
       this.tasksBySessionId.delete(task.sessionId);
+      this.agentBySessionId.delete(task.sessionId);
+    }
+    if (task.sessionId) {
+      this.client.session.abort({
+        path: { id: task.sessionId }
+      }).catch(() => {});
     }
     if (task.parentSessionId) {
       this.sendCompletionNotification(task).catch((err) => {
@@ -18261,6 +18369,7 @@ class BackgroundTaskManager {
     this.completionResolvers.clear();
     this.tasks.clear();
     this.tasksBySessionId.clear();
+    this.agentBySessionId.clear();
   }
 }
 // src/background/tmux-session-manager.ts
@@ -18342,6 +18451,19 @@ class TmuxSessionManager {
       await this.closeSession(sessionId);
     }
   }
+  async onSessionDeleted(event) {
+    if (!this.enabled)
+      return;
+    if (event.type !== "session.deleted")
+      return;
+    const sessionId = event.properties?.sessionID;
+    if (!sessionId)
+      return;
+    log("[tmux-session-manager] session deleted, closing pane", {
+      sessionId
+    });
+    await this.closeSession(sessionId);
+  }
   startPolling() {
     if (this.pollInterval)
       return;
@@ -18420,6 +18542,8 @@ class TmuxSessionManager {
 // src/hooks/auto-update-checker/cache.ts
 import * as fs3 from "fs";
 import * as path4 from "path";
+// src/cli/dynamic-model-selection.ts
+var FREE_BIASED_PROVIDERS = new Set(["opencode"]);
 // src/hooks/auto-update-checker/constants.ts
 import * as os3 from "os";
 import * as path3 from "path";
@@ -31789,11 +31913,16 @@ Key behaviors:
       const agent = String(args.agent);
       const prompt = String(args.prompt);
       const description = String(args.description);
+      const parentSessionId = toolContext.sessionID;
+      if (!manager.isAgentAllowed(parentSessionId, agent)) {
+        const allowed = manager.getAllowedSubagents(parentSessionId);
+        return `Agent '${agent}' is not allowed. Allowed agents: ${allowed.join(", ")}`;
+      }
       const task = manager.launch({
         agent,
         prompt,
         description,
-        parentSessionId: toolContext.sessionID
+        parentSessionId
       });
       return `Background task launched.
 
@@ -32164,11 +32293,14 @@ ${summary}`);
 
 // src/tools/grep/tools.ts
 var grep = tool({
-  description: "Fast content search tool with safety limits (60s timeout, 10MB output). " + "Searches file contents using regular expressions. " + 'Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.). ' + 'Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}"). ' + "Returns file paths with matches sorted by modification time.",
+  description: "Fast content search tool with safety limits (60s timeout, 10MB output). " + "Searches file contents using regular expressions. " + 'Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.). ' + 'Filter files by pattern with the include parameter (e.g. "*.js", "*.{ts,tsx}"). ' + "Returns file paths with matches sorted by modification time.",
   args: {
     pattern: tool.schema.string().describe("The regex pattern to search for in file contents"),
     include: tool.schema.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
-    path: tool.schema.string().optional().describe("The directory to search in. Defaults to the current working directory.")
+    path: tool.schema.string().optional().describe("The directory to search in. Defaults to the current working directory."),
+    caseSensitive: tool.schema.boolean().optional().default(false).describe("Perform case-sensitive search (default: false)"),
+    wholeWord: tool.schema.boolean().optional().default(false).describe("Match whole words only (default: false)"),
+    fixedStrings: tool.schema.boolean().optional().default(false).describe("Treat pattern as literal string (default: false)")
   },
   execute: async (args) => {
     try {
@@ -32178,7 +32310,10 @@ var grep = tool({
         pattern: args.pattern,
         paths: paths2,
         globs,
-        context: 0
+        context: 0,
+        caseSensitive: args.caseSensitive ?? false,
+        wholeWord: args.wholeWord ?? false,
+        fixedStrings: args.fixedStrings ?? false
       });
       return formatGrepResult(result);
     } catch (e) {
@@ -33162,6 +33297,8 @@ var OhMyOpenCodeLite = async (ctx) => {
       await tmuxSessionManager.onSessionCreated(input.event);
       await backgroundManager.handleSessionStatus(input.event);
       await tmuxSessionManager.onSessionStatus(input.event);
+      await backgroundManager.handleSessionDeleted(input.event);
+      await tmuxSessionManager.onSessionDeleted(input.event);
     },
     "experimental.chat.messages.transform": phaseReminderHook["experimental.chat.messages.transform"],
     "tool.execute.after": postReadNudgeHook["tool.execute.after"]

package/dist/tools/quota/api.d.ts

@@ -0,0 +1,5 @@
+import type { Account, AccountQuotaResult, AccountsConfig } from './types';
+export declare const CONFIG_PATHS: string[];
+export declare function loadAccountsConfig(): AccountsConfig | null;
+export declare function fetchAccountQuota(account: Account): Promise<AccountQuotaResult>;
+export declare function fetchAllQuotas(accounts: Account[]): Promise<AccountQuotaResult[]>;

package/dist/tools/quota/command.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/quota/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Compact quota display tool - groups models by quota family
+ *
+ * Output format:
+ * ```
+ * tornikevault
+ *   Claude   [░░░░░░░░░░]   0%  3h23m
+ *   G-Flash  [██████████] 100%  4h59m
+ *   G-Pro    [██████████] 100%  4h59m
+ *
+ * tzedgin
+ *   Claude   [░░░░░░░░░░]   0%  1h41m
+ *   G-Flash  [██████████] 100%  4h59m
+ *   G-Pro    [██████████] 100%  4h59m
+ * ```
+ */
+export declare const antigravity_quota: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};

package/dist/tools/quota/types.d.ts

@@ -0,0 +1,41 @@
+export interface Account {
+    email: string;
+    refreshToken: string;
+    projectId?: string;
+    managedProjectId?: string;
+    rateLimitResetTimes: Record<string, number>;
+}
+export interface AccountsConfig {
+    accounts: Account[];
+    activeIndex: number;
+}
+export interface QuotaInfo {
+    remainingFraction?: number;
+    resetTime?: string;
+}
+export interface ModelInfo {
+    displayName?: string;
+    model?: string;
+    quotaInfo?: QuotaInfo;
+    recommended?: boolean;
+}
+export interface QuotaResponse {
+    models?: Record<string, ModelInfo>;
+}
+export interface TokenResponse {
+    access_token: string;
+}
+export interface LoadCodeAssistResponse {
+    cloudaicompanionProject?: unknown;
+}
+export interface ModelQuota {
+    name: string;
+    percent: number;
+    resetIn: string;
+}
+export interface AccountQuotaResult {
+    email: string;
+    success: boolean;
+    error?: string;
+    models: ModelQuota[];
+}

package/dist/utils/env.d.ts

@@ -0,0 +1 @@
+export declare function getEnv(name: string): string | undefined;

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './agent-variant';
+export * from './env';
 export { log } from './logger';
 export * from './polling';
 export * from './tmux';