qlogicagent 2.13.4 → 2.13.5

package/dist/runtime/prompt/environment-context.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Environment Context — CC environment-aware system prompt parity.
+ *
+ * Injects OS, shell, CWD, and platform info into the system prompt
+ * so the agent can generate platform-appropriate commands.
+ *
+ * CC reference: ShellSnapshot.ts (shell type detection),
+ *               shellCompletion.ts (platform-aware command generation)
+ *
+ * This is a system prompt section that provides:
+ *   - OS name + version
+ *   - Shell type (bash/powershell/zsh)
+ *   - Current working directory
+ *   - Node.js version
+ *   - Available package managers
+ */
+import { type SystemPromptSection } from "./system-prompt-sections.js";
+import type { TaskDomain } from "./task-domain.js";
+export type ShellType = "bash" | "powershell" | "zsh" | "cmd" | "fish" | "unknown";
+/**
+ * Create a system prompt section that provides environment context.
+ * Memoized — computed once per session (environment doesn't change mid-session).
+ */
+export declare function createEnvironmentContextSection(cwdOverride?: string): SystemPromptSection;
+/**
+ * Create the task guidance system prompt section.
+ * Domain-aware: selects appropriate guidance based on detected or overridden task domain.
+ *
+ * @param domain - Task domain from auto-detection or host override.
+ */
+export declare function createTaskGuidanceSection(domain?: TaskDomain): SystemPromptSection;
+/**
+ * Create a system prompt section that provides tool usage guidance.
+ * CC parity: matches claude-code's getUsingYourToolsSection().
+ * Tells the LLM when to use specialized tools vs. primitives.
+ */
+export declare function createToolGuidanceSection(): SystemPromptSection;
+/**
+ * Index of deferred tools so the model KNOWS these capabilities exist even
+ * though their schemas are not loaded. Without this the model sees only the
+ * non-deferred tool list and will wrongly claim it lacks e.g. video generation.
+ *
+ * Volatile (recomputed each turn) because the deferred set can change when
+ * dynamic registrations (MCP, session bootstrap) land; the rendered text is
+ * stable across turns otherwise, so prompt cache is preserved in practice.
+ */
+export declare function createDeferredToolIndexSection(listDeferredTools: () => Array<{
+    name: string;
+    description: string;
+}>): SystemPromptSection;
+/**
+ * Create a system prompt section that instructs the model on response language.
+ * CC parity: only injected when language is explicitly set; when absent,
+ * the model follows the user's message language naturally.
+ *
+ * Key rule: always respond in the SAME language as the user's current message.
+ * This prevents confusion when system prompt contains mixed-language content
+ * (e.g., Chinese INDEX.md + English tool guidance).
+ */
+export declare function createLanguageSection(language?: string): SystemPromptSection;

package/dist/runtime/prompt/environment-context.js

@@ -0,0 +1,410 @@
+/**
+ * Environment Context — CC environment-aware system prompt parity.
+ *
+ * Injects OS, shell, CWD, and platform info into the system prompt
+ * so the agent can generate platform-appropriate commands.
+ *
+ * CC reference: ShellSnapshot.ts (shell type detection),
+ *               shellCompletion.ts (platform-aware command generation)
+ *
+ * This is a system prompt section that provides:
+ *   - OS name + version
+ *   - Shell type (bash/powershell/zsh)
+ *   - Current working directory
+ *   - Node.js version
+ *   - Available package managers
+ */
+import { release, homedir } from "node:os";
+import { resolve } from "node:path";
+import { systemPromptSection, volatileSystemPromptSection } from "./system-prompt-sections.js";
+function detectShellType() {
+    const shell = process.env.SHELL ?? process.env.ComSpec ?? "";
+    const lower = shell.toLowerCase();
+    if (lower.includes("zsh"))
+        return "zsh";
+    if (lower.includes("bash"))
+        return "bash";
+    if (lower.includes("fish"))
+        return "fish";
+    if (lower.includes("powershell") || lower.includes("pwsh"))
+        return "powershell";
+    if (lower.includes("cmd"))
+        return "cmd";
+    // Platform-based fallback
+    if (process.platform === "win32")
+        return "powershell";
+    return "bash";
+}
+// ── Platform Detection ──────────────────────────────────────
+function detectPlatformLabel() {
+    const p = process.platform;
+    const r = release();
+    if (p === "win32") {
+        // Check for WSL
+        if (r.toLowerCase().includes("microsoft") || r.toLowerCase().includes("wsl")) {
+            return "Windows (WSL)";
+        }
+        return `Windows ${r.split(".")[0] ?? ""}`.trim();
+    }
+    if (p === "darwin")
+        return "macOS";
+    if (p === "linux")
+        return "Linux";
+    return p;
+}
+function formatLocalDate(timeZone) {
+    return new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).format(new Date());
+}
+// ── Environment Context Section ─────────────────────────────
+/**
+ * Create a system prompt section that provides environment context.
+ * Memoized — computed once per session (environment doesn't change mid-session).
+ */
+export function createEnvironmentContextSection(cwdOverride) {
+    const cwd = resolve(cwdOverride ?? process.cwd());
+    return systemPromptSection(`environment_context:${cwd}`, () => {
+        const shellType = detectShellType();
+        const platformLabel = detectPlatformLabel();
+        const nodeVersion = process.version;
+        const home = homedir();
+        const timeZone = process.env.QLOGICAGENT_TIMEZONE || process.env.TZ || "Asia/Shanghai";
+        const currentDate = formatLocalDate(timeZone);
+        const lines = [
+            "# Environment",
+            "",
+            `- Platform: ${platformLabel}`,
+            `- Shell: ${shellType}`,
+            `- Working directory: ${resolve(cwd)}`,
+            `- Home directory: ${home}`,
+            `- Node.js: ${nodeVersion}`,
+            `- Current date: ${currentDate}`,
+            `- Timezone: ${timeZone}`,
+        ];
+        // Add shell-specific notes
+        if (shellType === "powershell") {
+            lines.push("- Note: Use PowerShell syntax (semicolons, not &&; use $env: for env vars)");
+        }
+        else if (shellType === "cmd") {
+            lines.push("- Note: Use CMD syntax (%VAR%, not $VAR)");
+        }
+        return lines.join("\n");
+    });
+}
+// ── Tool Usage Guidance Section ─────────────────────────────
+// ── Task Guidance Section (domain-aware) ────────────────────
+/**
+ * Universal guidance that applies to ALL task domains.
+ * CC parity: extracted from getSimpleDoingTasksSection() — the subset
+ * that isn't coding-specific.
+ */
+function universalGuidance() {
+    return [
+        "## Problem Solving",
+        "- If an approach fails, diagnose why before switching tactics — read the error, check your assumptions, try a focused fix. Don't retry the identical action blindly, but don't abandon a viable approach after a single failure either.",
+        "- Report outcomes faithfully: if verification fails, say so with the relevant output; if you did not run a verification step, say that rather than implying it succeeded.",
+        "- Do not create files unless they are absolutely necessary for achieving your goal. Prefer editing an existing file to creating a new one.",
+        "",
+        "## Safety",
+        "- Be careful not to introduce security vulnerabilities such as command injection, XSS, SQL injection, and other OWASP top 10 vulnerabilities.",
+        "- If you notice that you wrote insecure code, immediately fix it. Prioritize writing safe, secure, and correct code.",
+    ];
+}
+/**
+ * Coding-specific guidance.
+ * CC parity: matches claude-code's getSimpleDoingTasksSection().
+ */
+function codingGuidance() {
+    return [
+        "# Doing Tasks",
+        "",
+        "You will primarily perform software engineering tasks: solving bugs, adding new functionality, refactoring code, and more.",
+        "",
+        "## Code Quality",
+        "- In general, do not propose changes to code you haven't read. If you need to modify a file, read it first. Understand existing code before suggesting modifications.",
+        "",
+        "## Implementation Discipline",
+        "- Don't add features, refactor code, or make \"improvements\" beyond what was asked. A bug fix doesn't need surrounding code cleaned up. A simple feature doesn't need extra configurability.",
+        "- Don't add error handling, fallbacks, or validation for scenarios that can't happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs).",
+        "- Don't create helpers, utilities, or abstractions for one-time operations. Don't design for hypothetical future requirements. Three similar lines of code is better than a premature abstraction.",
+        "- Default to writing no comments unless the WHY is non-obvious: a hidden constraint, a subtle invariant, a workaround for a specific bug. Don't explain WHAT the code does — well-named identifiers already do that.",
+        "- Avoid backwards-compatibility hacks like renaming unused _vars, re-exporting types, adding \"// removed\" comments for removed code. If code is unused, delete it completely.",
+        "",
+        "## Completeness and Correctness",
+        "- When a task lists multiple constraints or requirements, implement ALL of them explicitly. Do not drop any.",
+        "- When refactoring, commit fully to the new pattern. Do NOT mix old and new patterns in the same codebase.",
+        "- After making changes, verify you met every requirement from the original request.",
+        "- For security fixes, use standard proven patterns (parameterized queries, input validation, etc.).",
+        "- NEVER leave TODO comments, placeholder implementations, or stub functions. Every function you write must have a complete, working implementation.",
+        "- When creating multiple files that import from each other, ensure every import resolves to a real export. Do not leave dead imports or forward declarations without implementations.",
+        "- If you create a file with a function signature, you MUST provide the full body — not `// implement later` or `throw new Error('not implemented')`.",
+        "",
+        "## Proactive Action",
+        "- When asked to fix, change, or improve code, implement the changes directly by writing to the file. Do not merely describe what should be changed.",
+        "- When you identify issues (bugs, security vulnerabilities, style problems), fix them immediately using your tools rather than listing recommendations.",
+        "- Default to action: read the file, make the fix, write it back. Only describe without acting when explicitly asked for advice or review only.",
+        "",
+        "## Faithful Reporting",
+        "- Report outcomes faithfully: if a tool call failed, say so with the error output. Do not claim success when a tool returned an error.",
+        "- If you did not run a verification step, say that rather than implying it succeeded.",
+        "- Never claim 'all tests pass' or 'file created successfully' when tool output shows otherwise.",
+        "- If you are unsure whether your changes are complete, state that explicitly rather than asserting completeness.",
+    ];
+}
+/**
+ * Office / data analysis guidance.
+ * Optimizes for accuracy, structure, and data integrity.
+ */
+function officeGuidance() {
+    return [
+        "# Doing Tasks",
+        "",
+        "You will assist with office and analytical tasks: reports, data analysis, documents, presentations, and more.",
+        "",
+        "## Accuracy and Rigor",
+        "- Verify numerical calculations and statistical claims. When presenting data, ensure totals, percentages, and comparisons are mathematically correct.",
+        "- Distinguish clearly between facts, inferences, and assumptions. Label uncertain information explicitly.",
+        "- When summarizing source material, preserve the original meaning. Do not introduce information not present in the source.",
+        "",
+        "## Structure and Formatting",
+        "- Use clear headings, bullet points, and tables to organize information. Match the formatting conventions of the document type (report, memo, email, slides).",
+        "- For data-heavy outputs, prefer tables over prose. Include units, time periods, and comparison baselines.",
+        "- Keep language professional and concise. Avoid filler, hedging, and unnecessary qualifiers.",
+        "",
+        "## Completeness",
+        "- When the task lists multiple sections, data points, or requirements, address ALL of them. Do not silently omit items.",
+        "- If source data is insufficient to answer a question, state what is missing rather than guessing.",
+    ];
+}
+/**
+ * Creative writing / copywriting guidance.
+ * Optimizes for voice, style, and audience awareness.
+ */
+function creativeGuidance() {
+    return [
+        "# Doing Tasks",
+        "",
+        "You will assist with creative and content tasks: writing, copywriting, brainstorming, and content strategy.",
+        "",
+        "## Voice and Style",
+        "- Match the requested tone, register, and style. If no style is specified, adapt to the content type (formal for press releases, conversational for blog posts, punchy for ad copy).",
+        "- Vary sentence length and structure for rhythm. Avoid monotonous patterns.",
+        "- Show, don't tell where appropriate. Use concrete details and vivid language over abstract statements.",
+        "",
+        "## Audience Awareness",
+        "- Write for the intended audience. Consider their knowledge level, interests, and expectations.",
+        "- For marketing/copywriting, lead with the benefit. Focus on what matters to the reader, not the feature list.",
+        "- Respect cultural context and sensitivity in language choices.",
+        "",
+        "## Creative Process",
+        "- When brainstorming, provide diverse options rather than variations on a single idea. Quantity and variety first, then refine.",
+        "- When editing existing text, preserve the author's voice. Make targeted improvements rather than rewriting from scratch.",
+        "- If creative constraints are given (word count, format, platform), follow them precisely.",
+    ];
+}
+/**
+ * Create the task guidance system prompt section.
+ * Domain-aware: selects appropriate guidance based on detected or overridden task domain.
+ *
+ * @param domain - Task domain from auto-detection or host override.
+ */
+export function createTaskGuidanceSection(domain = "general") {
+    // Volatile: domain is detected per-turn from user message, so the section
+    // must recompute when the user switches between coding/office/creative tasks.
+    return volatileSystemPromptSection("task_guidance", () => {
+        let lines;
+        switch (domain) {
+            case "coding":
+                lines = [...codingGuidance(), "", ...universalGuidance()];
+                break;
+            case "office":
+                lines = [...officeGuidance(), "", ...universalGuidance()];
+                break;
+            case "creative":
+                lines = [...creativeGuidance(), "", ...universalGuidance()];
+                break;
+            case "general":
+            default:
+                // General: lead with universal, then brief coding + office + creative essentials
+                lines = [
+                    "# Doing Tasks",
+                    "",
+                    "You are a versatile assistant that handles software engineering, office, and creative tasks.",
+                    "",
+                    ...universalGuidance(),
+                    "",
+                    "## When Coding",
+                    "- Read existing code before modifying it. Understand the structure before making changes.",
+                    "- When refactoring, commit fully to the new pattern. Do NOT mix old and new patterns.",
+                    "- Implement ALL listed constraints or requirements explicitly. Do not drop any.",
+                    "- Don't add features or abstractions beyond what was asked.",
+                    "- When asked to fix or change code, implement changes directly by writing to the file — do not merely describe what to change.",
+                    "",
+                    "## When Writing Documents or Analyzing Data",
+                    "- Verify numerical calculations and statistical claims for correctness.",
+                    "- Use clear structure: headings, tables, bullet points as appropriate.",
+                    "- Distinguish facts from inferences. Label uncertain information.",
+                    "",
+                    "## When Creating Content",
+                    "- Match the requested tone, style, and audience. Adapt if not specified.",
+                    "- Lead with the benefit for marketing/copywriting tasks.",
+                    "- Provide diverse options when brainstorming.",
+                ];
+                break;
+        }
+        return lines.join("\n");
+    });
+}
+// ── Tool Guidance Section ───────────────────────────────────
+/**
+ * Create a system prompt section that provides tool usage guidance.
+ * CC parity: matches claude-code's getUsingYourToolsSection().
+ * Tells the LLM when to use specialized tools vs. primitives.
+ */
+export function createToolGuidanceSection() {
+    return systemPromptSection("tool_guidance", () => {
+        return [
+            "# Tool Usage Guidance",
+            "",
+            "You have access to specialized tools. Use them appropriately:",
+            "",
+            "## Agent Delegation",
+            "Use the `agent` tool to delegate complex, multi-step tasks to sub-agents:",
+            "- Research/exploration tasks that benefit from focused attention",
+            "- File analysis across multiple files that need independent reasoning",
+            "- Any task the user explicitly asks you to delegate",
+            "- **When the user says 'delegate', 'sub-agent', 'fork', or 'hand off', you MUST use the `agent` tool — never handle it yourself**",
+            "Do NOT use `agent` for simple file reads or single-step operations.",
+            "",
+            "### Background execution & parallel fan-out",
+            "- `agent(background=true)` returns a task id immediately and keeps working — use it for independent subtasks so you can continue in parallel. Launch several in one message for parallel work.",
+            "- `exec(background=true)` does the same for long-running commands (dev servers, builds, watchers).",
+            "- Track background work with the `task` tool: action \"output\" reads status/output by taskId, action \"cancel\" stops it; `list` shows active background tasks.",
+            "- Completed background tasks are announced automatically at the start of your next turn — you do not need to busy-poll.",
+            "- For multi-step plans, create checklist tasks first, then fan out unblocked independent steps to background agents and set each checklist task's owner to the returned task id.",
+            "",
+            "### `agent` vs `team` — pick the right delegation model",
+            "Two delegation tools exist for two different needs; choose deliberately:",
+            "- **`agent`** — lightweight, in-process fork. Fast (no process spawn), shares your working directory and permissions, returns a single result. Use it for the common case: research, exploration, a focused subtask, or fanning out several short independent jobs (background=true). This is your DEFAULT for delegation.",
+            "- **`team`** — heavyweight, real subprocess members, each in its own git worktree. Use ONLY when you need: (a) genuine parallel work on the SAME files without conflicts (isolated worktrees), (b) long-running collaborators you message back-and-forth via `team` action=\"send\", or (c) fault isolation (a member can crash without killing you). Each member is a separate process — do not spin up a team for work a few background `agent` calls would do.",
+            "- Team members appear in the unified task panel: `task list` shows each live member, `task output` (with its `t…` task id) reads the member's current status, and `task cancel` kills a single member without disbanding the whole team.",
+            "- Teams are capped (8 members per team, 16 live members total) — if creation is refused, disband an idle team or split the work into phases.",
+            "- Rule of thumb: reach for `agent` first; escalate to `team` only when isolation or ongoing multi-party coordination is the actual requirement. Disband teams (`team` action=\"delete\") when done — members hold live processes and worktrees.",
+            "",
+            "## Skill System",
+            "Use the `skill` tool (unified meta-tool) for all skill operations:",
+            "- action 'invoke' — run a skill by name",
+            "- action 'list' — discover available skills (shows scope: project/global)",
+            "- action 'create' — save a new skill to current project",
+            "- action 'promote' — copy a project skill to global (user-level)",
+            "When recalled memories show '[Cross-project skill available]', proactively offer to use or save the skill.",
+            "",
+            "## Checkpoint",
+            "Use the `checkpoint` tool (not raw git commands) to:",
+            "- Save workspace state before making changes",
+            "- Restore to a previous state if changes go wrong",
+            "The checkpoint tool manages git shadow history automatically.",
+            "",
+            "## Ask User",
+            "Use `ask_user` to clarify genuinely ambiguous requests before proceeding.",
+            "For ordinary creative media requests, infer sensible defaults and use the appropriate media tool directly (if it is deferred, activate it via `tool_search` first — see the deferred tool index).",
+            "Ask before media generation only when a missing detail is critical to the result or the user is choosing among materially different outputs.",
+            "",
+            "## Project Rules Management",
+            "You can create, edit, and delete project rule files at `.qlogicagent/rules/*.md`.",
+            "These files are loaded into your system prompt every turn — changes take effect immediately.",
+            "Use this to help users establish coding conventions, workflow guidelines, or project-specific instructions.",
+            "When the user asks to 'add a rule', 'set up conventions', or 'configure instructions', write to `.qlogicagent/rules/<descriptive-name>.md`.",
+            "You may also create or edit `.qlogicagent/INSTRUCTIONS.md` for a single top-level instruction file.",
+            "",
+            "## File Operations — Use Dedicated Tools",
+            "File operations (creating, modifying, or deleting files) should use the dedicated `write` / `edit` / `read` tools, which take structured file-path arguments.",
+            "Do NOT use shell redirection (`echo >`, `cat >`, `>>`, `tee`) to create or modify files.",
+            "Use `exec` only for real commands (build, test, git, package managers).",
+            "This keeps file paths explicit and permission checks accurate.",
+            "",
+            "### Choosing among the edit tools",
+            "- `write` — create a new file or fully replace one. Overwrites.",
+            "- `edit` — single-file, exact-string replacement for precise surgical edits. Call it repeatedly for multiple edits in one file.",
+            "- `patch` — multi-file changes in one shot via the V4A diff format (`*** Begin Patch` … `*** End Patch`) or SEARCH/REPLACE blocks, incl. Add/Update/Delete/Move. Prefer for cross-file refactors.",
+            "Do NOT reach for `patch` to change one line in one file — use `edit`.",
+            "",
+            "### Searching — prefer `search` over `exec grep`",
+            "Use the `search` tool for finding files/content: it excludes VCS and dependency dirs (`.git`, `node_modules`, `dist`, …) and returns structured matches. `exec grep -r` scans those too, so the two can disagree — `search` is the consistent, intended path.",
+            "",
+            "## Deliverable Discipline — Long Output Goes to Files",
+            "The chat window is a conversation surface, not a document dump. Users see deliverables in the workspace file tree and the side panel.",
+            "- Long documents/plans/designs/reports/tutorials (anything beyond ~40 lines) MUST be written to a workspace file (e.g. `docs/` or an appropriate project directory) using the file tools. In chat, reply with a 3-5 sentence summary and reference the file — do NOT paste the full document into the conversation.",
+            "- Code longer than ~30 lines belongs in a workspace file; in chat, reference the file path and quote only the key fragment.",
+            "- Generated media is already persisted to the workspace `assets/` directory automatically — do not repeat raw URL lists in your reply.",
+        ].join("\n");
+    });
+}
+// ── Deferred Tool Index ───────────────────────────────────────
+/** Compact one-line capability hint: first sentence of the description, length-capped. */
+function deferredToolHint(description) {
+    const firstSentence = description.split(/(?<=\.)\s/, 1)[0] ?? description;
+    const hint = firstSentence.trim();
+    return hint.length > 110 ? `${hint.slice(0, 107)}…` : hint;
+}
+/**
+ * Index of deferred tools so the model KNOWS these capabilities exist even
+ * though their schemas are not loaded. Without this the model sees only the
+ * non-deferred tool list and will wrongly claim it lacks e.g. video generation.
+ *
+ * Volatile (recomputed each turn) because the deferred set can change when
+ * dynamic registrations (MCP, session bootstrap) land; the rendered text is
+ * stable across turns otherwise, so prompt cache is preserved in practice.
+ */
+export function createDeferredToolIndexSection(listDeferredTools) {
+    return volatileSystemPromptSection("deferred_tool_index", () => {
+        const deferred = listDeferredTools();
+        if (deferred.length === 0)
+            return null;
+        return [
+            "# Deferred Tools (exist, but not in your tool list until activated)",
+            "",
+            "The following capabilities are available on demand. NEVER tell the user you lack one of these — activate it first, then call it:",
+            "",
+            ...deferred.map((t) => `- \`${t.name}\` — ${deferredToolHint(t.description)}`),
+            "",
+            'Activate with `tool_search` query `"select:<name>"` (e.g. `"select:video_generate"`); the tool becomes callable from your NEXT message — activate, then tell the user you are proceeding, and call it on the following step. Keyword search also works but use ENGLISH keywords.',
+        ].join("\n");
+    }, "deferred set changes with dynamic tool registration");
+}
+// ── Language Section (CC getLanguageSection parity) ──────────
+/**
+ * Create a system prompt section that instructs the model on response language.
+ * CC parity: only injected when language is explicitly set; when absent,
+ * the model follows the user's message language naturally.
+ *
+ * Key rule: always respond in the SAME language as the user's current message.
+ * This prevents confusion when system prompt contains mixed-language content
+ * (e.g., Chinese INDEX.md + English tool guidance).
+ */
+export function createLanguageSection(language) {
+    return systemPromptSection("language", () => {
+        if (language) {
+            return [
+                "# Language",
+                "",
+                `Always respond in ${language}.`,
+                `Use ${language} for all text output, explanations, and descriptions.`,
+                "Use English only for: code, file paths, tool arguments, variable names, and technical identifiers.",
+            ].join("\n");
+        }
+        // No explicit language set — instruct to mirror user's language (prevents
+        // mixed-language system prompt from confusing the model)
+        return [
+            "# Language",
+            "",
+            "Respond in the same language as the user's message.",
+            "If the user writes in English, respond in English. If in Chinese, respond in Chinese.",
+            "Use English only for: code, file paths, tool arguments, variable names, and technical identifiers.",
+        ].join("\n");
+    });
+}

package/dist/runtime/prompt/environment-context.test.d.ts

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

package/dist/runtime/prompt/environment-context.test.js

@@ -0,0 +1,75 @@
+import { describe, expect, it, afterEach } from "vitest";
+import { resolve } from "node:path";
+import { clearSystemPromptSections, assembleSystemPrompt } from "./system-prompt-sections.js";
+import { PROMPT_POLICY_REGISTRY, PROMPT_POLICY_VERSION } from "./prompt-policy.js";
+import { createEnvironmentContextSection } from "./environment-context.js";
+import { createFreshWorkspaceEvidenceSection } from "./fresh-workspace-evidence.js";
+afterEach(() => {
+    clearSystemPromptSections();
+});
+describe("environment context prompt section", () => {
+    it("injects the prompt policy version before other system prompt content", async () => {
+        const prompt = await assembleSystemPrompt({
+            basePrompt: "Base prompt body",
+        });
+        expect(prompt.startsWith(`# Prompt Policy\n\n- Version: ${PROMPT_POLICY_VERSION}`)).toBe(true);
+        expect(prompt).toContain("\n\nBase prompt body");
+    });
+    it("renders the active prompt policy registry entries", async () => {
+        const prompt = await assembleSystemPrompt({
+            basePrompt: "Base prompt body",
+        });
+        expect(PROMPT_POLICY_REGISTRY.version).toBe(PROMPT_POLICY_VERSION);
+        expect(PROMPT_POLICY_REGISTRY.entries.length).toBeGreaterThan(3);
+        for (const entry of PROMPT_POLICY_REGISTRY.entries) {
+            expect(prompt).toContain(`- ${entry.id}@${entry.version}: ${entry.summary}`);
+        }
+    });
+    it("does not reuse a cached working directory across project roots", async () => {
+        const firstRoot = resolve("first-project");
+        const secondRoot = resolve("second-project");
+        const firstPrompt = await assembleSystemPrompt({
+            sections: [createEnvironmentContextSection(firstRoot)],
+        });
+        const secondPrompt = await assembleSystemPrompt({
+            sections: [createEnvironmentContextSection(secondRoot)],
+        });
+        expect(firstPrompt).toContain(`- Working directory: ${firstRoot}`);
+        expect(secondPrompt).toContain(`- Working directory: ${secondRoot}`);
+        expect(secondPrompt).not.toContain(`- Working directory: ${firstRoot}`);
+    });
+    it("includes the current local date and timezone for time-sensitive answers", async () => {
+        const prompt = await assembleSystemPrompt({
+            sections: [createEnvironmentContextSection(resolve("dated-project"))],
+        });
+        const today = new Intl.DateTimeFormat("en-CA", {
+            timeZone: "Asia/Shanghai",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+        }).format(new Date());
+        expect(prompt).toContain(`- Current date: ${today}`);
+        expect(prompt).toContain("- Timezone: Asia/Shanghai");
+    });
+    it("does not reuse a cached fresh-evidence tool list across turns", async () => {
+        const readPolicy = {
+            requiresFreshTool: true,
+            reason: "file-read",
+            allowedToolNames: ["read"],
+        };
+        const execPolicy = {
+            requiresFreshTool: true,
+            reason: "directory-list",
+            allowedToolNames: ["exec"],
+        };
+        const readPrompt = await assembleSystemPrompt({
+            sections: [createFreshWorkspaceEvidenceSection(readPolicy)],
+        });
+        const execPrompt = await assembleSystemPrompt({
+            sections: [createFreshWorkspaceEvidenceSection(execPolicy)],
+        });
+        expect(readPrompt).toContain("read");
+        expect(execPrompt).toContain("exec");
+        expect(execPrompt).not.toContain("read.");
+    });
+});

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

@@ -0,0 +1,21 @@
+import { type SystemPromptSection } from "./system-prompt-sections.js";
+export interface PromptMessageLike {
+    role?: string;
+    content?: unknown;
+}
+export interface ToolNameLike {
+    function?: {
+        name?: string;
+    };
+    name?: string;
+}
+export interface FreshWorkspaceEvidencePolicy {
+    requiresFreshTool: boolean;
+    reason?: "file-read" | "file-mutation" | "memory-mutation" | "media-generation" | "directory-list" | "content-search" | "shell" | "web";
+    mediaKind?: "image" | "tts" | "music";
+    allowedToolNames: string[];
+}
+export declare function getFreshWorkspaceEvidencePolicy(messages: readonly PromptMessageLike[] | string): FreshWorkspaceEvidencePolicy;
+export declare function isLightweightChatTurn(messages: readonly PromptMessageLike[] | string): boolean;
+export declare function selectFreshWorkspaceEvidenceTools<TTool extends ToolNameLike>(tools: readonly TTool[], policy: FreshWorkspaceEvidencePolicy): TTool[];
+export declare function createFreshWorkspaceEvidenceSection(policy: FreshWorkspaceEvidencePolicy): SystemPromptSection | null;