@chatpanel/events 0.31.0 → 0.33.0

package/index.js

@@ -28,6 +28,10 @@ export { checkInvariants, INVARIANTS } from './invariants.js';
 export { createMemoryAdapter, createLogStore, createBlobStore } from './store.js';
 export { createRegistry, REGISTRY_STATES } from './registry.js';
 export { defineSearchEngine, reconcileEngines, attemptOrder, ENGINE_KINDS, SearchEngineError } from './search-engines.js';
+export {
+  getWeather, weatherUrl, parseWeather, formatWeather, areaLabel, isAmbiguousLocation,
+  WEATHER_HOST, WEATHER_TIMEOUT_MS, WeatherError,
+} from './weather.js';
 export { defineToolGroup, createToolGroupRegistry, ToolGroupError } from './tool-groups.js';
 export { toolNeedFor } from './tool-need.js';
 export { parseFlowchart, layoutFlowchart, renderFlowchartSvg } from './flowchart.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/events",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "description": "The canonical ChatPanel event-log and capability contracts — typed durable facts, clock-free deterministic linearization, schema upcasting, and the invariants the replay harness asserts. Pure, dependency-free ESM shared by the ChatPanel extension, gateway and bridge.",
   "type": "module",
   "main": "index.js",

package/voice-intents.js

@@ -233,13 +233,35 @@ export function findWakeCommands(text, wake = compileWake(), { maxSentences = MA
   const tokens = tokenize(raw);
   if (!tokens.length) return [];
   const hits = wakeHits(raw, tokens, wake);
-  return hits.map((hit, idx) => {
-    // Bounded by the NEXT address, then by sentence count. A second wake word is the end of
-    // the first command however the sentences fall.
-    const stop = idx + 1 < hits.length ? hits[idx + 1].start : raw.length;
+  const out = [];
+  // How far the last command emitted reaches. A wake phrase the speaker used as a WORD, inside
+  // a command already running, is part of that command and not a second one.
+  let covered = 0;
+  for (let idx = 0; idx < hits.length; idx++) {
+    const hit = hits[idx];
+    // THE PRODUCT'S OWN NAME IS A WORD PEOPLE SAY.
+    //
+    // "Okay chat panel, take the notes of whatever we spoke so far in chat panel notes" holds
+    // the wake phrase twice: once as an address, once as the name of where to put them. The
+    // second was treated as a fresh address, which did two things and both were wrong — it cut
+    // the command down to "…so far", losing where they wanted the notes, and it emitted
+    // "notes. So that is good." as a command of its own, which noteIntent matched. One spoken
+    // request became two notes and a truncated one.
+    //
+    // A mention that is not an address and falls inside the command already being carried is
+    // skipped. A mention that stands on its own still gets through — the intent match is the
+    // safety net for an address this heuristic misjudged, and dropping those outright would
+    // trade a stray action for a lost one.
+    if (!hit.addressed && hit.start < covered) continue;
+    // Bounded by the next ADDRESS, then by sentence count. Deliberately the next address and
+    // not the next mention: a second wake word is the end of the first command only when the
+    // speaker was turning to us again, and the sentence they are still saying is not that.
+    let stop = raw.length;
+    for (let j = idx + 1; j < hits.length; j++) if (hits[j].addressed) { stop = hits[j].start; break; }
     const span = raw.slice(hit.end, stop);
     const command = trimTrailingLeadIn(stripLeadIn(firstSentences(span, maxSentences)).trim());
-    return {
+    covered = Math.max(covered, hit.end + span.indexOf(command) + command.length);
+    out.push({
       command,
       wake: hit.phrase,
       heard: raw.slice(hit.start, hit.end),
@@ -248,8 +270,9 @@ export function findWakeCommands(text, wake = compileWake(), { maxSentences = MA
       // What was said after the command's own sentences, up to the next address. Not part of
       // the command — kept so a caller refining with a model has the surrounding words.
       rest: raw.slice(hit.end + span.indexOf(command) + command.length, stop).trim(),
-    };
-  });
+    });
+  }
+  return out;
 }
 
 /**
@@ -380,7 +403,12 @@ export const REFINEMENT_SCHEMA = defineSchema({
     name: { type: 'string', max: 48, describe: 'a label of at most 6 words' },
     kind: {
       type: 'enum',
-      values: ['question', 'monitor', 'note', 'skill', 'timer', 'none'],
+      // 'action' is here because it was MISSING, and the gap was silent. A browser command
+      // ("go to google.com and search for chat panel") is not something they want to KNOW, so
+      // it does not read as a question — and the only other bucket that fitted a rambling,
+      // narrated demo was "none", which is dropped without a word. Spoken four different ways
+      // in one meeting, it did nothing every time while the timer beside it worked.
+      values: ['question', 'action', 'monitor', 'note', 'skill', 'timer', 'none'],
       // An unknown kind becomes a QUESTION — the least surprising thing to do with something
       // someone asked for, and the only kind that is undone by ignoring the answer. Guessing
       // "monitor" instead would leave a card watching the meeting that nobody asked for.
@@ -405,6 +433,7 @@ export function refinementPrompt(utterance) {
     '',
     'Pick the SMALLEST kind that does what they asked:',
     '  question — answer it once, now. The DEFAULT for anything they want to know.',
+    '  action   — DO something in the browser or an app ("go to google.com and search for X").',
     '  monitor  — only if they asked to be told as the meeting CONTINUES ("let me know if",',
     '             "keep an eye on"). A one-off question is NOT a monitor.',
     '  note     — they asked for notes written down ("take notes on", "write that up").',
@@ -474,6 +503,36 @@ export function settleRefinement(v) {
   return { request, name, kind, skill: v.skill || '' };
 }
 
+/**
+ * Did the user's own spoken words name this host?
+ *
+ * The authority test for a hands-free browser command. A URL a MODEL picked is
+ * attacker-influenced by construction — it has been reading page text and meeting captions —
+ * so it gets a confirmation dialog. A URL whose host the USER said out loud has already been
+ * reviewed by the only person that dialog would have asked, and a modal in a side panel is
+ * exactly what nobody in a meeting is looking at: "go to google.com and search for chat
+ * panel" was spoken four ways in one call and did nothing every time.
+ *
+ * Deliberately strict. The full hostname always counts ("google.com"). The bare first label
+ * counts ONLY for a two-label host, so saying "docs" can never authorise `docs.evil.test` —
+ * anything deeper has to be said in full.
+ *
+ * Shared rather than written in the panel because it is a pure decision with no platform in
+ * it: the bridge relays the same page tools, and a second copy of an authority rule is a
+ * second answer to "may this happen".
+ */
+export function spokenNamesHost(url, spoken) {
+  const said = String(spoken || '').toLowerCase();
+  if (!said) return false;
+  let host;
+  try { host = new URL(url).hostname.toLowerCase().replace(/^www\./, ''); } catch { return false; }
+  if (!host) return false;
+  if (said.includes(host)) return true;
+  const labels = host.split('.');
+  if (labels.length !== 2) return false;
+  return new RegExp(`\\b${labels[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(said);
+}
+
 /**
  * The same answer, AS IT ARRIVES.
  *