qlogicagent 2.13.3 → 2.13.5

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

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

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

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

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

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

@@ -0,0 +1,40 @@
+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");
+}