@sanctuary-framework/mcp-server 1.2.6 → 1.2.7

package/dist/index.cjs

@@ -4922,7 +4922,8 @@ var SIGNATURE_SCHEME_V1 = "ed25519-v1";
 var RESERVED_EVENT_TYPE_PREFIXES = [
   "EXTENSION_",
   "cross_fortress_",
-  "multi_master_"
+  "multi_master_",
+  "cross_harness_approval_"
 ];
 function isReservedEventType(s) {
   return RESERVED_EVENT_TYPE_PREFIXES.some((p) => s.startsWith(p));
@@ -9102,9 +9103,9 @@ function fingerprintDID(did) {
   return `${raw.slice(0, 6)}\u2026${raw.slice(-6)}`;
 }
 function countInjectionsToday(audit) {
-  const startOfDay = /* @__PURE__ */ new Date();
-  startOfDay.setHours(0, 0, 0, 0);
-  const cutoff = startOfDay.getTime();
+  const startOfDay2 = /* @__PURE__ */ new Date();
+  startOfDay2.setHours(0, 0, 0, 0);
+  const cutoff = startOfDay2.getTime();
   return audit.filter((e) => {
     const ts = new Date(e.timestamp).getTime();
     if (isNaN(ts) || ts < cutoff) return false;
@@ -9118,9 +9119,9 @@ var PROOF_CREATION_OPS = /* @__PURE__ */ new Set([
   "proof_commitment"
 ]);
 function countProofsToday(audit) {
-  const startOfDay = /* @__PURE__ */ new Date();
-  startOfDay.setHours(0, 0, 0, 0);
-  const cutoff = startOfDay.getTime();
+  const startOfDay2 = /* @__PURE__ */ new Date();
+  startOfDay2.setHours(0, 0, 0, 0);
+  const cutoff = startOfDay2.getTime();
   return audit.filter((e) => {
     if (e.layer !== "l3") return false;
     if (!PROOF_CREATION_OPS.has(e.operation)) return false;
@@ -16319,6 +16320,24 @@ async function handleApprovalInboxRoute(deps, req, res) {
       await handleStream2(deps, res);
       return true;
     }
+    if (method === "GET" && path === `${APPROVAL_INBOX_API_PREFIX}/revision`) {
+      const revision = await deps.aggregator.getRevision();
+      writeJSON4(res, 200, { ok: true, data: { revision } });
+      return true;
+    }
+    if (method === "GET" && path === `${APPROVAL_INBOX_API_PREFIX}/sync`) {
+      const sinceRaw = url.searchParams.get("since_revision");
+      const sinceParsed = sinceRaw === null ? 0 : Number.parseInt(sinceRaw, 10);
+      const sinceRevision = Number.isFinite(sinceParsed) && sinceParsed >= 0 ? sinceParsed : 0;
+      const limit = parseLimit2(
+        url.searchParams.get("limit"),
+        APPROVAL_INBOX_DEFAULT_LIMIT,
+        APPROVAL_INBOX_MAX_LIMIT
+      );
+      const delta = await deps.aggregator.getSync({ sinceRevision, limit });
+      writeJSON4(res, 200, { ok: true, data: delta });
+      return true;
+    }
     if (method === "GET" && path === `${APPROVAL_INBOX_API_PREFIX}/history`) {
       const limit = parseLimit2(
         url.searchParams.get("limit"),
@@ -19414,6 +19433,20 @@ var ApprovalAggregator = class {
   hydrated = false;
   /** Active SSE listeners. */
   listeners = /* @__PURE__ */ new Set();
+  /**
+   * Monotonic revision counter, bumped on every mutation (ingest of new
+   * entry, resolve, expire, delete). Hydrated from max(last_modified_revision)
+   * across persisted entries on first read; in-memory after that. v1.3
+   * Upsilon-4.
+   */
+  currentRevision = 0;
+  /**
+   * Removal tombstones: aggregator_id -> revision at removal. Used by the
+   * sync API to surface "removed" entries to mobile consumers between
+   * polls. In-memory only; server restart clears tombstones (mobile
+   * bootstraps via `list()` on reconnect). v1.3 Upsilon-4.
+   */
+  removedTombstones = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.storage = deps.storage;
     this.encryptionKey = derivePurposeKey(
@@ -19448,6 +19481,113 @@ var ApprovalAggregator = class {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
   }
+  /**
+   * Current aggregator revision. v1.3 Upsilon-4. Mobile companions
+   * poll the lightweight `/revision` route to detect that something
+   * changed before fetching a full sync delta.
+   */
+  async getRevision() {
+    await this.hydrate();
+    return this.currentRevision;
+  }
+  /**
+   * Compute a delta since `sinceRevision`. v1.3 Upsilon-4. Mobile
+   * clients poll this for cheap state-sync. Behavior:
+   *  - `added`: entries whose `created_at_revision > sinceRevision`.
+   *  - `changed`: entries that existed at `sinceRevision` but had a
+   *    status transition (resolve, expire) since.
+   *  - `removed`: aggregator_ids deleted after `sinceRevision`.
+   *  - `revision`: current aggregator revision; pass this back as
+   *    `sinceRevision` on the next call.
+   *
+   * `limit` caps the total count returned across all three lists,
+   * prioritized as added -> changed -> removed (newer-state first).
+   * When more changes exist than fit, the next call with the returned
+   * revision will pick up the rest because each entry's
+   * last_modified_revision is unchanged by truncation.
+   */
+  async getSync(opts) {
+    await this.hydrate();
+    await this.expireStale();
+    const sinceRevision = opts?.sinceRevision ?? 0;
+    const cap = Math.min(
+      opts?.limit ?? DEFAULT_LIST_PAGE_SIZE,
+      this.maxListLimit
+    );
+    const added = [];
+    const changed = [];
+    for (const entry of this.entries.values()) {
+      const lastMod = entry.last_modified_revision ?? 0;
+      if (lastMod <= sinceRevision) continue;
+      const createdRev = entry.created_at_revision ?? 0;
+      if (createdRev > sinceRevision) {
+        added.push(entry);
+      } else {
+        changed.push(entry);
+      }
+    }
+    const removed = [];
+    for (const [id, rev] of this.removedTombstones) {
+      if (rev > sinceRevision) removed.push(id);
+    }
+    added.sort(
+      (a, b) => (a.last_modified_revision ?? 0) - (b.last_modified_revision ?? 0)
+    );
+    changed.sort(
+      (a, b) => (a.last_modified_revision ?? 0) - (b.last_modified_revision ?? 0)
+    );
+    let remaining = cap;
+    const addedOut = added.slice(0, Math.max(0, remaining));
+    remaining -= addedOut.length;
+    const changedOut = changed.slice(0, Math.max(0, remaining));
+    remaining -= changedOut.length;
+    const removedOut = removed.slice(0, Math.max(0, remaining));
+    return {
+      revision: this.currentRevision,
+      added: addedOut,
+      changed: changedOut,
+      removed: removedOut
+    };
+  }
+  /**
+   * Delete an entry. Drops the in-memory record, the persisted bundle,
+   * and the at-rest payload (if a payload store is wired). Records a
+   * tombstone with the new revision so sync-API consumers see a
+   * `removed` delta. Returns true when an entry was deleted, false on
+   * unknown id. v1.3 Upsilon-4. Reserved for v1.4+ retention housekeeping;
+   * Upsilon-4 ships the surface so mobile sync-API tests can exercise the
+   * removal path.
+   */
+  async deleteEntry(aggregatorId) {
+    await this.hydrate();
+    const entry = this.entries.get(aggregatorId);
+    if (!entry) return false;
+    const dedupKey = `${entry.source_harness}|${entry.source_agent_id}|${entry.audit_log_entry_id}`;
+    this.entries.delete(aggregatorId);
+    this.dedupIndex.delete(dedupKey);
+    this.fullPayloads.delete(aggregatorId);
+    for (const [corr, id] of this.correlationIndex) {
+      if (id === aggregatorId) this.correlationIndex.delete(corr);
+    }
+    try {
+      await this.storage.delete(APPROVAL_AGGREGATOR_NAMESPACE, aggregatorId);
+    } catch {
+    }
+    if (this.payloadStore) {
+      try {
+        await this.payloadStore.deletePayload(aggregatorId);
+      } catch {
+      }
+    }
+    const revision = this.nextRevision();
+    this.removedTombstones.set(aggregatorId, revision);
+    this.emit({ type: "removed", entry: { ...entry } });
+    return true;
+  }
+  nextRevision() {
+    this.currentRevision += 1;
+    return this.currentRevision;
+  }
   /**
    * Ingest a gate event. Returns the aggregator entry on first sight,
    * `null` when deduped. Resolution events update the existing record;
@@ -19658,6 +19798,7 @@ var ApprovalAggregator = class {
     entry.status = decision;
     entry.resolved_at = this.now().toISOString();
     entry.resolved_by = operatorId;
+    entry.last_modified_revision = this.nextRevision();
     await this.persist(entry);
     this.auditLog.append(
       "l2",
@@ -19709,6 +19850,7 @@ var ApprovalAggregator = class {
     const expires = new Date(now.getTime() + this.pendingTtlMs);
     const hubInboxId = this.resolveHubInboxItemId(event);
     const enforcementChain = this.resolveEnforcementChain(event);
+    const revision = this.nextRevision();
     const entry = {
       aggregator_id: id,
       source_harness: ctx.source_harness,
@@ -19720,6 +19862,8 @@ var ApprovalAggregator = class {
       status: "pending",
       created_at: now.toISOString(),
       expires_at: expires.toISOString(),
+      created_at_revision: revision,
+      last_modified_revision: revision,
       ...hubInboxId !== void 0 ? { hub_inbox_item_id: hubInboxId } : {},
       ...enforcementChain.length > 0 ? { enforcement_chain: enforcementChain } : {}
     };
@@ -19762,6 +19906,7 @@ var ApprovalAggregator = class {
     entry.status = status;
     entry.resolved_at = event.resolution.decided_at;
     entry.resolved_by = event.resolution.decided_by;
+    entry.last_modified_revision = this.nextRevision();
     await this.persist(entry);
     this.auditLog.append(
       "l2",
@@ -19824,6 +19969,7 @@ var ApprovalAggregator = class {
       entry.status = "expired";
       entry.resolved_at = this.now().toISOString();
       entry.resolved_by = "system_ttl";
+      entry.last_modified_revision = this.nextRevision();
       await this.persist(entry);
       this.auditLog.append(
         "l2",
@@ -19870,6 +20016,10 @@ var ApprovalAggregator = class {
           this.entries.set(entry.aggregator_id, entry);
           const dedupKey = `${entry.source_harness}|${entry.source_agent_id}|${entry.audit_log_entry_id}`;
           this.dedupIndex.set(dedupKey, entry.aggregator_id);
+          const lastMod = entry.last_modified_revision ?? 0;
+          if (lastMod > this.currentRevision) {
+            this.currentRevision = lastMod;
+          }
         } catch {
         }
       }
@@ -32320,6 +32470,13 @@ init_encoding();
 // src/chat/operator-chat-audit-events.ts
 var OPERATOR_CHAT_OPS = {
   CONCIERGE_CHAT: "operator_concierge_chat",
+  /**
+   * Click-to-inspect panel opened on an agent row. Repurposed from the
+   * direct-agent session-open audit event in the v1.2 reshape; the click
+   * affordance now opens an inspect/approve panel (recent activity +
+   * pending approvals + policy summary) instead of a chat session.
+   */
+  AGENT_INSPECT_PANEL_OPENED: "agent_inspect_panel_opened",
   /**
    * Operator viewed concierge thread history (WP-V1.3-9 Tau-1). Emitted
    * when the operator hits the list-threads or read-thread route. Body
@@ -32488,9 +32645,10 @@ function isTrivialQuery(query) {
   if (norm.length < 8) return true;
   return TRIVIAL_GREETINGS.has(norm);
 }
-function classifyQuery(query) {
+function classifyQuery(query, parsedGrammar) {
   const normalized = query.toLowerCase();
   const matches = [];
+  const grammarAgent = parsedGrammar && parsedGrammar.agent_names.length > 0 ? parsedGrammar.agent_names[0] ?? null : null;
   for (const spec of CATEGORY_KEYWORDS) {
     const matchedPhrases = [];
     for (const pattern of spec.patterns) {
@@ -32502,11 +32660,14 @@ function classifyQuery(query) {
     }
     if (matchedPhrases.length === 0) continue;
     const confidence = Math.min(1, 0.4 + 0.3 * matchedPhrases.length);
+    const wantsAgentHint = spec.category === "agent_state" || spec.category === "agent_activity";
+    const agent_name_hint = wantsAgentHint ? grammarAgent ?? extractAgentNameHint(query) : null;
     matches.push({
       category: spec.category,
       confidence,
       matched_keywords: matchedPhrases,
-      agent_name_hint: spec.category === "agent_state" || spec.category === "agent_activity" ? extractAgentNameHint(query) : null
+      agent_name_hint,
+      ...parsedGrammar !== void 0 ? { query_grammar: parsedGrammar } : {}
     });
   }
   matches.sort((a, b) => {
@@ -32515,6 +32676,25 @@ function classifyQuery(query) {
   });
   return matches;
 }
+function fetcherHintsFromGrammar(parsed) {
+  if (!parsed) return void 0;
+  const hasTime = parsed.time_range !== null;
+  const hasAgents = parsed.agent_names.length > 0;
+  const hasEvents = parsed.event_types.length > 0;
+  if (!hasTime && !hasAgents && !hasEvents) return void 0;
+  const hints = {};
+  if (parsed.time_range) {
+    const range = parsed.time_range;
+    hints.time_range = {
+      start: range.start,
+      end: range.end,
+      ...range.relative_label !== void 0 ? { relative_label: range.relative_label } : {}
+    };
+  }
+  if (hasAgents) hints.agent_names = parsed.agent_names;
+  if (hasEvents) hints.event_types = parsed.event_types;
+  return hints;
+}
 function approxTokenLen(text) {
   return Math.ceil(text.length / APPROX_CHARS_PER_TOKEN);
 }
@@ -32528,42 +32708,45 @@ var CATEGORY_LABELS = {
   recent_receipts: "Recent receipts",
   verascore_deltas: "Verascore deltas"
 };
-async function runFetcher(match, fetchers) {
+async function runFetcher(match, fetchers, hints) {
   switch (match.category) {
     case "templates":
-      return fetchers.templates();
+      return fetchers.templates(hints);
     case "agent_state":
-      return fetchers.agent_state(match.agent_name_hint);
+      return fetchers.agent_state(match.agent_name_hint, hints);
     case "agent_activity":
-      return fetchers.agent_activity(match.agent_name_hint);
+      return fetchers.agent_activity(match.agent_name_hint, hints);
     case "audit_log":
-      return fetchers.audit_log();
+      return fetchers.audit_log(hints);
     case "sentinel_findings":
-      return fetchers.sentinel_findings();
+      return fetchers.sentinel_findings(hints);
     case "anomaly_alerts":
-      return fetchers.anomaly_alerts();
+      return fetchers.anomaly_alerts(hints);
     case "recent_receipts":
-      return fetchers.recent_receipts();
+      return fetchers.recent_receipts(hints);
     case "verascore_deltas":
-      return fetchers.verascore_deltas();
+      return fetchers.verascore_deltas(hints);
   }
 }
-function trivialMatch(category) {
+function trivialMatch(category, parsedGrammar) {
   return {
     category,
     confidence: 0.5,
     matched_keywords: ["llm-assist"],
-    agent_name_hint: null
+    agent_name_hint: parsedGrammar && parsedGrammar.agent_names.length > 0 ? parsedGrammar.agent_names[0] ?? null : null,
+    ...parsedGrammar !== void 0 ? { query_grammar: parsedGrammar } : {}
   };
 }
 async function foldContext(query, fetchers, opts) {
   const budget = opts?.maxTokens ?? DEFAULT_DYNAMIC_CONTEXT_TOKEN_BUDGET;
-  let matches = classifyQuery(query);
+  const parsed = opts?.parsed ?? null;
+  const hints = fetcherHintsFromGrammar(parsed);
+  let matches = classifyQuery(query, parsed);
   if (matches.length === 0 && !isTrivialQuery(query) && opts?.llmAssistClassify) {
     try {
       const picked = await opts.llmAssistClassify(query, CONTEXT_CATEGORIES);
       if (picked !== "none" && CONTEXT_CATEGORIES.includes(picked)) {
-        matches = [trivialMatch(picked)];
+        matches = [trivialMatch(picked, parsed)];
       }
     } catch {
     }
@@ -32574,7 +32757,7 @@ async function foldContext(query, fetchers, opts) {
   const attempts = [];
   for (const match of matches) {
     try {
-      const text = await runFetcher(match, fetchers);
+      const text = await runFetcher(match, fetchers, hints);
       const trimmed = text.trim();
       if (trimmed.length > 0) {
         attempts.push({ category: match.category, text: trimmed });
@@ -32616,6 +32799,520 @@ ${blocks.join("\n\n")}`;
   };
 }
 
+// src/composition/constants.ts
+var COMPOSITION_EVENT_TYPES = [
+  "composition_receipt_packed",
+  "composition_receipt_verified",
+  "composition_mandate_verified",
+  "composition_verascore_published",
+  "composition_sidecar_spawned",
+  "composition_sidecar_crashed",
+  "composition_sidecar_recovered",
+  "composition_degraded",
+  "composition_recovered"
+];
+
+// src/chat/concierge-query-grammar.ts
+var CANONICAL_AUDIT_EVENT_CLASSES = [
+  // Lifecycle / policy
+  "policy_change",
+  "approval_request",
+  "audit_truncate",
+  "lockdown",
+  "unwrap",
+  // Exit bundle (Tier 1)
+  "exit_bundle_export",
+  "exit_bundle_import_activate",
+  "exit_bundle_rekey",
+  // Cross-harness approval aggregator
+  "cross_harness_approval_aggregated",
+  "cross_harness_approval_resolved",
+  "cross_harness_approval_deduped",
+  "cross_harness_approval_payload_decrypted",
+  "cross_harness_approval_audit_trail_viewed",
+  "cross_harness_approval_replayed",
+  // Composition (full set from constants.ts)
+  ...COMPOSITION_EVENT_TYPES,
+  // Operator chat / concierge (full set from OPERATOR_CHAT_OPS)
+  OPERATOR_CHAT_OPS.CONCIERGE_CHAT,
+  OPERATOR_CHAT_OPS.AGENT_INSPECT_PANEL_OPENED,
+  OPERATOR_CHAT_OPS.CONCIERGE_HISTORY_READ,
+  OPERATOR_CHAT_OPS.CONCIERGE_THREAD_DELETED,
+  OPERATOR_CHAT_OPS.CONCIERGE_MEMORY_READ_FAILED,
+  OPERATOR_CHAT_OPS.CONCIERGE_CONTEXT_FETCHER_FAILED,
+  // Bridge / commitment
+  "bridge_commit",
+  "bridge_verify",
+  "bridge_attest",
+  "proof_commitment",
+  "proof_reveal",
+  // Reputation
+  "reputation_export",
+  "reputation_import",
+  "reputation_publish",
+  "reputation_record",
+  "reputation_query"
+];
+var EVENT_SYNONYMS = [
+  { phrase: "approvals", canonical: ["approval_request", "cross_harness_approval_aggregated", "cross_harness_approval_resolved"] },
+  { phrase: "approval", canonical: ["approval_request"] },
+  { phrase: "policy changes", canonical: ["policy_change"] },
+  { phrase: "policy change", canonical: ["policy_change"] },
+  { phrase: "policy edits", canonical: ["policy_change"] },
+  { phrase: "lockdowns", canonical: ["lockdown"] },
+  { phrase: "exit bundles", canonical: ["exit_bundle_export", "exit_bundle_import_activate"] },
+  { phrase: "exit bundle", canonical: ["exit_bundle_export"] },
+  { phrase: "audit truncations", canonical: ["audit_truncate"] },
+  { phrase: "audit truncation", canonical: ["audit_truncate"] },
+  { phrase: "compositions", canonical: ["composition_receipt_packed", "composition_receipt_verified"] },
+  { phrase: "receipts", canonical: ["composition_receipt_packed", "composition_receipt_verified"] },
+  { phrase: "receipt verifications", canonical: ["composition_receipt_verified"] },
+  { phrase: "concierge chats", canonical: [OPERATOR_CHAT_OPS.CONCIERGE_CHAT] },
+  { phrase: "cross harness approvals", canonical: ["cross_harness_approval_aggregated", "cross_harness_approval_resolved"] }
+];
+var MS_PER_HOUR = 60 * 60 * 1e3;
+var MS_PER_DAY = 24 * MS_PER_HOUR;
+var NUMBER_WORDS = {
+  a: 1,
+  an: 1,
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  twelve: 12,
+  twentyfour: 24
+};
+function resolveTimeRange(query, now) {
+  const normalized = query.trim();
+  const lower = normalized.toLowerCase();
+  const fromTo = lower.match(
+    /\b(?:from|between)\s+(.+?)\s+(?:to|and|-|until)\s+([\w:.\-+t /]+)/i
+  );
+  if (fromTo) {
+    const aSlice = fromTo[1];
+    const bSlice = fromTo[2];
+    if (aSlice !== void 0 && bSlice !== void 0) {
+      const a = parseInstant(aSlice, now);
+      const b = parseInstant(bSlice, now);
+      if (a && b) {
+        const start = a.getTime() <= b.getTime() ? a : b;
+        const end = a.getTime() <= b.getTime() ? b : a;
+        return {
+          range: { start, end },
+          matchedSubstring: fromTo[0]
+        };
+      }
+    }
+  }
+  const sinceMatch = lower.match(/\bsince\s+([\w:.\-+t /]+)/i);
+  if (sinceMatch) {
+    const slice = sinceMatch[1];
+    if (slice !== void 0) {
+      const start = parseInstant(slice, now);
+      if (start) {
+        return {
+          range: { start, end: now },
+          matchedSubstring: sinceMatch[0]
+        };
+      }
+    }
+  }
+  if (/\byesterday\b/.test(lower)) {
+    const startOfToday = startOfDay(now);
+    const start = new Date(startOfToday.getTime() - MS_PER_DAY);
+    const end = new Date(startOfToday.getTime() - 1);
+    return {
+      range: { start, end, relative_label: "yesterday" },
+      matchedSubstring: "yesterday"
+    };
+  }
+  if (/\btoday\b/.test(lower)) {
+    return {
+      range: {
+        start: startOfDay(now),
+        end: now,
+        relative_label: "today"
+      },
+      matchedSubstring: "today"
+    };
+  }
+  const compactHours = lower.match(/\blast\s+(\d+)\s*h\b/i);
+  if (compactHours) {
+    const tok = compactHours[1];
+    if (tok !== void 0) {
+      const n = Number.parseInt(tok, 10);
+      if (Number.isFinite(n) && n > 0) {
+        const start = new Date(now.getTime() - n * MS_PER_HOUR);
+        return {
+          range: { start, end: now, relative_label: `last ${n}h` },
+          matchedSubstring: compactHours[0]
+        };
+      }
+    }
+  }
+  const hoursMatch = lower.match(
+    /\b(?:past|last)\s+([\w]+|\d+)\s*(?:hr\b|hrs\b|hour|hours)/i
+  );
+  if (hoursMatch) {
+    const tok = hoursMatch[1];
+    if (tok !== void 0) {
+      const n = parseCount(tok);
+      if (n !== null && n > 0) {
+        const start = new Date(now.getTime() - n * MS_PER_HOUR);
+        return {
+          range: { start, end: now, relative_label: `past ${n} hour${n === 1 ? "" : "s"}` },
+          matchedSubstring: hoursMatch[0]
+        };
+      }
+    }
+  }
+  if (/\b(?:past|last)\s+hour\b/.test(lower)) {
+    const start = new Date(now.getTime() - MS_PER_HOUR);
+    return {
+      range: { start, end: now, relative_label: "past hour" },
+      matchedSubstring: lower.match(/\b(?:past|last)\s+hour\b/i)[0]
+    };
+  }
+  const daysMatch = lower.match(
+    /\b(?:past|last)\s+([\w]+|\d+)\s*(?:d\b|day|days)/i
+  );
+  if (daysMatch) {
+    const tok = daysMatch[1];
+    if (tok !== void 0) {
+      const n = parseCount(tok);
+      if (n !== null && n > 0) {
+        const start = new Date(now.getTime() - n * MS_PER_DAY);
+        return {
+          range: { start, end: now, relative_label: `past ${n} day${n === 1 ? "" : "s"}` },
+          matchedSubstring: daysMatch[0]
+        };
+      }
+    }
+  }
+  if (/\b(?:past|last)\s+day\b/.test(lower)) {
+    const start = new Date(now.getTime() - MS_PER_DAY);
+    return {
+      range: { start, end: now, relative_label: "past day" },
+      matchedSubstring: lower.match(/\b(?:past|last)\s+day\b/i)[0]
+    };
+  }
+  if (/\bthis\s+week\b/.test(lower)) {
+    const start = startOfWeek(now);
+    return {
+      range: { start, end: now, relative_label: "this week" },
+      matchedSubstring: lower.match(/\bthis\s+week\b/i)[0]
+    };
+  }
+  if (/\b(?:past|last)\s+week\b/.test(lower)) {
+    const start = new Date(now.getTime() - 7 * MS_PER_DAY);
+    return {
+      range: { start, end: now, relative_label: "past week" },
+      matchedSubstring: lower.match(/\b(?:past|last)\s+week\b/i)[0]
+    };
+  }
+  const isoMatch = normalized.match(
+    /\b(\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2})?(?:Z|[+-]\d{2}:\d{2})?)?)\b/
+  );
+  if (isoMatch) {
+    const tok = isoMatch[1];
+    if (tok !== void 0) {
+      const parsed = parseInstant(tok, now);
+      if (parsed) {
+        const isDateOnly = /^\d{4}-\d{2}-\d{2}$/.test(tok);
+        if (isDateOnly) {
+          return {
+            range: {
+              start: parsed,
+              end: new Date(parsed.getTime() + MS_PER_DAY - 1)
+            },
+            matchedSubstring: tok
+          };
+        }
+        return {
+          range: {
+            start: new Date(parsed.getTime() - 30 * 60 * 1e3),
+            end: new Date(parsed.getTime() + 30 * 60 * 1e3)
+          },
+          matchedSubstring: tok
+        };
+      }
+    }
+  }
+  return null;
+}
+function parseInstant(token, now) {
+  const trimmed = token.trim().replace(/[,.!?;]+$/g, "");
+  if (!trimmed) return null;
+  const lower = trimmed.toLowerCase();
+  if (lower === "now") return now;
+  if (lower === "today") return startOfDay(now);
+  if (lower === "yesterday") {
+    return new Date(startOfDay(now).getTime() - MS_PER_DAY);
+  }
+  const isoLike = trimmed.replace(" ", "T");
+  const parsed = new Date(isoLike);
+  if (!Number.isNaN(parsed.getTime())) return parsed;
+  return null;
+}
+function parseCount(token) {
+  const lower = token.toLowerCase();
+  if (/^\d+$/.test(lower)) {
+    const n = Number.parseInt(lower, 10);
+    return Number.isFinite(n) ? n : null;
+  }
+  return NUMBER_WORDS[lower] ?? null;
+}
+function startOfDay(d) {
+  const out = new Date(d);
+  out.setHours(0, 0, 0, 0);
+  return out;
+}
+function startOfWeek(d) {
+  const out = startOfDay(d);
+  const dayOfWeek = out.getDay();
+  const offsetToMonday = (dayOfWeek + 6) % 7;
+  out.setDate(out.getDate() - offsetToMonday);
+  return out;
+}
+function listFromRegistry(registry) {
+  if (!registry) return [];
+  if (Array.isArray(registry)) return registry;
+  if (typeof registry.list === "function") {
+    return registry.list();
+  }
+  return [];
+}
+function extractAgentNames(query, registry) {
+  const records = listFromRegistry(registry);
+  if (records.length === 0) return { matched: [], flagged: false };
+  const lowerQuery = query.toLowerCase();
+  const compactQuery = lowerQuery.replace(/[\s_-]+/g, "");
+  const matched = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rec of records) {
+    const id = rec.agent_id;
+    if (!id || seen.has(id)) continue;
+    const idLower = id.toLowerCase();
+    if (idLower.length < 3) continue;
+    const idCompact = idLower.replace(/[\s_-]+/g, "");
+    const wordRe = new RegExp(
+      `\\b${idLower.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`,
+      "i"
+    );
+    if (wordRe.test(query)) {
+      matched.push(id);
+      seen.add(id);
+      continue;
+    }
+    if (idCompact.length >= 4 && compactQuery.includes(idCompact)) {
+      matched.push(id);
+      seen.add(id);
+    }
+  }
+  const agentMention = lowerQuery.match(/\bagent\s+([a-z0-9_-]{3,40})/i);
+  const flagged = matched.length === 0 && agentMention !== null && agentMention[1] !== void 0 && !records.some((r) => r.agent_id.toLowerCase() === agentMention[1]?.toLowerCase());
+  return { matched, flagged };
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractEventTypes(query, enumValues) {
+  const lower = query.toLowerCase();
+  const matched = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ev of enumValues) {
+    if (seen.has(ev)) continue;
+    const re = new RegExp(`\\b${escapeRegex(ev)}\\b`, "i");
+    if (re.test(query)) {
+      matched.push(ev);
+      seen.add(ev);
+    }
+  }
+  for (const syn of EVENT_SYNONYMS) {
+    const re = new RegExp(
+      `\\b${syn.phrase.split(/\s+/).map(escapeRegex).join("\\s+")}\\b`,
+      "i"
+    );
+    if (re.test(query)) {
+      for (const c of syn.canonical) {
+        if (seen.has(c)) continue;
+        if (!enumValues.includes(c)) continue;
+        matched.push(c);
+        seen.add(c);
+      }
+    }
+  }
+  const globMatches = lower.match(/\b([a-z_]+)_\*/g) ?? [];
+  for (const glob of globMatches) {
+    const prefix = glob.slice(0, -2);
+    for (const ev of enumValues) {
+      if (seen.has(ev)) continue;
+      if (ev.startsWith(prefix)) {
+        matched.push(ev);
+        seen.add(ev);
+      }
+    }
+  }
+  const eventNounMention = /\b(?:event|events|class|classes)\b/i.test(query) && matched.length === 0;
+  return { matched, flagged: eventNounMention };
+}
+function deriveIntentPhrase(query, stripTokens) {
+  let out = query;
+  for (const tok of stripTokens) {
+    if (!tok) continue;
+    const re = new RegExp(escapeRegex(tok), "gi");
+    out = out.replace(re, " ");
+  }
+  return out.replace(/\s+/g, " ").trim();
+}
+function computeConfidence(parsed) {
+  const dims = [
+    { present: parsed.hasTimeMention, resolved: parsed.timeResolved },
+    { present: parsed.hasAgentMention, resolved: parsed.agentResolved },
+    { present: parsed.hasEventMention, resolved: parsed.eventResolved }
+  ];
+  const present = dims.filter((d) => d.present);
+  let base;
+  if (present.length === 0) {
+    base = parsed.intentEmpty ? 0 : 0.3;
+  } else {
+    const resolved = present.filter((d) => d.resolved).length;
+    base = resolved / present.length;
+  }
+  const adjusted = base - 0.15 * parsed.ambiguityCount;
+  if (adjusted < 0) return 0;
+  if (adjusted > 1) return 1;
+  return adjusted;
+}
+var TIME_MENTION_PROBE = /\b(yesterday|today|now|past|last|this\s+week|this\s+month|since|from|between|\d{4}-\d{2}-\d{2})\b/i;
+var AGENT_MENTION_PROBE = /\bagent[s]?\b/i;
+var EVENT_MENTION_PROBE = /\b(event|events|class|classes|approvals?|policy)\b/i;
+function parseQuery(query, opts) {
+  const now = opts?.now ?? /* @__PURE__ */ new Date();
+  const enumValues = opts?.eventClassEnum ?? CANONICAL_AUDIT_EVENT_CLASSES;
+  const original = query ?? "";
+  const trimmed = original.trim();
+  if (trimmed.length === 0) {
+    return {
+      time_range: null,
+      agent_names: [],
+      event_types: [],
+      intent_phrase: "",
+      ambiguity_flags: ["no_signal_extracted"],
+      parse_confidence: 0
+    };
+  }
+  const ambiguity_flags = /* @__PURE__ */ new Set();
+  const timeMatch = resolveTimeRange(trimmed, now);
+  const hasTimeMention = TIME_MENTION_PROBE.test(trimmed);
+  if (hasTimeMention && !timeMatch) {
+    ambiguity_flags.add("unknown_time_token");
+  }
+  const agentResult = extractAgentNames(trimmed, opts?.registry);
+  if (agentResult.flagged) {
+    ambiguity_flags.add("unknown_agent_token");
+  }
+  const hasAgentMention = AGENT_MENTION_PROBE.test(trimmed);
+  const eventResult = extractEventTypes(trimmed, enumValues);
+  const hasEventMention = EVENT_MENTION_PROBE.test(trimmed);
+  if (eventResult.flagged) {
+    ambiguity_flags.add("unknown_event_token");
+  }
+  const stripTokens = [];
+  if (timeMatch) stripTokens.push(timeMatch.matchedSubstring);
+  for (const name of agentResult.matched) stripTokens.push(name);
+  for (const ev of eventResult.matched) {
+    if (trimmed.toLowerCase().includes(ev.toLowerCase())) {
+      stripTokens.push(ev);
+    }
+  }
+  const intent_phrase = deriveIntentPhrase(trimmed, stripTokens);
+  const parse_confidence = computeConfidence({
+    hasTimeMention,
+    timeResolved: timeMatch !== null,
+    hasAgentMention,
+    agentResolved: agentResult.matched.length > 0,
+    hasEventMention,
+    eventResolved: eventResult.matched.length > 0,
+    intentEmpty: intent_phrase.length === 0,
+    ambiguityCount: ambiguity_flags.size
+  });
+  if (timeMatch === null && agentResult.matched.length === 0 && eventResult.matched.length === 0 && intent_phrase.length === 0) {
+    ambiguity_flags.add("no_signal_extracted");
+  }
+  return {
+    time_range: timeMatch ? timeMatch.range : null,
+    agent_names: agentResult.matched,
+    event_types: eventResult.matched,
+    intent_phrase,
+    ambiguity_flags: Array.from(ambiguity_flags),
+    parse_confidence
+  };
+}
+var LLM_ASSIST_THRESHOLD = 0.5;
+function isLowConfidence(parsed) {
+  return parsed.parse_confidence < LLM_ASSIST_THRESHOLD;
+}
+async function parseQueryWithLlmAssist(query, llmAssist, opts) {
+  const parsed = parseQuery(query, opts);
+  if (!llmAssist || !isLowConfidence(parsed)) return parsed;
+  let completion;
+  try {
+    completion = await llmAssist(query, parsed);
+  } catch {
+    return parsed;
+  }
+  if (!completion || typeof completion !== "object") return parsed;
+  const merged = { ...parsed };
+  if (parsed.time_range === null && completion.time_range) {
+    merged.time_range = completion.time_range;
+  }
+  if (parsed.agent_names.length === 0 && Array.isArray(completion.agent_names)) {
+    merged.agent_names = completion.agent_names.filter(
+      (s) => typeof s === "string" && s.length > 0
+    );
+  }
+  if (parsed.event_types.length === 0 && Array.isArray(completion.event_types)) {
+    const allowed = new Set(opts?.eventClassEnum ?? CANONICAL_AUDIT_EVENT_CLASSES);
+    merged.event_types = completion.event_types.filter(
+      (s) => typeof s === "string" && allowed.has(s)
+    );
+  }
+  merged.parse_confidence = Math.max(
+    parsed.parse_confidence,
+    computeConfidence({
+      hasTimeMention: TIME_MENTION_PROBE.test(query),
+      timeResolved: merged.time_range !== null,
+      hasAgentMention: AGENT_MENTION_PROBE.test(query),
+      agentResolved: merged.agent_names.length > 0,
+      hasEventMention: EVENT_MENTION_PROBE.test(query),
+      eventResolved: merged.event_types.length > 0,
+      intentEmpty: merged.intent_phrase.length === 0,
+      ambiguityCount: merged.ambiguity_flags.length
+    })
+  );
+  return merged;
+}
+function auditSafeSummary(parsed) {
+  return {
+    time_range: parsed.time_range ? {
+      start_iso: parsed.time_range.start.toISOString(),
+      end_iso: parsed.time_range.end.toISOString(),
+      ...parsed.time_range.relative_label !== void 0 ? { relative_label: parsed.time_range.relative_label } : {}
+    } : null,
+    agent_names: [...parsed.agent_names],
+    event_types: [...parsed.event_types],
+    ambiguity_flags: [...parsed.ambiguity_flags],
+    parse_confidence: parsed.parse_confidence
+  };
+}
+
 // src/chat/operator-chat-service.ts
 var DEFAULT_CONCIERGE_MAX_TOKENS = 512;
 var DEFAULT_CONCIERGE_HISTORY_WINDOW_TURNS = 10;
@@ -32670,6 +33367,8 @@ var OperatorChatService = class {
   contextFetchers;
   contextLlmAssist;
   dynamicContextBudget;
+  agentRegistry;
+  grammarLlmAssist;
   /**
    * In-memory thread_id assigned to the active concierge session.
    * The first sendConcierge call after construction allocates a fresh
@@ -32708,6 +33407,12 @@ var OperatorChatService = class {
       this.contextLlmAssist = deps.conciergeContextLlmAssist;
     }
     this.dynamicContextBudget = deps.conciergeDynamicContextBudget !== void 0 && deps.conciergeDynamicContextBudget > 0 ? deps.conciergeDynamicContextBudget : DEFAULT_CONCIERGE_DYNAMIC_CONTEXT_BUDGET;
+    if (deps.conciergeAgentRegistry) {
+      this.agentRegistry = deps.conciergeAgentRegistry;
+    }
+    if (deps.conciergeGrammarLlmAssist) {
+      this.grammarLlmAssist = deps.conciergeGrammarLlmAssist;
+    }
   }
   // ── Concierge ─────────────────────────────────────────────────────────
   /**
@@ -32766,6 +33471,7 @@ var OperatorChatService = class {
       await this.memory.appendTurn(threadId, "user", trimmed).catch(() => {
       });
     }
+    const parsedGrammar = await this.runGrammarParse(filterResult.filtered);
     const start = Date.now();
     let conciergeBody;
     let servedBy = "disabled";
@@ -32784,7 +33490,8 @@ var OperatorChatService = class {
           outcome = "substrate_disabled";
         } else {
           const dynamicResult = await this.runDynamicContextFold(
-            filterResult.filtered
+            filterResult.filtered,
+            parsedGrammar
           );
           dynamicCategoriesIncluded = dynamicResult.categoriesIncluded;
           const context = await this.assembleConciergeContext(
@@ -32855,7 +33562,8 @@ var OperatorChatService = class {
       ...this.memory ? {
         prior_turns_folded: memoryReadFailureReason === null ? priorTurns.length : 0
       } : {},
-      ...this.contextFetchers ? { dynamic_context_categories: [...dynamicCategoriesIncluded] } : {}
+      ...this.contextFetchers ? { dynamic_context_categories: [...dynamicCategoriesIncluded] } : {},
+      parsed_grammar: auditSafeSummary(parsedGrammar)
     };
     this.emit(OPERATOR_CHAT_OPS.CONCIERGE_CHAT, payload, outcome === "ok" ? "success" : "failure");
     return {
@@ -33070,8 +33778,12 @@ ${inbox}`
    * proceeds with no fold. Returns the rendered section + the list of
    * categories whose data made it into the section (used for the
    * round-trip audit emission).
+   *
+   * Tau-4: receives the pre-parsed `ParsedQuery` and forwards it as the
+   * `parsed` opt to `foldContext`, so fetchers see the structured
+   * `FetcherHints` derived from it.
    */
-  async runDynamicContextFold(query) {
+  async runDynamicContextFold(query, parsedGrammar) {
     if (!this.contextFetchers) {
       return { section: "", categoriesIncluded: [] };
     }
@@ -33080,10 +33792,24 @@ ${inbox}`
       ...this.contextLlmAssist ? { llmAssistClassify: this.contextLlmAssist } : {},
       onFetcherFailure: (category, error) => {
         this.emitContextFetcherFailed(category, classifyFetcherError(error));
-      }
+      },
+      parsed: parsedGrammar
     });
     return result;
   }
+  /**
+   * WP-V1.3-9 Tau-4: parse the (PII-filtered) operator query into a
+   * `ParsedQuery`. Routes through the LLM-assist completion hook when
+   * configured and the rule-based parse is below
+   * `LLM_ASSIST_THRESHOLD`. Always returns a parse object (never
+   * throws) so the audit emission can carry the result unconditionally.
+   */
+  async runGrammarParse(query) {
+    return parseQueryWithLlmAssist(query, this.grammarLlmAssist, {
+      ...this.agentRegistry !== void 0 ? { registry: this.agentRegistry } : {},
+      eventClassEnum: CANONICAL_AUDIT_EVENT_CLASSES
+    });
+  }
   /**
    * Emit the WP-V1.3-9 Tau-3 fetcher-failure audit event. Pulled out
    * of the fold path so the dynamic-context handler stays readable.