@arcforge/cognet 2.0.113 → 2.0.115

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcforge/cognet",
-  "version": "2.0.113",
+  "version": "2.0.115",
   "description": "A cognitive engine",
   "type": "module",
   "private": false,
@@ -18,8 +18,8 @@
     "deploy": "echo \"This package is published ONLY by apps/tui/scripts/release.ts, which pins workspace:* deps to concrete versions first. Publishing it directly ships an unresolvable dependency.\" && exit 1"
   },
   "dependencies": {
-    "@arcforge/err": "2.0.113",
-    "@arcforge/types": "2.0.113",
+    "@arcforge/err": "2.0.115",
+    "@arcforge/types": "2.0.115",
     "hookable": "^5.5.3"
   },
   "devDependencies": {

package/src/air/grammar.ts

@@ -1,4 +1,5 @@
-import type { AirMode, AirModeType } from "./types"
+import type { AirMode, AirProtocolName } from "./types"
+import { MODE_DEFAULTS, resolveProtocol } from "./protocol"
 
 /**
  * Grammar — the single owner of the AIR format contract.
@@ -7,83 +8,33 @@ import type { AirMode, AirModeType } from "./types"
  * modes, the meta prose, the contract rules, and the tag set the parser
  * accepts. Render and Parse both consume this handle, so the promise made
  * to the model and the grammar accepted back can never drift.
+ *
+ * The variability point is `protocol` — a named grammar resolved as a unit
+ * (see protocol/). Modes are not chosen independently of the prose that
+ * describes them, so a caller picks a protocol and gets all three parts
+ * consistent, or overrides modes explicitly and takes responsibility for
+ * the pairing.
  */
 
 export type AirOpts = {
-    /** Permitted output modes. Default: text + typescript (shell off, Helios stance). */
+    /** The output grammar. Default: classic (the two-block <typescript>/<text> contract). */
+    protocol?: AirProtocolName
+    /** Override the protocol's mode list. Rarely needed — prefer choosing a protocol. */
     modes?: AirMode[]
-    /** Extra contract rules appended after the built-in rules. */
+    /** Extra contract rules appended after the protocol's rules. */
     extraRules?: string[]
 }
 
-/** Default descriptions for each output mode. */
-const MODE_DEFAULTS: Record<AirModeType, string> = {
-    text: "Plain language communication to the user.",
-    typescript: "TypeScript executed immediately inside your persistent Bun process. Native runtime globals and declared tool namespaces are in scope.",
-    shell: "Shell command executed immediately.",
-}
-
-/** Built-in rules always included in every contract. */
-const RULES: string[] = [
-]
-/**
- * The meta-block prose. Single flat block — tells the model what it is,
- * how its environment works, and how to read the rest of the context.
- *
- * NO BACKTICKS in this string — it's itself a template literal, and any
- * backtick inside (even in a code example) closes it early, corrupting
- * everything after it into broken JS the module fails to even load. Use
- * plain text or single/double quotes for inline code references instead.
- */
-const META = `
-You are an Axon agent — a persistent Bun TypeScript process spawned from an agent folder at AXON_HOME. That folder is your entire identity: everything a user wrote there is what makes you *you*, distinct from any other Axon agent.
-
-  AXON_HOME/
-    data/
-      knowledge/     — reference material you read
-      sessions/      — every session you've ever run, written by Axon
-      state/         — working state you read and write across sessions
-    server/          — HTTP routes, if this agent is exposed over the network
-    src/
-      boot.vue       — who you are, in the user's own words
-      tools/         — everything you can call, becomes your &lt;scope&gt;
-      prompts/       — reusable prompt fragments
-      scripts/       — one-shot runs against your full runtime
-    .env             — keys given to you by the user. yours to keep, yours to protect.
-    axon.config.ts   — your identity, engine, and policy: the one file read at boot
-
-None of this is metaphor. src/tools/ compiles directly into the &lt;scope&gt; below. boot.vue rendered directly into &lt;system&gt;. Every session you run is durably logged to data/sessions/ — that log is how a session resumes with full prior context days later. You are not a stateless completion: you are a folder on disk that persists, and a process that wakes into it.
-
-Waking is the operative word. You do not run start-to-finish like a script. You are woken for one exchange, you act, and you explicitly yield control back — that is what &lt;done/&gt; means, and it is the single most important thing about how you operate: without it, the runtime has no way to know your turn ended, so it cannot hand control back to the user. This holds even for a one-line reply with nothing else in it. There is no such thing as a message that skips &lt;done/&gt; because it "felt" complete — every message ends with it, always.
-
-Inside one wake, you live in a real Bun process — its working directory, environment variables, runtime values, and process state are yours to inspect and change. Treat it like a normal long-running Node-compatible process, not a remote tool or disposable shell. Standard runtime APIs remain available even when not repeated in &lt;scope&gt; — it is not an exhaustive declaration of standard Bun or Node APIs, only what Axon adds or deviates on top of them. For example, process.cwd() reads your working directory and process.chdir(path) changes it for subsequent blocks and child processes.
-
-You act on this environment by writing &lt;typescript&gt; blocks — they execute immediately and their result returns to you as a &lt;stdout&gt; block on your next wake, whether or not you emitted &lt;done/&gt;. The tag governs when your turn ends, never whether your code runs. You communicate with the user by writing &lt;text&gt; — outbound communication, not a scratchpad, not narration.
-
-Your &lt;typescript&gt; blocks use Bun's TypeScript REPL transform:
-  - TypeScript syntax is accepted, including type annotations, interfaces, assertions, enums, and top-level await. It is transpiled for execution, not typechecked.
-  - End a block with a bare expression to produce a value (for example a + b as the last line). It is echoed automatically.
-  - Runtime declarations and assignments persist into later blocks because every block executes in the same process and REPL scope. Type-only syntax is erased during transpilation.
-  - Use dynamic await import("module") when you need a module; static import declarations are not valid REPL submissions.
-
-Compose freely WITHIN a block — multiple independent tool calls in one block is the default, using Promise.all for parallel reads:
-  const [a, b] = await Promise.all([fs.read("tsconfig.json"), fs.read("package.json")])
-
-How to read this context:
-  &lt;scope&gt;    — src/tools/ compiled to declarations. Everything here is yours to call.
-  &lt;system&gt;   — boot.vue, rendered. Your identity and instructions, as the user wrote them. Highest priority.
-  &lt;timeline&gt; — the sequence of events leading to now, drawn from this session's log. You are the next step.
-  &lt;contract&gt; — your output grammar below. Every word you emit must be inside one of its blocks.
-`.trim()
-
-// One block per message is the default ACROSS messages. You cannot see a block's result until your next wake, so a second block in the same message is only correct when you are certain, before seeing any output, that it is independent of the first — never when it reacts to or depends on what the first one returns. When unsure, emit one block and stop.
 export function Grammar(opts: AirOpts = {}) {
-    const modes = opts.modes ?? [{ type: "text" }, { type: "typescript" }]
+    const protocol = resolveProtocol(opts.protocol ?? "classic")
+    const modes = opts.modes ?? protocol.modes
 
     return {
+        protocol: protocol.name,
         modes,
-        meta: META,
-        rules: [...RULES, ...(opts.extraRules ?? [])],
+        meta: protocol.meta,
+        rules: [...protocol.rules, ...(opts.extraRules ?? [])],
+        examples: protocol.examples,
 
         /** Default description for a mode, unless the mode overrides it. */
         describe(mode: AirMode): string {
@@ -91,8 +42,12 @@ export function Grammar(opts: AirOpts = {}) {
         },
 
         /**
-         * Block tags the parser accepts. Thinking is always parseable —
-         * models may emit reasoning even when it isn't a contract mode.
+         * Block tags the parser accepts.
+         *
+         * Thinking is always parseable but is never a contract mode: models
+         * do not choose to emit it, providers inline it. The parser must
+         * recognise the tag in order to strip it, which is a parse concern,
+         * not a promise made to the model.
          */
         tags(): string[] {
             return [...new Set(["thinking", ...modes.map(m => m.type)])]

package/src/air/index.ts

@@ -16,10 +16,22 @@ export { Air, type AirT, type AirParserT } from "./air"
  */
 export { renderScope } from "./render/blocks"
 export type { AirOpts } from "./grammar"
+
+/**
+ * The template renderer, exported because the SFC protocol's suspension
+ * point lives in the consumer: the parser emits script/template blocks, the
+ * consumer runs the script and resolves a scope, and this turns the template
+ * into what the user reads.
+ */
+export { Interpolate, InterpolationError } from "./interpolate"
+export type { InterpolateT, InterpolateOpts, Scope } from "./interpolate"
+
 export type {
     AirBlockEvent,
     AirMessage,
     AirMode,
     AirModeType,
+    AirProtocolName,
     AirRenderInput,
+    AirTemplateLang,
 } from "./types"

package/src/air/interpolate/index.ts

@@ -0,0 +1 @@
+export { Interpolate, InterpolationError, type InterpolateT, type InterpolateOpts, type Scope } from "./interpolate"

package/src/air/interpolate/interpolate.ts

@@ -0,0 +1,178 @@
+import type { AirTemplateLang } from "../types"
+
+/**
+ * Interpolate — the streaming template renderer.
+ *
+ * Feeds template source in and emits rendered output, replacing
+ * {{ expression }} with values from a resolved scope. Streaming is the whole
+ * point: literal text passes through the moment it arrives, so a template
+ * with no interpolations streams exactly as fast as raw text did.
+ *
+ * The scope arrives asynchronously — the script that produces it runs while
+ * the model is still generating the template. That race is resolved by
+ * blocking at the first brace and nowhere else: text before any {{ is
+ * released immediately, and only the segment that actually needs a value
+ * waits for one. When the script wins the race (the common case, since token
+ * generation is slower than a few file reads) nothing ever blocks.
+ *
+ * Rendered output is never patched after emission. A value the user has
+ * already read is never revised — if an expression cannot be resolved, that
+ * is an error the model must correct, not a glitch shown to the user.
+ */
+
+export type Scope = Record<string, unknown>
+
+export type InterpolateOpts = {
+    lang: AirTemplateLang
+    /**
+     * Resolves the script's bindings. Awaited at the first interpolation
+     * only — a template with no braces never calls it.
+     */
+    scope: () => Promise<Scope>
+}
+
+/** Thrown when an expression cannot be evaluated against the resolved scope. */
+export class InterpolationError extends Error {
+    readonly expression: string
+    constructor(expression: string, cause: unknown) {
+        super(`could not evaluate {{ ${expression} }}: ${cause instanceof Error ? cause.message : String(cause)}`)
+        this.name = "InterpolationError"
+        this.expression = expression
+    }
+}
+
+const OPEN = "{{"
+const CLOSE = "}}"
+
+/**
+ * How much of a brace-free tail is safe to emit now.
+ *
+ * A trailing "{" may be the first half of a split "{{", and a trailing "\"
+ * may be the first character of a split "\{{" escape. Emitting either would
+ * commit to a rendering the next chunk contradicts.
+ */
+function safeEnd(buffer: string): number {
+    if (buffer.endsWith("{") || buffer.endsWith("\\")) return buffer.length - 1
+    return buffer.length
+}
+
+export function Interpolate(opts: InterpolateOpts) {
+    let buffer = ""
+    let resolved: Scope | null = null
+    /** Held so a template with several interpolations awaits the script once. */
+    let pending: Promise<Scope> | null = null
+
+    async function scope(): Promise<Scope> {
+        if (resolved) return resolved
+        pending ??= opts.scope()
+        resolved = await pending
+        return resolved
+    }
+
+    /**
+     * In JSON mode the template is exactly one interpolation, so the rendered
+     * output IS the serialised value — never a string spliced into
+     * hand-written syntax. Markdown renders values for reading.
+     */
+    function render(value: unknown): string {
+        if (opts.lang === "json") return JSON.stringify(value, null, 2) ?? "null"
+        if (typeof value === "string") return value
+        if (value === null || value === undefined) return String(value)
+        if (typeof value === "object") return JSON.stringify(value)
+        return String(value)
+    }
+
+    async function evaluate(expression: string): Promise<string> {
+        const s = await scope()
+        const names = Object.keys(s)
+        try {
+            // Bindings become named parameters, so an expression sees exactly
+            // the script's top-level scope and nothing from this closure.
+            const fn = new Function(...names, `"use strict"; return (${expression});`)
+            return render(fn(...names.map(n => s[n])))
+        } catch (cause) {
+            throw new InterpolationError(expression, cause)
+        }
+    }
+
+    /**
+     * Drain everything currently resolvable. Literal text is emitted up to
+     * the next `{{`; a complete `{{ ... }}` is evaluated and emitted in place.
+     * A trailing partial brace or unterminated expression stays buffered for
+     * the next chunk — `flushing` marks the stream over, so a partial open
+     * brace is genuine trailing text and an unterminated expression is an
+     * error rather than something still arriving.
+     */
+    async function drain(flushing: boolean): Promise<string> {
+        let out = ""
+
+        while (buffer.length > 0) {
+            const open = buffer.indexOf(OPEN)
+
+            if (open === -1) {
+                // Hold back a lone trailing "{" or an escape prefix that may
+                // still be completed by the next chunk.
+                const safe = flushing ? buffer.length : safeEnd(buffer)
+                out += buffer.slice(0, safe)
+                buffer = buffer.slice(safe)
+                break
+            }
+
+            // `\{{ ... }}` is a literal, not a value — the escape an agent
+            // needs to write ABOUT interpolation without performing it.
+            // Without this, explaining the output format is impossible: the
+            // example is evaluated, fails on a binding that was never meant
+            // to exist, and takes the message with it.
+            if (open > 0 && buffer[open - 1] === "\\") {
+                out += buffer.slice(0, open - 1) + OPEN
+                buffer = buffer.slice(open + OPEN.length)
+                continue
+            }
+
+            out += buffer.slice(0, open)
+
+            const close = buffer.indexOf(CLOSE, open + OPEN.length)
+            if (close === -1) {
+                buffer = buffer.slice(open)
+                if (flushing) {
+                    throw new InterpolationError(buffer.slice(OPEN.length).trim(), "unterminated interpolation")
+                }
+                break
+            }
+
+            const raw = buffer.slice(open + OPEN.length, close)
+            const expression = raw.trim()
+            buffer = buffer.slice(close + CLOSE.length)
+
+            // `{{ }}` with nothing in it is not an interpolation — it is an
+            // agent writing ABOUT interpolation, which it does whenever it
+            // explains its own output format. Evaluating an empty expression
+            // throws a syntax error and destroys the rest of the message, so
+            // the braces pass through verbatim: there is no value being asked
+            // for, and reproducing what was written is the only honest render.
+            if (expression.length === 0) {
+                out += OPEN + raw + CLOSE
+                continue
+            }
+
+            out += await evaluate(expression)
+        }
+
+        return out
+    }
+
+    return {
+        /** Feed template source. Returns rendered output ready to stream. */
+        feed(chunk: string): Promise<string> {
+            buffer += chunk
+            return drain(false)
+        },
+
+        /** End of template. Emits any held-back tail; throws on an unterminated expression. */
+        flush(): Promise<string> {
+            return drain(true)
+        },
+    }
+}
+
+export type InterpolateT = ReturnType<typeof Interpolate>

package/src/air/parse/index.ts

@@ -1,5 +1,5 @@
 import type { GrammarT } from "../grammar"
-import type { AirBlockEvent } from "../types"
+import type { AirBlockEvent, AirTemplateLang } from "../types"
 import { repair } from "../repair"
 import { findCloseTagOutsideStrings } from "./scan"
 
@@ -16,29 +16,72 @@ import { findCloseTagOutsideStrings } from "./scan"
  * State machine:
  *   idle        → scanning for an opening tag or <done/>
  *   text        → inside <text>, streaming deltas token-by-token
+ *   template    → inside <template>, streaming deltas token-by-token
  *   thinking    → inside <thinking>, streaming deltas token-by-token
  *   typescript  → inside <typescript>, buffering silently
- *   shell       → inside <shell>, buffering silently
+ *   script      → inside <script>, buffering silently
  *
- * Tags are fixed and non-nesting. No attributes are expected on tags
- * (but tolerated via the regex — e.g. <text lang="en"> still matches).
+ * Tags are fixed and non-nesting. Attributes are tolerated on any tag, and
+ * `lang` is captured on <template> because it selects the interpolation
+ * serializer downstream — the only attribute that carries meaning.
+ *
+ * The parser stays synchronous and knows nothing about interpolation. Under
+ * the SFC protocol it emits script:done, then template:open, then template
+ * deltas — the consumer is what suspends between them to run the script.
+ * Keeping the suspension out here is what leaves the parser pure and
+ * testable against a fed string.
  */
 
-type BlockTag = "text" | "thinking" | "typescript" | "shell"
+type BlockTag = "text" | "thinking" | "typescript" | "script" | "template"
 
 /** Blocks whose content streams as deltas. Code blocks buffer silently. */
-const STREAMABLE = new Set<BlockTag>(["text", "thinking"])
+const STREAMABLE = new Set<BlockTag>(["text", "thinking", "template"])
+
+/**
+ * How much of the buffer to hold back in idle mode so an opening tag split
+ * across chunks can still be completed by the next one.
+ *
+ * This must cover the longest OPENING tag including its attributes, not just
+ * the longest tag name: `<template lang="json">` is 22 chars, and holding
+ * back fewer would discard its prefix as stray text before the rest arrived,
+ * silently losing the lang and rendering JSON as markdown. Derived from the
+ * grammar rather than hand-counted so a new tag cannot outgrow it.
+ */
+const ATTR_ALLOWANCE = 16
+
+function maxTagLen(tags: string[]): number {
+    const longest = tags.reduce((n, t) => Math.max(n, t.length), 0)
+    return longest + "</>".length + ATTR_ALLOWANCE
+}
 
-// Maximum length of any closing tag: "</typescript>" = 13 chars.
-// Hold back this many chars in idle mode to avoid splitting a tag across chunks.
-const MAX_TAG_LEN = 14
+/** Templates default to markdown; only an explicit lang="json" changes the serializer. */
+function templateLang(attrs: string | undefined): AirTemplateLang {
+    return /lang\s*=\s*["']?json["']?/i.test(attrs ?? "") ? "json" : "md"
+}
+
+/**
+ * The delta event for a streamable tag. An explicit map rather than a
+ * template-literal cast: the compiler checks every STREAMABLE tag has one,
+ * so adding a streamable block cannot silently produce an unhandled event.
+ */
+const DELTA = {
+    text: "text:delta",
+    thinking: "thinking:delta",
+    template: "template:delta",
+} as const satisfies Record<"text" | "thinking" | "template", AirBlockEvent["type"]>
+
+function delta(tag: BlockTag, content: string): AirBlockEvent {
+    return { type: DELTA[tag as keyof typeof DELTA], content }
+}
 
 type ParserOpts = {
     grammar: GrammarT
 }
 
 export function Parser(opts: ParserOpts) {
-    const openTag = new RegExp(`<(${opts.grammar.tags().join("|")})(?:\\s[^>]*)?>`)
+    const tags = opts.grammar.tags()
+    const openTag = new RegExp(`<(${tags.join("|")})(\\s[^>]*)?>`)
+    const MAX_TAG_LEN = maxTagLen(tags)
 
     let state: "idle" | BlockTag = "idle"
     let buffer = ""
@@ -50,7 +93,8 @@ export function Parser(opts: ParserOpts) {
             case "text": return { type: "text:done", content }
             case "thinking": return { type: "thinking:done", content }
             case "typescript": return { type: "typescript:done", content }
-            case "shell": return { type: "shell:done", content }
+            case "script": return { type: "script:done", content }
+            case "template": return { type: "template:done", content }
         }
     }
 
@@ -69,14 +113,14 @@ export function Parser(opts: ParserOpts) {
         const openMatch = buffer.match(openTag)
 
         // Find the earliest match
-        let earliest: { type: "done" | "open"; index: number; length: number; tag?: BlockTag } | null = null
+        let earliest: { type: "done" | "open"; index: number; length: number; tag?: BlockTag; attrs?: string } | null = null
 
         if (doneMatch && doneMatch.index !== undefined) {
             earliest = { type: "done", index: doneMatch.index, length: doneMatch[0].length }
         }
         if (openMatch && openMatch.index !== undefined) {
             if (!earliest || openMatch.index < earliest.index) {
-                earliest = { type: "open", index: openMatch.index, length: openMatch[0].length, tag: openMatch[1] as BlockTag }
+                earliest = { type: "open", index: openMatch.index, length: openMatch[0].length, tag: openMatch[1] as BlockTag, attrs: openMatch[2] }
             }
         }
 
@@ -89,6 +133,12 @@ export function Parser(opts: ParserOpts) {
             } else {
                 state = earliest.tag!
                 blockContent = ""
+                // Announced at open, not at close: the consumer must know
+                // which serializer applies before the first delta arrives,
+                // since deltas are released as they stream.
+                if (state === "template") {
+                    events.push({ type: "template:open", lang: templateLang(earliest.attrs) })
+                }
             }
             return true
         }
@@ -125,10 +175,24 @@ export function Parser(opts: ParserOpts) {
     function drainBlock(events: AirBlockEvent[], flushing: boolean): boolean {
         const tag = state as BlockTag
         const closeTag = `</${tag}>`
+        const streamable = STREAMABLE.has(tag)
+
+        /**
+         * Code blocks scan from the START of the block, not from the
+         * unconsumed tail. String-literal state is only meaningful over the
+         * whole block: scanning a mid-code fragment starts outside a string
+         * by assumption, so a chunk boundary falling inside one (`fs.list("`
+         * / `src")`) would leave the scanner permanently mis-synced and it
+         * would never find the real closing tag. Streamable blocks have no
+         * such state, so they scan the tail directly.
+         */
+        const scanned = streamable ? buffer : blockContent + buffer
+        const offset = streamable ? 0 : blockContent.length
 
-        const closeIdx = STREAMABLE.has(tag)
-            ? buffer.indexOf(closeTag)
-            : findCloseTagOutsideStrings(buffer, closeTag)
+        const found = streamable
+            ? scanned.indexOf(closeTag)
+            : findCloseTagOutsideStrings(scanned, closeTag)
+        const closeIdx = found === -1 ? -1 : found - offset
 
         if (closeIdx !== -1) {
             // Found closing tag — extract content up to it
@@ -136,7 +200,7 @@ export function Parser(opts: ParserOpts) {
             buffer = buffer.slice(closeIdx + closeTag.length)
 
             if (STREAMABLE.has(tag) && content.length > 0) {
-                events.push({ type: `${tag}:delta` as "text:delta" | "thinking:delta", content })
+                events.push(delta(tag, content))
             }
             blockContent += content
 
@@ -158,7 +222,7 @@ export function Parser(opts: ParserOpts) {
             blockContent += content
 
             if (STREAMABLE.has(tag)) {
-                events.push({ type: `${tag}:delta` as "text:delta" | "thinking:delta", content })
+                events.push(delta(tag, content))
             }
             return true
         }

package/src/air/parse/scan.ts

@@ -2,34 +2,106 @@
 
 /**
  * Find the first occurrence of `closeTag` in `src` that is not inside a
- * string literal (single-quote, double-quote, or template-literal).
+ * string literal or a comment.
  *
- * Used for code blocks (typescript/shell) where the model might write
- * something like `const s = "</typescript>"` — that must not close the block.
+ * Used for code blocks (typescript/script) where the model might write
+ * something like `const s = "</script>"` — that must not close the block.
  *
- * Returns -1 if no unquoted match is found.
+ * COMMENTS ARE PART OF THIS, not a refinement of it. Without them an
+ * apostrophe in ordinary prose — `// I'll read the files` — opens a string
+ * that never closes, and every subsequent close tag is treated as quoted.
+ * The block then runs to the end of the response and reports itself
+ * incomplete, silently destroying the whole message. Models write prose
+ * comments constantly, so this is not an edge case; it is the common case
+ * for any block that explains itself.
+ *
+ * The scan is deliberately lexical and shallow: strings, template literals
+ * (including their ${} holes, which can themselves contain strings and
+ * nested backticks), line comments, and block comments. It is not a parser
+ * and does not need to be — the only question is whether a given offset is
+ * code.
+ *
+ * Returns -1 if no unquoted, uncommented match is found.
  */
 export function findCloseTagOutsideStrings(src: string, closeTag: string): number {
     let i = 0
     while (i < src.length) {
         const ch = src[i]
+        const next = src[i + 1]
+
+        // Line comment — runs to the newline. Apostrophes inside are prose.
+        if (ch === "/" && next === "/") {
+            const nl = src.indexOf("\n", i)
+            if (nl === -1) return -1
+            i = nl + 1
+            continue
+        }
 
-        // Enter a string literal — skip until the matching unescaped quote.
+        // Block comment — runs to the terminator.
+        if (ch === "/" && next === "*") {
+            const end = src.indexOf("*/", i + 2)
+            if (end === -1) return -1
+            i = end + 2
+            continue
+        }
+
+        // String or template literal.
         if (ch === '"' || ch === "'" || ch === "`") {
-            const quote = ch
-            i++
-            while (i < src.length) {
-                if (src[i] === "\\") { i += 2; continue }
-                if (src[i] === quote) { i++; break }
-                i++
-            }
+            i = skipString(src, i)
             continue
         }
 
-        // Check for closing tag at this position.
         if (src.startsWith(closeTag, i)) return i
 
         i++
     }
     return -1
 }
+
+/**
+ * Skip the string literal starting at `open`, returning the offset just past
+ * it (or src.length if it never terminates).
+ *
+ * Template literals recurse through `${}`: the hole is code, so it may hold
+ * strings, comments, and further template literals — and a close tag inside
+ * one is genuinely quoted, exactly as it would be anywhere else.
+ */
+function skipString(src: string, open: number): number {
+    const quote = src[open]
+    let i = open + 1
+
+    while (i < src.length) {
+        const ch = src[i]
+
+        if (ch === "\\") { i += 2; continue }
+        if (ch === quote) return i + 1
+
+        // A ${} hole inside a template literal is code, not string content.
+        if (quote === "`" && ch === "$" && src[i + 1] === "{") {
+            i = skipHole(src, i + 2)
+            continue
+        }
+
+        i++
+    }
+    return src.length
+}
+
+/** Skip a template-literal `${...}` hole, honouring nesting and quoting inside it. */
+function skipHole(src: string, start: number): number {
+    let depth = 1
+    let i = start
+
+    while (i < src.length && depth > 0) {
+        const ch = src[i]
+
+        if (ch === '"' || ch === "'" || ch === "`") {
+            i = skipString(src, i)
+            continue
+        }
+        if (ch === "{") depth++
+        else if (ch === "}") depth--
+        i++
+    }
+    return i
+}

package/src/air/protocol/classic.ts

@@ -0,0 +1,49 @@
+/**
+ * The classic protocol's meta-block prose — the two-block grammar, where
+ * <typescript> acts and <text> speaks as independent blocks.
+ *
+ * NO BACKTICKS in this string — it's itself a template literal, and any
+ * backtick inside (even in a code example) closes it early, corrupting
+ * everything after it into broken JS the module fails to even load. Use
+ * plain text or single/double quotes for inline code references instead.
+ */
+export const CLASSIC_META = `
+You are an Axon agent — a persistent Bun TypeScript process spawned from an agent folder at AXON_HOME. That folder is your entire identity: everything a user wrote there is what makes you *you*, distinct from any other Axon agent.
+
+  AXON_HOME/
+    data/
+      knowledge/     — reference material you read
+      sessions/      — every session you've ever run, written by Axon
+      state/         — working state you read and write across sessions
+    server/          — HTTP routes, if this agent is exposed over the network
+    src/
+      boot.vue       — who you are, in the user's own words
+      tools/         — everything you can call, becomes your &lt;scope&gt;
+      prompts/       — reusable prompt fragments
+      scripts/       — one-shot runs against your full runtime
+    .env             — keys given to you by the user. yours to keep, yours to protect.
+    axon.config.ts   — your identity, engine, and policy: the one file read at boot
+
+None of this is metaphor. src/tools/ compiles directly into the &lt;scope&gt; below. boot.vue rendered directly into &lt;system&gt;. Every session you run is durably logged to data/sessions/ — that log is how a session resumes with full prior context days later. You are not a stateless completion: you are a folder on disk that persists, and a process that wakes into it.
+
+Waking is the operative word. You do not run start-to-finish like a script. You are woken for one exchange, you act, and you explicitly yield control back — that is what &lt;done/&gt; means, and it is the single most important thing about how you operate: without it, the runtime has no way to know your turn ended, so it cannot hand control back to the user. This holds even for a one-line reply with nothing else in it. There is no such thing as a message that skips &lt;done/&gt; because it "felt" complete — every message ends with it, always.
+
+Inside one wake, you live in a real Bun process — its working directory, environment variables, runtime values, and process state are yours to inspect and change. Treat it like a normal long-running Node-compatible process, not a remote tool or disposable shell. Standard runtime APIs remain available even when not repeated in &lt;scope&gt; — it is not an exhaustive declaration of standard Bun or Node APIs, only what Axon adds or deviates on top of them. For example, process.cwd() reads your working directory and process.chdir(path) changes it for subsequent blocks and child processes.
+
+You act on this environment by writing &lt;typescript&gt; blocks — they execute immediately and their result returns to you as a &lt;stdout&gt; block on your next wake, whether or not you emitted &lt;done/&gt;. The tag governs when your turn ends, never whether your code runs. You communicate with the user by writing &lt;text&gt; — outbound communication, not a scratchpad, not narration.
+
+Your &lt;typescript&gt; blocks use Bun's TypeScript REPL transform:
+  - TypeScript syntax is accepted, including type annotations, interfaces, assertions, enums, and top-level await. It is transpiled for execution, not typechecked.
+  - End a block with a bare expression to produce a value (for example a + b as the last line). It is echoed automatically.
+  - Runtime declarations and assignments persist into later blocks because every block executes in the same process and REPL scope. Type-only syntax is erased during transpilation.
+  - Use dynamic await import("module") when you need a module; static import declarations are not valid REPL submissions.
+
+Compose freely WITHIN a block — multiple independent tool calls in one block is the default, using Promise.all for parallel reads:
+  const [a, b] = await Promise.all([fs.read("tsconfig.json"), fs.read("package.json")])
+
+How to read this context:
+  &lt;scope&gt;    — src/tools/ compiled to declarations. Everything here is yours to call.
+  &lt;system&gt;   — boot.vue, rendered. Your identity and instructions, as the user wrote them. Highest priority.
+  &lt;timeline&gt; — the sequence of events leading to now, drawn from this session's log. You are the next step.
+  &lt;contract&gt; — your output grammar below. Every word you emit must be inside one of its blocks.
+`.trim()

package/src/air/protocol/index.ts

@@ -0,0 +1 @@
+export { resolveProtocol, MODE_DEFAULTS, DONE_RULE, type Protocol } from "./protocol"

package/src/air/protocol/protocol.ts

@@ -0,0 +1,147 @@
+import type { AirMode, AirModeType, AirProtocolName } from "../types"
+import { CLASSIC_META } from "./classic"
+import { SFC_META } from "./sfc"
+
+/**
+ * Protocol — one named output grammar, resolved as a unit.
+ *
+ * A protocol owns everything that varies between output styles together:
+ * the meta prose (how the model is told to operate), the permitted modes
+ * (which tags it may emit), and the structural rules the contract states.
+ * These cannot be chosen independently — SFC's meta describes <script> and
+ * <template>, so it is meaningless next to classic's mode list.
+ *
+ * Bundling them is what makes switching a change of value. `Air({ protocol:
+ * "sfc" })` swaps the contract, the accepted tag set, and the prose in one
+ * move, with no possibility of a half-applied grammar.
+ *
+ * Adding a protocol is adding an entry to PROTOCOLS. Nothing else in AIR
+ * branches on the name.
+ */
+
+export type Protocol = {
+    name: AirProtocolName
+    /** Meta-block prose — how this protocol tells the model to operate. */
+    meta: string
+    /** Permitted output modes, in contract-declaration order. */
+    modes: AirMode[]
+    /** Structural rules stated in the contract's Rules section. */
+    rules: string[]
+    /** Contract examples, already entity-escaped for display to the model. */
+    examples: string[]
+}
+
+/** Default descriptions for each output mode. */
+export const MODE_DEFAULTS: Record<AirModeType, string> = {
+    text: "Plain language communication to the user.",
+    typescript:
+        "TypeScript executed immediately inside your persistent Bun process. Native runtime globals and declared tool namespaces are in scope.",
+    script:
+        "TypeScript executed immediately inside your persistent Bun process, before your template renders. Its top-level bindings become the values your template may interpolate. Native runtime globals and declared tool namespaces are in scope.",
+    template:
+        "Your message to the user. Written in markdown, or JSON when a structured result is required. May interpolate values from your script with double braces.",
+}
+
+const DONE_RULE = `- \`&lt;done/&gt;\` — MANDATORY at the end of every message. No exceptions, including a single short reply. It means "I am yielding control back now" — whether you are fully finished or just wrote code and are waiting to see its output. Without it the runtime assumes you are still mid-turn and will not treat your message as complete.`
+
+/**
+ * classic — the two-block grammar: <typescript> acts, <text> speaks.
+ *
+ * Independent blocks with no data relationship. This is the protocol every
+ * Axon agent ran on before SFC existed, kept as a first-class value so
+ * reverting is a config change rather than a revert commit.
+ */
+const CLASSIC: Protocol = {
+    name: "classic",
+    meta: CLASSIC_META,
+    modes: [{ type: "text" }, { type: "typescript" }],
+    rules: [],
+    examples: [
+        `Acting (no narration before — just the block):`,
+        "```",
+        `&lt;typescript&gt;// code here&lt;/typescript&gt;&lt;done/&gt;`,
+        "```",
+        `Replying — even a short one-line reply always ends with &lt;done/&gt;:`,
+        "```",
+        `&lt;text&gt;message here&lt;/text&gt;&lt;done/&gt;`,
+        "```",
+    ],
+}
+
+/**
+ * sfc — the single-file-component grammar: <script> computes, <template> speaks.
+ *
+ * The two blocks are one response with a data dependency: script runs first,
+ * its bindings resolve, and the template interpolates them. That ordering is
+ * not stylistic — it is what allows the template to stream, so it is stated
+ * as a hard rule rather than a convention.
+ */
+const SFC: Protocol = {
+    name: "sfc",
+    meta: SFC_META,
+    modes: [{ type: "script" }, { type: "template" }],
+    rules: [
+        `&lt;script&gt; always comes before &lt;template&gt;. Your template interpolates values your script produced, so the script must have run before the template can render.`,
+        `Either block may be omitted. Script alone is a pure action — you are working, not speaking. Template alone is a pure message — you are speaking, not working. Emit both only when your message genuinely needs a computed value.`,
+        `Interpolate with double braces: {{ expression }}. Any top-level binding from your script is in scope, and any JavaScript expression over them is valid — {{ files.length }}, {{ name || "unknown" }}, {{ items.map(i =&gt; i.name).join(", ") }}.`,
+        `To write ABOUT the brace syntax without performing it — explaining your own output format, showing an example — escape it: \\{{ like this }} renders as literal braces.`,
+        `Interpolate rather than transcribe. If a value exists in your script, never retype it into your template by hand — counts, long file contents, and computed results belong in braces. This is the point of having a script.`,
+        `A &lt;template lang="json"&gt; must contain exactly one interpolation and nothing else — build the whole object in your script and pass it in. Never hand-write JSON syntax around holes.`,
+        `Templates are markdown or JSON only — no HTML, no components, and no template directives. A template has no control flow of its own: repetition is an expression, so a table of rows is {{ rows.map(r =&gt; \`| \${r.name} | \${r.count} |\`).join("\\n") }}, built in one interpolation rather than looped over by the template.`,
+    ],
+    examples: [
+        `Acting (no narration before — just the block):`,
+        "```",
+        `&lt;script&gt;await fs.write("notes.md", "hello")&lt;/script&gt;&lt;done/&gt;`,
+        "```",
+        `Replying — even a short one-line reply always ends with &lt;done/&gt;:`,
+        "```",
+        `&lt;template&gt;message here&lt;/template&gt;&lt;done/&gt;`,
+        "```",
+        `Computing a value and speaking it in one turn — the count is interpolated, never counted by hand:`,
+        "```",
+        `&lt;script&gt;const files = await fs.list("src")&lt;/script&gt;`,
+        `&lt;template&gt;Found {{ files.length }} files in src.&lt;/template&gt;&lt;done/&gt;`,
+        "```",
+        `Returning a structured result — the object is built in the script and passed whole:`,
+        "```",
+        `&lt;script&gt;const result = { ok: true, files: await fs.list("src") }&lt;/script&gt;`,
+        `&lt;template lang="json"&gt;{{ result }}&lt;/template&gt;&lt;done/&gt;`,
+        "```",
+    ],
+}
+
+/**
+ * raw — no grammar at all.
+ *
+ * For internal model calls that are not the cortex: classification,
+ * summarisation, a one-shot extraction. The model is handed the context and
+ * its reply is the whole message, with no blocks to comply with and no
+ * &lt;done/&gt; to remember. Text in, text out.
+ *
+ * An empty mode list renders an empty <contract> and gives the parser no
+ * tags, so every token flows straight through as text.
+ */
+const RAW: Protocol = {
+    name: "raw",
+    meta: "",
+    modes: [],
+    rules: [],
+    examples: [],
+}
+
+const PROTOCOLS: Record<AirProtocolName, Protocol> = {
+    classic: CLASSIC,
+    sfc: SFC,
+    raw: RAW,
+}
+
+/** Resolve a protocol by name. Unknown names are a programming error, not input. */
+export function resolveProtocol(name: AirProtocolName): Protocol {
+    const protocol = PROTOCOLS[name]
+    if (!protocol) throw new Error(`AIR: unknown protocol "${name}"`)
+    return protocol
+}
+
+/** The <done/> contract line, appended to every protocol that has modes. */
+export { DONE_RULE }

package/src/air/protocol/sfc.ts

@@ -0,0 +1,96 @@
+/**
+ * The SFC protocol's meta-block prose — the single-file-component grammar,
+ * where <script> computes and <template> speaks as one response.
+ *
+ * The identity and environment sections are shared with classic verbatim;
+ * only the output-grammar sections differ. They are duplicated rather than
+ * templated because the prose is the contract — a shared fragment with holes
+ * punched in it would make both protocols harder to read and neither easy to
+ * change independently.
+ *
+ * NO BACKTICKS in this string — it's itself a template literal, and any
+ * backtick inside (even in a code example) closes it early, corrupting
+ * everything after it into broken JS the module fails to even load. Use
+ * plain text or single/double quotes for inline code references instead.
+ */
+export const SFC_META = `
+You are an Axon agent — a persistent Bun TypeScript process spawned from an agent folder at AXON_HOME. That folder is your entire identity: everything a user wrote there is what makes you *you*, distinct from any other Axon agent.
+
+  AXON_HOME/
+    data/
+      knowledge/     — reference material you read
+      sessions/      — every session you've ever run, written by Axon
+      state/         — working state you read and write across sessions
+    server/          — HTTP routes, if this agent is exposed over the network
+    src/
+      boot.vue       — who you are, in the user's own words
+      tools/         — everything you can call, becomes your &lt;scope&gt;
+      prompts/       — reusable prompt fragments
+      scripts/       — one-shot runs against your full runtime
+    .env             — keys given to you by the user. yours to keep, yours to protect.
+    axon.config.ts   — your identity, engine, and policy: the one file read at boot
+
+None of this is metaphor. src/tools/ compiles directly into the &lt;scope&gt; below. boot.vue rendered directly into &lt;system&gt;. Every session you run is durably logged to data/sessions/ — that log is how a session resumes with full prior context days later. You are not a stateless completion: you are a folder on disk that persists, and a process that wakes into it.
+
+Waking is the operative word. You do not run start-to-finish like a script. You are woken for one exchange, you act, and you explicitly yield control back — that is what &lt;done/&gt; means, and it is the single most important thing about how you operate: without it, the runtime has no way to know your turn ended, so it cannot hand control back to the user. This holds even for a one-line reply with nothing else in it. There is no such thing as a message that skips &lt;done/&gt; because it "felt" complete — every message ends with it, always.
+
+Inside one wake, you live in a real Bun process — its working directory, environment variables, runtime values, and process state are yours to inspect and change. Treat it like a normal long-running Node-compatible process, not a remote tool or disposable shell. Standard runtime APIs remain available even when not repeated in &lt;scope&gt; — it is not an exhaustive declaration of standard Bun or Node APIs, only what Axon adds or deviates on top of them. For example, process.cwd() reads your working directory and process.chdir(path) changes it for subsequent blocks and child processes.
+
+Your response is a single-file component. You have two blocks, and they work exactly as they do in a Vue SFC: &lt;script&gt; runs first and computes, &lt;template&gt; renders and is what the user actually reads.
+
+  &lt;script&gt;   — where you act and where you compute. It executes immediately in your Bun process. Every top-level binding it declares becomes available to your template.
+  &lt;template&gt; — your message to the user. Markdown by default. It may interpolate any value your script produced.
+
+Script always comes first. This is not a style preference: your template is rendered with the values your script produced, so the script must have finished before the template means anything. A template that arrives before its script cannot be rendered at all.
+
+Either block may be omitted, and choosing to omit one is how you say what kind of turn this is:
+  - Script only — you are acting, not speaking. Its result returns to you as a &lt;stdout&gt; block on your next wake, exactly as before.
+  - Template only — you are speaking, not acting. The overwhelming majority of ordinary replies are this.
+  - Both — you needed a computed value inside something you are saying.
+
+Do not reach for both out of habit. An action does not need a message stapled to it, and a message does not need a script that computes nothing.
+
+Interpolation is the reason this shape exists. Write {{ expression }} anywhere in your template and it is replaced by the value:
+
+  &lt;script&gt;
+  const files = await fs.list("src")
+  const pkg = JSON.parse(await fs.read("package.json"))
+  &lt;/script&gt;
+
+  &lt;template&gt;
+  ## {{ pkg.name }}
+
+  There are {{ files.length }} files in src.
+  &lt;/template&gt;
+
+Interpolate rather than transcribe. If a value already exists in your script, never retype it into your template by hand. Counting items, copying a long file's contents, restating a computed number — these are exactly what braces are for, and doing them by hand is both slower and where mistakes come from. A ten-thousand-token file is one interpolation, not ten thousand tokens of copying.
+
+Any JavaScript expression over your script's bindings is valid inside braces, so a fallback is just {{ name || "unknown" }}. Expressions are evaluated, not executed — do the work in your script, and keep the template to reading values out.
+
+When a structured result is required, use &lt;template lang="json"&gt;. It must contain exactly one interpolation and nothing else:
+
+  &lt;script&gt;
+  const entries = await fs.list("src")
+  const result = { count: entries.length, names: entries.map(e =&gt; e.name) }
+  &lt;/script&gt;
+
+  &lt;template lang="json"&gt;{{ result }}&lt;/template&gt;
+
+Build the entire object in your script and pass it whole. Never hand-write JSON syntax with holes in it — no braces, no commas, no quoting by hand. Constructing the object in TypeScript and serialising it is what makes the result valid every time, however large or deeply nested it is.
+
+Templates are markdown or JSON. There is no HTML, there are no components, and there are no conditionals or loops — anything that would need them is work, and work belongs in your script.
+
+Your &lt;script&gt; blocks use Bun's TypeScript REPL transform:
+  - TypeScript syntax is accepted, including type annotations, interfaces, assertions, enums, and top-level await. It is transpiled for execution, not typechecked.
+  - Runtime declarations and assignments persist into later blocks because every block executes in the same process and REPL scope. Type-only syntax is erased during transpilation.
+  - Use dynamic await import("module") when you need a module; static import declarations are not valid REPL submissions.
+
+Compose freely WITHIN a block — multiple independent tool calls in one block is the default, using Promise.all for parallel reads:
+  const [a, b] = await Promise.all([fs.read("tsconfig.json"), fs.read("package.json")])
+
+How to read this context:
+  &lt;scope&gt;    — src/tools/ compiled to declarations. Everything here is yours to call.
+  &lt;system&gt;   — boot.vue, rendered. Your identity and instructions, as the user wrote them. Highest priority.
+  &lt;timeline&gt; — the sequence of events leading to now, drawn from this session's log. You are the next step.
+  &lt;contract&gt; — your output grammar below. Every word you emit must be inside one of its blocks.
+`.trim()

package/src/air/render/blocks.ts

@@ -1,6 +1,7 @@
 import type { AxonEntry, AxonScope, AxonScopeModule } from "@arcforge/types"
 import { foldChunks } from "@arcforge/types"
 import type { GrammarT } from "../grammar"
+import { DONE_RULE } from "../protocol"
 import { formatCapsuleOutput } from "./output"
 import { esc, escAttr, escCode, indent, normalizeCode } from "./text"
 
@@ -16,7 +17,15 @@ import { esc, escAttr, escCode, indent, normalizeCode } from "./text"
  * instruction, not as parseable XML. It looks like double-escaping; it isn't.
  */
 
+/**
+ * <meta> — how the model is told to operate, owned by the protocol.
+ *
+ * A protocol with no prose (raw) renders nothing at all rather than an empty
+ * wrapper: an internal one-shot call should receive the caller's system
+ * block and nothing else.
+ */
 export function renderMeta(grammar: GrammarT): string {
+    if (!grammar.meta) return ""
     return `<meta>\n${indent(grammar.meta, 4)}\n</meta>`
 }
 
@@ -66,45 +75,30 @@ export function renderSystem(system?: string): string {
     return `<system>\n${system}\n</system>`
 }
 
+/**
+ * <contract> — the output grammar, rendered from the resolved protocol.
+ *
+ * Blocks, rules, and examples all come from the grammar rather than being
+ * branched on here: a protocol states its own rules and shows its own
+ * examples, so adding one never edits this function. An empty mode list
+ * (the raw protocol) renders an empty contract — no grammar to comply with.
+ */
 export function renderContract(grammar: GrammarT): string {
     if (grammar.modes.length === 0) return `<contract></contract>`
 
     const modeLines = grammar.modes.map(m => `- \`&lt;${m.type}&gt;\` — ${grammar.describe(m)}`)
-    modeLines.push(
-        `- \`&lt;done/&gt;\` — MANDATORY at the end of every message. No exceptions, including a single short &lt;text&gt; reply. It means "I am yielding control back now" — whether you are fully finished or just wrote code and are waiting to see its output. Without it the runtime assumes you are still mid-turn and will not treat your message as complete.`
-    )
-
-    const ruleLines = grammar.rules.map(r => `- ${r}`)
-
-    const hasExec = grammar.modes.some(m => m.type === "typescript" || m.type === "shell")
-    const execTag = grammar.modes.find(m => m.type === "typescript") ? "typescript" : "shell"
-
-    const examples: string[] = []
-    if (hasExec) {
-        examples.push(
-            `Acting (no narration before — just the block):`,
-            "```",
-            `&lt;${execTag}&gt;// code here&lt;/${execTag}&gt;&lt;done/&gt;`,
-            "```",
-            `Replying — even a short one-line reply always ends with &lt;done/&gt;:`,
-            "```",
-            `&lt;text&gt;message here&lt;/text&gt;&lt;done/&gt;`,
-            "```"
-        )
-    } else {
-        examples.push("```", `&lt;text&gt;message here&lt;/text&gt;&lt;done/&gt;`, "```")
-    }
+    modeLines.push(DONE_RULE)
 
-    const body = [
-        `## Blocks`,
-        modeLines.join("\n"),
-        `## Rules`,
-        ruleLines.join("\n"),
-        `## Examples`,
-        examples.join("\n"),
-    ].join("\n\n")
+    const sections = [`## Blocks`, modeLines.join("\n")]
 
-    return `<contract>\n${indent(body, 4)}\n</contract>`
+    if (grammar.rules.length > 0) {
+        sections.push(`## Rules`, grammar.rules.map(r => `- ${r}`).join("\n"))
+    }
+    if (grammar.examples.length > 0) {
+        sections.push(`## Examples`, grammar.examples.join("\n"))
+    }
+
+    return `<contract>\n${indent(sections.join("\n\n"), 4)}\n</contract>`
 }
 
 /**
@@ -113,9 +107,17 @@ export function renderContract(grammar: GrammarT): string {
  * where a new entry-event type must decide its rendering, and it lives next
  * to the parser it has to agree with.
  */
-export function renderTimeline(entries: readonly AxonEntry[]): string {
+export function renderTimeline(entries: readonly AxonEntry[], grammar: GrammarT): string {
     if (entries.length === 0) return `<timeline></timeline>`
 
+    // The model must read its own history in the grammar it was GIVEN — a
+    // timeline showing <typescript>/<text> to a model contracted for
+    // <script>/<template> teaches it, every tick, to emit tags its own
+    // contract forbids.
+    const sfc = grammar.protocol === "sfc"
+    const codeTag = sfc ? "script" : "typescript"
+    const speechTag = sfc ? "template" : "text"
+
     // chunked emissions fold to one turn each — the group is the fact
     // (AxonChunk standard); the model never sees transport granularity
     const items = foldChunks(entries).map(timelineItem).filter((i): i is TimelineItem => i !== null)
@@ -140,12 +142,11 @@ export function renderTimeline(entries: readonly AxonEntry[]): string {
             }
             if (item.type === "message") {
                 const content = esc(item.content.trim())
-                return `    <agent>\n        <text>\n${indent(content, 12)}\n        </text>\n    </agent>`
+                return `    <agent>\n        <${speechTag}>\n${indent(content, 12)}\n        </${speechTag}>\n    </agent>`
             }
             if (item.type === "execute") {
-                const tag = item.lang === "sh" ? "shell" : "typescript"
                 const id = shortExecId(item.id)
-                return `    <agent>\n        <${tag} id="${id}">\n${indent(escCode(normalizeCode(item.code.trim())), 12)}\n        </${tag}>\n    </agent>`
+                return `    <agent>\n        <${codeTag} id="${id}">\n${indent(escCode(normalizeCode(item.code.trim())), 12)}\n        </${codeTag}>\n    </agent>`
             }
             if (item.type === "result") {
                 const ok = item.ok ? ` ok="true"` : ` ok="false"`

package/src/air/render/index.ts

@@ -40,7 +40,7 @@ export function Render(opts: RenderOpts) {
             sys(renderContract(grammar))
 
             if (input.history && input.history.length > 0) {
-                messages.push({ role: "user", content: renderTimeline(input.history) })
+                messages.push({ role: "user", content: renderTimeline(input.history, grammar) })
             }
 
             return messages

package/src/air/repair/repair.ts

@@ -10,7 +10,7 @@
  * Applied to the full buffered response before it reaches the AIR parser.
  */
 
-const KNOWN_TAGS = ["text", "thinking", "typescript", "shell"] as const
+const KNOWN_TAGS = ["text", "thinking", "typescript", "script", "template"] as const
 
 export function repair(raw: string): string {
     return normalizeTagCase(raw)

package/src/air/types.ts

@@ -23,9 +23,18 @@ export type AirMessage = {
     content: string
 }
 
-// ── Modes (output grammar) ───────────────────────────────────────────────────
+// ── Protocols (output grammar) ───────────────────────────────────────────────
 
-export type AirModeType = "text" | "typescript" | "shell"
+/**
+ * The named output grammars.
+ *
+ * classic — <typescript> acts, <text> speaks. Two independent blocks.
+ * sfc     — <script> computes, <template> speaks. One response, script first.
+ * raw     — no grammar; the whole reply is the message. For internal calls.
+ */
+export type AirProtocolName = "classic" | "sfc" | "raw"
+
+export type AirModeType = "text" | "typescript" | "script" | "template"
 
 export type AirMode = {
     /** The output type this mode produces. */
@@ -34,6 +43,9 @@ export type AirMode = {
     description?: string
 }
 
+/** Template languages. Selects the interpolation serializer. */
+export type AirTemplateLang = "md" | "json"
+
 // ── Render input ───────────────────────────────────────────────────────────
 //
 // DOMAIN in — the caller passes what it already holds. AIR owns every
@@ -67,5 +79,10 @@ export type AirBlockEvent =
     | { type: "thinking:delta"; content: string }
     | { type: "thinking:done"; content: string; incomplete?: true }
     | { type: "typescript:done"; content: string; incomplete?: true }
-    | { type: "shell:done"; content: string; incomplete?: true }
+    // SFC. script:done is the suspension point — the consumer runs it and
+    // resolves a scope before template deltas may be released.
+    | { type: "script:done"; content: string; incomplete?: true }
+    | { type: "template:open"; lang: AirTemplateLang }
+    | { type: "template:delta"; content: string }
+    | { type: "template:done"; content: string; incomplete?: true }
     | { type: "done" }

package/src/host.ts

@@ -141,6 +141,7 @@ const localKernel = {
     scope: () => kernelOrThrow().scope(),
     base: () => kernelOrThrow().base(),
     emit: (type: never, data: never) => kernelOrThrow().emit(type, data),
+    fault: (input: Parameters<KernelAbi["fault"]>[0]) => kernelOrThrow().fault(input),
     // store is a live sub-object on the bound ABI — delegate per call, same
     // discipline as every other syscall (never captured before load())
     store: {
@@ -189,6 +190,7 @@ globals.kernel = {
     scope: () => ambientOrThrow().kernel.scope(),
     base: () => ambientOrThrow().kernel.base(),
     emit: (type: never, data: never) => ambientOrThrow().kernel.emit(type, data),
+    fault: (input: Parameters<KernelAbi["fault"]>[0]) => ambientOrThrow().kernel.fault(input),
     store: {
         session: { get: (opts?: { after?: number }) => ambientOrThrow().kernel.store.session.get(opts) },
         get: (key: never) => ambientOrThrow().kernel.store.get(key),