@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/memory/query-expansion.js

@@ -116,6 +116,157 @@ const STOP_WORDS_EN = new Set([
     "tell",
     "give",
 ]);
+const STOP_WORDS_KO = new Set([
+    // Particles (조사)
+    "은",
+    "는",
+    "이",
+    "가",
+    "을",
+    "를",
+    "의",
+    "에",
+    "에서",
+    "로",
+    "으로",
+    "와",
+    "과",
+    "도",
+    "만",
+    "까지",
+    "부터",
+    "한테",
+    "에게",
+    "께",
+    "처럼",
+    "같이",
+    "보다",
+    "마다",
+    "밖에",
+    "대로",
+    // Pronouns (대명사)
+    "나",
+    "나는",
+    "내가",
+    "나를",
+    "너",
+    "우리",
+    "저",
+    "저희",
+    "그",
+    "그녀",
+    "그들",
+    "이것",
+    "저것",
+    "그것",
+    "여기",
+    "저기",
+    "거기",
+    // Common verbs / auxiliaries (일반 동사/보조 동사)
+    "있다",
+    "없다",
+    "하다",
+    "되다",
+    "이다",
+    "아니다",
+    "보다",
+    "주다",
+    "오다",
+    "가다",
+    // Nouns (의존 명사 / vague)
+    "것",
+    "거",
+    "등",
+    "수",
+    "때",
+    "곳",
+    "중",
+    "분",
+    // Adverbs
+    "잘",
+    "더",
+    "또",
+    "매우",
+    "정말",
+    "아주",
+    "많이",
+    "너무",
+    "좀",
+    // Conjunctions
+    "그리고",
+    "하지만",
+    "그래서",
+    "그런데",
+    "그러나",
+    "또는",
+    "그러면",
+    // Question words
+    "왜",
+    "어떻게",
+    "뭐",
+    "언제",
+    "어디",
+    "누구",
+    "무엇",
+    "어떤",
+    // Time (vague)
+    "어제",
+    "오늘",
+    "내일",
+    "최근",
+    "지금",
+    "아까",
+    "나중",
+    "전에",
+    // Request words
+    "제발",
+    "부탁",
+]);
+// Common Korean trailing particles to strip from words for tokenization
+// Sorted by descending length so longest-match-first is guaranteed.
+const KO_TRAILING_PARTICLES = [
+    "에서",
+    "으로",
+    "에게",
+    "한테",
+    "처럼",
+    "같이",
+    "보다",
+    "까지",
+    "부터",
+    "마다",
+    "밖에",
+    "대로",
+    "은",
+    "는",
+    "이",
+    "가",
+    "을",
+    "를",
+    "의",
+    "에",
+    "로",
+    "와",
+    "과",
+    "도",
+    "만",
+].toSorted((a, b) => b.length - a.length);
+function stripKoreanTrailingParticle(token) {
+    for (const particle of KO_TRAILING_PARTICLES) {
+        if (token.length > particle.length && token.endsWith(particle)) {
+            return token.slice(0, -particle.length);
+        }
+    }
+    return null;
+}
+function isUsefulKoreanStem(stem) {
+    // Prevent bogus one-syllable stems from words like "논의" -> "논".
+    if (/[\uac00-\ud7af]/.test(stem)) {
+        return stem.length >= 2;
+    }
+    // Keep stripped ASCII stems for mixed tokens like "API를" -> "api".
+    return /^[a-z0-9_]+$/i.test(stem);
+}
 const STOP_WORDS_ZH = new Set([
     // Pronouns
     "我",
@@ -236,7 +387,7 @@ function isValidKeyword(token) {
     return true;
 }
 /**
- * Simple tokenizer that handles both English and Chinese text.
+ * Simple tokenizer that handles English, Chinese, and Korean text.
  * For Chinese, we do character-based splitting since we don't have a proper segmenter.
  * For English, we split on whitespace and punctuation.
  */
@@ -246,7 +397,7 @@ function tokenize(text) {
     // Split into segments (English words, Chinese character sequences, etc.)
     const segments = normalized.split(/[\s\p{P}]+/u).filter(Boolean);
     for (const segment of segments) {
-        // Check if segment contains CJK characters
+        // Check if segment contains CJK characters (Chinese)
         if (/[\u4e00-\u9fff]/.test(segment)) {
             // For Chinese, extract character n-grams (unigrams and bigrams)
             const chars = Array.from(segment).filter((c) => /[\u4e00-\u9fff]/.test(c));
@@ -257,6 +408,19 @@ function tokenize(text) {
                 tokens.push(chars[i] + chars[i + 1]);
             }
         }
+        else if (/[\uac00-\ud7af\u3131-\u3163]/.test(segment)) {
+            // For Korean (Hangul syllables and jamo), keep the word as-is unless it is
+            // effectively a stop word once trailing particles are removed.
+            const stem = stripKoreanTrailingParticle(segment);
+            const stemIsStopWord = stem !== null && STOP_WORDS_KO.has(stem);
+            if (!STOP_WORDS_KO.has(segment) && !stemIsStopWord) {
+                tokens.push(segment);
+            }
+            // Also emit particle-stripped stems when they are useful keywords.
+            if (stem && !STOP_WORDS_KO.has(stem) && isUsefulKoreanStem(stem)) {
+                tokens.push(stem);
+            }
+        }
         else {
             // For non-CJK, keep as single token
             tokens.push(segment);
@@ -278,7 +442,7 @@ export function extractKeywords(query) {
     const seen = new Set();
     for (const token of tokens) {
         // Skip stop words
-        if (STOP_WORDS_EN.has(token) || STOP_WORDS_ZH.has(token)) {
+        if (STOP_WORDS_EN.has(token) || STOP_WORDS_ZH.has(token) || STOP_WORDS_KO.has(token)) {
             continue;
         }
         // Skip invalid keywords

package/dist/memory/status-format.js

@@ -1,20 +1,25 @@
 export function resolveMemoryVectorState(vector) {
-    if (vector.enabled === false)
+    if (!vector.enabled) {
         return { tone: "muted", state: "disabled" };
-    if (vector.available === true)
+    }
+    if (vector.available === true) {
         return { tone: "ok", state: "ready" };
-    if (vector.available === false)
+    }
+    if (vector.available === false) {
         return { tone: "warn", state: "unavailable" };
+    }
     return { tone: "muted", state: "unknown" };
 }
 export function resolveMemoryFtsState(fts) {
-    if (fts.enabled === false)
+    if (!fts.enabled) {
         return { tone: "muted", state: "disabled" };
+    }
     return fts.available ? { tone: "ok", state: "ready" } : { tone: "warn", state: "unavailable" };
 }
 export function resolveMemoryCacheSummary(cache) {
-    if (!cache.enabled)
+    if (!cache.enabled) {
         return { tone: "muted", text: "cache off" };
+    }
     const suffix = typeof cache.entries === "number" ? ` (${cache.entries})` : "";
     return { tone: "ok", text: `cache on${suffix}` };
 }

package/dist/memory/sync-memory-files.js

@@ -3,7 +3,7 @@ import { buildFileEntry, listMemoryFiles } from "./internal.js";
 const log = createSubsystemLogger("memory");
 export async function syncMemoryFiles(params) {
     const files = await listMemoryFiles(params.workspaceDir);
-    const fileEntries = await Promise.all(files.map(async (file) => buildFileEntry(file, params.workspaceDir)));
+    const fileEntries = (await Promise.all(files.map(async (file) => buildFileEntry(file, params.workspaceDir)))).filter((entry) => entry !== null);
     log.debug("memory sync: indexing memory files", {
         files: fileEntries.length,
         needsFullReindex: params.needsFullReindex,

package/dist/node-host/invoke-system-run.js

@@ -0,0 +1,281 @@
+import crypto from "node:crypto";
+import { resolveAgentConfig } from "../agents/agent-scope.js";
+import { loadConfig } from "../config/config.js";
+import { addAllowlistEntry, analyzeArgvCommand, evaluateExecAllowlist, evaluateShellAllowlist, recordAllowlistUse, requiresExecApproval, resolveAllowAlwaysPatterns, resolveExecApprovals, resolveSafeBins, } from "../infra/exec-approvals.js";
+import { getTrustedSafeBinDirs } from "../infra/exec-safe-bin-trust.js";
+import { resolveSystemRunCommand } from "../infra/system-run-command.js";
+export async function handleSystemRunInvoke(opts) {
+    const command = resolveSystemRunCommand({
+        command: opts.params.command,
+        rawCommand: opts.params.rawCommand,
+    });
+    if (!command.ok) {
+        await opts.sendInvokeResult({
+            ok: false,
+            error: { code: "INVALID_REQUEST", message: command.message },
+        });
+        return;
+    }
+    if (command.argv.length === 0) {
+        await opts.sendInvokeResult({
+            ok: false,
+            error: { code: "INVALID_REQUEST", message: "command required" },
+        });
+        return;
+    }
+    const argv = command.argv;
+    const rawCommand = command.rawCommand ?? "";
+    const shellCommand = command.shellCommand;
+    const cmdText = command.cmdText;
+    const agentId = opts.params.agentId?.trim() || undefined;
+    const cfg = loadConfig();
+    const agentExec = agentId ? resolveAgentConfig(cfg, agentId)?.tools?.exec : undefined;
+    const configuredSecurity = opts.resolveExecSecurity(agentExec?.security ?? cfg.tools?.exec?.security);
+    const configuredAsk = opts.resolveExecAsk(agentExec?.ask ?? cfg.tools?.exec?.ask);
+    const approvals = resolveExecApprovals(agentId, {
+        security: configuredSecurity,
+        ask: configuredAsk,
+    });
+    const security = approvals.agent.security;
+    const ask = approvals.agent.ask;
+    const autoAllowSkills = approvals.agent.autoAllowSkills;
+    const sessionKey = opts.params.sessionKey?.trim() || "node";
+    const runId = opts.params.runId?.trim() || crypto.randomUUID();
+    const env = opts.sanitizeEnv(opts.params.env ?? undefined);
+    const safeBins = resolveSafeBins(agentExec?.safeBins ?? cfg.tools?.exec?.safeBins);
+    const trustedSafeBinDirs = getTrustedSafeBinDirs();
+    const bins = autoAllowSkills ? await opts.skillBins.current() : new Set();
+    let analysisOk = false;
+    let allowlistMatches = [];
+    let allowlistSatisfied = false;
+    let segments = [];
+    if (shellCommand) {
+        const allowlistEval = evaluateShellAllowlist({
+            command: shellCommand,
+            allowlist: approvals.allowlist,
+            safeBins,
+            cwd: opts.params.cwd ?? undefined,
+            env,
+            trustedSafeBinDirs,
+            skillBins: bins,
+            autoAllowSkills,
+            platform: process.platform,
+        });
+        analysisOk = allowlistEval.analysisOk;
+        allowlistMatches = allowlistEval.allowlistMatches;
+        allowlistSatisfied =
+            security === "allowlist" && analysisOk ? allowlistEval.allowlistSatisfied : false;
+        segments = allowlistEval.segments;
+    }
+    else {
+        const analysis = analyzeArgvCommand({ argv, cwd: opts.params.cwd ?? undefined, env });
+        const allowlistEval = evaluateExecAllowlist({
+            analysis,
+            allowlist: approvals.allowlist,
+            safeBins,
+            cwd: opts.params.cwd ?? undefined,
+            trustedSafeBinDirs,
+            skillBins: bins,
+            autoAllowSkills,
+        });
+        analysisOk = analysis.ok;
+        allowlistMatches = allowlistEval.allowlistMatches;
+        allowlistSatisfied =
+            security === "allowlist" && analysisOk ? allowlistEval.allowlistSatisfied : false;
+        segments = analysis.segments;
+    }
+    const isWindows = process.platform === "win32";
+    const cmdInvocation = shellCommand
+        ? opts.isCmdExeInvocation(segments[0]?.argv ?? [])
+        : opts.isCmdExeInvocation(argv);
+    if (security === "allowlist" && isWindows && cmdInvocation) {
+        analysisOk = false;
+        allowlistSatisfied = false;
+    }
+    const useMacAppExec = process.platform === "darwin";
+    if (useMacAppExec) {
+        const approvalDecision = opts.params.approvalDecision === "allow-once" ||
+            opts.params.approvalDecision === "allow-always"
+            ? opts.params.approvalDecision
+            : null;
+        const execRequest = {
+            command: argv,
+            rawCommand: rawCommand || shellCommand || null,
+            cwd: opts.params.cwd ?? null,
+            env: opts.params.env ?? null,
+            timeoutMs: opts.params.timeoutMs ?? null,
+            needsScreenRecording: opts.params.needsScreenRecording ?? null,
+            agentId: agentId ?? null,
+            sessionKey: sessionKey ?? null,
+            approvalDecision,
+        };
+        const response = await opts.runViaMacAppExecHost({ approvals, request: execRequest });
+        if (!response) {
+            if (opts.execHostEnforced || !opts.execHostFallbackAllowed) {
+                await opts.sendNodeEvent(opts.client, "exec.denied", opts.buildExecEventPayload({
+                    sessionKey,
+                    runId,
+                    host: "node",
+                    command: cmdText,
+                    reason: "companion-unavailable",
+                }));
+                await opts.sendInvokeResult({
+                    ok: false,
+                    error: {
+                        code: "UNAVAILABLE",
+                        message: "COMPANION_APP_UNAVAILABLE: macOS app exec host unreachable",
+                    },
+                });
+                return;
+            }
+        }
+        else if (!response.ok) {
+            const reason = response.error.reason ?? "approval-required";
+            await opts.sendNodeEvent(opts.client, "exec.denied", opts.buildExecEventPayload({
+                sessionKey,
+                runId,
+                host: "node",
+                command: cmdText,
+                reason,
+            }));
+            await opts.sendInvokeResult({
+                ok: false,
+                error: { code: "UNAVAILABLE", message: response.error.message },
+            });
+            return;
+        }
+        else {
+            const result = response.payload;
+            await opts.sendExecFinishedEvent({ sessionKey, runId, cmdText, result });
+            await opts.sendInvokeResult({
+                ok: true,
+                payloadJSON: JSON.stringify(result),
+            });
+            return;
+        }
+    }
+    if (security === "deny") {
+        await opts.sendNodeEvent(opts.client, "exec.denied", opts.buildExecEventPayload({
+            sessionKey,
+            runId,
+            host: "node",
+            command: cmdText,
+            reason: "security=deny",
+        }));
+        await opts.sendInvokeResult({
+            ok: false,
+            error: { code: "UNAVAILABLE", message: "SYSTEM_RUN_DISABLED: security=deny" },
+        });
+        return;
+    }
+    const requiresAsk = requiresExecApproval({
+        ask,
+        security,
+        analysisOk,
+        allowlistSatisfied,
+    });
+    const approvalDecision = opts.params.approvalDecision === "allow-once" || opts.params.approvalDecision === "allow-always"
+        ? opts.params.approvalDecision
+        : null;
+    const approvedByAsk = approvalDecision !== null || opts.params.approved === true;
+    if (requiresAsk && !approvedByAsk) {
+        await opts.sendNodeEvent(opts.client, "exec.denied", opts.buildExecEventPayload({
+            sessionKey,
+            runId,
+            host: "node",
+            command: cmdText,
+            reason: "approval-required",
+        }));
+        await opts.sendInvokeResult({
+            ok: false,
+            error: { code: "UNAVAILABLE", message: "SYSTEM_RUN_DENIED: approval required" },
+        });
+        return;
+    }
+    if (approvalDecision === "allow-always" && security === "allowlist") {
+        if (analysisOk) {
+            const patterns = resolveAllowAlwaysPatterns({
+                segments,
+                cwd: opts.params.cwd ?? undefined,
+                env,
+                platform: process.platform,
+            });
+            for (const pattern of patterns) {
+                if (pattern) {
+                    addAllowlistEntry(approvals.file, agentId, pattern);
+                }
+            }
+        }
+    }
+    if (security === "allowlist" && (!analysisOk || !allowlistSatisfied) && !approvedByAsk) {
+        await opts.sendNodeEvent(opts.client, "exec.denied", opts.buildExecEventPayload({
+            sessionKey,
+            runId,
+            host: "node",
+            command: cmdText,
+            reason: "allowlist-miss",
+        }));
+        await opts.sendInvokeResult({
+            ok: false,
+            error: { code: "UNAVAILABLE", message: "SYSTEM_RUN_DENIED: allowlist miss" },
+        });
+        return;
+    }
+    if (allowlistMatches.length > 0) {
+        const seen = new Set();
+        for (const match of allowlistMatches) {
+            if (!match?.pattern || seen.has(match.pattern)) {
+                continue;
+            }
+            seen.add(match.pattern);
+            recordAllowlistUse(approvals.file, agentId, match, cmdText, segments[0]?.resolution?.resolvedPath);
+        }
+    }
+    if (opts.params.needsScreenRecording === true) {
+        await opts.sendNodeEvent(opts.client, "exec.denied", opts.buildExecEventPayload({
+            sessionKey,
+            runId,
+            host: "node",
+            command: cmdText,
+            reason: "permission:screenRecording",
+        }));
+        await opts.sendInvokeResult({
+            ok: false,
+            error: { code: "UNAVAILABLE", message: "PERMISSION_MISSING: screenRecording" },
+        });
+        return;
+    }
+    let execArgv = argv;
+    if (security === "allowlist" &&
+        isWindows &&
+        !approvedByAsk &&
+        shellCommand &&
+        analysisOk &&
+        allowlistSatisfied &&
+        segments.length === 1 &&
+        segments[0]?.argv.length > 0) {
+        execArgv = segments[0].argv;
+    }
+    const result = await opts.runCommand(execArgv, opts.params.cwd?.trim() || undefined, env, opts.params.timeoutMs ?? undefined);
+    if (result.truncated) {
+        const suffix = "... (truncated)";
+        if (result.stderr.trim().length > 0) {
+            result.stderr = `${result.stderr}\n${suffix}`;
+        }
+        else {
+            result.stdout = `${result.stdout}\n${suffix}`;
+        }
+    }
+    await opts.sendExecFinishedEvent({ sessionKey, runId, cmdText, result });
+    await opts.sendInvokeResult({
+        ok: true,
+        payloadJSON: JSON.stringify({
+            exitCode: result.exitCode,
+            timedOut: result.timedOut,
+            success: result.success,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            error: result.error ?? null,
+        }),
+    });
+}