codehere 0.3.0-rc.6 → 0.3.0-rc.8

package/dist/infrastructure/orchestration/conductor-adapter.js

@@ -65,36 +65,99 @@ const ROUTING_RULES = [
 ];
 /** Default specialist when no routing rule matches. */
 const DEFAULT_SPECIALIST = 'claude-code';
+/**
+ * Tokenize a prompt for trigger matching. Splits on any non-alphanumeric
+ * boundary (whitespace, hyphens, punctuation), lowercases everything. So:
+ *
+ *   "Bug fix"        → ["bug", "fix"]
+ *   "set-up auth"    → ["set", "up", "auth"]    (trigger "set up" still matches via phrase below)
+ *   "unit-test it"   → ["unit", "test", "it"]
+ *   "prefix matter"  → ["prefix", "matter"]      (does NOT match `fix`)
+ *   "hotfixes"       → ["hotfixes"]              (does NOT match `fix`)
+ *
+ * Multi-word triggers ("add tests", "create new") are matched against the
+ * normalized prompt directly using word boundaries — so they catch
+ * "add tests" but not "added testing harness".
+ */
+function tokenize(prompt) {
+    const tokens = new Set(prompt
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean));
+    // Normalized form for multi-word phrase matching: ANY non-alphanumeric char
+    // (hyphens, underscores, slashes, dots, colons, commas, etc.) becomes a space,
+    // then collapse runs of whitespace. This matches the tokenizer's split rule
+    // exactly, so multi-word triggers like "add tests" catch all of:
+    //   "add tests"  "add-tests"  "add_tests"  "add/tests"  "add:tests"  "add.tests"
+    // Note: must NOT collapse the leading/trailing spaces — they're load-bearing
+    // for the boundary check below (`.includes(' ' + t + ' ')`).
+    const normalized = ' ' + prompt.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim() + ' ';
+    return { tokens, normalized };
+}
+/**
+ * Test whether a routing trigger matches a prompt. Single-word triggers must
+ * appear as whole tokens (no substring matches). Multi-word triggers must
+ * appear as a phrase in the normalized prompt (with leading/trailing spaces
+ * to enforce word boundaries on the ends).
+ */
+function triggerMatches(trigger, tokens, normalized) {
+    const t = trigger.toLowerCase().trim();
+    if (!t)
+        return false;
+    if (t.includes(' ')) {
+        return normalized.includes(' ' + t + ' ');
+    }
+    return tokens.has(t);
+}
 /**
  * Pick the right specialist for a given prompt.
  *
  * Algorithm:
- *  1. Walk routing rules in order.
- *  2. For the first rule whose triggers match, walk its `preferred` list.
- *  3. Return the first preferred adapter that's installed.
- *  4. If no rule matches OR no preferred adapter is installed, fall back to
- *     `DEFAULT_SPECIALIST` if it's installed; otherwise the first-installed
- *     adapter on the list.
+ *  1. Tokenize the prompt (whole-word matching, no substring false-positives).
+ *  2. Walk routing rules in order. Stop at the first rule whose triggers match.
+ *  3. Within that rule, return the first preferred adapter that's installed.
+ *  4. If that rule had a match but none of its preferred adapters are
+ *     installed, return DEFAULT_SPECIALIST (or first installed) with a
+ *     HONEST reason that names the matched rule and the fallback.
+ *  5. If no rule matched at all, return DEFAULT_SPECIALIST (or first
+ *     installed) with a "no intent matched" reason.
  *
  * Returns null if NO specialist is installed (caller must handle).
+ *
+ * Known limitation: a prompt with multiple intents (e.g. "fix the bug and
+ * add tests") routes by the first matching rule, not the dominant intent.
+ * The v0.4 LLM classifier inherently handles dominance via confidence
+ * scoring; the rule-based path here keeps the deterministic-priority
+ * contract instead.
  */
 export function pickSpecialist(prompt, installedAgentIds) {
     if (installedAgentIds.length === 0) {
         return null;
     }
-    const lowered = prompt.toLowerCase();
+    const installedSet = new Set(installedAgentIds);
+    const { tokens, normalized } = tokenize(prompt);
     for (const rule of ROUTING_RULES) {
-        const matches = rule.triggers.some((t) => lowered.includes(t));
+        const matches = rule.triggers.some((t) => triggerMatches(t, tokens, normalized));
         if (!matches)
             continue;
+        // Rule matched. Walk preferred specialists in order.
         for (const candidate of rule.preferred) {
-            if (installedAgentIds.includes(candidate)) {
+            if (installedSet.has(candidate)) {
                 return { agentId: candidate, reason: rule.reason };
             }
         }
+        // Rule matched but none of its preferred specialists are installed.
+        // Fall through with an HONEST reason that names the matched rule + fallback,
+        // so the audit log records what actually happened (Codex review caught
+        // the prior version saying "default routing" here, which was a lie).
+        const fallbackId = installedSet.has(DEFAULT_SPECIALIST) ? DEFAULT_SPECIALIST : installedAgentIds[0];
+        return {
+            agentId: fallbackId,
+            reason: `${rule.reason} — but none of [${rule.preferred.join(', ')}] installed; falling back to ${fallbackId}`,
+        };
     }
-    // No rule matched (or no preferred specialist installed) — default routing.
-    if (installedAgentIds.includes(DEFAULT_SPECIALIST)) {
+    // No rule matched. Default routing.
+    if (installedSet.has(DEFAULT_SPECIALIST)) {
         return { agentId: DEFAULT_SPECIALIST, reason: 'default routing (no specific intent matched)' };
     }
     return { agentId: installedAgentIds[0], reason: 'fallback to first available specialist' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.3.0-rc.6",
+  "version": "0.3.0-rc.8",
   "description": "A PM for your AI coding agents. Delegate, orchestrate, and audit Claude Code, Codex, Aider, and OpenCode from one local web UI — every AI action traced, every file scored.",
   "main": "dist/index.js",
   "type": "module",