contextdevkit 1.8.0

package/templates/contextkit/squads/agent-forge/lib/router.mjs

@@ -0,0 +1,165 @@
+/**
+ * Model router for agent-forge (ADR-0012). Reads `decision-rules.json` + the
+ * `capability-matrix.json`, applies deterministic SHORTLIST rules to a parsed
+ * Agent Blueprint, filters candidates by capability + residency, and emits a
+ * { primary, fallback, cheap_path, premium_path, applied_rules, rationale }
+ * decision. Quality opinions live in the eval harness, NOT here (ADR-0012 §5).
+ *
+ * Pure zero-dep (rule 1) — no provider SDKs, no YAML, just `node:` + JSON.parse.
+ * The architect/orchestrator parses YAML upstream via `lib/yaml.mjs` and hands
+ * `routeAgent` a plain JS object.
+ */
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_MATRIX = resolve(HERE, '..', 'router', 'capability-matrix.json');
+const DEFAULT_RULES = resolve(HERE, '..', 'router', 'decision-rules.json');
+
+async function loadJson(path) {
+  const raw = await readFile(path, 'utf-8');
+  return JSON.parse(raw.replace(/^/, ''));
+}
+
+export async function loadMatrix(path = DEFAULT_MATRIX) {
+  return loadJson(path);
+}
+
+export async function loadRules(path = DEFAULT_RULES) {
+  return loadJson(path);
+}
+
+function getPath(source, dotPath) {
+  return dotPath.split('.').reduce((node, key) => node?.[key], source);
+}
+
+function matchOne(actual, expected) {
+  if (expected && typeof expected === 'object' && !Array.isArray(expected)) {
+    for (const [op, ref] of Object.entries(expected)) {
+      if (op === '$eq' && actual !== ref) return false;
+      if (op === '$gt' && !(actual > ref)) return false;
+      if (op === '$gte' && !(actual >= ref)) return false;
+      if (op === '$lt' && !(actual < ref)) return false;
+      if (op === '$lte' && !(actual <= ref)) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(expected)) return expected.includes(actual);
+  return actual === expected;
+}
+
+function matchesWhen(when, blueprint) {
+  if (!when || !Object.keys(when).length) return true;
+  return Object.entries(when).every(([dotPath, expected]) => matchOne(getPath(blueprint, dotPath), expected));
+}
+
+function isAvailable(model, blueprint) {
+  if (!model) return false;
+  const caps = blueprint.capabilities || {};
+  const priv = blueprint.privacy || {};
+  if (caps.tools && model.capabilities?.tools === false) return false;
+  if ((caps.multimodal || blueprint.intent?.multimodal) && model.capabilities?.vision === false) return false;
+  if (caps.structured_output && model.capabilities?.structured_output === false) return false;
+  if (priv.allow_cloud_providers === false && !model.id.startsWith('self-hosted/')) return false;
+  if (priv.data_residency === 'on-prem' && !model.id.startsWith('self-hosted/')) return false;
+  return true;
+}
+
+function firstAvailable(ids, modelById, blueprint) {
+  for (const id of ids) {
+    if (isAvailable(modelById[id], blueprint)) return id;
+  }
+  return undefined;
+}
+
+function buildRationale(ctx) {
+  const { primary, fallback, cheap_path, premium_path, applied_rules, blueprint } = ctx;
+  const intent = blueprint.intent || {};
+  const facts = [`intent: ${intent.category || '?'}${intent.complexity ? ' (' + intent.complexity + ')' : ''}`];
+  if (intent.multimodal || blueprint.capabilities?.multimodal) facts.push('multimodal required');
+  if (blueprint.capabilities?.tools) facts.push('tool use required');
+  if (blueprint.privacy?.data_residency) facts.push(`residency: ${blueprint.privacy.data_residency}`);
+  if (blueprint.privacy?.allow_cloud_providers === false) facts.push('no-cloud (self-hosted only)');
+
+  const sameProvider = fallback && primary.split('/')[0] === fallback.split('/')[0];
+  const ruleTrace = applied_rules.length ? applied_rules.map((rule) => '`' + rule + '`').join(', ') : '`default-balanced`';
+  const lines = [
+    '## Model Selection Rationale',
+    '',
+    `<!-- Generated by agent-forge model-router. Applied rules: ${applied_rules.join(' → ') || '(default)'}. -->`,
+    `> **Authority:** the eval harness (golden + red-team) measured on your dataset, not these rules ([ADR-0012](../../memory/decisions/0012-agent-forge-squad-for-portable-agent-packages.md) §5).`,
+    '',
+    `**Primary:** \`${primary}\``,
+    `- Constraints applied: ${facts.join('; ')}.`,
+    `- Selected from the shortlist of rule(s): ${ruleTrace}.`,
+  ];
+  if (fallback) {
+    lines.push('');
+    lines.push(`**Fallback:** \`${fallback}\``);
+    lines.push(`- ${sameProvider ? 'WARN: same provider as primary — outage defense weakened. Review.' : 'Different provider from primary — outage defense.'}`);
+  } else {
+    lines.push('');
+    lines.push('**Fallback:** _no cross-provider candidate was available_. The eval gate may flag this — extend `decision-rules.json` or relax residency.');
+  }
+  if (cheap_path) {
+    lines.push('');
+    lines.push(`**Cheap path:** \`${cheap_path}\` — for cheap sub-tasks.`);
+  }
+  if (premium_path) {
+    lines.push('');
+    lines.push(`**Premium path:** \`${premium_path}\` — for calls flagged critical.`);
+  }
+  return lines.join('\n');
+}
+
+export async function routeAgent(blueprint, opts = {}) {
+  const matrix = opts.matrix ?? (await loadMatrix(opts.matrixPath));
+  const rules = opts.rules ?? (await loadRules(opts.rulesPath));
+  const cap = rules.max_rules ?? 15;
+  if (rules.rules.length > cap) {
+    throw new Error(`agent-forge router: decision-rules has ${rules.rules.length} rules (cap ${cap}). Split by intent category — blueprint §12.`);
+  }
+  const modelById = Object.fromEntries(matrix.models.map((model) => [model.id, model]));
+
+  const matched = [];
+  const primaryCandidates = [];
+  const fallbackCandidates = [];
+  let cheapPath;
+  let premiumPath;
+  let abortIfEmpty = false;
+
+  for (const rule of rules.rules) {
+    if (!matchesWhen(rule.when, blueprint)) continue;
+    matched.push(rule.id);
+    if (rule.then?.primary_candidates) primaryCandidates.push(...rule.then.primary_candidates);
+    if (rule.then?.fallback_candidates) fallbackCandidates.push(...rule.then.fallback_candidates);
+    if (rule.then?.cheap_path && !cheapPath) cheapPath = rule.then.cheap_path;
+    if (rule.then?.premium_path && !premiumPath) premiumPath = rule.then.premium_path;
+    if (rule.abort_if_no_candidate) abortIfEmpty = true;
+  }
+
+  const primary = firstAvailable(primaryCandidates, modelById, blueprint);
+  if (!primary) {
+    if (abortIfEmpty) {
+      throw new Error('agent-forge router: no candidate satisfies the blueprint constraints (residency/capabilities). Review the blueprint or extend decision-rules.');
+    }
+    throw new Error('agent-forge router: no matching rule produced an available primary candidate — add a default-balanced rule or specify capabilities precisely.');
+  }
+
+  const primaryProvider = primary.split('/')[0];
+  const allFallbacks = [...fallbackCandidates, ...primaryCandidates.filter((id) => id !== primary)];
+  const fallback = allFallbacks.find((id) => id.split('/')[0] !== primaryProvider && isAvailable(modelById[id], blueprint));
+
+  const cheapAvail = cheapPath && isAvailable(modelById[cheapPath], blueprint) ? cheapPath : undefined;
+  const premiumAvail = premiumPath && isAvailable(modelById[premiumPath], blueprint) ? premiumPath : undefined;
+
+  return {
+    primary,
+    fallback,
+    cheap_path: cheapAvail,
+    premium_path: premiumAvail,
+    applied_rules: matched,
+    rationale: buildRationale({ primary, fallback, cheap_path: cheapAvail, premium_path: premiumAvail, applied_rules: matched, blueprint }),
+  };
+}

package/templates/contextkit/squads/agent-forge/lib/tool-gen.mjs

@@ -0,0 +1,113 @@
+/**
+ * tool-designer — render the canonical JSON tool schemas to per-provider adapter
+ * files. Fase 1 shipped Anthropic + OpenAI; Fase 2 adds Gemini (functionDeclarations
+ * SUBSET — `additionalProperties` and `$schema` are dropped because Gemini's
+ * function-calling parser rejects them), DeepSeek (OpenAI-compat drop-in), and
+ * Ollama (OpenAI-compat via /v1/chat/completions). Provider-specific quirks live
+ * INSIDE these render functions — the canonical file stays neutral. Pure + zero-dep.
+ *
+ * Canonical shape: `tools/schemas.canonical.json` uses tool names as top-level keys
+ * (reserving `_note` / `$schema` for metadata). Each tool is
+ * `{ description, idempotent?, input_schema, error_format? }`.
+ */
+
+/** Walk the canonical object → `[{ name, description, input_schema, idempotent, error_format }]`. */
+export function parseCanonical(canonical) {
+  if (!canonical || typeof canonical !== 'object') return [];
+  return Object.entries(canonical)
+    .filter(([k]) => !k.startsWith('_') && !k.startsWith('$'))
+    .map(([name, def]) => ({
+      name,
+      description: def?.description || '',
+      input_schema: def?.input_schema || { type: 'object', properties: {}, required: [] },
+      idempotent: def?.idempotent ?? null,
+      error_format: def?.error_format ?? null,
+    }));
+}
+
+/** Anthropic `tools` array — `{ name, description, input_schema }`. Force-call via tool_choice. */
+export function renderAnthropic(tools) {
+  return {
+    _generated: 'agent-forge tool-designer (Fase 1) from ../schemas.canonical.json — do not hand-edit',
+    _format: "Anthropic `tools` array: { name, description, input_schema }. Force a tool with tool_choice: { type: 'tool', name }.",
+    tools: tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.input_schema })),
+  };
+}
+
+/** OpenAI `tools` array — `{ type: 'function', function: { name, description, parameters } }`. */
+export function renderOpenAI(tools) {
+  return {
+    _generated: 'agent-forge tool-designer (Fase 1) from ../schemas.canonical.json — do not hand-edit',
+    _format: "OpenAI `tools` array of type 'function'. Force a call with tool_choice: { type: 'function', function: { name } }.",
+    tools: tools.map((t) => ({
+      type: 'function',
+      function: { name: t.name, description: t.description, parameters: t.input_schema },
+    })),
+  };
+}
+
+/**
+ * Strip JSON-Schema fields Gemini's `functionDeclarations` parser rejects:
+ * `additionalProperties`, `$schema`, `$id`, `$ref` (subset enforcement).
+ * Recurses into nested object/array shapes.
+ */
+function downConvertForGemini(node) {
+  if (Array.isArray(node)) return node.map(downConvertForGemini);
+  if (!node || typeof node !== 'object') return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === 'additionalProperties' || key === '$schema' || key === '$id' || key === '$ref') continue;
+    out[key] = typeof value === 'object' ? downConvertForGemini(value) : value;
+  }
+  return out;
+}
+
+/** Google (Gemini) `tools[].functionDeclarations[]`. parameters is the JSON-Schema SUBSET. */
+export function renderGoogle(tools) {
+  return {
+    _generated: 'agent-forge tool-designer (Fase 2) from ../schemas.canonical.json — do not hand-edit',
+    _format: "Gemini `tools[].functionDeclarations[]`: { name, description, parameters }. parameters is a JSON-Schema SUBSET — additionalProperties + $schema dropped.",
+    functionDeclarations: tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: downConvertForGemini(t.input_schema),
+    })),
+  };
+}
+
+/** DeepSeek: OpenAI-compatible drop-in. */
+export function renderDeepSeek(tools) {
+  return {
+    _generated: 'agent-forge tool-designer (Fase 2) from ../schemas.canonical.json — do not hand-edit',
+    _format: "DeepSeek is OpenAI-compatible — same shape as openai.tools.json (type 'function').",
+    tools: tools.map((t) => ({
+      type: 'function',
+      function: { name: t.name, description: t.description, parameters: t.input_schema },
+    })),
+  };
+}
+
+/** Self-hosted (Ollama/vLLM) via OpenAI-compatible endpoint. Native function calling on Llama 3.x / Mistral. */
+export function renderOllama(tools) {
+  return {
+    _generated: 'agent-forge tool-designer (Fase 2) from ../schemas.canonical.json — do not hand-edit',
+    _format: "Self-hosted via OpenAI-compatible endpoint. Native function calling on Llama 3.x / Mistral; reliability below cloud — robust eval is critical.",
+    tools: tools.map((t) => ({
+      type: 'function',
+      function: { name: t.name, description: t.description, parameters: t.input_schema },
+    })),
+  };
+}
+
+/** One-stop adapter generator: anthropic + openai + google + deepseek + ollama. */
+export function generateAdapters(canonical) {
+  const tools = parseCanonical(canonical);
+  return {
+    tools,
+    anthropic: renderAnthropic(tools),
+    openai: renderOpenAI(tools),
+    google: renderGoogle(tools),
+    deepseek: renderDeepSeek(tools),
+    ollama: renderOllama(tools),
+  };
+}

package/templates/contextkit/squads/agent-forge/lib/yaml.mjs

@@ -0,0 +1,47 @@
+/**
+ * Optional YAML loader for agent-forge (ADR-0013). The ONLY place the `yaml` dependency
+ * is imported — every forge consumer goes through `parseYaml` / `stringifyYaml`. Mirrors
+ * the sanctioned `zod` optional-dynamic-import pattern (ADR-0001).
+ *
+ * ⛔ The L1–3 hot path (runtime/hooks/**, runtime/config/load.mjs) must NEVER import this
+ *    module — agent-forge is opt-in L4+ tooling. A selfcheck guard enforces that.
+ */
+
+let cachedYaml;
+
+/**
+ * Load the optional `yaml` lib, caching the module. Throws an actionable error (never a
+ * raw stack trace) when the dependency is not installed.
+ * @returns {Promise<object>} the `yaml` module
+ * @throws {Error} when `yaml` is not installed
+ */
+export async function loadYaml() {
+  if (cachedYaml) return cachedYaml;
+  try {
+    const mod = await import('yaml');
+    cachedYaml = mod.default ?? mod;
+    return cachedYaml;
+  } catch {
+    throw new Error('agent-forge needs the `yaml` package to read/write Agent Package files — run `npm i yaml`.');
+  }
+}
+
+/**
+ * Parse a YAML string into a JS value (BOM-safe, per immutable rule 4).
+ * @param {string} text raw YAML
+ * @returns {Promise<unknown>}
+ */
+export async function parseYaml(text) {
+  const yaml = await loadYaml();
+  return yaml.parse(String(text).replace(/^/, ''));
+}
+
+/**
+ * Serialize a JS value to a YAML string.
+ * @param {unknown} value
+ * @returns {Promise<string>}
+ */
+export async function stringifyYaml(value) {
+  const yaml = await loadYaml();
+  return yaml.stringify(value);
+}

package/templates/contextkit/squads/agent-forge/pipeline.yaml

@@ -0,0 +1,65 @@
+pipeline:
+  squad: agent-forge
+  version: "1.0.0"
+  description: >
+    Forge a portable APF package from an approved Agent Blueprint.
+    Linear with one conditional branch (tools), one conditional capability
+    (rag), and one bounded retry loop on the eval gate.
+
+  steps:
+    # 1 — sanity-check the blueprint before any work runs.
+    - id: validate-blueprint
+      agent: forge-orchestrator
+      execution: inline
+      model_tier: fast
+
+    # 2 — route to a tier+provider shortlist (capability matrix + decision rules).
+    - id: route
+      agent: model-router
+      execution: inline
+      model_tier: fast
+
+    # 3 — human picks one model from the shortlist; the choice lands on disk.
+    - id: checkpoint-shortlist
+      type: checkpoint
+      outputFile: pipeline/data/shortlist.md
+
+    # 4 — emit the per-provider system prompts (canonical + 5 adapters).
+    - id: generate-prompt
+      agent: prompt-engineer
+      execution: inline
+      model_tier: powerful
+
+    # 5 — emit the per-provider tool schemas (only when the blueprint declares tools).
+    - id: generate-tools
+      agent: tool-designer
+      execution: inline
+      model_tier: powerful
+      condition: blueprint.tools.length > 0
+
+    # 6 — emit the RAG config (only when the blueprint enables retrieval).
+    - id: generate-rag
+      agent: rag-designer
+      execution: inline
+      model_tier: powerful
+      condition: capabilities.rag == true
+
+    # 7 — populate the three governance pillars from the blueprint (throws on under-config).
+    - id: governance
+      agent: governance-officer
+      execution: inline
+      model_tier: powerful
+
+    # 8 — refuse to ship unless the eval gate passes; loop back to refine the prompt up to 3 times.
+    - id: eval-gate
+      agent: eval-designer
+      execution: subagent
+      model_tier: powerful
+      on_reject: generate-prompt
+      max_review_cycles: 3
+
+    # 9 — assemble the APF tree, stamp provenance, write to agent-packages/.
+    - id: package
+      agent: packager
+      execution: inline
+      model_tier: fast

package/templates/contextkit/squads/agent-forge/router/capability-matrix.json

@@ -0,0 +1,112 @@
+{
+  "_note": "Seed capability matrix for the agent-forge model-router. Economics are ILLUSTRATIVE and date-stamped; refresh via /forge-refresh-matrix and gate changes through an ADR (ADR-0012, constraint 6). Authority for 'best model for this agent' is the eval harness measured on the user's golden set, NOT this file (constraint 5). Anthropic model IDs are current; other providers are plausible seeds to verify on first refresh.",
+  "updated": "2026-05-25",
+  "version": "0.1.0",
+  "allowed_providers": ["anthropic", "openai", "google", "deepseek", "self-hosted"],
+  "models": [
+    {
+      "id": "anthropic/claude-opus-4-7",
+      "tier": "premium",
+      "context_window": 200000,
+      "input_usd_per_mtok": 15.0,
+      "output_usd_per_mtok": 75.0,
+      "latency_p50_ms": 4500,
+      "strengths": ["reasoning", "coding", "agentic", "long-context"],
+      "weaknesses": ["cost"],
+      "capabilities": { "tools": true, "vision": true, "structured_output": true, "prompt_caching": true, "streaming": true },
+      "residency": ["us", "eu"],
+      "zero_retention_available": true
+    },
+    {
+      "id": "anthropic/claude-sonnet-4-6",
+      "tier": "balanced",
+      "context_window": 200000,
+      "input_usd_per_mtok": 3.0,
+      "output_usd_per_mtok": 15.0,
+      "latency_p50_ms": 1800,
+      "strengths": ["balanced", "tools", "coding", "pt-br"],
+      "capabilities": { "tools": true, "vision": true, "structured_output": true, "prompt_caching": true, "streaming": true },
+      "residency": ["us", "eu"],
+      "zero_retention_available": true
+    },
+    {
+      "id": "anthropic/claude-haiku-4-5",
+      "tier": "cheap",
+      "context_window": 200000,
+      "input_usd_per_mtok": 0.8,
+      "output_usd_per_mtok": 4.0,
+      "latency_p50_ms": 700,
+      "strengths": ["classification", "extraction-simple", "low-latency"],
+      "capabilities": { "tools": true, "vision": true, "prompt_caching": true, "streaming": true },
+      "residency": ["us", "eu"],
+      "zero_retention_available": true
+    },
+    {
+      "id": "openai/gpt-4o",
+      "tier": "balanced",
+      "context_window": 128000,
+      "strengths": ["multimodal", "tools", "structured_output"],
+      "capabilities": { "tools": true, "vision": true, "structured_output": true, "prompt_caching": true, "streaming": true },
+      "residency": ["us", "eu"]
+    },
+    {
+      "id": "openai/gpt-4o-mini",
+      "tier": "cheap",
+      "context_window": 128000,
+      "strengths": ["cost", "low-latency", "classification"],
+      "capabilities": { "tools": true, "vision": true, "structured_output": true, "prompt_caching": true, "streaming": true },
+      "residency": ["us", "eu"]
+    },
+    {
+      "id": "google/gemini-2.5-pro",
+      "tier": "balanced",
+      "context_window": 2000000,
+      "strengths": ["long-context", "multimodal", "cost"],
+      "capabilities": { "tools": true, "vision": true, "structured_output": true, "prompt_caching": true, "streaming": true },
+      "residency": ["us", "eu"],
+      "notes": "safetySettings must be set explicitly; function-calling uses a JSON-Schema subset"
+    },
+    {
+      "id": "google/gemini-2.5-flash",
+      "tier": "cheap",
+      "context_window": 1000000,
+      "strengths": ["latency", "cost", "long-context"],
+      "capabilities": { "tools": true, "vision": true, "streaming": true },
+      "residency": ["us", "eu"]
+    },
+    {
+      "id": "deepseek/deepseek-v3",
+      "tier": "balanced",
+      "strengths": ["coding", "reasoning", "cost"],
+      "weaknesses": ["pt-br-nuance", "vision"],
+      "capabilities": { "tools": true, "vision": false, "streaming": true },
+      "residency": ["cn"],
+      "notes": "OpenAI-compatible API; prefers explicit CoT; reasoner variants split reasoning_content"
+    },
+    {
+      "id": "deepseek/deepseek-coder",
+      "tier": "specialist-coding",
+      "strengths": ["code-generation", "cost"],
+      "capabilities": { "tools": true, "vision": false, "streaming": true },
+      "residency": ["cn"]
+    },
+    {
+      "id": "self-hosted/llama-3.x-70b",
+      "tier": "self-hosted",
+      "strengths": ["data-residency", "no-egress", "predictable-cost"],
+      "weaknesses": ["operational-complexity", "tool-use-reliability"],
+      "capabilities": { "tools": true, "vision": false, "streaming": true },
+      "residency": ["on-prem", "any"],
+      "cost_model": "infra-only",
+      "notes": "Ollama (own + OpenAI-compatible endpoint) or vLLM (OpenAI-compatible); per-model chat_template"
+    },
+    {
+      "id": "self-hosted/mistral-large",
+      "tier": "self-hosted",
+      "strengths": ["multilingual-eu", "data-residency"],
+      "capabilities": { "tools": true, "vision": false, "streaming": true },
+      "residency": ["on-prem", "any", "eu"],
+      "cost_model": "infra-only"
+    }
+  ]
+}

package/templates/contextkit/squads/agent-forge/router/decision-rules.json

@@ -0,0 +1,120 @@
+{
+  "_note": "Deterministic SHORTLISTS for the model-router. Rules return candidate id arrays; the EVAL HARNESS picks the actual best from the shortlist (ADR-0012 §5). NO hardcoded quality claims here. Capped at 15 rules per blueprint §12 — split by intent category if you outgrow it. Operators in `when`: literal (===), array (oneOf), or { '$gt'|'$gte'|'$lt'|'$lte'|'$eq': value }.",
+  "updated": "2026-05-26",
+  "version": "0.1.0",
+  "max_rules": 15,
+  "rules": [
+    {
+      "id": "residency-no-cloud",
+      "when": { "privacy.allow_cloud_providers": false },
+      "then": {
+        "primary_candidates": ["self-hosted/llama-3.x-70b", "self-hosted/mistral-large"]
+      },
+      "abort_if_no_candidate": true
+    },
+    {
+      "id": "residency-on-prem",
+      "when": { "privacy.data_residency": "on-prem" },
+      "then": {
+        "primary_candidates": ["self-hosted/llama-3.x-70b", "self-hosted/mistral-large"]
+      },
+      "abort_if_no_candidate": true
+    },
+    {
+      "id": "classification-low",
+      "when": { "intent.category": "classification", "intent.complexity": "low" },
+      "then": {
+        "primary_candidates": ["anthropic/claude-haiku-4-5", "google/gemini-2.5-flash", "openai/gpt-4o-mini"],
+        "fallback_candidates": ["deepseek/deepseek-v3"]
+      }
+    },
+    {
+      "id": "extraction-simple",
+      "when": { "intent.category": "extraction", "intent.complexity": ["low", "medium"] },
+      "then": {
+        "primary_candidates": ["anthropic/claude-sonnet-4-6", "anthropic/claude-haiku-4-5"],
+        "fallback_candidates": ["google/gemini-2.5-pro", "openai/gpt-4o"],
+        "cheap_path": "anthropic/claude-haiku-4-5"
+      }
+    },
+    {
+      "id": "extraction-high",
+      "when": { "intent.category": "extraction", "intent.complexity": "high" },
+      "then": {
+        "primary_candidates": ["anthropic/claude-sonnet-4-6"],
+        "fallback_candidates": ["openai/gpt-4o", "google/gemini-2.5-pro"],
+        "premium_path": "anthropic/claude-opus-4-7"
+      }
+    },
+    {
+      "id": "rag-answer-large-context",
+      "when": { "intent.category": "rag-answer", "context_window_needed_tokens": { "$gt": 200000 } },
+      "then": {
+        "primary_candidates": ["google/gemini-2.5-pro"],
+        "fallback_candidates": ["anthropic/claude-sonnet-4-6"]
+      }
+    },
+    {
+      "id": "rag-answer",
+      "when": { "intent.category": "rag-answer" },
+      "then": {
+        "primary_candidates": ["anthropic/claude-sonnet-4-6"],
+        "fallback_candidates": ["openai/gpt-4o", "deepseek/deepseek-v3"]
+      }
+    },
+    {
+      "id": "coding-high",
+      "when": { "intent.category": "coding", "intent.complexity": "high" },
+      "then": {
+        "primary_candidates": ["anthropic/claude-sonnet-4-6"],
+        "fallback_candidates": ["openai/gpt-4o"],
+        "cheap_path": "deepseek/deepseek-coder",
+        "premium_path": "anthropic/claude-opus-4-7"
+      }
+    },
+    {
+      "id": "coding",
+      "when": { "intent.category": "coding" },
+      "then": {
+        "primary_candidates": ["anthropic/claude-sonnet-4-6", "deepseek/deepseek-coder"],
+        "fallback_candidates": ["openai/gpt-4o"],
+        "cheap_path": "deepseek/deepseek-coder"
+      }
+    },
+    {
+      "id": "reasoning-high",
+      "when": { "intent.category": "reasoning", "intent.complexity": "high" },
+      "then": {
+        "primary_candidates": ["anthropic/claude-opus-4-7"],
+        "fallback_candidates": ["openai/gpt-4o", "google/gemini-2.5-pro"],
+        "cheap_path": "anthropic/claude-sonnet-4-6"
+      }
+    },
+    {
+      "id": "agentic-multi-step",
+      "when": { "intent.category": "agentic-multi-step" },
+      "then": {
+        "primary_candidates": ["anthropic/claude-sonnet-4-6", "anthropic/claude-opus-4-7"],
+        "fallback_candidates": ["openai/gpt-4o"]
+      }
+    },
+    {
+      "id": "summarization",
+      "when": { "intent.category": "summarization" },
+      "then": {
+        "primary_candidates": ["anthropic/claude-haiku-4-5", "google/gemini-2.5-flash"],
+        "fallback_candidates": ["anthropic/claude-sonnet-4-6"]
+      }
+    },
+    {
+      "id": "default-balanced",
+      "when": {},
+      "then": {
+        "primary_candidates": ["anthropic/claude-sonnet-4-6"],
+        "fallback_candidates": ["openai/gpt-4o", "google/gemini-2.5-pro"],
+        "cheap_path": "anthropic/claude-haiku-4-5",
+        "premium_path": "anthropic/claude-opus-4-7"
+      }
+    }
+  ]
+}

package/templates/contextkit/squads/agent-forge/templates/agent-package/.agentforgerc

@@ -0,0 +1,12 @@
+{
+  "apf_version": "1",
+  "package_version": "0.1.0",
+  "checksum": "{{SHA256_OF_PACKAGE_CONTENTS}}",
+  "provenance": {
+    "forged_by": "agent-forge@{{FORGE_VERSION}}",
+    "blueprint_hash": "{{SHA256}}",
+    "eval_run": "{{EVAL_RUN_ID}}",
+    "eval_passed_at": "{{ISO8601}}",
+    "authorizing_adr": "{{ADR-XXXX}}"
+  }
+}

package/templates/contextkit/squads/agent-forge/templates/agent-package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog — {{AGENT_NAME}}
+
+Semver, strict. **Major** = contract break (tool removed, intent changes, input/output
+schema changes). **Minor** = additive capability or tool, no break. **Patch** = prompt
+fix, threshold tweak, or model swap within the same family + generation.
+
+Each version carries a provenance hash in `.agentforgerc` (which forge version, which
+blueprint, which eval run, which authorizing ADR).
+
+## [0.1.0] - {{YYYY-MM-DD}}
+
+### Added
+- Initial forge by agent-forge.

package/templates/contextkit/squads/agent-forge/templates/agent-package/LICENSE

@@ -0,0 +1,5 @@
+{{CHOOSE_A_LICENSE}}
+
+This Agent Package is licensed by its author. Replace this file with your chosen
+license (e.g. MIT, Apache-2.0, or a proprietary notice). agent-forge does not impose
+one — the package is yours.