@renseiai/agentfactory 0.8.0

package/dist/src/templates/loader.js

@@ -0,0 +1,114 @@
+/**
+ * Template Loader
+ *
+ * Discovers, parses, and validates workflow templates from YAML files.
+ * Supports layered resolution:
+ *   1. Built-in defaults (packages/core/src/templates/defaults/)
+ *   2. Project-level overrides (.agentfactory/templates/ in repo root)
+ *   3. Inline config overrides (programmatic)
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { validateWorkflowTemplate, validatePartialTemplate } from './types.js';
+/**
+ * Load all workflow templates from a directory.
+ * Only processes .yaml and .yml files at the top level.
+ *
+ * The map key is determined by `metadata.name` when it differs from `metadata.workType`,
+ * enabling strategy-specific compound keys like "refinement-context-enriched".
+ * When `metadata.name` equals `metadata.workType`, the key is simply the work type.
+ */
+export function loadTemplatesFromDir(dir) {
+    const templates = new Map();
+    if (!fs.existsSync(dir)) {
+        return templates;
+    }
+    const files = fs.readdirSync(dir).filter(f => (f.endsWith('.yaml') || f.endsWith('.yml')) && !f.startsWith('_'));
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const template = loadTemplateFile(filePath);
+        if (template) {
+            // Use metadata.name as the key when it differs from workType (strategy templates),
+            // otherwise fall back to workType for backward compatibility.
+            const key = template.metadata.name !== template.metadata.workType
+                ? template.metadata.name
+                : template.metadata.workType;
+            templates.set(key, template);
+        }
+    }
+    return templates;
+}
+/**
+ * Load and validate a single workflow template YAML file.
+ */
+export function loadTemplateFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const data = parseYaml(content);
+        return validateWorkflowTemplate(data, filePath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load template ${filePath}: ${message}`);
+    }
+}
+/**
+ * Load all partial templates from a directory (including subdirectories).
+ * Returns a map of partial name → content string.
+ *
+ * Partial names are derived from file paths relative to the partials directory:
+ *   partials/cli-instructions.yaml → "cli-instructions"
+ *   partials/frontend/linear-cli.yaml → "frontend/linear-cli"
+ */
+export function loadPartialsFromDir(dir, frontend) {
+    const partials = new Map();
+    if (!fs.existsSync(dir)) {
+        return partials;
+    }
+    loadPartialsRecursive(dir, dir, partials, frontend);
+    return partials;
+}
+function loadPartialsRecursive(baseDir, currentDir, partials, frontend) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            loadPartialsRecursive(baseDir, fullPath, partials, frontend);
+            continue;
+        }
+        if (!entry.name.endsWith('.yaml') && !entry.name.endsWith('.yml')) {
+            continue;
+        }
+        try {
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            const data = parseYaml(content);
+            const partial = validatePartialTemplate(data, fullPath);
+            // Skip frontend-specific partials that don't match the current frontend
+            if (partial.metadata.frontend && frontend && partial.metadata.frontend !== frontend) {
+                continue;
+            }
+            // Derive partial name from relative path (without extension)
+            const relativePath = path.relative(baseDir, fullPath);
+            const name = relativePath.replace(/\.(yaml|yml)$/, '').replace(/\\/g, '/');
+            partials.set(name, partial.content);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load partial ${fullPath}: ${message}`);
+        }
+    }
+}
+/**
+ * Get the path to the built-in default templates directory.
+ */
+export function getBuiltinDefaultsDir() {
+    // Resolve relative to this file's location
+    return path.join(path.dirname(new URL(import.meta.url).pathname), 'defaults');
+}
+/**
+ * Get the path to the built-in default partials directory.
+ */
+export function getBuiltinPartialsDir() {
+    return path.join(getBuiltinDefaultsDir(), 'partials');
+}

package/dist/src/templates/registry.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Template Registry
+ *
+ * In-memory registry that resolves workflow templates by work type.
+ * Supports layered resolution with built-in defaults, project overrides,
+ * and inline config overrides.
+ */
+import type { AgentWorkType } from '@renseiai/agentfactory-linear';
+import type { WorkflowTemplate, TemplateContext, TemplateRegistryConfig, ToolPermission, ToolPermissionAdapter } from './types.js';
+/**
+ * Template Registry manages workflow templates and renders prompts.
+ *
+ * Supports strategy-aware template resolution: given a (workType, strategy) tuple,
+ * the registry first looks for a strategy-specific template (e.g., "refinement-context-enriched")
+ * and falls back to the base work type template (e.g., "refinement").
+ */
+export declare class TemplateRegistry {
+    /**
+     * Internal map uses string keys to support both base work types (e.g., "development")
+     * and strategy-specific compound keys (e.g., "refinement-context-enriched").
+     */
+    private templates;
+    private handlebars;
+    private toolPermissionAdapter?;
+    constructor();
+    /**
+     * Create and initialize a registry from configuration.
+     */
+    static create(config?: TemplateRegistryConfig): TemplateRegistry;
+    /**
+     * Initialize the registry by loading templates from configured sources.
+     * Resolution order (later sources override earlier):
+     *   1. Built-in defaults
+     *   2. Each directory in templateDirs (in order)
+     *   3. Inline template overrides
+     */
+    initialize(config?: TemplateRegistryConfig): void;
+    /**
+     * Set the tool permission adapter for provider-specific translation.
+     */
+    setToolPermissionAdapter(adapter: ToolPermissionAdapter): void;
+    /**
+     * Look up a template by work type, with optional strategy for compound key resolution.
+     *
+     * Resolution order:
+     *   1. "{workType}-{strategy}" (e.g., "refinement-context-enriched")
+     *   2. "{workType}" (e.g., "refinement" -- fallback)
+     *
+     * Returns undefined if no template is registered.
+     */
+    getTemplate(workType: AgentWorkType, strategy?: string): WorkflowTemplate | undefined;
+    /**
+     * Check if a template is registered for a work type (optionally with strategy).
+     */
+    hasTemplate(workType: AgentWorkType, strategy?: string): boolean;
+    /**
+     * Get all registered template keys (base work types and strategy-specific keys).
+     */
+    getRegisteredWorkTypes(): string[];
+    /**
+     * Render a template for a work type with the given context variables.
+     * Optionally specify a strategy for strategy-aware template resolution.
+     * Returns null if no template is registered for the work type.
+     */
+    renderPrompt(workType: AgentWorkType, context: TemplateContext, strategy?: string): string | null;
+    /**
+     * Get the translated tool permissions for a work type (optionally with strategy).
+     * Returns undefined if no template or no tool permissions defined.
+     */
+    getToolPermissions(workType: AgentWorkType, strategy?: string): string[] | undefined;
+    /**
+     * Get disallowed tools for a work type (optionally with strategy).
+     */
+    getDisallowedTools(workType: AgentWorkType, strategy?: string): ToolPermission[] | undefined;
+    /**
+     * Register a partial template for use in Handlebars rendering.
+     */
+    registerPartial(name: string, content: string): void;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/templates/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/templates/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,sBAAsB,EACtB,cAAc,EACd,qBAAqB,EACtB,MAAM,YAAY,CAAA;AAQnB;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAC3B;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,qBAAqB,CAAC,CAAuB;;IAcrD;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,GAAE,sBAA2B,GAAG,gBAAgB;IAMpE;;;;;;OAMG;IACH,UAAU,CAAC,MAAM,GAAE,sBAA2B,GAAG,IAAI;IA4CrD;;OAEG;IACH,wBAAwB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI;IAI9D;;;;;;;;OAQG;IACH,WAAW,CAAC,QAAQ,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IASrF;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO;IAQhE;;OAEG;IACH,sBAAsB,IAAI,MAAM,EAAE;IAIlC;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAkBjG;;;OAGG;IACH,kBAAkB,CAAC,QAAQ,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAgBpF;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc,EAAE,GAAG,SAAS;IAK5F;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;CAGrD"}

package/dist/src/templates/registry.js

@@ -0,0 +1,177 @@
+/**
+ * Template Registry
+ *
+ * In-memory registry that resolves workflow templates by work type.
+ * Supports layered resolution with built-in defaults, project overrides,
+ * and inline config overrides.
+ */
+import Handlebars from 'handlebars';
+import { loadTemplatesFromDir, loadPartialsFromDir, getBuiltinDefaultsDir, getBuiltinPartialsDir, } from './loader.js';
+/**
+ * Template Registry manages workflow templates and renders prompts.
+ *
+ * Supports strategy-aware template resolution: given a (workType, strategy) tuple,
+ * the registry first looks for a strategy-specific template (e.g., "refinement-context-enriched")
+ * and falls back to the base work type template (e.g., "refinement").
+ */
+export class TemplateRegistry {
+    /**
+     * Internal map uses string keys to support both base work types (e.g., "development")
+     * and strategy-specific compound keys (e.g., "refinement-context-enriched").
+     */
+    templates = new Map();
+    handlebars;
+    toolPermissionAdapter;
+    constructor() {
+        this.handlebars = Handlebars.create();
+        // Register custom helpers
+        this.handlebars.registerHelper('eq', function (a, b) {
+            return a === b;
+        });
+        this.handlebars.registerHelper('neq', function (a, b) {
+            return a !== b;
+        });
+    }
+    /**
+     * Create and initialize a registry from configuration.
+     */
+    static create(config = {}) {
+        const registry = new TemplateRegistry();
+        registry.initialize(config);
+        return registry;
+    }
+    /**
+     * Initialize the registry by loading templates from configured sources.
+     * Resolution order (later sources override earlier):
+     *   1. Built-in defaults
+     *   2. Each directory in templateDirs (in order)
+     *   3. Inline template overrides
+     */
+    initialize(config = {}) {
+        const { templateDirs = [], templates, useBuiltinDefaults = true, frontend } = config;
+        // Layer 1: Built-in defaults
+        if (useBuiltinDefaults) {
+            const builtinDir = getBuiltinDefaultsDir();
+            const builtinTemplates = loadTemplatesFromDir(builtinDir);
+            for (const [key, template] of builtinTemplates) {
+                this.templates.set(key, template);
+            }
+            // Load built-in partials
+            const builtinPartialsDir = getBuiltinPartialsDir();
+            const builtinPartials = loadPartialsFromDir(builtinPartialsDir, frontend);
+            for (const [name, content] of builtinPartials) {
+                this.handlebars.registerPartial(`partials/${name}`, content);
+            }
+        }
+        // Layer 2: Project-level overrides (each dir in order)
+        for (const dir of templateDirs) {
+            const dirTemplates = loadTemplatesFromDir(dir);
+            for (const [key, template] of dirTemplates) {
+                this.templates.set(key, template);
+            }
+            // Load partials from each dir's partials subdirectory
+            const partialsDir = `${dir}/partials`;
+            const partials = loadPartialsFromDir(partialsDir, frontend);
+            for (const [name, content] of partials) {
+                this.handlebars.registerPartial(`partials/${name}`, content);
+            }
+        }
+        // Layer 3: Inline config overrides (highest priority)
+        if (templates) {
+            for (const [workType, template] of Object.entries(templates)) {
+                if (template) {
+                    this.templates.set(workType, template);
+                }
+            }
+        }
+    }
+    /**
+     * Set the tool permission adapter for provider-specific translation.
+     */
+    setToolPermissionAdapter(adapter) {
+        this.toolPermissionAdapter = adapter;
+    }
+    /**
+     * Look up a template by work type, with optional strategy for compound key resolution.
+     *
+     * Resolution order:
+     *   1. "{workType}-{strategy}" (e.g., "refinement-context-enriched")
+     *   2. "{workType}" (e.g., "refinement" -- fallback)
+     *
+     * Returns undefined if no template is registered.
+     */
+    getTemplate(workType, strategy) {
+        if (strategy) {
+            const strategyKey = `${workType}-${strategy}`;
+            const strategyTemplate = this.templates.get(strategyKey);
+            if (strategyTemplate)
+                return strategyTemplate;
+        }
+        return this.templates.get(workType);
+    }
+    /**
+     * Check if a template is registered for a work type (optionally with strategy).
+     */
+    hasTemplate(workType, strategy) {
+        if (strategy) {
+            const strategyKey = `${workType}-${strategy}`;
+            if (this.templates.has(strategyKey))
+                return true;
+        }
+        return this.templates.has(workType);
+    }
+    /**
+     * Get all registered template keys (base work types and strategy-specific keys).
+     */
+    getRegisteredWorkTypes() {
+        return Array.from(this.templates.keys());
+    }
+    /**
+     * Render a template for a work type with the given context variables.
+     * Optionally specify a strategy for strategy-aware template resolution.
+     * Returns null if no template is registered for the work type.
+     */
+    renderPrompt(workType, context, strategy) {
+        const template = this.getTemplate(workType, strategy);
+        if (!template) {
+            return null;
+        }
+        try {
+            const compiledTemplate = this.handlebars.compile(template.prompt, { noEscape: true });
+            return compiledTemplate(context);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const key = strategy ? `${workType}-${strategy}` : workType;
+            throw new Error(`Failed to render template for work type "${key}": ${message}`);
+        }
+    }
+    /**
+     * Get the translated tool permissions for a work type (optionally with strategy).
+     * Returns undefined if no template or no tool permissions defined.
+     */
+    getToolPermissions(workType, strategy) {
+        const template = this.getTemplate(workType, strategy);
+        if (!template?.tools?.allow) {
+            return undefined;
+        }
+        if (this.toolPermissionAdapter) {
+            return this.toolPermissionAdapter.translatePermissions(template.tools.allow);
+        }
+        // Without an adapter, return string permissions as-is
+        return template.tools.allow.map(p => typeof p === 'string' ? p : p.shell);
+    }
+    /**
+     * Get disallowed tools for a work type (optionally with strategy).
+     */
+    getDisallowedTools(workType, strategy) {
+        const template = this.getTemplate(workType, strategy);
+        return template?.tools?.disallow;
+    }
+    /**
+     * Register a partial template for use in Handlebars rendering.
+     */
+    registerPartial(name, content) {
+        this.handlebars.registerPartial(name, content);
+    }
+}

package/dist/src/templates/registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=registry.test.d.ts.map

package/dist/src/templates/registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.test.d.ts","sourceRoot":"","sources":["../../../src/templates/registry.test.ts"],"names":[],"mappings":""}

package/dist/src/templates/registry.test.js

@@ -0,0 +1,198 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TemplateRegistry } from './registry.js';
+import { ClaudeToolPermissionAdapter } from './adapters.js';
+describe('TemplateRegistry', () => {
+    let registry;
+    beforeEach(() => {
+        registry = new TemplateRegistry();
+    });
+    describe('basic operations', () => {
+        it('returns undefined for unregistered work type', () => {
+            expect(registry.getTemplate('development')).toBeUndefined();
+            expect(registry.hasTemplate('development')).toBe(false);
+        });
+        it('returns empty list of registered work types initially', () => {
+            expect(registry.getRegisteredWorkTypes()).toEqual([]);
+        });
+        it('returns null when rendering unregistered work type', () => {
+            expect(registry.renderPrompt('development', { identifier: 'SUP-123' })).toBeNull();
+        });
+    });
+    describe('inline templates', () => {
+        const devTemplate = {
+            apiVersion: 'v1',
+            kind: 'WorkflowTemplate',
+            metadata: { name: 'development', workType: 'development' },
+            tools: { allow: [{ shell: 'pnpm *' }] },
+            prompt: 'Start work on {{identifier}}.',
+        };
+        it('registers and renders inline templates', () => {
+            registry.initialize({ templates: { development: devTemplate }, useBuiltinDefaults: false });
+            expect(registry.hasTemplate('development')).toBe(true);
+            const result = registry.renderPrompt('development', { identifier: 'SUP-123' });
+            expect(result).toBe('Start work on SUP-123.');
+        });
+        it('handles mentionContext conditional', () => {
+            const template = {
+                apiVersion: 'v1',
+                kind: 'WorkflowTemplate',
+                metadata: { name: 'dev', workType: 'development' },
+                prompt: 'Work on {{identifier}}.{{#if mentionContext}}\nContext: {{mentionContext}}{{/if}}',
+            };
+            registry.initialize({ templates: { development: template }, useBuiltinDefaults: false });
+            // Without mentionContext
+            expect(registry.renderPrompt('development', { identifier: 'SUP-1' }))
+                .toBe('Work on SUP-1.');
+            // With mentionContext
+            expect(registry.renderPrompt('development', { identifier: 'SUP-1', mentionContext: 'fix bug' }))
+                .toBe('Work on SUP-1.\nContext: fix bug');
+        });
+    });
+    describe('partials', () => {
+        it('renders templates with registered partials', () => {
+            const template = {
+                apiVersion: 'v1',
+                kind: 'WorkflowTemplate',
+                metadata: { name: 'dev', workType: 'development' },
+                prompt: 'Work on {{identifier}}.{{> partials/test-partial}}',
+            };
+            registry.initialize({ templates: { development: template }, useBuiltinDefaults: false });
+            registry.registerPartial('partials/test-partial', '\nTest partial content.');
+            const result = registry.renderPrompt('development', { identifier: 'SUP-1' });
+            expect(result).toBe('Work on SUP-1.\nTest partial content.');
+        });
+        it('throws on missing partial', () => {
+            const template = {
+                apiVersion: 'v1',
+                kind: 'WorkflowTemplate',
+                metadata: { name: 'dev', workType: 'development' },
+                prompt: 'Work on {{identifier}}.{{> partials/missing}}',
+            };
+            registry.initialize({ templates: { development: template }, useBuiltinDefaults: false });
+            expect(() => registry.renderPrompt('development', { identifier: 'SUP-1' }))
+                .toThrow('Failed to render template');
+        });
+    });
+    describe('tool permissions', () => {
+        it('returns undefined when no tools defined', () => {
+            const template = {
+                apiVersion: 'v1',
+                kind: 'WorkflowTemplate',
+                metadata: { name: 'dev', workType: 'development' },
+                prompt: 'test',
+            };
+            registry.initialize({ templates: { development: template }, useBuiltinDefaults: false });
+            expect(registry.getToolPermissions('development')).toBeUndefined();
+        });
+        it('returns raw permissions without adapter', () => {
+            const template = {
+                apiVersion: 'v1',
+                kind: 'WorkflowTemplate',
+                metadata: { name: 'dev', workType: 'development' },
+                tools: { allow: [{ shell: 'pnpm *' }, 'Read'] },
+                prompt: 'test',
+            };
+            registry.initialize({ templates: { development: template }, useBuiltinDefaults: false });
+            const perms = registry.getToolPermissions('development');
+            expect(perms).toEqual(['pnpm *', 'Read']);
+        });
+        it('translates permissions with Claude adapter', () => {
+            const template = {
+                apiVersion: 'v1',
+                kind: 'WorkflowTemplate',
+                metadata: { name: 'dev', workType: 'development' },
+                tools: {
+                    allow: [{ shell: 'pnpm *' }, { shell: 'git commit *' }],
+                    disallow: ['user-input'],
+                },
+                prompt: 'test',
+            };
+            registry.initialize({ templates: { development: template }, useBuiltinDefaults: false });
+            registry.setToolPermissionAdapter(new ClaudeToolPermissionAdapter());
+            const perms = registry.getToolPermissions('development');
+            expect(perms).toEqual(['Bash(pnpm:*)', 'Bash(git commit:*)']);
+        });
+        it('returns disallowed tools', () => {
+            const template = {
+                apiVersion: 'v1',
+                kind: 'WorkflowTemplate',
+                metadata: { name: 'dev', workType: 'development' },
+                tools: { disallow: ['user-input'] },
+                prompt: 'test',
+            };
+            registry.initialize({ templates: { development: template }, useBuiltinDefaults: false });
+            expect(registry.getDisallowedTools('development')).toEqual(['user-input']);
+        });
+    });
+    describe('built-in defaults', () => {
+        it('loads built-in default templates when useBuiltinDefaults is true', () => {
+            const fullRegistry = TemplateRegistry.create({ useBuiltinDefaults: true });
+            // Should have loaded templates for all 11 base work types + 5 strategy templates
+            const workTypes = fullRegistry.getRegisteredWorkTypes();
+            expect(workTypes.length).toBe(16);
+            expect(workTypes).toContain('development');
+            expect(workTypes).toContain('qa');
+            expect(workTypes).toContain('coordination');
+            // Strategy-specific templates
+            expect(workTypes).toContain('refinement-context-enriched');
+            expect(workTypes).toContain('refinement-decompose');
+            expect(workTypes).toContain('development-retry');
+            expect(workTypes).toContain('qa-retry');
+            expect(workTypes).toContain('qa-native');
+        });
+        it('renders a built-in template with variables', () => {
+            const fullRegistry = TemplateRegistry.create({ useBuiltinDefaults: true });
+            const result = fullRegistry.renderPrompt('development', { identifier: 'SUP-999' });
+            expect(result).toContain('SUP-999');
+            expect(result).toContain('Implement the feature/fix');
+        });
+        it('built-in templates include CLI instructions partial', () => {
+            const fullRegistry = TemplateRegistry.create({ useBuiltinDefaults: true });
+            const result = fullRegistry.renderPrompt('development', { identifier: 'SUP-1', linearCli: 'pnpm af-linear', packageManager: 'pnpm' });
+            expect(result).toContain('pnpm af-linear');
+            expect(result).toContain('LINEAR CLI (CRITICAL)');
+        });
+        it('built-in QA template includes work result marker', () => {
+            const fullRegistry = TemplateRegistry.create({ useBuiltinDefaults: true });
+            const result = fullRegistry.renderPrompt('qa', { identifier: 'SUP-1' });
+            expect(result).toContain('WORK_RESULT:passed');
+            expect(result).toContain('WORK_RESULT:failed');
+        });
+        it('built-in coordination template includes shared worktree safety', () => {
+            const fullRegistry = TemplateRegistry.create({ useBuiltinDefaults: true });
+            const result = fullRegistry.renderPrompt('coordination', { identifier: 'SUP-1' });
+            expect(result).toContain('SHARED WORKTREE');
+            expect(result).toContain('git worktree remove');
+        });
+        it('built-in templates handle mentionContext', () => {
+            const fullRegistry = TemplateRegistry.create({ useBuiltinDefaults: true });
+            const result = fullRegistry.renderPrompt('development', {
+                identifier: 'SUP-1',
+                mentionContext: 'Fix the login bug',
+            });
+            expect(result).toContain('Fix the login bug');
+            expect(result).toContain('Additional context');
+        });
+        it('built-in templates omit mentionContext when not provided', () => {
+            const fullRegistry = TemplateRegistry.create({ useBuiltinDefaults: true });
+            const result = fullRegistry.renderPrompt('development', { identifier: 'SUP-1' });
+            expect(result).not.toContain('Additional context');
+        });
+    });
+    describe('layer override', () => {
+        it('inline templates override built-in defaults', () => {
+            const customTemplate = {
+                apiVersion: 'v1',
+                kind: 'WorkflowTemplate',
+                metadata: { name: 'custom-dev', workType: 'development' },
+                prompt: 'Custom prompt for {{identifier}}.',
+            };
+            const customRegistry = TemplateRegistry.create({
+                useBuiltinDefaults: true,
+                templates: { development: customTemplate },
+            });
+            const result = customRegistry.renderPrompt('development', { identifier: 'SUP-1' });
+            expect(result).toBe('Custom prompt for SUP-1.');
+        });
+    });
+});

package/dist/src/templates/renderer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Template Renderer
+ *
+ * Bridge between the template registry and the existing prompt generation
+ * functions. Provides a drop-in replacement for generatePromptForWorkType
+ * that uses templates when available and falls back to hardcoded prompts.
+ */
+import type { AgentWorkType } from '@renseiai/agentfactory-linear';
+import type { TemplateContext } from './types.js';
+import type { TemplateRegistry } from './registry.js';
+/**
+ * Render a prompt from a template registry with fallback support.
+ *
+ * Supports strategy-aware resolution: when a strategy is provided,
+ * the registry first looks for a strategy-specific template
+ * (e.g., "refinement-context-enriched") before falling back to the base template.
+ *
+ * @param registry - The template registry to use
+ * @param workType - The work type to generate a prompt for
+ * @param context - Template variables
+ * @param fallback - Fallback function when no template is available
+ * @param strategy - Optional escalation strategy for strategy-aware resolution
+ * @returns The rendered prompt string
+ */
+export declare function renderPromptWithFallback(registry: TemplateRegistry | null, workType: AgentWorkType, context: TemplateContext, fallback: (identifier: string, workType: AgentWorkType, options?: {
+    parentContext?: string;
+    mentionContext?: string;
+}) => string, strategy?: string): string;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/src/templates/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../../src/templates/renderer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAErD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,EACjC,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,MAAM,EAChI,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAcR"}

package/dist/src/templates/renderer.js

@@ -0,0 +1,35 @@
+/**
+ * Template Renderer
+ *
+ * Bridge between the template registry and the existing prompt generation
+ * functions. Provides a drop-in replacement for generatePromptForWorkType
+ * that uses templates when available and falls back to hardcoded prompts.
+ */
+/**
+ * Render a prompt from a template registry with fallback support.
+ *
+ * Supports strategy-aware resolution: when a strategy is provided,
+ * the registry first looks for a strategy-specific template
+ * (e.g., "refinement-context-enriched") before falling back to the base template.
+ *
+ * @param registry - The template registry to use
+ * @param workType - The work type to generate a prompt for
+ * @param context - Template variables
+ * @param fallback - Fallback function when no template is available
+ * @param strategy - Optional escalation strategy for strategy-aware resolution
+ * @returns The rendered prompt string
+ */
+export function renderPromptWithFallback(registry, workType, context, fallback, strategy) {
+    // If registry exists and has a template, use it
+    if (registry?.hasTemplate(workType, strategy)) {
+        const rendered = registry.renderPrompt(workType, context, strategy);
+        if (rendered !== null) {
+            return rendered;
+        }
+    }
+    // Fall back to hardcoded prompt generation
+    return fallback(context.identifier, workType, {
+        parentContext: context.parentContext,
+        mentionContext: context.mentionContext,
+    });
+}

package/dist/src/templates/strategy-templates.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=strategy-templates.test.d.ts.map

package/dist/src/templates/strategy-templates.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-templates.test.d.ts","sourceRoot":"","sources":["../../../src/templates/strategy-templates.test.ts"],"names":[],"mappings":""}