context-mode 1.0.121 → 1.0.122

package/build/adapters/pi/extension.d.ts

@@ -22,5 +22,14 @@
  * a prior load.
  */
 export declare let _mcpBridgeReady: Promise<void>;
+/**
+ * Returns true iff `argv` matches a Pi top-level short-circuit invocation
+ * (help or version). Only argv[0] is inspected — Pi's runCli only checks
+ * the first token, and subcommand-level `--help` (e.g. `pi stats --help`)
+ * still spins up a real session, so we must NOT skip bootstrap there.
+ *
+ * Exported for unit tests.
+ */
+export declare function isPiShortCircuitArgv(argv: readonly string[]): boolean;
 /** Pi extension default export. Called once by Pi runtime with the extension API. */
 export default function piExtension(pi: any): void;

package/build/adapters/pi/extension.js

@@ -193,6 +193,41 @@ function handleCommandText(text, ctx) {
     }
     return { text };
 }
+// ── Pi short-circuit argv detection (#534) ───────────────
+//
+// Pi's runtime loads every extension during module discovery, BEFORE its
+// `runCli()` decides whether the invocation is a real session or a
+// short-lived help / version print. Without this guard, even `pi --help`
+// causes us to spawn `server.bundle.mjs` as a long-lived stdio child —
+// which is then reparented to PID 1 the moment Pi's `--help` handler
+// returns. The MCP SDK's StdioServerTransport CPU-spins on the half-closed
+// pipe until the 30 s ppid poll catches up, accumulating multi-hour orphans
+// (see issue #534, plus the historical #311 / #388 fixes that only addressed
+// the *recovery* path — not the *prevention* path).
+//
+// Token set verified against the Pi 14.x source — specifically:
+//   refs/platforms/oh-my-pi/packages/coding-agent/src/cli.ts:runCli
+//
+//     if (first === "--help" || first === "-h" || first === "--version"
+//      || first === "-v" || first === "help") { /* short-circuit */ }
+//
+// We mirror it exactly — no inferred flags, no `-V` (Pi uses lowercase `-v`),
+// no `--no-help`. Anything else (including `pi stats --help`) routes through
+// the normal launch path and the bridge bootstraps as usual.
+const PI_SHORT_CIRCUIT_TOKENS = new Set(["--help", "-h", "--version", "-v", "help"]);
+/**
+ * Returns true iff `argv` matches a Pi top-level short-circuit invocation
+ * (help or version). Only argv[0] is inspected — Pi's runCli only checks
+ * the first token, and subcommand-level `--help` (e.g. `pi stats --help`)
+ * still spins up a real session, so we must NOT skip bootstrap there.
+ *
+ * Exported for unit tests.
+ */
+export function isPiShortCircuitArgv(argv) {
+    if (argv.length === 0)
+        return false;
+    return PI_SHORT_CIRCUIT_TOKENS.has(argv[0]);
+}
 // ── Extension entry point ────────────────────────────────
 /** Pi extension default export. Called once by Pi runtime with the extension API. */
 export default function piExtension(pi) {
@@ -534,6 +569,18 @@ export default function piExtension(pi) {
     // Best-effort: a missing bundle or a spawn failure must NOT prevent
     // the rest of the extension (session capture, hooks, slash commands)
     // from initializing. We log to stderr and continue.
+    // Short-circuit guard (#534): skip the MCP bridge bootstrap for
+    // `pi --help` / `pi --version` / `pi help` and similar. Pi prints and
+    // exits within milliseconds, but the bridge child would otherwise live
+    // long enough to be reparented to PID 1, half-close stdin, and pin a CPU
+    // core via the MCP SDK's stdio loop. We use process.argv directly so the
+    // guard works for any caller that boots Pi with a short-circuit token,
+    // regardless of how the runtime wires its CLI parser.
+    const piArgv = process.argv.slice(2);
+    if (isPiShortCircuitArgv(piArgv)) {
+        _mcpBridgeReady = Promise.resolve();
+        return;
+    }
     const serverBundle = resolve(pluginRoot, "server.bundle.mjs");
     if (existsSync(serverBundle)) {
         _mcpBridgeReady = bootstrapMCPTools(pi, serverBundle).then((handle) => {

package/build/adapters/qwen-code/hooks.d.ts

@@ -0,0 +1,26 @@
+/**
+ * adapters/qwen-code/hooks — Qwen Code hook definitions.
+ *
+ * Qwen Code is a Gemini CLI fork (packages/core/src/tools/tool-names.ts —
+ * shares native names like `run_shell_command`, `read_file`). The hook wire
+ * protocol is JSON stdin / stdout, identical to Claude Code and Gemini CLI.
+ *
+ * Config: ~/.qwen/settings.json under "hooks" key.
+ */
+/**
+ * Negative-lookahead matcher for external MCP tool namespaces on Qwen Code (#529).
+ *
+ * Qwen Code MCP wire shape: `mcp__<server>__<tool>` (shared with Gemini CLI
+ * upstream). Own context-mode MCP surfaces as both
+ * `mcp__plugin_context-mode_context-mode__ctx_*` (Claude shim path when users
+ * install via the Claude marketplace) and `mcp__context-mode__ctx_*` (Qwen
+ * canonical — see hooks/core/tool-naming.mjs). The negative lookahead
+ * `(?!.*context-mode)` excludes both variants from the external-MCP routing
+ * branch so context-mode's own tools (already wired by the explicit entries
+ * above this catch-all) are not double-routed.
+ *
+ * Without this matcher, large payloads from slack / telegram / gdrive / notion
+ * MCPs bypass the routing nudge and flood the model's context window —
+ * PostToolUse runs too late to keep the raw data out.
+ */
+export declare const EXTERNAL_MCP_MATCHER_PATTERN = "mcp__(?!.*context-mode)";

package/build/adapters/qwen-code/hooks.js

@@ -0,0 +1,29 @@
+/**
+ * adapters/qwen-code/hooks — Qwen Code hook definitions.
+ *
+ * Qwen Code is a Gemini CLI fork (packages/core/src/tools/tool-names.ts —
+ * shares native names like `run_shell_command`, `read_file`). The hook wire
+ * protocol is JSON stdin / stdout, identical to Claude Code and Gemini CLI.
+ *
+ * Config: ~/.qwen/settings.json under "hooks" key.
+ */
+// ─────────────────────────────────────────────────────────
+// External MCP routing matcher (#529)
+// ─────────────────────────────────────────────────────────
+/**
+ * Negative-lookahead matcher for external MCP tool namespaces on Qwen Code (#529).
+ *
+ * Qwen Code MCP wire shape: `mcp__<server>__<tool>` (shared with Gemini CLI
+ * upstream). Own context-mode MCP surfaces as both
+ * `mcp__plugin_context-mode_context-mode__ctx_*` (Claude shim path when users
+ * install via the Claude marketplace) and `mcp__context-mode__ctx_*` (Qwen
+ * canonical — see hooks/core/tool-naming.mjs). The negative lookahead
+ * `(?!.*context-mode)` excludes both variants from the external-MCP routing
+ * branch so context-mode's own tools (already wired by the explicit entries
+ * above this catch-all) are not double-routed.
+ *
+ * Without this matcher, large payloads from slack / telegram / gdrive / notion
+ * MCPs bypass the routing nudge and flood the model's context window —
+ * PostToolUse runs too late to keep the raw data out.
+ */
+export const EXTERNAL_MCP_MATCHER_PATTERN = "mcp__(?!.*context-mode)";

package/build/adapters/qwen-code/index.js

@@ -16,6 +16,7 @@ import { readFileSync, writeFileSync, existsSync, } from "node:fs";
 import { resolve, join } from "node:path";
 import { homedir } from "node:os";
 import { ClaudeCodeBaseAdapter } from "../claude-code-base.js";
+import { EXTERNAL_MCP_MATCHER_PATTERN } from "./hooks.js";
 import { buildNodeCommand, } from "../types.js";
 // ─────────────────────────────────────────────────────────
 // Adapter implementation
@@ -55,6 +56,9 @@ export class QwenCodeAdapter extends ClaudeCodeBaseAdapter {
             "mcp__plugin_context-mode_context-mode__ctx_execute",
             "mcp__plugin_context-mode_context-mode__ctx_execute_file",
             "mcp__plugin_context-mode_context-mode__ctx_batch_execute",
+            // External MCP catch-all (#529). Negative-lookahead excludes context-mode's
+            // own server segments so the explicit entries above are not double-routed.
+            EXTERNAL_MCP_MATCHER_PATTERN,
         ].join("|");
         return {
             PreToolUse: [
@@ -247,6 +251,8 @@ export class QwenCodeAdapter extends ClaudeCodeBaseAdapter {
                     "mcp__plugin_context-mode_context-mode__ctx_execute",
                     "mcp__plugin_context-mode_context-mode__ctx_execute_file",
                     "mcp__plugin_context-mode_context-mode__ctx_batch_execute",
+                    // External MCP catch-all (#529) — keep in sync with generateHookConfig above.
+                    EXTERNAL_MCP_MATCHER_PATTERN,
                 ].join("|"),
             },
             {

package/build/cli.js

@@ -25,7 +25,7 @@ import { resolveClaudeConfigDir } from "./util/claude-config.js";
 // v1.0.119 — Issue #523 Layer 5 heal: post-bump assertion on .claude-plugin/plugin.json
 // mcpServers args. Single source of truth shared with start.mjs HEAL block + postinstall.
 // @ts-expect-error — JS module, no TS declarations
-import { healPluginJsonMcpServers } from "../scripts/heal-installed-plugins.mjs";
+import { healPluginJsonMcpServers, healMcpJsonArgs } from "../scripts/heal-installed-plugins.mjs";
 // Private 16-LOC copy of browserOpenArgv. Canonical version lives in src/server.ts;
 // duplicated here so the cli bundle does not pull server.ts top-level boot side effects.
 // Keep in sync — pure data, no I/O.
@@ -804,6 +804,31 @@ async function upgrade() {
                 const message = err instanceof Error ? err.message : String(err);
                 throw new Error(`plugin.json drift check failed: ${message}`);
             }
+            // v1.0.122 — Issue #531 — Layer 6 heal: assert .mcp.json's
+            // mcpServers["context-mode"].args[0] is the literal ${CLAUDE_PLUGIN_ROOT}/start.mjs
+            // placeholder. Asymmetric-heal sibling of the plugin.json assertion above.
+            // cli.ts writes .mcp.json at ~line 829-845 with the placeholder, but never
+            // asserted the on-disk shape afterwards — if a future regression dropped
+            // the placeholder write or a parallel normalize baked in an absolute path,
+            // upgrade() would declare success on a poisoned tree. Belt-and-braces:
+            // first call cleans any drift; second call MUST return healed:[] or throw.
+            // Single source of truth shared with start.mjs HEAL block + postinstall.
+            try {
+                const pluginCacheRoot = resolve(resolveClaudeConfigDir(), "plugins", "cache");
+                const pluginKey = "context-mode@context-mode";
+                const firstPass = healMcpJsonArgs({ pluginRoot, pluginCacheRoot, pluginKey });
+                if (firstPass && firstPass.error) {
+                    throw new Error(firstPass.error);
+                }
+                const secondPass = healMcpJsonArgs({ pluginRoot, pluginCacheRoot, pluginKey });
+                if (secondPass && Array.isArray(secondPass.healed) && secondPass.healed.length > 0) {
+                    throw new Error(`.mcp.json drift: mcpServers.args still poisoned after first heal pass (healed=${secondPass.healed.join(",")})`);
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                throw new Error(`.mcp.json drift check failed: ${message}`);
+            }
             // v1.0.114 hotfix — marketplace post-pull assertion: clone (if
             // present) MUST be on newVersion. Mert's case showed marketplace
             // stuck at v1.0.89 — the sync block above swallowed that silently.

package/build/executor.js

@@ -238,11 +238,11 @@ export class PolyglotExecutor {
                     ? cmd.slice(1).map(a => a.replace(/\\/g, "/"))
                     : cmd.slice(1);
             }
-            const proc = spawn(spawnCmd, spawnArgs, {
+            // Common options shared by both spawn variants below.
+            const commonOpts = {
                 cwd,
                 stdio: ["ignore", "pipe", "pipe"],
                 env: this.#buildSafeEnv(sandboxTmpDir),
-                shell: needsShell,
                 // On Unix, create a new process group so killTree can kill all children
                 detached: !isWin,
                 // Hide the spawned-process console window on Windows. Without this,
@@ -250,7 +250,22 @@ export class PolyglotExecutor {
                 // leaving the MCP response empty and popping a Git Bash terminal over
                 // the user's IDE. Issue #384.
                 ...buildSpawnOptions(process.platform),
-            });
+            };
+            // DEP0190 fix: when shell is true (Windows .cmd/.bat shims), pass a
+            // single command string instead of cmd + args array. Node.js warns
+            // that args are unsafely concatenated when shell:true is combined with
+            // the args-array form of spawn(). Colllapsing to a string avoids the
+            // warning while preserving the same shell behavior.
+            let proc;
+            if (needsShell) {
+                const fullCmd = [spawnCmd, ...spawnArgs]
+                    .map(a => /\s/.test(a) ? JSON.stringify(a) : a)
+                    .join(" ");
+                proc = spawn(fullCmd, [], { ...commonOpts, shell: true });
+            }
+            else {
+                proc = spawn(spawnCmd, spawnArgs, { ...commonOpts, shell: false });
+            }
             let timedOut = false;
             let resolved = false;
             // Issue #406 — if the caller didn't pass a timeout we don't fire one.

package/build/lifecycle.d.ts

@@ -44,6 +44,21 @@ export interface IsParentAliveDeps {
  * {@link defaultIsParentAlive} (captured once at module load).
  */
 export declare function makeDefaultIsParentAlive(deps?: IsParentAliveDeps): () => boolean;
+/**
+ * Resolve the parent-liveness poll interval based on context (#534).
+ *
+ * When this process is the MCP bridge child spawned by the Pi adapter
+ * (`bootstrapMCPTools` in `src/adapters/pi/mcp-bridge.ts` sets
+ * `CONTEXT_MODE_BRIDGE_DEPTH=1` in the child env), we tighten the poll to
+ * 1 s. The Pi parent can disappear in under 50 ms (`pi --help` prints
+ * usage and returns), so the default 30 s window leaves a long-lived
+ * CPU-spinning orphan. For top-level MCP servers (depth 0 / absent) we
+ * keep the original 30 s cadence — the existing #311/#388 ppid + stdin
+ * recovery paths already cover Claude Code style hosts.
+ *
+ * Exported for unit-testing.
+ */
+export declare function lifecycleGuardIntervalForEnv(env?: NodeJS.ProcessEnv): number;
 /**
  * Start the lifecycle guard. Returns a cleanup function.
  * Skipped automatically when stdin is a TTY (e.g. OpenCode ts-plugin).

package/build/lifecycle.js

@@ -71,12 +71,35 @@ export function makeDefaultIsParentAlive(deps = {}) {
     };
 }
 const defaultIsParentAlive = makeDefaultIsParentAlive();
+/**
+ * Resolve the parent-liveness poll interval based on context (#534).
+ *
+ * When this process is the MCP bridge child spawned by the Pi adapter
+ * (`bootstrapMCPTools` in `src/adapters/pi/mcp-bridge.ts` sets
+ * `CONTEXT_MODE_BRIDGE_DEPTH=1` in the child env), we tighten the poll to
+ * 1 s. The Pi parent can disappear in under 50 ms (`pi --help` prints
+ * usage and returns), so the default 30 s window leaves a long-lived
+ * CPU-spinning orphan. For top-level MCP servers (depth 0 / absent) we
+ * keep the original 30 s cadence — the existing #311/#388 ppid + stdin
+ * recovery paths already cover Claude Code style hosts.
+ *
+ * Exported for unit-testing.
+ */
+export function lifecycleGuardIntervalForEnv(env = process.env) {
+    const raw = env.CONTEXT_MODE_BRIDGE_DEPTH;
+    if (raw === undefined)
+        return 30_000;
+    const depth = Number.parseInt(raw, 10);
+    if (!Number.isFinite(depth) || depth <= 0)
+        return 30_000;
+    return 1000;
+}
 /**
  * Start the lifecycle guard. Returns a cleanup function.
  * Skipped automatically when stdin is a TTY (e.g. OpenCode ts-plugin).
  */
 export function startLifecycleGuard(opts) {
-    const interval = opts.checkIntervalMs ?? 30_000;
+    const interval = opts.checkIntervalMs ?? lifecycleGuardIntervalForEnv();
     const check = opts.isParentAlive ?? defaultIsParentAlive;
     let stopped = false;
     const shutdown = () => {

package/build/runtime.js

@@ -60,11 +60,15 @@ function runnableExists(cmd) {
     // fallthrough can be slow). On POSIX, 1500ms is plenty for a real binary
     // and keeps cold detection of python3 → python → py under ~5s total (#454).
     try {
-        execFileSync(cmd, ["--version"], {
-            shell: isWindows,
-            stdio: "pipe",
-            timeout: isWindows ? 5000 : 1500,
-        });
+        // DEP0190 fix: avoid args array with shell:true on Windows.
+        // Use execSync with a command string when shell is required;
+        // keep execFileSync (no shell) on POSIX.
+        if (isWindows) {
+            execSync(`"${cmd}" --version`, { stdio: "pipe", timeout: 5000 });
+        }
+        else {
+            execFileSync(cmd, ["--version"], { stdio: "pipe", timeout: 1500 });
+        }
         return true;
     }
     catch {
@@ -152,14 +156,31 @@ function resolveWindowsBash() {
 }
 function getVersion(cmd, args = ["--version"]) {
     try {
-        return execFileSync(cmd, args, {
-            encoding: "utf-8",
-            shell: process.platform === "win32",
-            stdio: ["pipe", "pipe", "pipe"],
-            timeout: 5000,
-        })
-            .trim()
-            .split(/\r?\n/)[0];
+        // DEP0190 fix: avoid args array with shell:true on Windows.
+        if (process.platform === "win32") {
+            // Hardening (PR #537 review): quote any cmd.exe metacharacter, not just
+            // whitespace. Current arg sources are internally controlled, but cheap
+            // defense-in-depth for future call sites.
+            const cmdStr = [cmd, ...args]
+                .map(a => /[\s"&|<>^()%!]/.test(a) ? JSON.stringify(a) : a)
+                .join(" ");
+            return execSync(cmdStr, {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+                timeout: 5000,
+            })
+                .trim()
+                .split(/\r?\n/)[0];
+        }
+        else {
+            return execFileSync(cmd, args, {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+                timeout: 5000,
+            })
+                .trim()
+                .split(/\r?\n/)[0];
+        }
     }
     catch {
         return "unknown";

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",