qlogicagent 2.13.5 → 2.13.7

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

@@ -1,60 +0,0 @@
-/**
- * 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

@@ -1,410 +0,0 @@
-/**
- * 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

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

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

@@ -1,75 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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;