qlogicagent 2.13.5 → 2.13.7

package/dist/runtime/prompt/instruction-loader.js

@@ -1,515 +0,0 @@
-/**
- * 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 { readFile, readdir, stat } from "node:fs/promises";
-import { dirname, extname, isAbsolute, join, parse, resolve } from "node:path";
-import { homedir } from "node:os";
-import { getDefaultPathService } from "../../runtime/infra/default-path-service.js";
-import { MAX_INCLUDE_DEPTH } from "../config/tunable-defaults.js";
-// ── Constants ───────────────────────────────────────────────────────────────
-/** Instruction file names (CC parity: CLAUDE.md → INSTRUCTIONS.md / AGENTS.md) */
-const PROJECT_FILENAME = "INSTRUCTIONS.md";
-const LOCAL_FILENAME = "INSTRUCTIONS.local.md";
-/**
- * Text file extensions allowed for @include directives.
- * Prevents binary files from being loaded into instructions.
- * CC parity: same set from claudemd.ts TEXT_FILE_EXTENSIONS.
- */
-const TEXT_FILE_EXTENSIONS = new Set([
-    // Markdown and text
-    ".md", ".txt", ".text",
-    // Data formats
-    ".json", ".yaml", ".yml", ".toml", ".xml", ".csv",
-    // Web
-    ".html", ".htm", ".css", ".scss", ".sass", ".less",
-    // JavaScript/TypeScript
-    ".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs", ".mts", ".cts",
-    // Python
-    ".py", ".pyi", ".pyw",
-    // Ruby
-    ".rb", ".erb", ".rake",
-    // Go
-    ".go",
-    // Rust
-    ".rs",
-    // Java/Kotlin/Scala
-    ".java", ".kt", ".kts", ".scala",
-    // C/C++
-    ".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".hxx",
-    // C#
-    ".cs",
-    // Swift
-    ".swift",
-    // Shell
-    ".sh", ".bash", ".zsh", ".fish", ".ps1", ".bat", ".cmd",
-    // Config
-    ".env", ".ini", ".cfg", ".conf", ".config", ".properties",
-    // Database
-    ".sql", ".graphql", ".gql",
-    // Protocol
-    ".proto",
-    // Frontend frameworks
-    ".vue", ".svelte", ".astro",
-    // Other languages
-    ".php", ".pl", ".pm", ".lua", ".r", ".R", ".dart",
-    ".ex", ".exs", ".erl", ".hrl",
-    ".clj", ".cljs", ".cljc", ".edn",
-    ".hs", ".lhs", ".elm",
-    ".ml", ".mli",
-    ".f", ".f90", ".f95", ".for",
-    // Build files
-    ".cmake", ".make", ".makefile", ".gradle", ".sbt",
-    // Documentation
-    ".rst", ".adoc", ".asciidoc", ".org", ".tex", ".latex",
-    // Lock files
-    ".lock",
-    // Misc
-    ".log", ".diff", ".patch",
-]);
-// ── Core Functions ─────────────────────────────────────────
-/**
- * Safely read a file, returning null on any error (ENOENT, EACCES, etc.)
- */
-async function safeReadFile(filePath) {
-    try {
-        return await readFile(filePath, "utf-8");
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Strip block-level HTML comments from markdown content.
- * CC parity: uses simple regex approach (no marked dependency).
- * Preserves comments inside code blocks/spans.
- */
-function stripHtmlComments(content) {
-    if (!content.includes("<!--"))
-        return content;
-    // Strip block-level comments (own line). Simple version — doesn't
-    // handle comments inside fenced code blocks, but sufficient for
-    // instruction files which rarely have code blocks with HTML comments.
-    return content.replace(/^[ \t]*<!--[\s\S]*?-->[ \t]*$/gm, "");
-}
-/**
- * Parse frontmatter for glob patterns.
- * Format: YAML frontmatter with `paths` field.
- *
- * ```
- *-
- * paths: ["src/**", "lib/**"]
- *-
- * ```
- */
-function parseFrontmatter(content) {
-    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-    if (!match)
-        return { content };
-    const frontmatter = match[1];
-    const body = content.slice(match[0].length);
-    // Extract paths from YAML (simple parser — handles array and string)
-    const pathsMatch = frontmatter.match(/^paths:\s*(.+)$/m);
-    if (!pathsMatch)
-        return { content: body };
-    let paths = [];
-    const rawPaths = pathsMatch[1].trim();
-    // JSON array format: ["src/**", "lib/**"]
-    if (rawPaths.startsWith("[")) {
-        try {
-            paths = JSON.parse(rawPaths);
-        }
-        catch { /* ignore */ }
-    }
-    else {
-        // Single path or comma-separated
-        paths = rawPaths.split(",").map(p => p.trim()).filter(Boolean);
-    }
-    // Filter out match-all patterns
-    const effective = paths
-        .map(p => p.endsWith("/**") ? p.slice(0, -3) : p)
-        .filter(p => p.length > 0 && p !== "**");
-    return {
-        content: body,
-        globs: effective.length > 0 ? effective : undefined,
-    };
-}
-/**
- * Extract @include paths from text content.
- * CC parity: @path, @./path, @~/path, @/path
- * Skips code blocks and inline code.
- */
-function extractIncludePaths(content, basePath) {
-    const paths = new Set();
-    const includeRegex = /(?:^|\s)@((?:[^\s\\]|\\ )+)/g;
-    // Remove code blocks first to avoid extracting from code
-    const noCodeBlocks = content.replace(/```[\s\S]*?```/g, "");
-    const noInlineCode = noCodeBlocks.replace(/`[^`]+`/g, "");
-    let match;
-    while ((match = includeRegex.exec(noInlineCode)) !== null) {
-        let path = match[1];
-        if (!path)
-            continue;
-        // Strip fragment identifiers
-        const hashIndex = path.indexOf("#");
-        if (hashIndex !== -1)
-            path = path.substring(0, hashIndex);
-        if (!path)
-            continue;
-        // Unescape spaces
-        path = path.replace(/\\ /g, " ");
-        // Resolve path.
-        // SECURITY BOUNDARY: @~/ and absolute paths are intentional CC-parity features.
-        // Users writing INSTRUCTIONS.md control what gets included — this is by-design.
-        // The file is already restricted to TEXT_FILE_EXTENSIONS and size-limited by
-        // processInstructionFile(). Sensitive files (.env, keys) should NOT be listed
-        // in INSTRUCTIONS.md by users, but we do not enforce an ACL here.
-        let resolvedPath;
-        if (path.startsWith("~/")) {
-            resolvedPath = join(homedir(), path.slice(2));
-        }
-        else if (isAbsolute(path)) {
-            resolvedPath = path;
-        }
-        else if (path.startsWith("./")) {
-            resolvedPath = resolve(dirname(basePath), path);
-        }
-        else if (/^[a-zA-Z0-9._-]/.test(path) && !path.startsWith("@")) {
-            resolvedPath = resolve(dirname(basePath), path);
-        }
-        else {
-            continue;
-        }
-        paths.add(resolvedPath);
-    }
-    return [...paths];
-}
-/**
- * Process a single instruction file and its @includes recursively.
- * CC parity: processMemoryFile()
- */
-async function processInstructionFile(filePath, type, processedPaths, depth = 0, parent) {
-    const normalizedPath = filePath.toLowerCase();
-    if (processedPaths.has(normalizedPath) || depth >= MAX_INCLUDE_DEPTH) {
-        return [];
-    }
-    // Skip non-text files
-    const ext = extname(filePath).toLowerCase();
-    if (ext && !TEXT_FILE_EXTENSIONS.has(ext))
-        return [];
-    processedPaths.add(normalizedPath);
-    const rawContent = await safeReadFile(filePath);
-    if (!rawContent?.trim())
-        return [];
-    // Parse frontmatter
-    const { content: withoutFrontmatter, globs } = parseFrontmatter(rawContent);
-    // Strip HTML comments
-    const content = stripHtmlComments(withoutFrontmatter);
-    if (!content.trim())
-        return [];
-    const result = [];
-    // Add the main file
-    const info = { path: filePath, type, content: content.trim() };
-    if (parent)
-        info.parent = parent;
-    if (globs)
-        info.globs = globs;
-    result.push(info);
-    // Process @includes
-    const includePaths = extractIncludePaths(withoutFrontmatter, filePath);
-    for (const includePath of includePaths) {
-        const included = await processInstructionFile(includePath, type, processedPaths, depth + 1, filePath);
-        result.push(...included);
-    }
-    return result;
-}
-/**
- * Process all .md files in a rules directory (recursive).
- * CC parity: processMdRules()
- */
-async function processRulesDirectory(rulesDir, type, processedPaths, conditionalOnly, visitedDirs = new Set()) {
-    if (visitedDirs.has(rulesDir))
-        return [];
-    visitedDirs.add(rulesDir);
-    const result = [];
-    try {
-        const entries = await readdir(rulesDir, { withFileTypes: true });
-        for (const entry of entries) {
-            const entryPath = join(rulesDir, entry.name);
-            if (entry.isDirectory()) {
-                result.push(...await processRulesDirectory(entryPath, type, processedPaths, conditionalOnly, visitedDirs));
-            }
-            else if (entry.isFile() && entry.name.endsWith(".md")) {
-                const files = await processInstructionFile(entryPath, type, processedPaths);
-                result.push(...files.filter(f => conditionalOnly ? !!f.globs : !f.globs));
-            }
-        }
-    }
-    catch {
-        // Directory doesn't exist or permission denied — skip silently
-    }
-    return result;
-}
-/**
- * Find the git root by walking up from a directory.
- */
-async function findGitRoot(startDir) {
-    let dir = startDir;
-    const root = parse(dir).root;
-    while (dir !== root) {
-        try {
-            const gitDir = join(dir, ".git");
-            const s = await stat(gitDir);
-            if (s.isDirectory() || s.isFile())
-                return dir;
-        }
-        catch { /* continue */ }
-        dir = dirname(dir);
-    }
-    return null;
-}
-// ── Main Loader ────────────────────────────────────────────
-/**
- * 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 async function loadInstructions(cwd, hooks) {
-    const result = [];
-    const processedPaths = new Set();
-    // Project instructions — walkup from cwd to git root (or filesystem root)
-    const gitRoot = await findGitRoot(cwd);
-    const stopAt = gitRoot ?? parse(cwd).root;
-    const dirs = [];
-    let current = cwd;
-    while (true) {
-        dirs.push(current);
-        if (current === stopAt && current !== cwd)
-            break;
-        const parent = dirname(current);
-        if (parent === current)
-            break; // filesystem root
-        current = parent;
-    }
-    // Process from root downward to CWD (closer = higher priority = loaded later)
-    for (const dir of dirs.reverse()) {
-        // INSTRUCTIONS.md
-        result.push(...await processInstructionFile(join(dir, PROJECT_FILENAME), "Project", processedPaths));
-        // .qlogicagent/INSTRUCTIONS.md
-        result.push(...await processInstructionFile(getDefaultPathService().getProjectInstructionsPath(dir), "Project", processedPaths));
-        // .qlogicagent/rules/*.md (unconditional only)
-        result.push(...await processRulesDirectory(getDefaultPathService().getProjectRulesDir(dir), "Project", processedPaths, false));
-        // INSTRUCTIONS.local.md
-        result.push(...await processInstructionFile(join(dir, LOCAL_FILENAME), "Local", processedPaths));
-    }
-    // Fire hook
-    if (hooks && result.length > 0) {
-        hooks.invoke("instructions.loaded", {
-            sessionId: "",
-            source: cwd,
-            fileCount: result.length,
-        }).catch(() => { });
-    }
-    return result;
-}
-/**
- * Build the instructions prompt string from loaded files.
- * CC parity: getClaudeMds()
- */
-export function buildInstructionsPrompt(files) {
-    if (files.length === 0)
-        return "";
-    const INSTRUCTION_PROMPT = "Codebase and user instructions are shown below. " +
-        "Be sure to adhere to these instructions. " +
-        "IMPORTANT: These instructions OVERRIDE any default behavior " +
-        "and you MUST follow them exactly as written.";
-    const sections = [];
-    const literalRequirements = extractLiteralResponseRequirements(files);
-    if (literalRequirements.length > 0) {
-        sections.push([
-            "## Active literal response requirements",
-            "The current instruction files contain hard requirements for exact response markers.",
-            "When responding, reproduce these literals exactly and do not omit them for brevity:",
-            ...literalRequirements.map((req) => `- ${req.placement}: "${req.marker}"`),
-        ].join("\n"));
-    }
-    for (const file of files) {
-        if (!file.content)
-            continue;
-        const desc = file.type === "Project"
-            ? " (project instructions, checked into the codebase)"
-            : file.type === "Local"
-                ? " (user's private project instructions, not checked in)"
-                : " (user's private global instructions for all projects)";
-        sections.push(`Contents of ${file.path}${desc}:\n\n${file.content.trim()}`);
-    }
-    return sections.length > 0
-        ? `${INSTRUCTION_PROMPT}\n\n${sections.join("\n\n")}`
-        : "";
-}
-export function extractLiteralResponseRequirements(files) {
-    const requirements = new Map();
-    for (const file of files) {
-        const content = file.content;
-        const quoted = /["'“”‘’]([^"'“”‘’\r\n]{2,100})["'“”‘’]/g;
-        let match;
-        while ((match = quoted.exec(content)) !== null) {
-            const marker = match[1]?.trim();
-            if (!marker || !looksLikeLiteralMarker(marker))
-                continue;
-            const context = getLocalRequirementContext(content, match.index, quoted.lastIndex);
-            if (looksLikeEveryResponseRequirement(context)) {
-                requirements.set(marker, {
-                    marker,
-                    placement: inferLiteralRequirementPlacement(context),
-                });
-            }
-        }
-    }
-    return [...requirements.values()];
-}
-function getLocalRequirementContext(content, markerStart, markerEnd) {
-    const starts = ["\n", ".", "。", ";", "；"].map((token) => content.lastIndexOf(token, markerStart));
-    const start = Math.max(-1, ...starts) + 1;
-    const endCandidates = ["\n", ".", "。", ";", "；"]
-        .map((token) => content.indexOf(token, markerEnd))
-        .filter((index) => index >= 0);
-    const end = endCandidates.length > 0 ? Math.min(...endCandidates) : content.length;
-    return content.slice(start, end);
-}
-export function applyLiteralResponseRequirements(content, requirements) {
-    let next = content;
-    for (const requirement of requirements) {
-        if (!canAutoEnforceLiteral(requirement.marker))
-            continue;
-        if (next.includes(requirement.marker))
-            continue;
-        if (requirement.placement === "prefix") {
-            next = next.trim().length > 0 ? `${requirement.marker} ${next}` : requirement.marker;
-        }
-        else {
-            next = next.trim().length > 0 ? `${next.trimEnd()}\n${requirement.marker}` : requirement.marker;
-        }
-    }
-    return next;
-}
-function looksLikeEveryResponseRequirement(context) {
-    const normalized = context.toLowerCase();
-    const universal = normalized.includes("every response") ||
-        normalized.includes("all responses") ||
-        normalized.includes("always") ||
-        context.includes("所有回复") ||
-        context.includes("每次回复") ||
-        context.includes("每个回复") ||
-        context.includes("永远");
-    if (!universal)
-        return false;
-    return normalized.includes("must") ||
-        normalized.includes("required") ||
-        normalized.includes("exact") ||
-        context.includes("必须") ||
-        context.includes("务必") ||
-        context.includes("硬性要求");
-}
-function inferLiteralRequirementPlacement(context) {
-    const normalized = context.toLowerCase();
-    const prefixScore = maxKeywordIndex(normalized, ["start with", "begin with"]) +
-        maxKeywordIndex(context, ["开头", "必须以"]);
-    const suffixScore = maxKeywordIndex(normalized, ["end with", "append", "at the end"]) +
-        maxKeywordIndex(context, ["末尾", "结尾", "结束标记"]);
-    if (prefixScore >= 0 || suffixScore >= 0) {
-        return prefixScore > suffixScore ? "prefix" : "suffix";
-    }
-    return "include";
-}
-function maxKeywordIndex(value, keywords) {
-    let max = -1;
-    for (const keyword of keywords) {
-        const index = value.lastIndexOf(keyword);
-        if (index > max)
-            max = index;
-    }
-    return max;
-}
-function looksLikeLiteralMarker(value) {
-    const marker = value.trim();
-    if (marker.length < 2 || marker.length > 100)
-        return false;
-    if (/https?:\/\//i.test(marker))
-        return false;
-    return /[A-Z0-9_\-[\]—-]/.test(marker);
-}
-function canAutoEnforceLiteral(value) {
-    return /[A-Z\[\]—-]/.test(value);
-}
-/**
- * Get conditional rules that match a target file path.
- * CC parity: getManagedAndUserConditionalRules() + getMemoryFilesForNestedDirectory()
- */
-export async function getConditionalRules(cwd, targetPath) {
-    const processedPaths = new Set();
-    const result = [];
-    // Project conditional rules — walkup
-    const gitRoot = await findGitRoot(cwd);
-    const stopAt = gitRoot ?? parse(cwd).root;
-    let current = cwd;
-    while (true) {
-        const rulesDir = getDefaultPathService().getProjectRulesDir(current);
-        result.push(...await processRulesDirectory(rulesDir, "Project", processedPaths, true));
-        if (current === stopAt)
-            break;
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    // Filter by glob match — simple startsWith check (no picomatch dependency)
-    const normalizedTarget = targetPath.replace(/\\/g, "/");
-    return result.filter(file => {
-        if (!file.globs)
-            return false;
-        return file.globs.some(glob => {
-            const normalizedGlob = glob.replace(/\\/g, "/");
-            // Simple prefix match for directory-based patterns
-            return normalizedTarget.startsWith(normalizedGlob) ||
-                normalizedTarget.includes(`/${normalizedGlob}/`) ||
-                normalizedTarget.endsWith(`/${normalizedGlob}`);
-        });
-    });
-}
-// ── Cache ──────────────────────────────────────────────────
-/**
- * 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 async function getInstructions(cwd, hooks) {
-    return loadInstructions(cwd, hooks);
-}
-/** Clear the instruction cache. Called after file changes or compaction. */
-export function resetInstructionCache() { }

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

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

package/dist/runtime/prompt/instruction-loader.test.js

@@ -1,64 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { applyLiteralResponseRequirements, buildInstructionsPrompt, extractLiteralResponseRequirements, getInstructions, loadInstructions, } from "./instruction-loader.js";
-const roots = [];
-function makeProjectRoot() {
-    const root = mkdtempSync(join(tmpdir(), "qlogicagent-instruction-loader-"));
-    roots.push(root);
-    return root;
-}
-afterEach(() => {
-    for (const root of roots.splice(0)) {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-describe("instruction loader", () => {
-    it("ignores legacy .qlogicagent/instructions markdown files", async () => {
-        const projectRoot = makeProjectRoot();
-        const dir = join(projectRoot, ".qlogicagent", "instructions");
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(join(dir, "architecture.md"), "# Architecture\nUNIQUE_MARKER_ALPHA_789", "utf8");
-        const files = await loadInstructions(projectRoot);
-        const prompt = buildInstructionsPrompt(files);
-        expect(files.map((file) => file.path)).not.toContain(join(dir, "architecture.md"));
-        expect(prompt).not.toContain("architecture.md");
-        expect(prompt).not.toContain("UNIQUE_MARKER_ALPHA_789");
-    });
-    it("ignores legacy .instructions.md project files", async () => {
-        const projectRoot = makeProjectRoot();
-        writeFileSync(join(projectRoot, ".instructions.md"), "# Legacy\nUNIQUE_MARKER_BETA_456", "utf8");
-        const prompt = buildInstructionsPrompt(await loadInstructions(projectRoot));
-        expect(prompt).not.toContain(".instructions.md");
-        expect(prompt).not.toContain("UNIQUE_MARKER_BETA_456");
-    });
-    it("reloads instructions on each call so hot changes take effect next turn", async () => {
-        const projectRoot = makeProjectRoot();
-        const instructionsPath = join(projectRoot, "INSTRUCTIONS.md");
-        const before = buildInstructionsPrompt(await getInstructions(projectRoot));
-        expect(before).not.toContain("HOT_RELOAD_MARKER_456");
-        writeFileSync(instructionsPath, "# Hot Reload\nHOT_RELOAD_MARKER_456", "utf8");
-        const files = await getInstructions(projectRoot);
-        const prompt = buildInstructionsPrompt(files);
-        expect(prompt).toContain("HOT_RELOAD_MARKER_456");
-    });
-    it("summarizes exact literal markers that must appear in every response", async () => {
-        const projectRoot = makeProjectRoot();
-        writeFileSync(join(projectRoot, "INSTRUCTIONS.md"), '# Language Rule\n\nAll responses must end with the exact marker "END_MARKER".', "utf8");
-        const prompt = buildInstructionsPrompt(await getInstructions(projectRoot));
-        expect(prompt).toContain("Active literal response requirements");
-        expect(prompt).toContain('"END_MARKER"');
-    });
-    it("can enforce exact prefix and suffix markers from active instructions", async () => {
-        const projectRoot = makeProjectRoot();
-        writeFileSync(join(projectRoot, "INSTRUCTIONS.md"), [
-            'All responses must start with the exact marker "[VERIFIED]".',
-            'All responses must end with the exact marker "END_MARKER".',
-        ].join("\n"), "utf8");
-        const requirements = extractLiteralResponseRequirements(await getInstructions(projectRoot));
-        const content = applyLiteralResponseRequirements("hello", requirements);
-        expect(content.startsWith("[VERIFIED]")).toBe(true);
-        expect(content.endsWith("END_MARKER")).toBe(true);
-    });
-});

package/dist/runtime/prompt/prompt-policy.d.ts

@@ -1,12 +0,0 @@
-export declare const PROMPT_POLICY_VERSION = 1;
-export interface PromptPolicyRegistryEntry {
-    id: string;
-    version: number;
-    summary: string;
-}
-export interface PromptPolicyRegistry {
-    version: number;
-    entries: readonly PromptPolicyRegistryEntry[];
-}
-export declare const PROMPT_POLICY_REGISTRY: PromptPolicyRegistry;
-export declare function createPromptPolicyHeader(registry?: PromptPolicyRegistry): string;

package/dist/runtime/prompt/prompt-policy.js

@@ -1,40 +0,0 @@
-export const PROMPT_POLICY_VERSION = 1;
-export const PROMPT_POLICY_REGISTRY = {
-    version: PROMPT_POLICY_VERSION,
-    entries: [
-        {
-            id: "system-prompt-assembly",
-            version: 1,
-            summary: "assemble policy header, instructions, base prompt, dynamic sections, and append text in stable order",
-        },
-        {
-            id: "instruction-loading",
-            version: 1,
-            summary: "load user/project/local INSTRUCTIONS.md and .qlogicagent/rules with includes and conditional paths",
-        },
-        {
-            id: "environment-context",
-            version: 1,
-            summary: "inject platform, shell, cwd, date, timezone, and task guidance context",
-        },
-        {
-            id: "fresh-workspace-evidence",
-            version: 1,
-            summary: "require fresh file, shell, web, memory, or media tools for state-sensitive requests",
-        },
-        {
-            id: "deferred-tool-index",
-            version: 1,
-            summary: "advertise deferred capabilities so the agent activates available tools before declining",
-        },
-    ],
-};
-export function createPromptPolicyHeader(registry = PROMPT_POLICY_REGISTRY) {
-    return [
-        "# Prompt Policy",
-        "",
-        `- Version: ${registry.version}`,
-        "- Registry:",
-        ...registry.entries.map((entry) => `  - ${entry.id}@${entry.version}: ${entry.summary}`),
-    ].join("\n");
-}