context-mode 1.0.121 → 1.0.123

package/build/session/extract.js

@@ -704,17 +704,38 @@ function extractWorktree(input) {
 /**
  * Category 6: decision
  * User corrections / approach selections.
+ *
+ * Universal-rule detector (Hybrid C, issue #535):
+ *   A decision message typically takes the structural shape
+ *     "{negation/rejection} X {separator} Y" — across every human language.
+ *
+ *   We treat the following as the structural shape:
+ *     - contains a clause separator (ASCII `,` `;`, fullwidth `，` `；`,
+ *       Japanese ideographic `、`, Arabic `،`), AND
+ *     - codepoint length is in the corrective range (15..500), AND
+ *     - the message is not a question (no cross-script `?`), AND
+ *     - contains at least one alphabetic codepoint.
+ *
+ *   The renderer prints the raw message back to the next LLM, so the gate
+ *   only needs to be a coarse "looks like a correction" filter — the LLM
+ *   handles fine-grained interpretation. No per-language keyword list.
  */
-const DECISION_PATTERNS = [
-    /\b(don'?t|do not|never|always|instead|rather|prefer)\b/i,
-    /\b(use|switch to|go with|pick|choose)\s+\w+\s+(instead|over|not)\b/i,
-    /\b(no,?\s+(use|do|try|make))\b/i,
-    // Turkish patterns
-    /\b(hayır|hayir|evet|böyle|boyle|degil|değil|yerine|kullan)\b/i,
-];
+const CLAUSE_SEPARATOR_PATTERN = /[,;，；、،]/u;
+const DECISION_MIN_CHARS = 15;
+const DECISION_MAX_CHARS = 500;
+function looksLikeDecision(trimmed) {
+    if (QUESTION_MARK_PATTERN.test(trimmed))
+        return false;
+    if (!ALPHABETIC_PATTERN.test(trimmed))
+        return false;
+    if (!CLAUSE_SEPARATOR_PATTERN.test(trimmed))
+        return false;
+    const codepointLength = [...trimmed].length;
+    return codepointLength >= DECISION_MIN_CHARS && codepointLength <= DECISION_MAX_CHARS;
+}
 function extractUserDecision(message) {
-    const isDecision = DECISION_PATTERNS.some(p => p.test(message));
-    if (!isDecision)
+    const trimmed = message.trim();
+    if (!looksLikeDecision(trimmed))
         return [];
     return [{
             type: "decision",
@@ -726,16 +747,58 @@ function extractUserDecision(message) {
 /**
  * Category 7: role
  * Persona / behavioral directive patterns.
+ *
+ * Universal-rule detector (Hybrid C, issue #535):
+ *   A persona/role statement is structurally a single non-question clause
+ *   of moderate length containing more than one lexical token — e.g.
+ *     "You are a senior engineer", "Tu es développeur",
+ *     "あなたは経験豊富なエンジニアです", "Sen kıdemli mühendisisin".
+ *
+ *   We treat the following as the structural shape:
+ *     - codepoint length is in the persona range (12..120), AND
+ *     - is not a question (no cross-script `?`), AND
+ *     - is a single clause (no clause separator that would mark it as a
+ *       decision), AND
+ *     - carries enough lexical density: either two whitespace-separated
+ *       runs of letters, OR a continuous Unicode-letter run of ≥6
+ *       codepoints (a fallback for scripts without word spaces — Japanese,
+ *       Chinese, Thai).
+ *
+ *   The renderer prints the raw message back to the next LLM verbatim,
+ *   so the gate only needs a coarse "looks like a persona statement"
+ *   filter — no per-language keyword list.
  */
-const ROLE_PATTERNS = [
-    /\b(act as|you are|behave like|pretend|role of|persona)\b/i,
-    /\b(senior|staff|principal|lead)\s+(engineer|developer|architect)\b/i,
-    // Turkish patterns
-    /\b(gibi davran|rolünde|olarak çalış)\b/i,
-];
+// Lower bound accommodates information-dense scripts (Chinese, Japanese,
+// Korean) where a complete persona sentence may use as few as 8 codepoints
+// — e.g. "你是高级工程师" — while still excluding bare single-token noise.
+const ROLE_MIN_CHARS = 8;
+const ROLE_MAX_CHARS = 120;
+const TWO_LEXICAL_TOKENS_PATTERN = /\p{L}+\s+\p{L}+/u;
+const CONTINUOUS_LETTER_RUN_PATTERN = /\p{L}{6,}/u;
+function looksLikeRole(trimmed) {
+    // Role prompts are persona-prefix shaped: the FIRST SENTENCE declares the
+    // role (e.g. "You are a senior backend engineer. <long context...>").
+    // Apply the structural test to the first clause only — real-world role
+    // prompts often append context paragraphs that would blow the length cap
+    // if we tested the whole message. First-clause shape is the load-bearing
+    // signal across languages (English "You are X.", French "Tu es X.",
+    // Japanese "あなたは X です。" all parse the same way under a period split).
+    const firstClause = trimmed.split(/[.!\n。！]/u)[0].trim();
+    if (QUESTION_MARK_PATTERN.test(firstClause))
+        return false;
+    if (CLAUSE_SEPARATOR_PATTERN.test(firstClause))
+        return false;
+    if (!ALPHABETIC_PATTERN.test(firstClause))
+        return false;
+    const codepointLength = [...firstClause].length;
+    if (codepointLength < ROLE_MIN_CHARS || codepointLength > ROLE_MAX_CHARS)
+        return false;
+    return (TWO_LEXICAL_TOKENS_PATTERN.test(firstClause) ||
+        CONTINUOUS_LETTER_RUN_PATTERN.test(firstClause));
+}
 function extractRole(message) {
-    const isRole = ROLE_PATTERNS.some(p => p.test(message));
-    if (!isRole)
+    const trimmed = message.trim();
+    if (!looksLikeRole(trimmed))
         return [];
     return [{
             type: "role",
@@ -747,50 +810,90 @@ function extractRole(message) {
 /**
  * Category 13: intent
  * Session mode classification from user messages.
+ *
+ * Universal-rule detector (Hybrid C, issue #535):
+ *   investigate — message contains a question mark from any script:
+ *                 ASCII `?` U+003F, fullwidth `？` U+FF1F, Arabic `؟` U+061F,
+ *                 Spanish opening `¿` U+00BF.
+ *                 (Greek `;` U+037E and Armenian `՞` U+055E are excluded —
+ *                  Greek shares its codepoint with ASCII semicolon, which
+ *                  would produce false positives across the corpus.)
+ *
+ * Structural / Unicode-aware — no per-language keyword list.
  */
-const INTENT_PATTERNS = [
-    { mode: "investigate", pattern: /\b(why|how does|explain|understand|what is|analyze|debug|look into)\b/i },
-    { mode: "implement", pattern: /\b(create|add|build|implement|write|make|develop|fix)\b/i },
-    { mode: "discuss", pattern: /\b(think about|consider|should we|what if|pros and cons|opinion)\b/i },
-    { mode: "review", pattern: /\b(review|check|audit|verify|test|validate)\b/i },
-];
+const QUESTION_MARK_PATTERN = /[?？؟¿]/u;
+/**
+ * "Imperative tone" structural heuristic for implement intent:
+ *   - trimmed length < IMPERATIVE_MAX_CHARS codepoints (short directive,
+ *     not a discursive paragraph)
+ *   - contains no question mark from any script
+ *   - contains at least one alphabetic codepoint (filters pure punctuation noise)
+ *
+ * `[...str]` walks Unicode codepoints so CJK / Indic scripts are measured
+ * fairly against the budget rather than penalised by UTF-16 unit count.
+ */
+const ALPHABETIC_PATTERN = /\p{L}/u;
+const IMPERATIVE_MAX_CHARS = 60;
+function isImperativeTone(trimmed) {
+    if (QUESTION_MARK_PATTERN.test(trimmed))
+        return false;
+    if (!ALPHABETIC_PATTERN.test(trimmed))
+        return false;
+    const codepointLength = [...trimmed].length;
+    return codepointLength > 0 && codepointLength < IMPERATIVE_MAX_CHARS;
+}
 function extractIntent(message) {
-    const match = INTENT_PATTERNS.find(({ pattern }) => pattern.test(message));
-    if (!match)
+    const trimmed = message.trim();
+    if (!trimmed)
+        return [];
+    let mode;
+    if (QUESTION_MARK_PATTERN.test(trimmed)) {
+        mode = "investigate";
+    }
+    else if (isImperativeTone(trimmed)) {
+        mode = "implement";
+    }
+    if (!mode)
         return [];
     return [{
             type: "intent",
             category: "intent",
-            data: safeString(match.mode),
+            data: safeString(mode),
             priority: 4,
         }];
 }
 /**
  * Category 25: blocked-on
  * Detect when work is blocked on something, or when a blocker is resolved.
+ *
+ * Universal-rule detector (Hybrid C, issue #535):
+ *   Programming-domain error markers are script-agnostic — they are
+ *   emitted by tooling regardless of the user's spoken language. The
+ *   words "Error", "Exception", "Traceback" stay in their original
+ *   English form inside a Chinese / Arabic / Russian terminal log.
+ *
+ *   blocker matches:
+ *     - the literal "Error:" / "Exception:" / "Traceback" tokens, OR
+ *     - a Python-style frame line ("File ", `line:col`), OR
+ *     - a JS / Java-style stack frame ("at <ident>(...)" with a
+ *       `:line:col` suffix).
+ *
+ *   blocker_resolved matches:
+ *     - a Unicode check-mark glyph (✓ U+2713, ✔ U+2714, ✅ U+2705,
+ *       ☑ U+2611, 🎉 U+1F389), OR
+ *     - the structural marker "fixed: …" / "resolved: …" — these are
+ *       programming-domain conventions (git log, PR titles, CHANGELOG
+ *       entries) rather than natural-language phrases.
  */
-const BLOCKER_PATTERNS = [
-    /\bblocked on\b/i,
-    /\bwaiting for\b/i,
-    /\bneed\s+\S+\s+before\b/i,
-    /\bcan'?t proceed until\b/i,
-    /\bdepends on\b/i,
-    /\bblocked\b/i,
-    // Turkish patterns
-    /\bbekliyor\b/i,
-    /\bbekliyorum\b/i,
-];
-const BLOCKER_RESOLVED_PATTERNS = [
-    /\bunblocked\b/i,
-    /\bresolved\b/i,
-    /\bgot the\s+\S+/i,
-    /\bis ready now\b/i,
-    /\bcan proceed\b/i,
-];
+const BLOCKER_MARKERS_PATTERN = /(?:\bError\s*:|\bException\s*:|\bTraceback\b|\bat\s+\S+\s*\([^)]*:\d+:\d+\))/u;
+const BLOCKER_RESOLVED_CHECKMARK_PATTERN = /[✓✔✅☑🎉]/u;
+const BLOCKER_RESOLVED_MARKER_PATTERN = /^\s*(?:fixed|resolved)\s*:/iu;
 function extractBlocker(message) {
     const events = [];
-    // Check resolution first — if both match, resolution takes priority
-    const isResolved = BLOCKER_RESOLVED_PATTERNS.some(p => p.test(message));
+    // Resolution takes precedence — if both shapes match, render the
+    // happier signal so the snapshot reflects the latest state.
+    const isResolved = BLOCKER_RESOLVED_CHECKMARK_PATTERN.test(message) ||
+        BLOCKER_RESOLVED_MARKER_PATTERN.test(message);
     if (isResolved) {
         events.push({
             type: "blocker_resolved",
@@ -800,8 +903,7 @@ function extractBlocker(message) {
         });
         return events;
     }
-    const isBlocked = BLOCKER_PATTERNS.some(p => p.test(message));
-    if (isBlocked) {
+    if (BLOCKER_MARKERS_PATTERN.test(message)) {
         events.push({
             type: "blocker",
             category: "blocked-on",

package/build/session/snapshot.js

@@ -342,6 +342,43 @@ function buildIntentSection(intentEvents) {
     const lastIntent = intentEvents[intentEvents.length - 1];
     return `  <intent mode="${escapeXML(lastIntent.data)}"/>`;
 }
+/**
+ * Raw-prompt safety net (issue #535):
+ * Always surface the most recent user prompts verbatim so the next LLM
+ * sees them even if every universal-rule detector misses. Bound per-prompt
+ * payload to RECENT_MESSAGE_MAX_CHARS Unicode codepoints; bound the total
+ * count to RECENT_MESSAGES_LIMIT to keep the resume block compact.
+ */
+const RECENT_MESSAGES_LIMIT = 3;
+const RECENT_MESSAGE_MAX_CHARS = 400;
+function truncateForSnapshot(value, max) {
+    const codepoints = [...value];
+    if (codepoints.length <= max)
+        return value;
+    return codepoints.slice(0, max).join("");
+}
+function buildRecentMessagesSection(userPromptEvents) {
+    if (userPromptEvents.length === 0)
+        return "";
+    // Last N in chronological order — newest at the bottom mirrors the
+    // way the user reads their own scrollback.
+    const recent = userPromptEvents.slice(-RECENT_MESSAGES_LIMIT);
+    const items = recent
+        .map(ev => {
+        const body = truncateForSnapshot(ev.data ?? "", RECENT_MESSAGE_MAX_CHARS);
+        if (!body)
+            return "";
+        return `    <message>${escapeXML(body)}</message>`;
+    })
+        .filter(Boolean);
+    if (items.length === 0)
+        return "";
+    return [
+        `  <recent_user_messages count="${items.length}">`,
+        ...items,
+        `  </recent_user_messages>`,
+    ].join("\n");
+}
 // ── Main builder ─────────────────────────────────────────────────────────────
 /**
  * Build a reference-based resume snapshot XML string from stored session events.
@@ -369,6 +406,7 @@ export function buildResumeSnapshot(events, opts) {
     const intentEvents = [];
     const skillEvents = [];
     const roleEvents = [];
+    const userPromptEvents = [];
     for (const ev of events) {
         switch (ev.category) {
             case "file":
@@ -407,6 +445,9 @@ export function buildResumeSnapshot(events, opts) {
             case "role":
                 roleEvents.push(ev);
                 break;
+            case "user-prompt":
+                userPromptEvents.push(ev);
+                break;
         }
     }
     // ── Build all sections ──
@@ -451,6 +492,11 @@ export function buildResumeSnapshot(events, opts) {
     const intent = buildIntentSection(intentEvents);
     if (intent)
         sections.push(intent);
+    // Raw-prompt safety net — always last so it stays adjacent to the next
+    // LLM turn and is read after the structured sections.
+    const recentMessages = buildRecentMessagesSection(userPromptEvents);
+    if (recentMessages)
+        sections.push(recentMessages);
     // ── Assemble ──
     const header = `<session_resume events="${events.length}" compact_count="${compactCount}" generated_at="${now}">`;
     const footer = `</session_resume>`;