@causyne/agent 1.10.21 → 1.11.0

package/src/promptMentions.ts

@@ -0,0 +1,212 @@
+// Resolution of `@` mentions for files and directories in user prompts.
+//
+// Pure Node.js. Zero dependencies. No external shell commands.
+//
+// Extracts both quoted (`@"path with spaces/file.js"`, `@'path'`) and
+// unquoted (`@path/to/file.js`) mentions, resolves them against the active
+// working directory and known subprojects, and formats bounded context
+// representations so the agent immediately possesses referenced files and
+// folder trees without needing exploratory tool calls.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const MAX_MENTION_FILE_LINES = 500;
+const MAX_MENTION_DIR_ITEMS = 40;
+
+export interface Mention {
+  raw: string;
+  path: string;
+  isQuoted: boolean;
+  isMeta?: boolean;
+}
+
+export interface ResolveMentionOptions {
+  cwd?: string;
+  subprojects?: string[];
+}
+
+export interface ResolvedMentionContext {
+  mentions: Mention[];
+  referencedContext: string;
+  detectedSubproject: string | null;
+}
+
+/**
+ * Extract all @ mentions from prompt text.
+ *
+ * @param text - User prompt text.
+ * @returns Array of parsed mentions.
+ */
+export function extractMentions(text: string): Mention[] {
+  if (!text || typeof text !== 'string') return [];
+  const mentions: Mention[] = [];
+  const seen = new Set<string>();
+
+  // 1. Quoted mentions: @"..." or @'...'
+  // This allows spaces, e.g. @"pixel2d games/main.js" or @'assets/sprite sheet.png'
+  const quotedRegex = /(?:^|\s)@(["'])([^"'\n\r]+)\1/g;
+  let match: RegExpExecArray | null;
+  while ((match = quotedRegex.exec(text)) !== null) {
+    const raw = match[0].trim();
+    const cleanPath = (match[2] ?? '').trim();
+    if (cleanPath && !seen.has(cleanPath)) {
+      seen.add(cleanPath);
+      mentions.push({ raw, path: cleanPath, isQuoted: true });
+    }
+  }
+
+  // 2. Unquoted mentions: @path/to/file or @dir/
+  // Matches @ preceded by start-of-line or whitespace, not part of an email address
+  const unquotedRegex = /(?:^|\s)@([a-zA-Z0-9_.\-/\\]+)(?=$|\s|[.,;:?!)\]}])/g;
+  while ((match = unquotedRegex.exec(text)) !== null) {
+    const raw = match[0].trim();
+    const cleanPath = (match[1] ?? '').trim();
+
+    // Skip if already captured via quotes or if empty
+    if (!cleanPath || seen.has(cleanPath)) continue;
+
+    // Do not capture npm scope prefixes on their own or common non-file @ words
+    if (cleanPath === 'here' || cleanPath === 'all' || cleanPath === 'workspace') {
+      seen.add(cleanPath);
+      mentions.push({ raw, path: cleanPath, isQuoted: false, isMeta: true });
+      continue;
+    }
+
+    seen.add(cleanPath);
+    mentions.push({ raw, path: cleanPath, isQuoted: false });
+  }
+
+  return mentions;
+}
+
+/**
+ * Resolve mentioned files and folders against the active working directory
+ * and detected subprojects. Returns bounded context blocks for model ingestion.
+ *
+ * @param prompt - Raw prompt string.
+ * @param options - Resolution options.
+ * @returns Bounded context and list of mentions.
+ */
+export async function resolveMentionedContext(
+  prompt: string,
+  options: ResolveMentionOptions = {}
+): Promise<ResolvedMentionContext> {
+  const mentions = extractMentions(prompt);
+  if (mentions.length === 0) {
+    return { mentions: [], referencedContext: '', detectedSubproject: null };
+  }
+
+  const cwd = options.cwd || process.cwd();
+  const subprojects = Array.isArray(options.subprojects) ? options.subprojects : [];
+  const sections: string[] = [];
+  let detectedSubproject: string | null = null;
+
+  for (const m of mentions) {
+    if (m.isMeta) {
+      if (m.path === 'workspace' || m.path === 'here') {
+        sections.push(`📁 REFERENCED SCOPE: Whole workspace (${cwd})`);
+      }
+      continue;
+    }
+
+    let targetPath = path.resolve(cwd, m.path);
+    let found = false;
+
+    try {
+      if (fs.existsSync(targetPath)) {
+        found = true;
+      }
+    } catch {
+      // ignore
+    }
+
+    // Check if path refers to a file/folder inside any detected subproject
+    if (!found && subprojects.length > 0) {
+      for (const sp of subprojects) {
+        const candidate = path.resolve(cwd, sp, m.path);
+        try {
+          if (fs.existsSync(candidate)) {
+            targetPath = candidate;
+            found = true;
+            detectedSubproject = sp;
+            break;
+          }
+        } catch {
+          // ignore
+        }
+      }
+    }
+
+    // Check if the mention path explicitly names a subproject (e.g. @"pixel2d games/...")
+    if (subprojects.length > 0) {
+      for (const sp of subprojects) {
+        if (m.path === sp || m.path.startsWith(sp + '/') || m.path.startsWith(sp + '\\')) {
+          detectedSubproject = sp;
+          break;
+        }
+      }
+    }
+
+    const relPath = path.relative(cwd, targetPath);
+
+    if (!found) {
+      sections.push(`📂 REFERENCED PATH: ${m.path} (Note: path was not found on disk at ${relPath})`);
+      continue;
+    }
+
+    try {
+      const stats = fs.statSync(targetPath);
+      if (stats.isDirectory()) {
+        const entries = fs.readdirSync(targetPath, { withFileTypes: true });
+        const summary = entries
+          .filter(e => !e.name.startsWith('.') && e.name !== 'node_modules')
+          .slice(0, MAX_MENTION_DIR_ITEMS)
+          .map(e => e.isDirectory() ? `${e.name}/` : e.name);
+
+        const more = entries.length > MAX_MENTION_DIR_ITEMS
+          ? `\n  ... (${entries.length - MAX_MENTION_DIR_ITEMS} more items)`
+          : '';
+
+        sections.push(
+          `📁 REFERENCED DIRECTORY: ${relPath}/\n` +
+          `Directory listing (${summary.length} items):\n` +
+          summary.map(s => `  - ${s}`).join('\n') +
+          more
+        );
+      } else if (stats.isFile()) {
+        const content = fs.readFileSync(targetPath, 'utf8');
+        const lines = content.split('\n');
+        let body: string;
+        if (lines.length > MAX_MENTION_FILE_LINES) {
+          body = lines.slice(0, MAX_MENTION_FILE_LINES).join('\n') +
+            `\n\n... [Truncated: showing first ${MAX_MENTION_FILE_LINES} of ${lines.length} lines. Use fs.read for remaining lines.]`;
+        } else {
+          body = content;
+        }
+
+        sections.push(
+          `📄 REFERENCED FILE: ${relPath} (${lines.length} lines):\n` +
+          '```\n' +
+          body + '\n' +
+          '```'
+        );
+      }
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      sections.push(`📂 REFERENCED PATH: ${relPath} (Error reading: ${msg})`);
+    }
+  }
+
+  const referencedContext = sections.length > 0
+    ? `\n\n=== REFERENCED WORKSPACE CONTEXT (@ mentions) ===\n` +
+      sections.join('\n\n') +
+      `\n=== END REFERENCED WORKSPACE CONTEXT ===\n`
+    : '';
+
+  return {
+    mentions,
+    referencedContext,
+    detectedSubproject
+  };
+}

package/src/sandbox.js

@@ -360,7 +360,7 @@ export class Sandbox {
     if (toolName === 'desktop_act' || toolName === 'computer_use') {
       return { allowed: true, risk: 'extreme' };
     }
-    if (toolName === 'ui_forge') {
+    if (toolName === 'ui_forge' || toolName === 'document_forge') {
       return { allowed: true, risk: 'safe' };
     }
     if (toolName === 'fs_write' || toolName === 'fs_move' || toolName === 'fs_edit' || toolName === 'MultiEdit') {

package/src/textDiff.js

@@ -1,4 +1,4 @@
-// A unified diff, in pure JavaScript.
+// A unified diff, in pure JavaScript / TypeScript.
 //
 // The git backend gets patches from git itself. This exists so the NATIVE
 // backend — the fallback for a machine with no git, or a workspace that is not
@@ -9,13 +9,10 @@
 // No dependency: this is a standard LCS over lines, which is what `diff -u`
 // computes. Bounded, because a checkpoint diff is a UI affordance and must
 // never become the reason a request times out.
-
 /** Above this many lines on either side, fall back to counts without a patch. */
 const MAX_DIFF_LINES = 4000;
-
 /** Context lines around each change, matching `diff -u` and git's default. */
 const CONTEXT = 3;
-
 /**
  * Longest common subsequence over two line arrays.
  *
@@ -24,127 +21,138 @@ const CONTEXT = 3;
  * second, and anything larger is not something a human reads in a dialog.
  */
 function lcsTable(a, b) {
-  const table = [];
-  for (let i = 0; i <= a.length; i++) table.push(new Uint32Array(b.length + 1));
-  for (let i = a.length - 1; i >= 0; i--) {
-    for (let j = b.length - 1; j >= 0; j--) {
-      table[i][j] = a[i] === b[j]
-        ? table[i + 1][j + 1] + 1
-        : Math.max(table[i + 1][j], table[i][j + 1]);
+    const table = [];
+    for (let i = 0; i <= a.length; i++)
+        table.push(new Uint32Array(b.length + 1));
+    for (let i = a.length - 1; i >= 0; i--) {
+        const tableI = table[i];
+        const tableNext = table[i + 1];
+        for (let j = b.length - 1; j >= 0; j--) {
+            tableI[j] = a[i] === b[j]
+                ? tableNext[j + 1] + 1
+                : Math.max(tableNext[j], tableI[j + 1]);
+        }
     }
-  }
-  return table;
+    return table;
 }
-
 /** Walk the table into a flat edit script: ' ' keep, '-' remove, '+' add. */
 function editScript(a, b) {
-  const table = lcsTable(a, b);
-  const ops = [];
-  let i = 0;
-  let j = 0;
-  while (i < a.length && j < b.length) {
-    if (a[i] === b[j]) { ops.push([' ', a[i]]); i++; j++; }
-    else if (table[i + 1][j] >= table[i][j + 1]) { ops.push(['-', a[i]]); i++; }
-    else { ops.push(['+', b[j]]); j++; }
-  }
-  while (i < a.length) ops.push(['-', a[i++]]);
-  while (j < b.length) ops.push(['+', b[j++]]);
-  return ops;
+    const table = lcsTable(a, b);
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            ops.push([' ', a[i]]);
+            i++;
+            j++;
+        }
+        else if (table[i + 1][j] >= table[i][j + 1]) {
+            ops.push(['-', a[i]]);
+            i++;
+        }
+        else {
+            ops.push(['+', b[j]]);
+            j++;
+        }
+    }
+    while (i < a.length)
+        ops.push(['-', a[i++]]);
+    while (j < b.length)
+        ops.push(['+', b[j++]]);
+    return ops;
 }
-
 function splitLines(text) {
-  if (text === '') return [];
-  return text.replace(/\n$/, '').split('\n');
+    if (text === '')
+        return [];
+    return text.replace(/\n$/, '').split('\n');
 }
-
 /**
  * A unified diff of `before` → `after`.
- *
- * @returns {{patch: string, additions: number, deletions: number, truncated: boolean}}
  */
 export function unifiedDiff(before, after, pathLabel = 'file') {
-  const a = splitLines(before);
-  const b = splitLines(after);
-
-  if (a.length > MAX_DIFF_LINES || b.length > MAX_DIFF_LINES) {
-    // Counting without the table keeps a huge file cheap: the exact per-line
-    // patch is not worth an O(n*m) allocation nobody will read.
-    return {
-      patch: '',
-      additions: b.length,
-      deletions: a.length,
-      truncated: true
-    };
-  }
-
-  const ops = editScript(a, b);
-  let additions = 0;
-  let deletions = 0;
-  for (const [kind] of ops) {
-    if (kind === '+') additions++;
-    else if (kind === '-') deletions++;
-  }
-  if (additions === 0 && deletions === 0) {
-    return { patch: '', additions: 0, deletions: 0, truncated: false };
-  }
-
-  // Group changes into hunks with CONTEXT lines of surrounding text, so the
-  // output is readable rather than the whole file with markers.
-  const lines = [`--- a/${pathLabel}`, `+++ b/${pathLabel}`];
-  let index = 0;
-  let oldLine = 1;
-  let newLine = 1;
-
-  while (index < ops.length) {
-    if (ops[index][0] === ' ') {
-      if (ops[index][0] === ' ') { oldLine++; newLine++; }
-      index++;
-      continue;
-    }
-
-    // Walk back for leading context, then forward to the end of the change.
-    const start = Math.max(0, index - CONTEXT);
-    let end = index;
-    let quiet = 0;
-    while (end < ops.length && quiet <= CONTEXT * 2) {
-      quiet = ops[end][0] === ' ' ? quiet + 1 : 0;
-      end++;
+    const a = splitLines(before);
+    const b = splitLines(after);
+    if (a.length > MAX_DIFF_LINES || b.length > MAX_DIFF_LINES) {
+        // Counting without the table keeps a huge file cheap: the exact per-line
+        // patch is not worth an O(n*m) allocation nobody will read.
+        return {
+            patch: '',
+            additions: b.length,
+            deletions: a.length,
+            truncated: true
+        };
     }
-    end = Math.min(ops.length, end);
-
-    let oldStart = oldLine;
-    let newStart = newLine;
-    for (let k = start; k < index; k++) {
-      if (ops[k][0] !== '+') oldStart--;
-      if (ops[k][0] !== '-') newStart--;
+    const ops = editScript(a, b);
+    let additions = 0;
+    let deletions = 0;
+    for (const [kind] of ops) {
+        if (kind === '+')
+            additions++;
+        else if (kind === '-')
+            deletions++;
     }
-
-    let oldCount = 0;
-    let newCount = 0;
-    const body = [];
-    for (let k = start; k < end; k++) {
-      const [kind, text] = ops[k];
-      if (kind !== '+') oldCount++;
-      if (kind !== '-') newCount++;
-      body.push(`${kind}${text}`);
+    if (additions === 0 && deletions === 0) {
+        return { patch: '', additions: 0, deletions: 0, truncated: false };
     }
-
-    lines.push(`@@ -${Math.max(1, oldStart)},${oldCount} +${Math.max(1, newStart)},${newCount} @@`);
-    lines.push(...body);
-
-    for (let k = index; k < end; k++) {
-      if (ops[k][0] !== '+') oldLine++;
-      if (ops[k][0] !== '-') newLine++;
+    // Group changes into hunks with CONTEXT lines of surrounding text, so the
+    // output is readable rather than the whole file with markers.
+    const lines = [`--- a/${pathLabel}`, `+++ b/${pathLabel}`];
+    let index = 0;
+    let oldLine = 1;
+    let newLine = 1;
+    while (index < ops.length) {
+        const opIndex = ops[index];
+        if (opIndex[0] === ' ') {
+            oldLine++;
+            newLine++;
+            index++;
+            continue;
+        }
+        // Walk back for leading context, then forward to the end of the change.
+        const start = Math.max(0, index - CONTEXT);
+        let end = index;
+        let quiet = 0;
+        while (end < ops.length && quiet <= CONTEXT * 2) {
+            quiet = ops[end][0] === ' ' ? quiet + 1 : 0;
+            end++;
+        }
+        end = Math.min(ops.length, end);
+        let oldStart = oldLine;
+        let newStart = newLine;
+        for (let k = start; k < index; k++) {
+            if (ops[k][0] !== '+')
+                oldStart--;
+            if (ops[k][0] !== '-')
+                newStart--;
+        }
+        let oldCount = 0;
+        let newCount = 0;
+        const body = [];
+        for (let k = start; k < end; k++) {
+            const [kind, text] = ops[k];
+            if (kind !== '+')
+                oldCount++;
+            if (kind !== '-')
+                newCount++;
+            body.push(`${kind}${text}`);
+        }
+        lines.push(`@@ -${Math.max(1, oldStart)},${oldCount} +${Math.max(1, newStart)},${newCount} @@`);
+        lines.push(...body);
+        for (let k = index; k < end; k++) {
+            if (ops[k][0] !== '+')
+                oldLine++;
+            if (ops[k][0] !== '-')
+                newLine++;
+        }
+        index = end;
     }
-    index = end;
-  }
-
-  return { patch: lines.join('\n'), additions, deletions, truncated: false };
+    return { patch: lines.join('\n'), additions, deletions, truncated: false };
 }
-
 /** Binary content has no useful line diff — detected the way git detects it. */
 export function looksBinary(buffer) {
-  if (!buffer || buffer.length === 0) return false;
-  const sample = buffer.subarray(0, Math.min(8000, buffer.length));
-  return sample.includes(0);
+    if (!buffer || buffer.length === 0)
+        return false;
+    const sample = buffer.subarray(0, Math.min(8000, buffer.length));
+    return sample.includes(0);
 }

package/src/textDiff.ts

@@ -0,0 +1,169 @@
+// A unified diff, in pure JavaScript / TypeScript.
+//
+// The git backend gets patches from git itself. This exists so the NATIVE
+// backend — the fallback for a machine with no git, or a workspace that is not
+// a repository — can answer the same question. Without it, REVIEW would show
+// line counts on one machine and real changes on another, which is the kind of
+// inconsistency that makes a feature feel broken rather than degraded.
+//
+// No dependency: this is a standard LCS over lines, which is what `diff -u`
+// computes. Bounded, because a checkpoint diff is a UI affordance and must
+// never become the reason a request times out.
+
+/** Above this many lines on either side, fall back to counts without a patch. */
+const MAX_DIFF_LINES = 4000;
+
+/** Context lines around each change, matching `diff -u` and git's default. */
+const CONTEXT = 3;
+
+export interface UnifiedDiffResult {
+  patch: string;
+  additions: number;
+  deletions: number;
+  truncated: boolean;
+}
+
+/**
+ * Longest common subsequence over two line arrays.
+ *
+ * Classic dynamic programming. O(n*m) in time and memory, which is why
+ * MAX_DIFF_LINES exists — at the cap this is 16M cells, still well under a
+ * second, and anything larger is not something a human reads in a dialog.
+ */
+function lcsTable(a: string[], b: string[]): Uint32Array[] {
+  const table: Uint32Array[] = [];
+  for (let i = 0; i <= a.length; i++) table.push(new Uint32Array(b.length + 1));
+  for (let i = a.length - 1; i >= 0; i--) {
+    const tableI = table[i]!;
+    const tableNext = table[i + 1]!;
+    for (let j = b.length - 1; j >= 0; j--) {
+      tableI[j] = a[i] === b[j]
+        ? tableNext[j + 1]! + 1
+        : Math.max(tableNext[j]!, tableI[j + 1]!);
+    }
+  }
+  return table;
+}
+
+type EditOp = [' ' | '-' | '+', string];
+
+/** Walk the table into a flat edit script: ' ' keep, '-' remove, '+' add. */
+function editScript(a: string[], b: string[]): EditOp[] {
+  const table = lcsTable(a, b);
+  const ops: EditOp[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      ops.push([' ', a[i]!]);
+      i++;
+      j++;
+    } else if (table[i + 1]![j]! >= table[i]![j + 1]!) {
+      ops.push(['-', a[i]!]);
+      i++;
+    } else {
+      ops.push(['+', b[j]!]);
+      j++;
+    }
+  }
+  while (i < a.length) ops.push(['-', a[i++]!]);
+  while (j < b.length) ops.push(['+', b[j++]!]);
+  return ops;
+}
+
+function splitLines(text: string): string[] {
+  if (text === '') return [];
+  return text.replace(/\n$/, '').split('\n');
+}
+
+/**
+ * A unified diff of `before` → `after`.
+ */
+export function unifiedDiff(before: string, after: string, pathLabel = 'file'): UnifiedDiffResult {
+  const a = splitLines(before);
+  const b = splitLines(after);
+
+  if (a.length > MAX_DIFF_LINES || b.length > MAX_DIFF_LINES) {
+    // Counting without the table keeps a huge file cheap: the exact per-line
+    // patch is not worth an O(n*m) allocation nobody will read.
+    return {
+      patch: '',
+      additions: b.length,
+      deletions: a.length,
+      truncated: true
+    };
+  }
+
+  const ops = editScript(a, b);
+  let additions = 0;
+  let deletions = 0;
+  for (const [kind] of ops) {
+    if (kind === '+') additions++;
+    else if (kind === '-') deletions++;
+  }
+  if (additions === 0 && deletions === 0) {
+    return { patch: '', additions: 0, deletions: 0, truncated: false };
+  }
+
+  // Group changes into hunks with CONTEXT lines of surrounding text, so the
+  // output is readable rather than the whole file with markers.
+  const lines = [`--- a/${pathLabel}`, `+++ b/${pathLabel}`];
+  let index = 0;
+  let oldLine = 1;
+  let newLine = 1;
+
+  while (index < ops.length) {
+    const opIndex = ops[index]!;
+    if (opIndex[0] === ' ') {
+      oldLine++;
+      newLine++;
+      index++;
+      continue;
+    }
+
+    // Walk back for leading context, then forward to the end of the change.
+    const start = Math.max(0, index - CONTEXT);
+    let end = index;
+    let quiet = 0;
+    while (end < ops.length && quiet <= CONTEXT * 2) {
+      quiet = ops[end]![0] === ' ' ? quiet + 1 : 0;
+      end++;
+    }
+    end = Math.min(ops.length, end);
+
+    let oldStart = oldLine;
+    let newStart = newLine;
+    for (let k = start; k < index; k++) {
+      if (ops[k]![0] !== '+') oldStart--;
+      if (ops[k]![0] !== '-') newStart--;
+    }
+
+    let oldCount = 0;
+    let newCount = 0;
+    const body: string[] = [];
+    for (let k = start; k < end; k++) {
+      const [kind, text] = ops[k]!;
+      if (kind !== '+') oldCount++;
+      if (kind !== '-') newCount++;
+      body.push(`${kind}${text}`);
+    }
+
+    lines.push(`@@ -${Math.max(1, oldStart)},${oldCount} +${Math.max(1, newStart)},${newCount} @@`);
+    lines.push(...body);
+
+    for (let k = index; k < end; k++) {
+      if (ops[k]![0] !== '+') oldLine++;
+      if (ops[k]![0] !== '-') newLine++;
+    }
+    index = end;
+  }
+
+  return { patch: lines.join('\n'), additions, deletions, truncated: false };
+}
+
+/** Binary content has no useful line diff — detected the way git detects it. */
+export function looksBinary(buffer: Buffer | Uint8Array | null | undefined): boolean {
+  if (!buffer || buffer.length === 0) return false;
+  const sample = buffer.subarray(0, Math.min(8000, buffer.length));
+  return sample.includes(0);
+}

package/src/toolPacks.js

@@ -87,7 +87,8 @@ export const PACKS = {
     'blender_act',
     'creative_apps',
     'resolve_act',
-    'palmier_act'
+    'palmier_act',
+    'document_forge'
   ],
   system: [
     // Channel B of the Three-Channel Doctrine: reading the screen as structured
@@ -110,7 +111,9 @@ export const PACKS = {
   advanced: [
     'tool_forge',
     'plugin_manager',
+    'document_forge',
     'agent_subagent_orchestrate',
+    'peer_agent_delegate',
     'code_search_ast',
     'code_list_symbols',
     'pdf_read'
@@ -370,7 +373,7 @@ const MEDIA_INTENT = /\b(image|images|picture|photo|gambar|render|3d model|blend
 
 const SYSTEM_INTENT = /\b(process|processes|pid|kill|port|zip|unzip|tar|archive|compress|extract|clipboard|copy to clipboard|print|printer|cetak|open in browser|launch app|computer use|vision grounding|desktop vision|gui agent|coordinate click|desktop control)\b/i;
 
-const ADVANCED_INTENT = /\b(pdf|forge a tool|custom tool|new tool|plugin|plugins|custom plugin|subagent|sub-agent|parallel agent|swarm|ast|symbols|refactor across)\b/i;
+const ADVANCED_INTENT = /\b(pdf|document|proposal|dokumen|screenplay|naskah|shotlist|shot list|voiceover|dubbing|forge a tool|custom tool|new tool|plugin|plugins|custom plugin|subagent|sub-agent|parallel agent|swarm|ast|symbols|refactor across)\b/i;
 
 const INTENT_MATCHERS = {
   game: GAME_INTENT,