qlogicagent 2.13.4 → 2.13.5

package/dist/runtime/prompt/fresh-workspace-evidence.js

@@ -0,0 +1,224 @@
+import { volatileSystemPromptSection } from "./system-prompt-sections.js";
+const NO_FRESH_TOOL_POLICY = {
+    requiresFreshTool: false,
+    allowedToolNames: [],
+};
+const FILE_EXTENSIONS = [
+    "txt", "json", "jsonl", "ts", "tsx", "js", "jsx", "mjs", "cjs", "md", "mdx",
+    "yaml", "yml", "toml", "ini", "xml", "csv", "tsv", "env", "py", "go", "rs",
+    "java", "kt", "kts", "cs", "cpp", "c", "h", "hpp", "html", "css", "scss",
+    "sass", "less", "sql", "lock", "log", "sh", "ps1", "bat", "cmd",
+];
+const FILE_PATH_RE = new RegExp(`(?:^|[\\s"'` + "`" + `([{:,])(?:\\.?[\\w@~.-]+[\\\\/])*[\\w@~.-]+\\.(?:${FILE_EXTENSIONS.join("|")})\\b`, "i");
+const MUTATION_RE = /write|create|edit|replace|change|update|modify|overwrite|fix|implement|\u5199|\u65b0\u5efa|\u521b\u5efa|\u7f16\u8f91|\u66ff\u6362|\u6539\u6210|\u4fee\u6539|\u4fee\u590d|\u5b9e\u73b0|\u8986\u76d6/i;
+const MEMORY_FILE_ACTION_RE = /(?:memory|\u8bb0\u5fc6).*(?:create_file|\u8bb0\u5fc6\u6587\u4ef6|\u6587\u4ef6)|(?:create_file).*(?:memory|\u8bb0\u5fc6)/i;
+const MEMORY_EXPLICIT_ACTION_RE = /(?:memory|\u8bb0\u5fc6).*(?:(?:add|replace|remove|create_file|write_file|read_file|delete_file|list_files|search|remember|temporal|feedback)\s+action\b|action\s*[:=]?\s*['"]?(?:add|replace|remove|create_file|write_file|read_file|delete_file|list_files|search|remember|temporal|feedback)\b|\u5220\u9664|\u79fb\u9664|\u66ff\u6362|\u521b\u5efa|\u8bfb\u53d6|\u641c\u7d22)|(?:(?:add|replace|remove|create_file|write_file|read_file|delete_file|list_files|search|remember|temporal|feedback)\s+action\b|action\s*[:=]?\s*['"]?(?:add|replace|remove|create_file|write_file|read_file|delete_file|list_files|search|remember|temporal|feedback)\b).*(?:memory|\u8bb0\u5fc6)/i;
+const DIRECTORY_LIST_RE = /(?:current\s+directory|directory\s+(?:contains|listing|files)|list\s+(?:the\s+)?files|what\s+files|\u5f53\u524d\u76ee\u5f55|\u76ee\u5f55\u4e0b|\u54ea\u4e9b\u6587\u4ef6|\u5217\u51fa.*\u6587\u4ef6)/i;
+const CONTENT_SEARCH_RE = /(?:which\s+file.*contains|contains.*which\s+file|\u54ea(?:\u4e2a|\u4e9b|\u4e00\u4e2a)?\u6587\u4ef6.*\u5305\u542b|\u5305\u542b.*\u54ea(?:\u4e2a|\u4e9b|\u4e00\u4e2a)?\u6587\u4ef6)/i;
+const SHELL_RE = /(?:^|\s)(?:run|execute)\s+(?:this\s+)?(?:command|shell)?\b|\b(?:echo|pwd|ls|dir|cat|type)\b|\u6267\u884c|\u8fd0\u884c/i;
+const URL_RE = /https?:\/\/\S+/i;
+const WEB_FACT_RE = /fetch|open|visit|url|return|response|httpbin|\u8bbf\u95ee|\u7f51\u9875|\u8fd4\u56de|\u770b\u4e0b|\u770b\u770b/i;
+const IMAGE_GENERATION_RE = /(?:\bimage_generate\b|\bgenerate\s+(?:an?\s+)?image\b|\bmake\s+(?:an?\s+)?image\b|\bdraw\s+(?:an?\s+)?(?:image|picture|illustration)\b|\bcreate\s+(?:an?\s+)?(?:image|picture|illustration)\b|\u751f\u56fe|\u751f\u6210(?:一张|个|幅)?(?:图片|图像|插画|海报|头像)?|\u753b(?:一张|一个|一幅|一只|一群|个|张|幅|一下)?.+|\u753b(?:一张|个|幅|一幅)?.*(?:图|图片|图像|插画|画面)|(?:图片|图像|插画|海报|头像).*\u751f\u6210)/i;
+const TTS_GENERATION_RE = /(?:\btts\b|\btext[-\s]?to[-\s]?speech\b|\bread\s+(?:this\s+)?(?:aloud|out)\b|\bgenerate\s+(?:a\s+)?(?:spoken\s+)?(?:audio|voice|speech|narration)\b|\bcreate\s+(?:a\s+)?(?:spoken\s+)?(?:audio|voice|speech|narration)\b|\bmake\s+(?:a\s+)?(?:voice\s+message|spoken\s+audio)\b|\u6587\u5b57\u8f6c\u8bed\u97f3|\u8bed\u97f3\u5408\u6210|\u8f6c\u6210\u8bed\u97f3|\u8f6c\u8bed\u97f3|\u751f\u6210.*(?:\u8bed\u97f3|\u97f3\u9891|\u58f0\u97f3|\u5f55\u97f3|\u6709\u58f0)|(?:\u8bfb|\u6717\u8bfb|\u64ad\u62a5|\u914d\u97f3|\u65c1\u767d).*(?:\u4e00\u6bb5|\u8fd9\u6bb5|\u8fd9\u4e9b|\u6587\u5b57|\u5185\u5bb9|\u8bed\u97f3|\u97f3\u9891)?)/i;
+const MUSIC_GENERATION_RE = /(?:\bmusic_generate\b|\bgenerate\s+(?:a\s+)?(?:song|music|melody|bgm)\b|\bcreate\s+(?:a\s+)?(?:song|music|melody|bgm)\b|\bmake\s+(?:a\s+)?(?:song|music|melody|bgm)\b|\u751f\u6210.*(?:\u6b4c\u66f2|\u97f3\u4e50|\u65cb\u5f8b|\u914d\u4e50|\u80cc\u666f\u97f3\u4e50|\u7eaf\u97f3\u4e50|\u54fc\u5531)|(?:\u4f5c\u66f2|\u7f16\u66f2|\u5199\u4e00\u9996\u6b4c))/i;
+const LIGHTWEIGHT_CHAT_RE = /^(?:hi|hello|hey|ping|test|yo|在吗|在不在|你在吗|你好|您好|早上好|中午好|晚上好|哈喽|嗨|有人吗|能听到吗|你是谁|你还在吗)[？！!?.。~\s]*$/i;
+export function getFreshWorkspaceEvidencePolicy(messages) {
+    const text = typeof messages === "string" ? messages : getLatestUserText(messages);
+    if (!text.trim())
+        return NO_FRESH_TOOL_POLICY;
+    if (MUSIC_GENERATION_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "media-generation",
+            mediaKind: "music",
+            allowedToolNames: ["music_generate"],
+        };
+    }
+    if (TTS_GENERATION_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "media-generation",
+            mediaKind: "tts",
+            allowedToolNames: ["tts"],
+        };
+    }
+    if (IMAGE_GENERATION_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "media-generation",
+            mediaKind: "image",
+            allowedToolNames: ["image_generate"],
+        };
+    }
+    if (URL_RE.test(text) && WEB_FACT_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "web",
+            allowedToolNames: ["web_fetch"],
+        };
+    }
+    if ((MEMORY_FILE_ACTION_RE.test(text) && FILE_PATH_RE.test(text)) || MEMORY_EXPLICIT_ACTION_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "memory-mutation",
+            allowedToolNames: ["memory"],
+        };
+    }
+    if (MUTATION_RE.test(text) && FILE_PATH_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "file-mutation",
+            allowedToolNames: ["read", "search", "write", "edit", "patch"],
+        };
+    }
+    if (FILE_PATH_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "file-read",
+            allowedToolNames: ["read", "search"],
+        };
+    }
+    if (DIRECTORY_LIST_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "directory-list",
+            allowedToolNames: ["exec"],
+        };
+    }
+    if (CONTENT_SEARCH_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "content-search",
+            allowedToolNames: ["search"],
+        };
+    }
+    if (SHELL_RE.test(text)) {
+        return {
+            requiresFreshTool: true,
+            reason: "shell",
+            allowedToolNames: ["exec"],
+        };
+    }
+    return NO_FRESH_TOOL_POLICY;
+}
+export function isLightweightChatTurn(messages) {
+    const text = typeof messages === "string" ? messages : getLatestUserText(messages);
+    const normalized = text.trim();
+    if (!normalized || normalized.length > 24)
+        return false;
+    return LIGHTWEIGHT_CHAT_RE.test(normalized);
+}
+/**
+ * Orchestration primitives that survive every evidence filter.
+ * The policy's job is to FORCE fresh-evidence tools into the turn, not to
+ * strip the coordination layer — removing task/agent here silently breaks
+ * sub-agent delegation and background-task tracking on any turn whose text
+ * happens to match an evidence pattern (e.g. "write reports/x.json").
+ */
+// think was removed as a tool — native model reasoning owns that lane.
+// send_message merged into team(action="send").
+const ALWAYS_AVAILABLE_TOOL_NAMES = new Set(["task", "agent", "ask_user", "team"]);
+export function selectFreshWorkspaceEvidenceTools(tools, policy) {
+    if (!policy.requiresFreshTool || policy.allowedToolNames.length === 0) {
+        return [...tools];
+    }
+    const allowed = new Set(policy.allowedToolNames);
+    const selected = tools.filter((tool) => {
+        const name = getToolName(tool);
+        return allowed.has(name) || ALWAYS_AVAILABLE_TOOL_NAMES.has(name);
+    });
+    const hasEvidenceTool = selected.some((tool) => allowed.has(getToolName(tool)));
+    return hasEvidenceTool ? selected : [...tools];
+}
+export function createFreshWorkspaceEvidenceSection(policy) {
+    if (!policy.requiresFreshTool)
+        return null;
+    const allowed = policy.allowedToolNames.join(", ");
+    if (policy.reason === "file-mutation") {
+        return volatileSystemPromptSection("fresh_workspace_evidence", () => [
+            "# Workspace File Action Required",
+            "",
+            "The latest user request asks you to create, edit, fix, or implement files in the workspace.",
+            `Before answering, call the appropriate tool for this turn: ${allowed}.`,
+            "Use write/edit/patch to make the requested on-disk change. Reading or searching can locate context, but does not satisfy the requested action.",
+            "Do not merely describe code, print snippets, or claim completion without a successful file-changing tool result.",
+            "If a file-changing tool fails, make at most two focused attempts, then report the exact failure.",
+        ].join("\n"));
+    }
+    if (policy.reason === "memory-mutation") {
+        return volatileSystemPromptSection("fresh_workspace_evidence", () => [
+            "# Memory File Action Required",
+            "",
+            "The latest user request explicitly asks to use the memory tool for a memory file action.",
+            `Before answering, call the appropriate tool for this turn: ${allowed}.`,
+            "Use the requested memory action and target filename instead of workspace file write/edit tools.",
+            "For removal requests, call memory with action='remove' and set old_text to the exact INDEX.md line or labeled marker line the user asked to remove.",
+            "Do not call action='add', action='remember', or action='create_file' for a removal request.",
+            "Do not merely describe the memory content or create a regular workspace file.",
+        ].join("\n"));
+    }
+    if (policy.reason === "media-generation") {
+        const mediaLabel = policy.mediaKind === "tts"
+            ? "spoken audio / text-to-speech"
+            : policy.mediaKind === "music"
+                ? "music or song"
+                : "image";
+        const placeholderWarning = policy.mediaKind === "tts"
+            ? "Do not answer by saying you cannot generate audio when the TTS tool is available, and do not invent a placeholder audio URL."
+            : policy.mediaKind === "music"
+                ? "Do not answer by describing music in text or inventing a placeholder audio URL."
+                : "Do not answer by inventing a Markdown image URL or placeholder attachment path.";
+        const toolGuidance = policy.mediaKind === "tts"
+            ? "Use TTS for spoken-word output, narration, reading text aloud, or voice messages. STT is only for transcribing incoming speech."
+            : policy.mediaKind === "music"
+                ? "Use music generation for songs, melodies, BGM, or sung/musical output; use TTS only for spoken words."
+                : "Use image generation for pictures, illustrations, posters, avatars, or visual output.";
+        return volatileSystemPromptSection("fresh_workspace_evidence", () => [
+            "# Media Generation Required",
+            "",
+            `The latest user request asks you to create ${mediaLabel}.`,
+            `Before answering, call the appropriate media tool for this turn: ${allowed}.`,
+            placeholderWarning,
+            toolGuidance,
+            "For ordinary creative requests, infer reasonable defaults for purpose, style, and size instead of asking follow-up questions.",
+            "Ask the user only when a missing detail is critical to the result or the request is genuinely ambiguous.",
+        ].join("\n"));
+    }
+    return volatileSystemPromptSection("fresh_workspace_evidence", () => [
+        "# Fresh Workspace Evidence",
+        "",
+        "The latest user request asks for current workspace, shell, or URL state.",
+        `Before answering, call one of these tools for this turn: ${allowed}.`,
+        "Do not answer this request from conversation history, memory, or prior tool results.",
+        "For an explicit filename, inspect that exact file first and report the observed value.",
+        "If the filename is not found at the given path, use search to locate it, then read the located file before answering.",
+        "A filename search alone is not enough to answer content or code-symbol questions.",
+    ].join("\n"));
+}
+function getLatestUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message?.role !== "user")
+            continue;
+        return stringifyContent(message.content);
+    }
+    return "";
+}
+function stringifyContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((item) => {
+            if (!item || typeof item !== "object")
+                return "";
+            const record = item;
+            return typeof record.text === "string" ? record.text : "";
+        })
+            .join("");
+    }
+    return "";
+}
+function getToolName(tool) {
+    return tool.function?.name ?? tool.name ?? "";
+}

package/dist/runtime/prompt/fresh-workspace-evidence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/prompt/fresh-workspace-evidence.test.js

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import { createFreshWorkspaceEvidenceSection, getFreshWorkspaceEvidencePolicy, isLightweightChatTurn, selectFreshWorkspaceEvidenceTools, } from "./fresh-workspace-evidence.js";
+const tools = ["read", "search", "write", "edit", "patch", "exec", "web_fetch", "memory", "image_generate", "tts", "music_generate"].map((name) => ({
+    type: "function",
+    function: { name },
+}));
+describe("fresh workspace evidence policy", () => {
+    it("requires file evidence tools for explicit file fact questions", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "data.json \u91cc\u7684 version \u662f\u591a\u5c11\uff1f" },
+        ]);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.allowedToolNames).toEqual(["read", "search"]);
+        // Orchestration primitives (task/agent/ask_user) always survive the filter
+        expect(selectFreshWorkspaceEvidenceTools(tools, policy).map(t => t.function.name)).toEqual(["read", "search"]);
+    });
+    it("requires file evidence for code symbol explanation requests", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "buggy.ts \u91cc\u7684 formatName \u662f\u5e72\u4ec0\u4e48\u7684" },
+        ]);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.allowedToolNames).toEqual(["read", "search"]);
+    });
+    it("prioritizes explicit filenames over current-directory wording", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: 'Read the file "this_file_does_not_exist_12345.txt" in the current directory.' },
+        ]);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.reason).toBe("file-read");
+        expect(policy.allowedToolNames).toEqual(["read", "search"]);
+    });
+    it("requires file-changing tools for explicit workspace mutation requests", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "\u521b\u5efa\u6587\u4ef6 src/calculator.ts\uff0c\u5b9e\u73b0 Calculator \u7c7b" },
+        ]);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.reason).toBe("file-mutation");
+        expect(policy.allowedToolNames).toEqual(["read", "search", "write", "edit", "patch"]);
+        expect(selectFreshWorkspaceEvidenceTools(tools, policy).map(t => t.function.name)).toEqual(["read", "search", "write", "edit", "patch"]);
+    });
+    it("keeps memory available when an explicit memory-tool file action mentions a topic file", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "请用你的memory工具创建一个名为 coding-standards.md 的记忆文件，使用 create_file action。" },
+        ]);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.reason).toBe("memory-mutation");
+        expect(policy.allowedToolNames).toContain("memory");
+        expect(selectFreshWorkspaceEvidenceTools(tools, policy).map(t => t.function.name)).toContain("memory");
+    });
+    it("activates memory guidance for explicit remove actions even without a filename", async () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: '请用你的memory工具删除关于"用法语回复"的记忆条目（包含 REMOVABLE_RULE 的那行）。使用 remove action。' },
+        ]);
+        const section = createFreshWorkspaceEvidenceSection(policy);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.reason).toBe("memory-mutation");
+        expect(policy.allowedToolNames).toEqual(["memory"]);
+        expect(section).not.toBeNull();
+        expect(await section.compute()).toContain("action='remove'");
+    });
+    it("requires exec for current directory listings", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "\u5f53\u524d\u76ee\u5f55\u4e0b\u6709\u54ea\u4e9b\u6587\u4ef6\uff1f" },
+        ]);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.allowedToolNames).toEqual(["exec"]);
+    });
+    it("requires image_generate for direct image creation requests", async () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "画一群小鸡在水里游泳，有的小鸡戴了泳帽，有的戴了护目镜" },
+        ]);
+        const section = createFreshWorkspaceEvidenceSection(policy);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.reason).toBe("media-generation");
+        expect(policy.allowedToolNames).toEqual(["image_generate"]);
+        expect(selectFreshWorkspaceEvidenceTools(tools, policy).map(t => t.function.name)).toEqual(["image_generate"]);
+        expect(await section.compute()).toContain("Do not answer by inventing a Markdown image URL");
+    });
+    it("requires tts for spoken audio generation requests", async () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "\u751f\u6210\u4e00\u6bb5\u6d4b\u8bd5\u97f3\u9891\uff0c\u8bf4\u4eca\u5929\u7684\u5de5\u4f5c\u5f00\u59cb\u4e86" },
+        ]);
+        const section = createFreshWorkspaceEvidenceSection(policy);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.reason).toBe("media-generation");
+        expect(policy.mediaKind).toBe("tts");
+        expect(policy.allowedToolNames).toEqual(["tts"]);
+        expect(selectFreshWorkspaceEvidenceTools(tools, policy).map(t => t.function.name)).toEqual(["tts"]);
+        expect(await section.compute()).toContain("STT is only for transcribing incoming speech");
+    });
+    it("requires music_generate for song and music generation requests", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "\u751f\u6210\u4e00\u6bb5\u8f7b\u5feb\u7684\u80cc\u666f\u97f3\u4e50" },
+        ]);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.reason).toBe("media-generation");
+        expect(policy.mediaKind).toBe("music");
+        expect(policy.allowedToolNames).toEqual(["music_generate"]);
+        expect(selectFreshWorkspaceEvidenceTools(tools, policy).map(t => t.function.name)).toEqual(["music_generate"]);
+    });
+    it("does not treat voice availability questions as tts generation", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "\u4f60\u53ef\u4ee5\u542c\u89c1\u6211\u8bf4\u7684\u8bdd\u5417" },
+        ]);
+        expect(policy.requiresFreshTool).toBe(false);
+    });
+    it("never strips orchestration/coordination tools from evidence-filtered turns", () => {
+        const orchestrationTools = ["read", "search", "write", "task", "agent", "ask_user", "team", "web_search"].map((name) => ({
+            type: "function",
+            function: { name },
+        }));
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "Create a team, message the member via team send, then write reports/result.json with the reply." },
+        ]);
+        expect(policy.requiresFreshTool).toBe(true);
+        const selected = selectFreshWorkspaceEvidenceTools(orchestrationTools, policy).map(t => t.function.name);
+        expect(selected).toContain("task");
+        expect(selected).toContain("agent");
+        expect(selected).toContain("ask_user");
+        // Team coordination primitives must also survive — a "write reports/..." mention
+        // must not strip the very tools the turn needs to orchestrate (live-caught bug).
+        expect(selected).toContain("team");
+        expect(selected).not.toContain("web_search"); // non-orchestration tools still filtered
+    });
+    it("does not require tools for ordinary conversation", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "Summarize the design tradeoffs in plain English." },
+        ]);
+        expect(policy.requiresFreshTool).toBe(false);
+        expect(selectFreshWorkspaceEvidenceTools(tools, policy)).toHaveLength(tools.length);
+    });
+    it("classifies short availability checks as lightweight chat turns", () => {
+        expect(isLightweightChatTurn([{ role: "user", content: "在吗" }])).toBe(true);
+        expect(isLightweightChatTurn([{ role: "user", content: "hello!" }])).toBe(true);
+        expect(isLightweightChatTurn([{ role: "user", content: "src/math.ts 里有什么" }])).toBe(false);
+        expect(isLightweightChatTurn([{ role: "user", content: "帮我实现一个设置同步功能" }])).toBe(false);
+    });
+    it("narrows edit requests to file-action tools instead of read-only evidence tools", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: 'main.ts \u91cc\u7684 greet \u51fd\u6570\uff0c\u628a "Hello, " \u6539\u6210 "Hi, "' },
+        ]);
+        expect(policy.requiresFreshTool).toBe(true);
+        expect(policy.reason).toBe("file-mutation");
+        expect(policy.allowedToolNames).toContain("edit");
+        expect(policy.allowedToolNames).toContain("write");
+    });
+    it("adds an explicit freshness instruction when active", () => {
+        const policy = getFreshWorkspaceEvidencePolicy([
+            { role: "user", content: "Run echo HELLO and tell me the output." },
+        ]);
+        const section = createFreshWorkspaceEvidenceSection(policy);
+        expect(policy.allowedToolNames).toEqual(["exec"]);
+        expect(section).not.toBeNull();
+        expect(section.name).toBe("fresh_workspace_evidence");
+    });
+    it("adds an explicit file-action instruction for mutation requests", async () => {
+        const policy = getFreshWorkspaceEvidencePolicy("src/math.ts \u7684 divide \u51fd\u6570\u6709 bug\uff0c\u4fee\u590d\u5b83");
+        const section = createFreshWorkspaceEvidenceSection(policy);
+        expect(section).not.toBeNull();
+        const content = await section.compute();
+        expect(content).toContain("Workspace File Action Required");
+    });
+});

package/dist/runtime/prompt/index.d.ts

@@ -0,0 +1,5 @@
+export { assembleSystemPrompt, clearSystemPromptSections, systemPromptSection, type SystemPromptSection, } from "./system-prompt-sections.js";
+export { PROMPT_POLICY_REGISTRY, PROMPT_POLICY_VERSION, createPromptPolicyHeader, type PromptPolicyRegistry, type PromptPolicyRegistryEntry, } from "./prompt-policy.js";
+export { getInstructions, buildInstructionsPrompt, resetInstructionCache, } from "./instruction-loader.js";
+export { createEnvironmentContextSection, createTaskGuidanceSection, createToolGuidanceSection, createLanguageSection } from "./environment-context.js";
+export { detectTaskDomain, resolveTaskDomain, loadProjectTaskDomain, persistTaskDomain, shouldPersistDomain, type TaskDomain, type DomainResolutionContext } from "./task-domain.js";

package/dist/runtime/prompt/index.js

@@ -0,0 +1,6 @@
+// runtime/prompt — prompt engineering subsystem
+export { assembleSystemPrompt, clearSystemPromptSections, systemPromptSection, } from "./system-prompt-sections.js";
+export { PROMPT_POLICY_REGISTRY, PROMPT_POLICY_VERSION, createPromptPolicyHeader, } from "./prompt-policy.js";
+export { getInstructions, buildInstructionsPrompt, resetInstructionCache, } from "./instruction-loader.js";
+export { createEnvironmentContextSection, createTaskGuidanceSection, createToolGuidanceSection, createLanguageSection } from "./environment-context.js";
+export { detectTaskDomain, resolveTaskDomain, loadProjectTaskDomain, persistTaskDomain, shouldPersistDomain } from "./task-domain.js";

package/dist/runtime/prompt/instruction-loader.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Instruction Loader — CC claudemd.ts parity (adapted for qlogicagent).
+ *
+ * Discovers and loads instruction files following CC's load order:
+ *   1. User instructions (~/.qlogicagent/INSTRUCTIONS.md)
+ *   2. Project instructions (INSTRUCTIONS.md, .qlogicagent/INSTRUCTIONS.md,
+ *      .qlogicagent/rules/*.md — walkup from cwd to git root)
+ *   3. Local instructions (INSTRUCTIONS.local.md — private, not checked in)
+ *
+ * Features ported from CC:
+ *   - Walkup discovery (cwd → root)
+ *   - @include directive support (text files only)
+ *   - Frontmatter globs for conditional rules
+ *   - HTML comment stripping
+ *   - Memoized loading with cache invalidation
+ *   - TEXT_FILE_EXTENSIONS whitelist
+ *   - MAX_INCLUDE_DEPTH circular reference prevention
+ *
+ * Reference: claude-code src/utils/claudemd.ts
+ */
+import type { HookRegistry } from "../../contracts/hooks.js";
+export type InstructionType = "User" | "Project" | "Local";
+export interface InstructionFileInfo {
+    path: string;
+    type: InstructionType;
+    content: string;
+    /** Path of the file that @included this one */
+    parent?: string;
+    /** Glob patterns from frontmatter — file only applies when target path matches */
+    globs?: string[];
+}
+export interface LiteralResponseRequirement {
+    marker: string;
+    placement: "prefix" | "suffix" | "include";
+}
+/**
+ * Load all instruction files following CC's discovery order.
+ *
+ * Discovery order (priority: last loaded = highest):
+ *   1. User: ~/.qlogicagent/INSTRUCTIONS.md, ~/.qlogicagent/rules/*.md
+ *   2. Project: Walk from git root → cwd, each dir:
+ *      - INSTRUCTIONS.md
+ *      - .qlogicagent/INSTRUCTIONS.md
+ *      - .qlogicagent/rules/*.md (unconditional)
+ *   3. Local: INSTRUCTIONS.local.md (per dir, walkup)
+ *
+ * @param cwd - Starting directory for walkup discovery
+ * @param hooks - Optional hook registry for instructions.loaded event
+ */
+export declare function loadInstructions(cwd: string, hooks?: HookRegistry): Promise<InstructionFileInfo[]>;
+/**
+ * Build the instructions prompt string from loaded files.
+ * CC parity: getClaudeMds()
+ */
+export declare function buildInstructionsPrompt(files: InstructionFileInfo[]): string;
+export declare function extractLiteralResponseRequirements(files: InstructionFileInfo[]): LiteralResponseRequirement[];
+export declare function applyLiteralResponseRequirements(content: string, requirements: readonly LiteralResponseRequirement[]): string;
+/**
+ * Get conditional rules that match a target file path.
+ * CC parity: getManagedAndUserConditionalRules() + getMemoryFilesForNestedDirectory()
+ */
+export declare function getConditionalRules(cwd: string, targetPath: string): Promise<InstructionFileInfo[]>;
+/**
+ * Load instructions for the current turn.
+ * This intentionally reloads from disk every call so instruction edits become
+ * visible on the next turn without depending on a filesystem watcher.
+ */
+export declare function getInstructions(cwd: string, hooks?: HookRegistry): Promise<InstructionFileInfo[]>;
+/** Clear the instruction cache. Called after file changes or compaction. */
+export declare function resetInstructionCache(): void;