Add structured critique and continuation rescues

Author: baum777

src/canonical/auditLog.ts

@@ -91,6 +91,11 @@ export function buildAuditRecord(params: {
   classifierIntent?: IntentClass;
   baseIntent?: IntentClass;
   sourceIntent?: IntentClass;
+  hasParentContext?: boolean;
+  continuationSignal?: boolean;
+  continuationSupportScore?: number;
+  structuredCritiqueSignal?: boolean;
+  structuredCritiqueSupportScore?: number;
   orchestrationEligibleMinimal?: boolean;
   conceptualProbeRescue?: boolean;
   fastPathBypassReason?: string;
@@ -135,6 +140,11 @@ export function buildAuditRecord(params: {
     classifierIntent: params.classifierIntent,
     baseIntent: params.baseIntent,
     sourceIntent: params.sourceIntent,
+    hasParentContext: params.hasParentContext,
+    continuationSignal: params.continuationSignal,
+    continuationSupportScore: params.continuationSupportScore,
+    structuredCritiqueSignal: params.structuredCritiqueSignal,
+    structuredCritiqueSupportScore: params.structuredCritiqueSupportScore,
     orchestrationEligibleMinimal: params.orchestrationEligibleMinimal,
     conceptualProbeRescue: params.conceptualProbeRescue,
     fastPathBypassReason: params.fastPathBypassReason,

src/canonical/classifier.ts

@@ -7,6 +7,12 @@ import type {
   EvidenceClass,
 } from "./types.js";
 import { isConceptualProbe } from "./conceptualProbe.js";
+import {
+  assessConversationContinue,
+} from "./conversationContinue.js";
+import {
+  assessStructuredCritique,
+} from "./structuredCritique.js";
 import { normalizeCanonicalInputText } from "./inputNormalization.js";
 
 const GREETING_PATTERNS = [
@@ -125,23 +131,77 @@ function classifyIntentText(text: string, event: CanonicalEvent): IntentClass {
   return "irrelevant";
 }
 
-function classifyIntent(event: CanonicalEvent): IntentClass {
+function classifyIntentTrace(event: CanonicalEvent): {
+  intent: IntentClass;
+  baseIntent: IntentClass;
+  hasParentContext: boolean;
+  continuationSignal: boolean;
+  continuationSupportScore: number;
+  structuredCritiqueSignal: boolean;
+  structuredCritiqueSupportScore: number;
+} {
   const normalization = normalizeCanonicalInputText(event.text);
   for (const candidate of normalization.classifierTextCandidates) {
     const intent = classifyIntentText(candidate, event);
+    const continuation = assessConversationContinue(candidate, event);
+    const critique = assessStructuredCritique(candidate, event);
+
+    if ((intent === "question" || intent === "irrelevant") && continuation.continuationSignal) {
+      return {
+        intent: "conversation_continue",
+        baseIntent: intent,
+        hasParentContext: continuation.hasParentContext,
+        continuationSignal: true,
+        continuationSupportScore: continuation.continuationSupportScore,
+        structuredCritiqueSignal: false,
+        structuredCritiqueSupportScore: critique.structuredCritiqueSupportScore,
+      };
+    }
+
+    if ((intent === "question" || intent === "irrelevant") && critique.structuredCritiqueSignal) {
+      return {
+        intent: "structured_critique",
+        baseIntent: intent,
+        hasParentContext: critique.hasParentContext,
+        continuationSignal: false,
+        continuationSupportScore: continuation.continuationSupportScore,
+        structuredCritiqueSignal: true,
+        structuredCritiqueSupportScore: critique.structuredCritiqueSupportScore,
+      };
+    }
+
     if (intent !== "irrelevant") {
-      return intent;
+      return {
+        intent,
+        baseIntent: intent,
+        hasParentContext: continuation.hasParentContext,
+        continuationSignal: false,
+        continuationSupportScore: continuation.continuationSupportScore,
+        structuredCritiqueSignal: false,
+        structuredCritiqueSupportScore: critique.structuredCritiqueSupportScore,
+      };
     }
   }
 
-  return "irrelevant";
+  const continuation = assessConversationContinue(normalization.normalizedText, event);
+  const critique = assessStructuredCritique(normalization.normalizedText, event);
+  return {
+    intent: "irrelevant",
+    baseIntent: "irrelevant",
+    hasParentContext: continuation.hasParentContext,
+    continuationSignal: false,
+    continuationSupportScore: continuation.continuationSupportScore,
+    structuredCritiqueSignal: false,
+    structuredCritiqueSupportScore: critique.structuredCritiqueSupportScore,
+  };
 }
 
 function classifyTarget(event: CanonicalEvent, intent: IntentClass): TargetClass {
   if (event.cashtags.length > 0) return "token";
   if (intent === "embodiment_query") return "embodiment";
   if (intent === "lore_query") return "lore";
   if (intent === "conceptual_probe") return "claim";
+  if (intent === "structured_critique") return "claim";
   if (intent === "greeting" || intent === "casual_ping" || intent === "conversation_continue") return "conversation";
   if (intent === "market_question_general") return "market_structure";
   if (intent === "accusation") return "behavior";
@@ -154,8 +214,8 @@ function classifyTarget(event: CanonicalEvent, intent: IntentClass): TargetClass
 
 function classifyEvidence(event: CanonicalEvent, intent: IntentClass): EvidenceClass {
   const text = event.text;
-  const hasParent = !!event.parent_text;
-  const hasContext = event.conversation_context.length > 0;
+  const hasParent = !!event.parent_text?.trim();
+  const hasContext = event.conversation_context.length > 0 || Boolean(event.context?.trim()) || Boolean(event.quoted_text?.trim());
 
   const productProof = countPatternMatches(text, PRODUCT_PROOF_PATTERNS);
   const parentProof = event.parent_text
@@ -165,7 +225,7 @@ function classifyEvidence(event: CanonicalEvent, intent: IntentClass): EvidenceC
   if (productProof >= 2 || (productProof >= 1 && parentProof >= 1)) {
     return "self_contained_strong";
   }
-  if (intent === "conceptual_probe") {
+  if (intent === "conceptual_probe" || intent === "structured_critique") {
     return "contextual_medium";
   }
   if (hasParent || hasContext || productProof >= 1) {
@@ -210,10 +270,18 @@ function extractEvidenceBullets(event: CanonicalEvent, intent: IntentClass): str
   if (intent === "conceptual_probe") {
     bullets.push("structured frontier question");
   }
+  if (intent === "structured_critique") {
+    bullets.push("structured skepticism about incentives or architecture");
+  }
   if (countPatternMatches(text, PERFORMANCE_PATTERNS) > 0) {
     bullets.push("includes unverified performance claims");
   }
-  if (countPatternMatches(text, PRODUCT_PROOF_PATTERNS) === 0 && intent !== "question") {
+  if (
+    countPatternMatches(text, PRODUCT_PROOF_PATTERNS) === 0 &&
+    intent !== "question" &&
+    intent !== "conversation_continue" &&
+    intent !== "structured_critique"
+  ) {
     bullets.push("no concrete product proof in visible text");
   }
   if (countPatternMatches(text, VOLUME_BEHAVIOR_PATTERNS) > 0) {
@@ -273,7 +341,8 @@ function classifyPolicyBlock(intent: IntentClass, spamProb: number, riskFlags: s
 }
 
 export function classify(event: CanonicalEvent): ClassifierOutput {
-  const intent = classifyIntent(event);
+  const intentTrace = classifyIntentTrace(event);
+  const intent = intentTrace.intent;
   const target = classifyTarget(event, intent);
   const evidence_class = classifyEvidence(event, intent);
   const bait_probability = estimateBaitProbability(event);
@@ -293,5 +362,11 @@ export function classify(event: CanonicalEvent): ClassifierOutput {
     policy_reasons: policy.reasons,
     evidence_bullets,
     risk_flags,
+    baseIntent: intentTrace.baseIntent,
+    hasParentContext: intentTrace.hasParentContext,
+    continuationSignal: intentTrace.continuationSignal,
+    continuationSupportScore: intentTrace.continuationSupportScore,
+    structuredCritiqueSignal: intentTrace.structuredCritiqueSignal,
+    structuredCritiqueSupportScore: intentTrace.structuredCritiqueSupportScore,
   };
 }

src/canonical/conversationContinue.ts

@@ -0,0 +1,121 @@
+import type { CanonicalEvent } from "./types.js";
+
+export interface ConversationContinueAssessment {
+  hasParentContext: boolean;
+  formSignal: boolean;
+  relevanceSignal: boolean;
+  continuationSignal: boolean;
+  continuationSupportScore: number;
+  reasons: string[];
+}
+
+const CONTINUATION_FORM_PATTERNS: RegExp[] = [
+  /^(?:and|so|then)\b/i,
+  /\band\s+what\s+about\b/i,
+  /\bthen\s+where\s+is\b/i,
+  /\bwhat\s+fails?\s+first\b/i,
+  /\bwhat\s+bottlenecks?\b/i,
+  /\bwhere\s+is\s+the\s+bottleneck\b/i,
+  /\bwhere\s+does\b.*\b(?:break|fail|bottleneck|break\s+down)\b/i,
+];
+
+const CONTINUATION_RELEVANCE_PATTERNS: RegExp[] = [
+  /\bexecution\b/i,
+  /\bbottleneck(?:s)?\b/i,
+  /\barchitecture\b/i,
+  /\bstructure\b/i,
+  /\bthesis\b/i,
+  /\bincentive(?:s)?\b/i,
+  /\brisk\b/i,
+  /\binterface\b/i,
+  /\bfailure(?:\s+mode)?\b/i,
+  /\bbreak(?:s|down)?\b/i,
+  /\bconstraint(?:s)?\b/i,
+  /\btrade[- ]?off(?:s)?\b/i,
+  /\bdependenc(?:y|ies)\b/i,
+  /\bimplementation\b/i,
+];
+
+const CONTINUATION_NEGATIVE_PATTERNS: RegExp[] = [
+  /^\s*(?:and|so|then)\s*[?!.]*$/i,
+  /^\s*(?:and|so|then)\s+(?:lol|lmao|lmfao|haha|hehe|bruh|bro)\b/i,
+  /^\s*(?:and|so|then)\s+(?:buy|sell|ape|long|short|trade)\b/i,
+  /^\s*(?:what\s+now|now\s+what|why\??|so\??|and\??)\s*$/i,
+];
+
+function normalize(text: string): string {
+  return (text ?? "").trim().replace(/\s+/g, " ");
+}
+
+function wordCount(text: string): number {
+  const normalized = normalize(text);
+  if (!normalized) return 0;
+  return normalized.split(" ").filter(Boolean).length;
+}
+
+function hasPatternMatch(text: string, patterns: RegExp[]): boolean {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+export function hasRelevantParentContext(event: CanonicalEvent): boolean {
+  return Boolean(
+    event.parent_text?.trim() ||
+    event.quoted_text?.trim() ||
+    event.context?.trim() ||
+    (event.conversation_context?.length ?? 0) > 0,
+  );
+}
+
+export function looksLikeContinuation(text: string): boolean {
+  const normalized = normalize(text);
+  if (!normalized) return false;
+  return hasPatternMatch(normalized, CONTINUATION_FORM_PATTERNS);
+}
+
+export function hasContinuationRelevance(text: string): boolean {
+  const normalized = normalize(text);
+  if (!normalized) return false;
+  return hasPatternMatch(normalized, CONTINUATION_RELEVANCE_PATTERNS);
+}
+
+function isNegativeContinuation(text: string): boolean {
+  const normalized = normalize(text);
+  if (!normalized) return true;
+  if (wordCount(normalized) < 3) return true;
+  return hasPatternMatch(normalized, CONTINUATION_NEGATIVE_PATTERNS);
+}
+
+export function assessConversationContinue(
+  text: string,
+  event: CanonicalEvent,
+): ConversationContinueAssessment {
+  const normalized = normalize(text);
+  const hasParentContext = hasRelevantParentContext(event);
+  const formSignal = looksLikeContinuation(normalized);
+  const relevanceSignal = hasContinuationRelevance(normalized);
+  const negativeSignal = isNegativeContinuation(normalized);
+  const supportScore = Math.round(
+    (
+      (
+        (formSignal ? 1 : 0) +
+        (hasParentContext ? 1 : 0) +
+        (relevanceSignal ? 1 : 0)
+      ) / 3
+    ) * 100,
+  ) / 100;
+
+  const reasons: string[] = [];
+  if (formSignal) reasons.push("form_signal");
+  if (hasParentContext) reasons.push("parent_context");
+  if (relevanceSignal) reasons.push("relevance_signal");
+  if (negativeSignal) reasons.push("negative_followup");
+
+  return {
+    hasParentContext,
+    formSignal,
+    relevanceSignal,
+    continuationSignal: formSignal && hasParentContext && relevanceSignal && !negativeSignal,
+    continuationSupportScore: supportScore,
+    reasons,
+  };
+}

src/canonical/modeSelector.ts

@@ -15,7 +15,7 @@ const SOCIAL_MODE_MAP: Partial<Record<IntentClass, CanonicalMode>> = {
   market_question_general: "market_banter",
   embodiment_query: "embodiment_reply",
   lore_query: "lore_drop",
-  conversation_continue: "conversation_hook",
+  conversation_continue: "neutral_clarification",
 };
 
 export function selectMode(
@@ -39,6 +39,10 @@ export function selectMode(
     return "neutral_clarification";
   }
 
+  if (cls.intent === "structured_critique") {
+    return "skeptical_breakdown";
+  }
+
   const socialMode = SOCIAL_MODE_MAP[cls.intent];
   if (socialMode) {
     return socialMode;