@0xmaxma/claude-gateway 2.0.4 → 2.0.5

package/mcp/lazy-tools.ts

@@ -0,0 +1,41 @@
+import type { McpToolDefinition, McpToolResult } from './types';
+
+export const LAZY_TOOL_DEFINITIONS: McpToolDefinition[] = [
+  { name: 'tool_search', description: 'Discover available gateway capabilities. Empty query lists tool names and descriptions; search by query or exact name to retrieve original argument schemas before calling tool_call. Results are paginated. This catalog contains only tools authorized for this worker.',
+    inputSchema: { type: 'object', properties: { query: { type: 'string' }, name: { type: 'string' }, offset: { type: 'integer', minimum: 0 }, limit: { type: 'integer', minimum: 1, maximum: 20 }, include_schema: { type: 'boolean' } }, additionalProperties: false } },
+  { name: 'tool_call', description: 'Execute a gateway capability discovered with tool_search. Use its exact name and original arguments. All original permissions, validation and cancellation apply. Task reporting and memory retrieval remain directly available.',
+    inputSchema: { type: 'object', properties: { name: { type: 'string' }, arguments: { type: 'object' } }, required: ['name', 'arguments'], additionalProperties: false } },
+];
+
+const fail = (text: string): McpToolResult => ({ content: [{ type: 'text', text }], isError: true });
+const result = (value: unknown): McpToolResult => ({ content: [{ type: 'text', text: JSON.stringify(value) }] });
+
+/** Discovery is data-only. Invocation delegates to the SAME dispatcher as direct calls. */
+export function createLazyToolCatalog(tools: readonly McpToolDefinition[], excludeReserved = true) {
+  const reserved = new Set(LAZY_TOOL_DEFINITIONS.map(tool => tool.name));
+  const catalog = [...tools].filter(tool => !excludeReserved || !reserved.has(tool.name))
+    .sort((a, b) => a.name.localeCompare(b.name));
+  const names = new Set(catalog.map(tool => tool.name));
+  return {
+    search(args: Record<string, unknown>): McpToolResult {
+      if ((args.query !== undefined && typeof args.query !== 'string') ||
+          (args.name !== undefined && typeof args.name !== 'string') ||
+          (args.include_schema !== undefined && typeof args.include_schema !== 'boolean')) return fail('Invalid search arguments');
+      const offset = args.offset ?? 0; const limit = args.limit ?? 5;
+      if (typeof offset !== 'number' || !Number.isSafeInteger(offset) || offset < 0 ||
+          typeof limit !== 'number' || !Number.isInteger(limit) || limit < 1 || limit > 20) return fail('Invalid search pagination');
+      const query = String(args.query ?? '').trim().toLowerCase();
+      const name = String(args.name ?? '').trim().toLowerCase();
+      const matches = catalog.filter(tool => name ? tool.name.toLowerCase() === name :
+        query.split(/\s+/).every(word => `${tool.name} ${tool.description}`.toLowerCase().includes(word)));
+      const schemas = args.include_schema ?? Boolean(query || name);
+      return result({ total: matches.length, offset, next_offset: offset + limit < matches.length ? offset + limit : null,
+        tools: matches.slice(offset, offset + limit).map(tool => schemas ? tool : { name: tool.name, description: tool.description }) });
+    },
+    async call(args: Record<string, unknown>, dispatch: (name: string, input: Record<string, unknown>) => Promise<McpToolResult>): Promise<McpToolResult> {
+      if (typeof args.name !== 'string' || !names.has(args.name)) return fail('Unknown or unauthorized gateway tool');
+      if (!args.arguments || typeof args.arguments !== 'object' || Array.isArray(args.arguments)) return fail('Tool arguments must be an object');
+      return dispatch(args.name, args.arguments as Record<string, unknown>);
+    },
+  };
+}

package/mcp/server.ts

@@ -14,6 +14,7 @@ import {
 } from '@modelcontextprotocol/sdk/types.js';
 import { gatewayModules } from './modules';
 import { AGENT_TASK_TOOLS, WORKER_REPORT_TOOLS, callTaskBridge } from './tools/tasks/module';
+import { createLazyToolCatalog, LAZY_TOOL_DEFINITIONS } from './lazy-tools';
 import { buildChannelInstructions } from './instructions';
 import type { ChannelModule, ToolModule, McpToolDefinition } from './types';
 
@@ -52,9 +53,23 @@ for (const mod of modules) {
   }
 }
 
-const taskTools = ORCHESTRATION_ROLE === 'agent' ? AGENT_TASK_TOOLS.filter(tool => (tool.name !== 'conversation_intake' || process.env.GATEWAY_SEMANTIC_INTAKE === 'true') && (tool.name !== 'capabilities_list' || process.env.GATEWAY_CAPABILITY_CATALOG === 'true')) : ORCHESTRATION_ROLE === 'worker' ? WORKER_REPORT_TOOLS.filter(tool => tool.name !== 'task_memory_append' || process.env.GATEWAY_ORCHESTRATION_WRITE_MEMORY === 'true') : [];
+// conversation_intake is declared on every agent turn, whatever the semantic-intake feature
+// state. The advertised tool list is position 0 of Anthropic's cached [tools, system, messages]
+// prefix, and the feature is decided per turn (runtime.ts computes it from the flag AND from
+// whether this turn is a notification), so filtering the declaration here re-wrote the prefix
+// mid-session and invalidated the whole cache — the same defect ee800a7 fixed for the response
+// schema. The turn's INTAKE_OVERLAY prompt text, below the cache breakpoint, is what asks for
+// the tool; the bridge refuses the call outright when the feature is not active.
+const taskTools = ORCHESTRATION_ROLE === 'agent' ? AGENT_TASK_TOOLS.filter(tool => tool.name !== 'capabilities_list' || process.env.GATEWAY_CAPABILITY_CATALOG === 'true') : ORCHESTRATION_ROLE === 'worker' ? WORKER_REPORT_TOOLS.filter(tool => tool.name !== 'task_memory_append' || process.env.GATEWAY_ORCHESTRATION_WRITE_MEMORY === 'true') : [];
 if (ORCHESTRATION_ROLE && process.env.GATEWAY_ORCHESTRATION_TICKET_FILE) visibleTools.push(...taskTools);
 
+// Preserve the full policy-filtered inventory internally; only schema exposure is lazy.
+const lazyEnabled = ORCHESTRATION_ROLE === 'worker' && process.env.GATEWAY_LAZY_TOOLS === 'true';
+const deferredTools = visibleTools.filter(tool => toolMap.has(tool.name) && !['memory_search','memory_get'].includes(tool.name));
+const deferredNames = new Set(deferredTools.map(tool => tool.name));
+const lazyCatalog = createLazyToolCatalog(deferredTools);
+const advertisedTools = lazyEnabled ? [...visibleTools.filter(tool => !deferredNames.has(tool.name)), ...LAZY_TOOL_DEFINITIONS] : visibleTools;
+
 // Initialize channel modules so their bot API clients are ready for tool calls.
 // initBot() returns immediately after creating the client — no blocking.
 for (const mod of modules) {
@@ -79,47 +94,51 @@ const mcp = new Server(
         'claude/channel/permission': {},
       },
     },
-    instructions: ORCHESTRATION_ROLE ? 'Use scoped capability discovery, task tools and memory retrieval. The agent writes user-facing responses; workers return task results and orchestration handles delivery.' : buildChannelInstructions(imageEnabled, videoEnabled),
+    instructions: ORCHESTRATION_ROLE ? 'Use scoped capability discovery, task tools and memory retrieval. The agent writes user-facing responses; workers return task results and orchestration handles delivery.' + (lazyEnabled ? ' Gateway execution capabilities are available through tool_search and tool_call: search for the capability to read its original arguments, then invoke it by exact name. An unlisted execution tool is not unavailable; inspect the catalog. Task reporting and memory retrieval remain direct tools.' : '') : buildChannelInstructions(imageEnabled, videoEnabled),
   },
 );
 
 mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: visibleTools,
+  tools: advertisedTools,
 }));
 
 mcp.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
-  const toolName = req.params.name;
+  const dispatch = async (toolName: string, args: Record<string, unknown>) => {
+    if (ORCHESTRATION_ROLE && process.env.GATEWAY_ORCHESTRATION_TICKET_FILE && taskTools.some(tool => tool.name === toolName)) {
+      return callTaskBridge(toolName, args, String(extra.requestId), AbortSignal.any([extra.signal, shutdownController.signal]));
+    }
+
+    const mod = toolMap.get(toolName);
+    if (!mod) {
+      return {
+        content: [{ type: 'text', text: `unknown tool: ${toolName}` }],
+        isError: true,
+      };
+    }
+    if (ORCHESTRATION_ROLE === 'worker' && process.env.GATEWAY_ORCHESTRATION_MEDIA === 'true') {
+      const validation = await callTaskBridge('task_validate', {}, String(extra.requestId), AbortSignal.any([extra.signal, shutdownController.signal]));
+      if (validation.isError) return validation;
+    }
+
+    // extra.signal fires on notifications/cancelled for THIS call (the SDK matches
+    // it by requestId) — the CLI sends that when a user Stop/Ctrl-C interrupts an
+    // in-flight tool call. Threaded through so a long-running module (image
+    // generation's poll loop) can react instead of running to its full timeout.
+    // Also combine with shutdownController.signal: the CLI sending that
+    // notification is only a "SHOULD" in the MCP spec, not a "MUST", and in
+    // practice a Stop that lets the CLI process exit cleanly (rather than
+    // staying alive to keep chatting) closes this server's stdin without ever
+    // sending notifications/cancelled — extra.signal would then never fire, and
+    // an in-flight image generation would poll to its full timeout instead of
+    // cancelling. stdin closing is a reliable, protocol-independent signal that
+    // the turn is over either way, so it backstops the notification.
+    const combinedSignal = AbortSignal.any([extra.signal, shutdownController.signal]);
+    return mod.handleTool(toolName, args, combinedSignal);
+  };
   const args = (req.params.arguments ?? {}) as Record<string, unknown>;
-  if (ORCHESTRATION_ROLE && process.env.GATEWAY_ORCHESTRATION_TICKET_FILE && taskTools.some(tool => tool.name === toolName)) {
-    return callTaskBridge(toolName, args, String(extra.requestId), AbortSignal.any([extra.signal, shutdownController.signal]));
-  }
-
-  const mod = toolMap.get(toolName);
-  if (!mod) {
-    return {
-      content: [{ type: 'text', text: `unknown tool: ${toolName}` }],
-      isError: true,
-    };
-  }
-  if (ORCHESTRATION_ROLE === 'worker' && process.env.GATEWAY_ORCHESTRATION_MEDIA === 'true') {
-    const validation = await callTaskBridge('task_validate', {}, String(extra.requestId), AbortSignal.any([extra.signal, shutdownController.signal]));
-    if (validation.isError) return validation;
-  }
-
-  // extra.signal fires on notifications/cancelled for THIS call (the SDK matches
-  // it by requestId) — the CLI sends that when a user Stop/Ctrl-C interrupts an
-  // in-flight tool call. Threaded through so a long-running module (image
-  // generation's poll loop) can react instead of running to its full timeout.
-  // Also combine with shutdownController.signal: the CLI sending that
-  // notification is only a "SHOULD" in the MCP spec, not a "MUST", and in
-  // practice a Stop that lets the CLI process exit cleanly (rather than
-  // staying alive to keep chatting) closes this server's stdin without ever
-  // sending notifications/cancelled — extra.signal would then never fire, and
-  // an in-flight image generation would poll to its full timeout instead of
-  // cancelling. stdin closing is a reliable, protocol-independent signal that
-  // the turn is over either way, so it backstops the notification.
-  const combinedSignal = AbortSignal.any([extra.signal, shutdownController.signal]);
-  return mod.handleTool(toolName, args, combinedSignal);
+  if (lazyEnabled && req.params.name === 'tool_search') return lazyCatalog.search(args);
+  if (lazyEnabled && req.params.name === 'tool_call') return lazyCatalog.call(args, dispatch);
+  return dispatch(req.params.name, args);
 });
 
 // Connect MCP transport

package/mcp/tools/discord/commands.ts

@@ -11,6 +11,8 @@ export const SLASH_COMMANDS: SlashCommandDef[] = [
     description: 'Ask the agent a question',
     options: [{ name: 'question', description: 'Your question', required: true, type: 'STRING' }],
   },
+  { name: 'clear', description: 'Reset model context without deleting chat history' },
+  { name: 'compact', description: 'Compact Claude Code context without changing chat history' },
   { name: 'session', description: 'Show current session info' },
   {
     name: 'new',

package/mcp/tools/tasks/module.ts

@@ -5,18 +5,7 @@ import type { McpToolDefinition, McpToolResult } from '../../types';
 
 const schema = (properties: Record<string, unknown>, required: string[]) => ({ type: 'object', properties, required, additionalProperties: false });
 const text = { type: 'string' };
-export const AGENT_TASK_TOOLS: McpToolDefinition[] = [
-  { name: 'capabilities_list', description: 'Discover all capabilities this agent can offer: installed/shared/native skills, gateway MCP tools and enabled connector/plugin MCP tools, including tools executed only by workers. Read metadata only; never executes a tool or grants permissions. Use query to find relevant tools before assigning work. Follow next_offset until null when the user asks for the complete list, passing catalog_version from the first page. On CAPABILITY_CATALOG_CHANGED restart from offset 0. Report unavailable discovery honestly; do not confuse your own restricted callable tools with the capabilities of the agent as a whole.', inputSchema: schema({query:text,catalog_version:text,offset:{type:'integer',minimum:0}},[]) },
-  { name: 'conversation_intake', description: 'Prepare executable work, incomplete materials, or an amendment to an existing task. Do not call this for greetings, introductions, casual conversation or questions you can answer directly; answer those normally once. When semantic intake is enabled, acknowledge before work mutations. Incomplete material is inspected now; the gateway asks the supplied clarification after the configured silence interval, not on every item.',
-    inputSchema: schema({mode:{type:'string',enum:['ready','wait','update']},acknowledgement:{type:'string',description:'A brief contextual message addressed directly to the user about the work you will do. Immediately displayed and spoken aloud. Never include private classification, reasoning, or instructions to yourself.'},preparation:text,clarification:text,task_id:text},['mode']) },
-  { name: 'task_spawn', description: 'Durably queue a task for an independent worker. Returns after commit without waiting for worker startup or completion.',
-    inputSchema: schema({ title: text, instructions: text, target_profile: text, spoken_acknowledgement: { type: 'string', description: 'Required for live voice: a short natural response in the user language explaining the specific work you are about to do. Describe the specific user request as your own task, in the voice of your existing persona; do not announce handing it to a worker or use a generic acknowledgement. Speak as the person doing the work; avoid Thai delegation phrases such as สั่งเช็คแล้ว, สั่งไปแล้ว or ส่งให้ตรวจแล้ว. Describe queued work as accepted/to do next, and only say it is running when that state is confirmed. Do not claim completion. The gateway manages playback and channel text-before-voice ordering.' }, skill_name: { type: 'string', description: 'Exact installed gateway or discovered Claude Code runtime skill name for skill-worker. Native skills are invoked directly by the CLI; shared/workspace skills are supplied with their resources. Never supply a file path.' }, skill_args: { type: 'string', description: 'Arguments for the installed skill; required with skill_name.' }, continue_task_id: { type: 'string', description: 'Prior task ID in this conversation for related follow-up work. Reuses its worker session when compatible; waits for success by default. Queue every authorized dependent step now, using each returned task ID for the next step. Omit for independent work.' }, continuation_policy: { type: 'string', enum: ['after_success', 'after_terminal'], description: 'With continue_task_id: after_success (default) starts only after the predecessor succeeds; otherwise fails without executing. Use after_terminal only for explicitly authorized recovery/inspection that must run after failure or cancellation.' }, context_refs: { type: 'array', items: text, description: 'Only orchestration input IDs, authorized attachment refs or task artifact IDs. Put project filenames in instructions instead.' } }, ['title', 'instructions', 'target_profile']) },
-  { name: 'task_status', description: 'Read the task index in this conversation without waiting. Pass task_id to retrieve the complete stored result and evidence before discussing an earlier task. An index entry is not a partial worker report.', inputSchema: schema({ task_id: text }, []) },
-  { name: 'task_cancel', description: 'Request cancellation, including needs_reconciliation cleanup. cancel_requested is not proof of termination. Existing files are retained. Set replaced_by_task_id only for a known replacement task, never infer from similar titles.', inputSchema: schema({ task_id: text, replaced_by_task_id: text }, ['task_id']) },
-  { name: 'task_update', description: 'Accept a revised task instruction. applied_revision changes only when the worker accepts it.', inputSchema: schema({ task_id: text, expected_revision: { type: 'integer', minimum: 1 }, instruction: text, mode: { type: 'string', enum: ['when_ready', 'interrupt_and_resume'] } }, ['task_id', 'expected_revision', 'instruction', 'mode']) },
-  { name: 'task_question', description: 'Manage pending questions without answering or resuming work. Ask stages one natural separate message after your reply; discuss marks ongoing consultation; defer/mute/resume persist the user reminder preference.', inputSchema: schema({ action: { type: 'string', enum: ['ask','discuss','defer','mute','resume'] }, question_ids: { type: 'array', items: text, minItems: 1, maxItems: 20 }, text, delay_ms: { type: 'integer', minimum: 60000, maximum: 2592000000 } }, ['action', 'question_ids']) },
-  { name: 'task_answer', description: 'Answer the matching pending question on a task.', inputSchema: schema({ task_id: text, question_id: text, answer: text }, ['task_id', 'question_id', 'answer']) },
-];
+export { AGENT_TASK_TOOLS } from '../../../dist/orchestration/agent-tool-schemas.js';
 export const WORKER_REPORT_TOOLS: McpToolDefinition[] = [
   { name: 'task_memory_append', description: 'Append an explicitly requested memory note for a channel task. API tasks cannot write memory. Files are restricted to MEMORY.md, USER.md, or memory/<name>.md. Retains existing content and deduplicates retries.', inputSchema: schema({ note: text, path: text }, ['note']) },
   { name: 'task_stage_file', description: 'Stage a finished image or document for the user. The orchestration attaches it to the next completed agent response after this task succeeds, using the original destination. This tool does not send to a channel. Call once per output file. For an image returned by an MCP tool (such as a remote browser screenshot), omit path to use the latest captured image in this attempt, or pass source_tool_call_id to select its tool call. The gateway saves the actual image bytes; never invent a screenshot filename. For an existing local file supply path.', inputSchema: schema({ path: text, source_tool_call_id: text, caption: text }, []) },

package/mcp/tools/telegram/receiver-server.ts

@@ -877,8 +877,8 @@ const BOT_COMMANDS = [
   { command: 'sessions', description: 'Manage conversation sessions' },
   { command: 'new', description: 'Create a new session' },
   { command: 'rename', description: 'Rename current session' },
-  { command: 'clear', description: 'Clear current session history' },
-  { command: 'compact', description: 'Summarize and compress session history' },
+  { command: 'clear', description: 'Reset Claude Code context; keep chat history' },
+  { command: 'compact', description: 'Compact Claude Code context' },
   { command: 'stop', description: ORCHESTRATION_ENABLED ? 'Stop the agent reply and choose a task to cancel' : 'Interrupt the agent and stop current work' },
   { command: 'restart', description: 'Graceful restart session' },
   { command: 'model', description: 'Show current AI model' },
@@ -1169,8 +1169,8 @@ bot.command('help', async ctx => {
     `/sessions — list and switch between sessions\n` +
     `/new <name> — create a new session\n` +
     `/rename <name> — rename current session\n` +
-    `/clear — clear current session history\n` +
-    `/compact — summarise and compress session history\n` +
+    `/clear — reset context; keep chat history\n` +
+    `/compact — compact Claude Code context; keep chat history\n` +
     (ORCHESTRATION_ENABLED ? `/stop — stop the reply and choose a task to cancel\n` : `/stop — interrupt the running turn\n`) +
     `/restart — graceful restart session\n\n` +
     `*Agent*\n` +
@@ -1355,7 +1355,7 @@ bot.command('compact', async ctx => {
     .text('\u274c Cancel', 'compact:cancel')
 
   await ctx.reply(
-    '🧠 Compact session?\nThis will summarise old messages and keep only recent history.',
+    '🧠 Compact session?\nThis compacts Claude Code context. Your chat history stays unchanged.',
     { reply_markup: keyboard },
   )
 })
@@ -1583,18 +1583,18 @@ bot.command('sessions', async ctx => {
   }
 })
 
-// /clear — show Yes/No confirmation before clearing session history
+// /clear — confirm a fresh CLI context without deleting history
 bot.command('clear', async ctx => {
   if (ctx.chat?.type !== 'private') return
   const access = loadAccess()
   if (!access.allowFrom.includes(String(ctx.from!.id))) return
 
   await ctx.reply(
-    '🗑️ Clear session?\n\nThis will delete all message history. This cannot be undone.',
+    'Reset Claude Code context?\n\nChat history and attachments stay unchanged. Your next message starts a new context with the latest 50 messages.',
     {
       reply_markup: {
         inline_keyboard: [[
-          { text: '✅ Yes, clear it', callback_data: 'session_clear_confirm' },
+          { text: '✅ Reset context', callback_data: 'session_clear_confirm' },
           { text: '❌ Cancel', callback_data: 'session_clear_cancel' },
         ]],
       },
@@ -1880,10 +1880,10 @@ bot.on('callback_query:data', async ctx => {
           payload: { model: newModel },
         }),
       })
-      const result = (await res.json()) as { success?: boolean; error?: string; restarted?: boolean }
+      const result = (await res.json()) as { success?: boolean; error?: string; restarted?: boolean; appliesNextTurn?: boolean }
       if (result.success) {
         await ctx.answerCallbackQuery({ text: `✅ Model changed to ${newModel}` }).catch(() => {})
-        await ctx.editMessageText(`\u2705 Model changed to ${newModel}`).catch(() => {})
+        await ctx.editMessageText(`\u2705 Model changed to ${newModel}${result.appliesNextTurn ? "\nApplies to the next response; current work continues." : ""}`).catch(() => {})
       } else {
         await ctx.answerCallbackQuery({ text: result.error ?? 'Failed' }).catch(() => {})
       }
@@ -1920,7 +1920,7 @@ bot.on('callback_query:data', async ctx => {
           chat_id: String(ctx.callbackQuery.message?.chat.id),
         }),
       })
-      const result = (await res.json()) as { success?: boolean; error?: string; restarted?: boolean }
+      const result = (await res.json()) as { success?: boolean; error?: string; restarted?: boolean; appliesNextTurn?: boolean }
       if (result.success) {
         if (result.restarted === false) {
           // No active session — nothing to restart
@@ -2085,8 +2085,8 @@ bot.on('callback_query:data', async ctx => {
     }
     const chatId = String(ctx.callbackQuery.message?.chat.id)
     try {
-      await ctx.answerCallbackQuery({ text: 'Clearing...' }).catch(() => {})
-      await ctx.editMessageText('\u23f3 Clearing session...').catch(() => {})
+      await ctx.answerCallbackQuery({ text: 'Resetting context...' }).catch(() => {})
+      await ctx.editMessageText('\u23f3 Resetting context...').catch(() => {})
       const res = await fetch(CALLBACK_URL_BASE + '/command', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -2094,7 +2094,7 @@ bot.on('callback_query:data', async ctx => {
       })
       const result = (await res.json()) as { success?: boolean; error?: string }
       if (result.success) {
-        await ctx.reply('\uD83D\uDCA1 Session has been cleared').catch(() => {})
+        await ctx.reply('\uD83D\uDCA1 Claude Code context reset. Chat history is unchanged. The next message loads the latest 50 messages.').catch(() => {})
       } else {
         await ctx.reply(`\u274C Clear failed: ${result.error ?? 'Unknown error'}`).catch(() => {})
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xmaxma/claude-gateway",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "Multi-agent gateway for Claude",
   "repository": {
     "type": "git",
@@ -52,6 +52,7 @@
     "chokidar": "^3.5.0",
     "cron-parser": "^5.5.0",
     "express": "^4.18.0",
+    "js-tiktoken": "^1.0.21",
     "js-yaml": "^4.1.0",
     "lru-cache": "^10.0.0",
     "node-cron": "^3.0.0",

package/resource/dashboard/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The Poppins Project Authors (https://github.com/itfoundry/Poppins)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.